AbstractManeuverTriggers.java

  1. /* Copyright 2002-2025 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 ResettableManeuverTriggers {

  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 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.         initializeResetters(initialState, target);

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

  74.     }

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

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

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

  99.     }

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

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

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

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

  130.     /** {@inheritDoc} */
  131.     @Override
  132.     public void addResetter(final ManeuverTriggersResetter resetter) {
  133.         resetters.add(resetter);
  134.     }

  136.     /** {@inheritDoc} */
  137.     @Override
  138.     public <T extends CalculusFieldElement<T>> void addResetter(final Field<T> field, final FieldManeuverTriggersResetter<T> resetter) {

  140.         // check if we already have resetters for this field
  141.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.computeIfAbsent(field, k -> new ArrayList<>());

  143.         // add the resetter to the list
  144.         list.add(resetter);

  146.     }

  148.     /** Initialize resetters.
  149.      * @param initialState initial state
  150.      * @param target target date for the propagation
  151.      */
  152.     protected void initializeResetters(final SpacecraftState initialState, final AbsoluteDate target) {
  153.         for (final ManeuverTriggersResetter r : resetters) {
  154.             r.init(initialState, target);
  155.         }
  156.     }

  158.     /** Notify resetters.
  159.      * @param state spacecraft state at trigger date (before applying the maneuver)
  160.      * @param start if true, the trigger is the start of the maneuver
  161.      */
  162.     protected void notifyResetters(final SpacecraftState state, final boolean start) {
  163.         for (final ManeuverTriggersResetter r : resetters) {
  164.             r.maneuverTriggered(state, start);
  165.         }
  166.     }

  168.     /** Apply resetters.
  169.      * @param state spacecraft state at trigger date
  170.      * @return reset state
  171.      */
  172.     protected SpacecraftState applyResetters(final SpacecraftState state) {
  173.         SpacecraftState reset = state;
  174.         for (final ManeuverTriggersResetter r : resetters) {
  175.             reset = r.resetState(reset);
  176.         }
  177.         return reset;
  178.     }

  180.     /** Initialize resetters.
  181.      * @param initialState initial state
  182.      * @param target target date for the propagation
  183.      * @param <T> type of the field elements
  184.      */
  185.     protected <T extends CalculusFieldElement<T>> void initializeResetters(final FieldSpacecraftState<T> initialState, final FieldAbsoluteDate<T> target) {
  186.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(initialState.getDate().getField());
  187.         if (list != null) {
  188.             for (final FieldManeuverTriggersResetter<?> r : list) {
  189.                 @SuppressWarnings("unchecked")
  190.                 final FieldManeuverTriggersResetter<T> tr = (FieldManeuverTriggersResetter<T>) r;
  191.                 tr.init(initialState, target);
  192.             }
  193.         }
  194.     }

  196.     /** Notify resetters.
  197.      * @param state spacecraft state at trigger date (before applying the maneuver)
  198.      * @param start if true, the trigger is the start of the maneuver
  199.      * @param <T> type of the field elements
  200.      */
  201.     protected <T extends CalculusFieldElement<T>> void notifyResetters(final FieldSpacecraftState<T> state, final boolean start) {
  202.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(state.getDate().getField());
  203.         if (list != null) {
  204.             for (final FieldManeuverTriggersResetter<?> r : list) {
  205.                 @SuppressWarnings("unchecked")
  206.                 final FieldManeuverTriggersResetter<T> tr = (FieldManeuverTriggersResetter<T>) r;
  207.                 tr.maneuverTriggered(state, start);
  208.             }
  209.         }
  210.     }

  212.     /** Apply resetters.
  213.      * @param state spacecraft state at trigger date
  214.      * @param <T> type of the field elements
  215.      * @return reset state
  216.      */
  217.     protected <T extends CalculusFieldElement<T>> FieldSpacecraftState<T>
  218.         applyResetters(final FieldSpacecraftState<T> state) {
  219.         FieldSpacecraftState<T> reset = state;
  220.         final List<FieldManeuverTriggersResetter<?>> list = fieldResetters.get(state.getDate().getField());
  221.         if (list != null) {
  222.             for (final FieldManeuverTriggersResetter<?> r : list) {
  223.                 @SuppressWarnings("unchecked")
  224.                 final FieldManeuverTriggersResetter<T> tr = (FieldManeuverTriggersResetter<T>) r;
  225.                 reset = tr.resetState(reset);
  226.             }
  227.         }
  228.         return reset;
  229.     }

  231. }
Created with JaCoCo 0.8.12.202403310830