FieldDateDetector.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.events;

  19. import java.util.ArrayList;

  21. import org.orekit.errors.OrekitIllegalArgumentException;
  22. import org.hipparchus.RealFieldElement;
  23. import org.orekit.errors.OrekitException;
  24. import org.orekit.errors.OrekitMessages;
  25. import org.orekit.propagation.FieldSpacecraftState;
  26. import org.orekit.propagation.events.handlers.FieldEventHandler;
  27. import org.orekit.propagation.events.handlers.FieldStopOnEvent;
  28. import org.orekit.time.FieldAbsoluteDate;
  29. import org.orekit.time.FieldTimeStamped;

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

  50.     /** Last date for g computation. */
  51.     private FieldAbsoluteDate<T> gDate;

  53.     /** List of event dates. */
  54.     private final ArrayList<FieldEventDate<T>> eventDateList;

  56.     /** Current event date. */
  57.     private int currentIndex;

  59.     /** Build a new instance.
  60.      * <p>First event dates are set here, but others can be
  61.      * added later with {@link #addEventDate(FieldAbsoluteDate)}.</p>
  62.      * @param maxCheck maximum checking interval (s)
  63.      * @param threshold convergence threshold (s)
  64.      * @param dates list of event dates
  65.      * @see #addEventDate(FieldAbsoluteDate)
  66.      */
  67.     @SafeVarargs
  68.     public FieldDateDetector(final T maxCheck, final T threshold, final FieldTimeStamped<T>... dates) {
  69.         this(maxCheck, threshold, DEFAULT_MAX_ITER, new FieldStopOnEvent<FieldDateDetector<T>, T>(), dates);
  70.     }

  72.     /** Build a new instance.
  73.      * <p>This constructor is dedicated to single date detection.
  74.      * {@link #getMaxCheckInterval() max check interval} is set to 1.0e10, so almost
  75.      * no other date can be added. Tolerance is set to 1.0e-9.</p>
  76.      * @param target target date
  77.      * @see #addEventDate(FieldAbsoluteDate)
  78.      */
  79.     public FieldDateDetector(final FieldAbsoluteDate<T> target) {
  80.         this(target.getField().getZero().add(1.0e10), target.getField().getZero().add(1.e-9), target);
  81.     }

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

  108.     /** {@inheritDoc} */
  109.     @Override
  110.     protected FieldDateDetector<T> create(final T newMaxCheck, final T newThreshold,
  111.                                           final int newMaxIter, final FieldEventHandler<? super FieldDateDetector<T>, T> newHandler) {
  112.         @SuppressWarnings("unchecked")
  113.         final FieldTimeStamped<T>[] dates = eventDateList.toArray(new FieldEventDate[eventDateList.size()]);
  114.         return new FieldDateDetector<>(newMaxCheck, newThreshold, newMaxIter, newHandler, dates);
  115.     }

  117.     /** Compute the value of the switching function.
  118.      * This function measures the difference between the current and the target date.
  119.      * @param s the current state information: date, kinematics, attitude
  120.      * @return value of the switching function
  121.      * @exception OrekitException if some specific error occurs
  122.      */
  123.     public T g(final FieldSpacecraftState<T> s) throws OrekitException {
  124.         gDate = s.getDate();
  125.         if (currentIndex < 0) {
  126.             return s.getA().getField().getZero().add(-1);
  127.         } else {
  128.             final FieldEventDate<T> event = getClosest(gDate);
  129.             return event.isgIncrease() ? gDate.durationFrom(event.getDate()) : event.getDate().durationFrom(gDate);
  130.         }
  131.     }

  133.     /** Get the current event date according to the propagator.
  134.      * @return event date
  135.      */
  136.     public FieldAbsoluteDate<T> getDate() {
  137.         return currentIndex < 0 ? null : eventDateList.get(currentIndex).getDate();
  138.     }

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

  175.     /** Get the closest EventDate to the target date.
  176.      * @param target target date
  177.      * @return current EventDate
  178.      */
  179.     private FieldEventDate<T> getClosest(final FieldAbsoluteDate<T> target) {
  180.         final T dt = target.durationFrom(eventDateList.get(currentIndex).getDate());
  181.         if (dt.getReal() < 0.0 && currentIndex > 0) {
  182.             boolean found = false;
  183.             while (currentIndex > 0 && !found) {
  184.                 if (target.durationFrom(eventDateList.get(currentIndex - 1).getDate()).getReal() < eventDateList.get(currentIndex).getDate().durationFrom(target).getReal()) {
  185.                     currentIndex--;
  186.                 } else {
  187.                     found = true;
  188.                 }
  189.             }
  190.         } else if (dt.getReal() > 0.0 && currentIndex < eventDateList.size() - 1) {
  191.             final int maxIndex = eventDateList.size() - 1;
  192.             boolean found = false;
  193.             while (currentIndex < maxIndex && !found) {
  194.                 if (target.durationFrom(eventDateList.get(currentIndex + 1).getDate()).getReal() > eventDateList.get(currentIndex).getDate().durationFrom(target).getReal()) {
  195.                     currentIndex++;
  196.                 } else {
  197.                     found = true;
  198.                 }
  199.             }
  200.         }
  201.         return eventDateList.get(currentIndex);
  202.     }

  204.     /** Event date specification. */
  205.     private static class FieldEventDate<T extends RealFieldElement<T>> implements FieldTimeStamped<T> {

  207.         /** Event date. */
  208.         private final FieldAbsoluteDate<T> eventDate;

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

  213.         /** Simple constructor.
  214.          * @param date date
  215.          * @param increase if true, g function increases around event date
  216.          */
  217.         FieldEventDate(final FieldAbsoluteDate<T> date, final boolean increase) {
  218.             this.eventDate = date;
  219.             this.gIncrease = increase;
  220.         }

  222.         /** Getter for event date.
  223.          * @return event date
  224.          */
  225.         public FieldAbsoluteDate<T> getDate() {
  226.             return eventDate;
  227.         }

  229.         /** Getter for g function way at event date.
  230.          * @return g function increasing flag
  231.          */
  232.         public boolean isgIncrease() {
  233.             return gIncrease;
  234.         }

  236.     }

  238. }
Created with JaCoCo 0.7.9.201702052155