AbstractManeuverTriggers.java

  1. /* Copyright 2002-2022 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.forces.maneuvers.trigger;

  19. import java.util.ArrayList;
  20. import java.util.HashMap;
  21. import java.util.List;
  22. import java.util.Map;

  24. import org.hipparchus.CalculusFieldElement;
  25. import org.hipparchus.Field;
  26. import org.orekit.propagation.FieldSpacecraftState;
  27. import org.orekit.propagation.SpacecraftState;
  28. import org.orekit.time.AbsoluteDate;
  29. import org.orekit.time.FieldAbsoluteDate;
  30. import org.orekit.utils.TimeSpanMap;

  32. /** Base class for triggers.
  33.  * @author Luc Maisonobe
  34.  * @since 11.1
  35.  */
  36. public abstract class AbstractManeuverTriggers implements ManeuverTriggers {

  38.     /** Firing time spans. */
  39.     private TimeSpanMap<Boolean> firings;

  41.     /** Propagation direction. */
  42.     private boolean forward;

  44.     /** Resetters for the maneuver triggers. */
  45.     private final List<ManeuverTriggersResetter> resetters;

  47.     /** Cached field-based resetters. */
  48.     private final transient Map<Field<? extends CalculusFieldElement<?>>, List<FieldManeuverTriggersResetter<?>>> fieldResetters;

  50.     /** Simple constructor.
  51.      */
  52.     protected AbstractManeuverTriggers() {
  53.         this.firings        = new TimeSpanMap<>(Boolean.FALSE);
  54.         this.resetters      = new ArrayList<>();
  55.         this.fieldResetters = new HashMap<>();
  56.     }

  58.     /** {@inheritDoc} */
  59.     @Override
  60.     public void init(final SpacecraftState initialState, final AbsoluteDate target) {

  62.         forward = target.isAfterOrEqualTo(initialState);
  63.         firings = new TimeSpanMap<>(Boolean.FALSE);
  64.         for (final ManeuverTriggersResetter r : resetters) {
  65.             r.init(initialState, target);
  66.         }

  68.         if (isFiringOnInitialState(initialState, forward)) {
  69.             if (forward) {
  70.                 firings.addValidAfter(Boolean.TRUE, initialState.getDate(), false);
  71.             } else {
  72.                 firings.addValidBefore(Boolean.TRUE, initialState.getDate(), false);
  73.             }
  74.         }

  76.     }

  78.     /** {@inheritDoc} */
  79.     @SuppressWarnings("unchecked")
  80.     @Override
  81.     public <T extends CalculusFieldElement<T>> void init(final FieldSpacecraftState<T> initialState, final FieldAbsoluteDate<T> target) {

  83.         forward = target.isAfterOrEqualTo(initialState);
  84.         firings = new TimeSpanMap<>(Boolean.FALSE);
  85.         // check if we already have resetters for this field
  86.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(initialState.getDate().getField());
  87.         if (list != null) {
  88.             for (FieldManeuverTriggersResetter<?> r : list) {
  89.                 ((FieldManeuverTriggersResetter<T>) r).init(initialState, target);
  90.             }
  91.         }

  93.         if (isFiringOnInitialState(initialState.toSpacecraftState(), forward)) {
  94.             if (forward) {
  95.                 firings.addValidAfter(Boolean.TRUE, initialState.getDate().toAbsoluteDate(), false);
  96.             } else {
  97.                 firings.addValidBefore(Boolean.TRUE, initialState.getDate().toAbsoluteDate(), false);
  98.             }
  99.         }

  101.     }

  103.     /**
  104.      * Method to check if the thruster is firing on initialization. can be called by
  105.      * sub classes
  106.      *
  107.      * @param initialState initial spacecraft state
  108.      * @param isForward if true, propagation will be in the forward direction
  109.      * @return true if firing in propagation direction
  110.      */
  111.     protected abstract boolean isFiringOnInitialState(SpacecraftState initialState, boolean isForward);

  113.     /** {@inheritDoc} */
  114.     @Override
  115.     public boolean isFiring(final AbsoluteDate date, final double[] parameters) {
  116.         return firings.get(date);
  117.     }

  119.     /** {@inheritDoc} */
  120.     @Override
  121.     public <S extends CalculusFieldElement<S>> boolean isFiring(final FieldAbsoluteDate<S> date, final S[] parameters) {
  122.         return firings.get(date.toAbsoluteDate());
  123.     }

  125.     /** Get the firings detected during last propagation.
  126.      * @return firings detected during last propagation
  127.      */
  128.     public TimeSpanMap<Boolean> getFirings() {
  129.         return firings;
  130.     }

  132.     /** Add a resetter.
  133.      * @param resetter resetter to add
  134.      */
  135.     public void addResetter(final ManeuverTriggersResetter resetter) {
  136.         resetters.add(resetter);
  137.     }

  139.     /** Add a resetter.
  140.      * @param field field to which the state belongs
  141.      * @param resetter resetter to add
  142.      * @param <T> type of the field elements
  143.      */
  144.     public <T extends CalculusFieldElement<T>> void addResetter(final Field<T> field, final FieldManeuverTriggersResetter<T> resetter) {

  146.         // check if we already have resetters for this field
  147.         List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(field);
  148.         if (list == null) {
  149.             list = new ArrayList<>();
  150.             fieldResetters.put(field, list);
  151.         }

  153.         // add the resetter to the list
  154.         list.add(resetter);

  156.     }

  158.     /** Initialize resetters.
  159.      * @param initialState initial state
  160.      * @param target target date for the propagation
  161.      */
  162.     protected void initializeResetters(final SpacecraftState initialState, final AbsoluteDate target) {
  163.         for (final ManeuverTriggersResetter r : resetters) {
  164.             r.init(initialState, target);
  165.         }
  166.     }

  168.     /** Notify resetters.
  169.      * @param state spacecraft state at trigger date (before applying the maneuver)
  170.      * @param start if true, the trigger is the start of the maneuver
  171.      */
  172.     protected void notifyResetters(final SpacecraftState state, final boolean start) {
  173.         for (final ManeuverTriggersResetter r : resetters) {
  174.             r.maneuverTriggered(state, start);
  175.         }
  176.     }

  178.     /** Apply resetters.
  179.      * @param state spacecraft state at trigger date
  180.      * @return reset state
  181.      */
  182.     protected SpacecraftState applyResetters(final SpacecraftState state) {
  183.         SpacecraftState reset = state;
  184.         for (final ManeuverTriggersResetter r : resetters) {
  185.             reset = r.resetState(reset);
  186.         }
  187.         return reset;
  188.     }

  190.     /** Initialize resetters.
  191.      * @param initialState initial state
  192.      * @param target target date for the propagation
  193.      * @param <T> type of the field elements
  194.      */
  195.     protected <T extends CalculusFieldElement<T>> void initializeResetters(final FieldSpacecraftState<T> initialState, final FieldAbsoluteDate<T> target) {
  196.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(initialState.getDate().getField());
  197.         if (list != null) {
  198.             for (final FieldManeuverTriggersResetter<?> r : list) {
  199.                 @SuppressWarnings("unchecked")
  200.                 final FieldManeuverTriggersResetter<T> tr = (FieldManeuverTriggersResetter<T>) r;
  201.                 tr.init(initialState, target);
  202.             }
  203.         }
  204.     }

  206.     /** Notify resetters.
  207.      * @param state spacecraft state at trigger date (before applying the maneuver)
  208.      * @param start if true, the trigger is the start of the maneuver
  209.      * @param <T> type of the field elements
  210.      */
  211.     protected <T extends CalculusFieldElement<T>> void notifyResetters(final FieldSpacecraftState<T> state, final boolean start) {
  212.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(state.getDate().getField());
  213.         if (list != null) {
  214.             for (final FieldManeuverTriggersResetter<?> r : list) {
  215.                 @SuppressWarnings("unchecked")
  216.                 final FieldManeuverTriggersResetter<T> tr = (FieldManeuverTriggersResetter<T>) r;
  217.                 tr.maneuverTriggered(state, start);
  218.             }
  219.         }
  220.     }

  222.     /** Apply resetters.
  223.      * @param state spacecraft state at trigger date
  224.      * @param <T> type of the field elements
  225.      * @return reset state
  226.      */
  227.     protected <T extends CalculusFieldElement<T>> FieldSpacecraftState<T>
  228.         applyResetters(final FieldSpacecraftState<T> state) {
  229.         FieldSpacecraftState<T> reset = state;
  230.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(state.getDate().getField());
  231.         if (list != null) {
  232.             for (final FieldManeuverTriggersResetter<?> r : list) {
  233.                 @SuppressWarnings("unchecked")
  234.                 final FieldManeuverTriggersResetter<T> tr = (FieldManeuverTriggersResetter<T>) r;
  235.                 reset = tr.resetState(reset);
  236.             }
  237.         }
  238.         return reset;
  239.     }

  241. }
Created with JaCoCo 0.8.7.202105040129