DateDetector.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (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.events;

  19. import java.util.ArrayList;

  21. import org.hipparchus.ode.events.Action;
  22. import org.orekit.errors.OrekitIllegalArgumentException;
  23. import org.orekit.errors.OrekitMessages;
  24. import org.orekit.propagation.SpacecraftState;
  25. import org.orekit.propagation.events.handlers.EventHandler;
  26. import org.orekit.propagation.events.handlers.StopOnEvent;
  27. import org.orekit.time.AbsoluteDate;
  28. import org.orekit.time.TimeStamped;

  30. /** Finder for date events.
  31.  * <p>This class finds date events (i.e. occurrence of some predefined dates).</p>
  32.  * <p>As of version 5.1, it is an enhanced date detector:</p>
  33.  * <ul>
  34.  *   <li>it can be defined without prior date ({@link #DateDetector(double, double, TimeStamped...)})</li>
  35.  *   <li>several dates can be added ({@link #addEventDate(AbsoluteDate)})</li>
  36.  * </ul>
  37.  * <p>The gap between the added dates must be more than the maxCheck.</p>
  38.  * <p>The default implementation behavior is to {@link Action#STOP stop}
  39.  * propagation at the first event date occurrence. This can be changed by calling
  40.  * {@link #withHandler(EventHandler)} after construction.</p>
  41.  * @see org.orekit.propagation.Propagator#addEventDetector(EventDetector)
  42.  * @author Luc Maisonobe
  43.  * @author Pascal Parraud
  44.  */
  45. public class DateDetector extends AbstractDetector<DateDetector> implements TimeStamped {

  47.     /** Last date for g computation. */
  48.     private AbsoluteDate gDate;

  50.     /** List of event dates. */
  51.     private final ArrayList<EventDate> eventDateList;

  53.     /** Current event date. */
  54.     private int currentIndex;

  56.     /** Build a new instance.
  57.      * <p>First event dates are set here, but others can be
  58.      * added later with {@link #addEventDate(AbsoluteDate)}.</p>
  59.      * @param maxCheck maximum checking interval (s)
  60.      * @param threshold convergence threshold (s)
  61.      * @param dates list of event dates
  62.      * @see #addEventDate(AbsoluteDate)
  63.      */
  64.     public DateDetector(final double maxCheck, final double threshold, final TimeStamped... dates) {
  65.         this(maxCheck, threshold, DEFAULT_MAX_ITER, new StopOnEvent<DateDetector>(), dates);
  66.     }

  68.     /** Build a new instance.
  69.      * <p>This constructor is dedicated to single date detection.
  70.      * {@link #getMaxCheckInterval() max check interval} is set to 1.0e10, so almost
  71.      * no other date can be added. Tolerance is set to 1.0e-9.</p>
  72.      * @param target target date
  73.      * @see #addEventDate(AbsoluteDate)
  74.      */
  75.     public DateDetector(final AbsoluteDate target) {
  76.         this(1.0e10, 1.e-9, target);
  77.     }

  79.     /** Private constructor with full parameters.
  80.      * <p>
  81.      * This constructor is private as users are expected to use the builder
  82.      * API with the various {@code withXxx()} methods to set up the instance
  83.      * in a readable manner without using a huge amount of parameters.
  84.      * </p>
  85.      * @param maxCheck maximum checking interval (s)
  86.      * @param threshold convergence threshold (s)
  87.      * @param maxIter maximum number of iterations in the event time search
  88.      * @param handler event handler to call at event occurrences
  89.      * @param dates list of event dates
  90.      * @since 6.1
  91.      */
  92.     private DateDetector(final double maxCheck, final double threshold,
  93.                          final int maxIter, final EventHandler<? super DateDetector> handler,
  94.                          final TimeStamped... dates) {
  95.         super(maxCheck, threshold, maxIter, handler);
  96.         this.currentIndex  = -1;
  97.         this.gDate         = null;
  98.         this.eventDateList = new ArrayList<DateDetector.EventDate>(dates.length);
  99.         for (final TimeStamped ts : dates) {
  100.             addEventDate(ts.getDate());
  101.         }
  102.     }

  104.     /** {@inheritDoc} */
  105.     @Override
  106.     protected DateDetector create(final double newMaxCheck, final double newThreshold,
  107.                                   final int newMaxIter, final EventHandler<? super DateDetector> newHandler) {
  108.         return new DateDetector(newMaxCheck, newThreshold, newMaxIter, newHandler,
  109.                                 eventDateList.toArray(new EventDate[eventDateList.size()]));
  110.     }

  112.     /** Compute the value of the switching function.
  113.      * This function measures the difference between the current and the target date.
  114.      * @param s the current state information: date, kinematics, attitude
  115.      * @return value of the switching function
  116.      */
  117.     public double g(final SpacecraftState s) {
  118.         gDate = s.getDate();
  119.         if (currentIndex < 0) {
  120.             return -1.0;
  121.         } else {
  122.             final EventDate event = getClosest(gDate);
  123.             return event.isgIncrease() ? gDate.durationFrom(event.getDate()) : event.getDate().durationFrom(gDate);
  124.         }
  125.     }

  127.     /** Get the current event date according to the propagator.
  128.      * @return event date
  129.      */
  130.     public AbsoluteDate getDate() {
  131.         return currentIndex < 0 ? null : eventDateList.get(currentIndex).getDate();
  132.     }

  134.     /** Add an event date.
  135.      * <p>The date to add must be:</p>
  136.      * <ul>
  137.      *   <li>less than the smallest already registered event date minus the maxCheck</li>
  138.      *   <li>or more than the largest already registered event date plus the maxCheck</li>
  139.      * </ul>
  140.      * @param target target date
  141.      * @throws IllegalArgumentException if the date is too close from already defined interval
  142.      * @see #DateDetector(double, double, TimeStamped...)
  143.      */
  144.     public void addEventDate(final AbsoluteDate target) throws IllegalArgumentException {
  145.         final boolean increasing;
  146.         if (currentIndex < 0) {
  147.             increasing = (gDate == null) ? true : target.durationFrom(gDate) > 0.0;
  148.             currentIndex = 0;
  149.             eventDateList.add(new EventDate(target, increasing));
  150.         } else {
  151.             final int lastIndex = eventDateList.size() - 1;
  152.             if (eventDateList.get(0).getDate().durationFrom(target) > getMaxCheckInterval()) {
  153.                 increasing = !eventDateList.get(0).isgIncrease();
  154.                 eventDateList.add(0, new EventDate(target, increasing));
  155.                 currentIndex++;
  156.             } else if (target.durationFrom(eventDateList.get(lastIndex).getDate()) > getMaxCheckInterval()) {
  157.                 increasing = !eventDateList.get(lastIndex).isgIncrease();
  158.                 eventDateList.add(new EventDate(target, increasing));
  159.             } else {
  160.                 throw new OrekitIllegalArgumentException(OrekitMessages.EVENT_DATE_TOO_CLOSE,
  161.                                                          target,
  162.                                                          eventDateList.get(0).getDate(),
  163.                                                          eventDateList.get(lastIndex).getDate(),
  164.                                                          getMaxCheckInterval());
  165.             }
  166.         }
  167.     }

  169.     /** Get the closest EventDate to the target date.
  170.      * @param target target date
  171.      * @return current EventDate
  172.      */
  173.     private EventDate getClosest(final AbsoluteDate target) {
  174.         final double dt = target.durationFrom(eventDateList.get(currentIndex).getDate());
  175.         if (dt < 0.0 && currentIndex > 0) {
  176.             boolean found = false;
  177.             while (currentIndex > 0 && !found) {
  178.                 if (target.durationFrom(eventDateList.get(currentIndex - 1).getDate()) < eventDateList.get(currentIndex).getDate().durationFrom(target)) {
  179.                     currentIndex--;
  180.                 } else {
  181.                     found = true;
  182.                 }
  183.             }
  184.         } else if (dt > 0.0 && currentIndex < eventDateList.size() - 1) {
  185.             final int maxIndex = eventDateList.size() - 1;
  186.             boolean found = false;
  187.             while (currentIndex < maxIndex && !found) {
  188.                 if (target.durationFrom(eventDateList.get(currentIndex + 1).getDate()) > eventDateList.get(currentIndex).getDate().durationFrom(target)) {
  189.                     currentIndex++;
  190.                 } else {
  191.                     found = true;
  192.                 }
  193.             }
  194.         }
  195.         return eventDateList.get(currentIndex);
  196.     }

  198.     /** Event date specification. */
  199.     private static class EventDate implements TimeStamped {

  201.         /** Event date. */
  202.         private final AbsoluteDate eventDate;

  204.         /** Flag for g function way around event date. */
  205.         private final boolean gIncrease;

  207.         /** Simple constructor.
  208.          * @param date date
  209.          * @param increase if true, g function increases around event date
  210.          */
  211.         EventDate(final AbsoluteDate date, final boolean increase) {
  212.             this.eventDate = date;
  213.             this.gIncrease = increase;
  214.         }

  216.         /** Getter for event date.
  217.          * @return event date
  218.          */
  219.         public AbsoluteDate getDate() {
  220.             return eventDate;
  221.         }

  223.         /** Getter for g function way at event date.
  224.          * @return g function increasing flag
  225.          */
  226.         public boolean isgIncrease() {
  227.             return gIncrease;
  228.         }

  230.     }

  232. }
Created with JaCoCo 0.8.6.202009150832