FieldAbstractIntegratedPropagator.java

  1. /* Copyright 2002-2024 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.integration;

  19. import java.util.ArrayList;
  20. import java.util.Arrays;
  21. import java.util.Collection;
  22. import java.util.Collections;
  23. import java.util.HashMap;
  24. import java.util.LinkedList;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.Queue;

  29. import org.hipparchus.CalculusFieldElement;
  30. import org.hipparchus.Field;
  31. import org.hipparchus.analysis.solvers.FieldBracketingNthOrderBrentSolver;
  32. import org.hipparchus.exception.MathIllegalArgumentException;
  33. import org.hipparchus.exception.MathIllegalStateException;
  34. import org.hipparchus.ode.FieldDenseOutputModel;
  35. import org.hipparchus.ode.FieldExpandableODE;
  36. import org.hipparchus.ode.FieldODEIntegrator;
  37. import org.hipparchus.ode.FieldODEState;
  38. import org.hipparchus.ode.FieldODEStateAndDerivative;
  39. import org.hipparchus.ode.FieldOrdinaryDifferentialEquation;
  40. import org.hipparchus.ode.FieldSecondaryODE;
  41. import org.hipparchus.ode.events.Action;
  42. import org.hipparchus.ode.events.FieldAdaptableInterval;
  43. import org.hipparchus.ode.events.FieldODEEventDetector;
  44. import org.hipparchus.ode.events.FieldODEEventHandler;
  45. import org.hipparchus.ode.sampling.AbstractFieldODEStateInterpolator;
  46. import org.hipparchus.ode.sampling.FieldODEStateInterpolator;
  47. import org.hipparchus.ode.sampling.FieldODEStepHandler;
  48. import org.hipparchus.util.MathArrays;
  49. import org.hipparchus.util.Precision;
  50. import org.orekit.attitudes.AttitudeProvider;
  51. import org.orekit.errors.OrekitException;
  52. import org.orekit.errors.OrekitInternalError;
  53. import org.orekit.errors.OrekitMessages;
  54. import org.orekit.frames.Frame;
  55. import org.orekit.orbits.OrbitType;
  56. import org.orekit.orbits.PositionAngleType;
  57. import org.orekit.propagation.FieldAbstractPropagator;
  58. import org.orekit.propagation.FieldBoundedPropagator;
  59. import org.orekit.propagation.FieldEphemerisGenerator;
  60. import org.orekit.propagation.FieldSpacecraftState;
  61. import org.orekit.propagation.PropagationType;
  62. import org.orekit.propagation.events.FieldEventDetector;
  63. import org.orekit.propagation.events.handlers.FieldEventHandler;
  64. import org.orekit.propagation.sampling.FieldOrekitStepHandler;
  65. import org.orekit.propagation.sampling.FieldOrekitStepInterpolator;
  66. import org.orekit.time.FieldAbsoluteDate;
  67. import org.orekit.utils.FieldArrayDictionary;


  70. /** Common handling of {@link org.orekit.propagation.FieldPropagator FieldPropagator}
  71.  *  methods for both numerical and semi-analytical propagators.
  72.  * @author Luc Maisonobe
  73.  * @param <T> type of the field element
  74.  */
  75. public abstract class FieldAbstractIntegratedPropagator<T extends CalculusFieldElement<T>> extends FieldAbstractPropagator<T> {

  77.     /** Internal name used for complete secondary state dimension.
  78.      * @since 11.1
  79.      */
  80.     private static final String SECONDARY_DIMENSION = "Orekit-secondary-dimension";

  82.     /** Event detectors not related to force models. */
  83.     private final List<FieldEventDetector<T>> detectors;

  85.     /** Step handlers dedicated to ephemeris generation. */
  86.     private final List<FieldStoringStepHandler> ephemerisGenerators;

  88.     /** Integrator selected by the user for the orbital extrapolation process. */
  89.     private final FieldODEIntegrator<T> integrator;

  91.     /** Offsets of secondary states managed by {@link AdditionalEquations}.
  92.      * @since 11.1
  93.      */
  94.     private final Map<String, Integer> secondaryOffsets;

  96.     /** Additional derivatives providers.
  97.      * @since 11.1
  98.      */
  99.     private List<FieldAdditionalDerivativesProvider<T>> additionalDerivativesProviders;

  101.     /** Counter for differential equations calls. */
  102.     private int calls;

  104.     /** Mapper between raw double components and space flight dynamics objects. */
  105.     private FieldStateMapper<T> stateMapper;

  107.     /** Flag for resetting the state at end of propagation. */
  108.     private boolean resetAtEnd;

  110.     /** Type of orbit to output (mean or osculating) <br/>
  111.      * <p>
  112.      * This is used only in the case of semi-analytical propagators where there is a clear separation between
  113.      * mean and short periodic elements. It is ignored by the Numerical propagator.
  114.      * </p>
  115.      */
  116.     private PropagationType propagationType;

  118.     /** Build a new instance.
  119.      * @param integrator numerical integrator to use for propagation.
  120.      * @param propagationType type of orbit to output (mean or osculating).
  121.      * @param field Field used by default
  122.      */
  123.     protected FieldAbstractIntegratedPropagator(final Field<T> field, final FieldODEIntegrator<T> integrator, final PropagationType propagationType) {
  124.         super(field);
  125.         detectors                      = new ArrayList<>();
  126.         ephemerisGenerators            = new ArrayList<>();
  127.         additionalDerivativesProviders = new ArrayList<>();
  128.         this.secondaryOffsets          = new HashMap<>();
  129.         this.integrator                = integrator;
  130.         this.propagationType           = propagationType;
  131.         this.resetAtEnd                = true;
  132.     }

  134.     /** Allow/disallow resetting the initial state at end of propagation.
  135.      * <p>
  136.      * By default, at the end of the propagation, the propagator resets the initial state
  137.      * to the final state, thus allowing a new propagation to be started from there without
  138.      * recomputing the part already performed. Calling this method with {@code resetAtEnd} set
  139.      * to false changes prevents such reset.
  140.      * </p>
  141.      * @param resetAtEnd if true, at end of each propagation, the {@link
  142.      * #getInitialState() initial state} will be reset to the final state of
  143.      * the propagation, otherwise the initial state will be preserved
  144.      * @since 9.0
  145.      */
  146.     public void setResetAtEnd(final boolean resetAtEnd) {
  147.         this.resetAtEnd = resetAtEnd;
  148.     }

  150.     /** Getter for the resetting flag regarding initial state.
  151.      * @return resetting flag
  152.      * @since 12.0
  153.      */
  154.     public boolean getResetAtEnd() {
  155.         return this.resetAtEnd;
  156.     }

  158.     /** Initialize the mapper.
  159.      * @param field Field used by default
  160.      */
  161.     protected void initMapper(final Field<T> field) {
  162.         final T zero = field.getZero();
  163.         stateMapper = createMapper(null, zero.add(Double.NaN), null, null, null, null);
  164.     }

  166.     /** Get the integrator's name.
  167.      * @return name of underlying integrator
  168.      * @since 12.0
  169.      */
  170.     public String getIntegratorName() {
  171.         return integrator.getName();
  172.     }

  174.     /**  {@inheritDoc} */
  175.     public void setAttitudeProvider(final AttitudeProvider attitudeProvider) {
  176.         super.setAttitudeProvider(attitudeProvider);
  177.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  178.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  179.                                    attitudeProvider, stateMapper.getFrame());
  180.     }

  182.     /** Set propagation orbit type.
  183.      * @param orbitType orbit type to use for propagation
  184.      */
  185.     protected void setOrbitType(final OrbitType orbitType) {
  186.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  187.                                    orbitType, stateMapper.getPositionAngleType(),
  188.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  189.     }

  191.     /** Get propagation parameter type.
  192.      * @return orbit type used for propagation
  193.      */
  194.     protected OrbitType getOrbitType() {
  195.         return stateMapper.getOrbitType();
  196.     }

  198.     /** Check if only the mean elements should be used in a semi-analytical propagation.
  199.      * @return {@link PropagationType MEAN} if only mean elements have to be used or
  200.      *         {@link PropagationType OSCULATING} if osculating elements have to be also used.
  201.      */
  202.     protected PropagationType isMeanOrbit() {
  203.         return propagationType;
  204.     }

  206.     /** Get the propagation type.
  207.      * @return propagation type.
  208.      * @since 11.3.2
  209.      */
  210.     public PropagationType getPropagationType() {
  211.         return propagationType;
  212.     }

  214.     /** Set position angle type.
  215.      * <p>
  216.      * The position parameter type is meaningful only if {@link
  217.      * #getOrbitType() propagation orbit type}
  218.      * support it. As an example, it is not meaningful for propagation
  219.      * in {@link OrbitType#CARTESIAN Cartesian} parameters.
  220.      * </p>
  221.      * @param positionAngleType angle type to use for propagation
  222.      */
  223.     protected void setPositionAngleType(final PositionAngleType positionAngleType) {
  224.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  225.                                    stateMapper.getOrbitType(), positionAngleType,
  226.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  227.     }

  229.     /** Get propagation parameter type.
  230.      * @return angle type to use for propagation
  231.      */
  232.     protected PositionAngleType getPositionAngleType() {
  233.         return stateMapper.getPositionAngleType();
  234.     }

  236.     /** Set the central attraction coefficient μ.
  237.      * @param mu central attraction coefficient (m³/s²)
  238.      */
  239.     public void setMu(final T mu) {
  240.         stateMapper = createMapper(stateMapper.getReferenceDate(), mu,
  241.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  242.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  243.     }

  245.     /** Get the central attraction coefficient μ.
  246.      * @return mu central attraction coefficient (m³/s²)
  247.      * @see #setMu(CalculusFieldElement)
  248.      */
  249.     public T getMu() {
  250.         return stateMapper.getMu();
  251.     }

  253.     /** Get the number of calls to the differential equations computation method.
  254.      * <p>The number of calls is reset each time the {@link #propagate(FieldAbsoluteDate)}
  255.      * method is called.</p>
  256.      * @return number of calls to the differential equations computation method
  257.      */
  258.     public int getCalls() {
  259.         return calls;
  260.     }

  262.     /** {@inheritDoc} */
  263.     @Override
  264.     public boolean isAdditionalStateManaged(final String name) {

  266.         // first look at already integrated states
  267.         if (super.isAdditionalStateManaged(name)) {
  268.             return true;
  269.         }

  271.         // then look at states we integrate ourselves
  272.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  273.             if (provider.getName().equals(name)) {
  274.                 return true;
  275.             }
  276.         }

  278.         return false;
  279.     }

  281.     /** {@inheritDoc} */
  282.     @Override
  283.     public String[] getManagedAdditionalStates() {
  284.         final String[] alreadyIntegrated = super.getManagedAdditionalStates();
  285.         final String[] managed = new String[alreadyIntegrated.length + additionalDerivativesProviders.size()];
  286.         System.arraycopy(alreadyIntegrated, 0, managed, 0, alreadyIntegrated.length);
  287.         for (int i = 0; i < additionalDerivativesProviders.size(); ++i) {
  288.             managed[i + alreadyIntegrated.length] = additionalDerivativesProviders.get(i).getName();
  289.         }
  290.         return managed;
  291.     }

  293.     /** Add a provider for user-specified state derivatives to be integrated along with the orbit propagation.
  294.      * @param provider provider for additional derivatives
  295.      * @see #addAdditionalStateProvider(org.orekit.propagation.FieldAdditionalStateProvider)
  296.      * @since 11.1
  297.      */
  298.     public void addAdditionalDerivativesProvider(final FieldAdditionalDerivativesProvider<T> provider) {
  299.         // check if the name is already used
  300.         if (isAdditionalStateManaged(provider.getName())) {
  301.             // these derivatives are already registered, complain
  302.             throw new OrekitException(OrekitMessages.ADDITIONAL_STATE_NAME_ALREADY_IN_USE,
  303.                                       provider.getName());
  304.         }

  306.         // this is really a new set of derivatives, add it
  307.         additionalDerivativesProviders.add(provider);

  309.         secondaryOffsets.clear();

  311.     }

  313.     /** Get an unmodifiable list of providers for additional derivatives.
  314.      * @return providers for additional derivatives
  315.      * @since 11.1
  316.      */
  317.     public List<FieldAdditionalDerivativesProvider<T>> getAdditionalDerivativesProviders() {
  318.         return Collections.unmodifiableList(additionalDerivativesProviders);
  319.     }

  321.     /** {@inheritDoc} */
  322.     public <D extends FieldEventDetector<T>> void addEventDetector(final D detector) {
  323.         detectors.add(detector);
  324.     }

  326.     /** {@inheritDoc} */
  327.     public Collection<FieldEventDetector<T>> getEventsDetectors() {
  328.         return Collections.unmodifiableCollection(detectors);
  329.     }

  331.     /** {@inheritDoc} */
  332.     public void clearEventsDetectors() {
  333.         detectors.clear();
  334.     }

  336.     /** Set up all user defined event detectors.
  337.      */
  338.     protected void setUpUserEventDetectors() {
  339.         for (final FieldEventDetector<T> detector : detectors) {
  340.             setUpEventDetector(integrator, detector);
  341.         }
  342.     }

  344.     /** Wrap an Orekit event detector and register it to the integrator.
  345.      * @param integ integrator into which event detector should be registered
  346.      * @param detector event detector to wrap
  347.      */
  348.     protected void setUpEventDetector(final FieldODEIntegrator<T> integ, final FieldEventDetector<T> detector) {
  349.         integ.addEventDetector(new FieldAdaptedEventDetector(detector));
  350.     }

  352.     /** {@inheritDoc} */
  353.     @Override
  354.     public FieldEphemerisGenerator<T> getEphemerisGenerator() {
  355.         final FieldStoringStepHandler storingHandler = new FieldStoringStepHandler();
  356.         ephemerisGenerators.add(storingHandler);
  357.         return storingHandler;
  358.     }

  360.     /** Create a mapper between raw double components and spacecraft state.
  361.     /** Simple constructor.
  362.      * <p>
  363.      * The position parameter type is meaningful only if {@link
  364.      * #getOrbitType() propagation orbit type}
  365.      * support it. As an example, it is not meaningful for propagation
  366.      * in {@link OrbitType#CARTESIAN Cartesian} parameters.
  367.      * </p>
  368.      * @param referenceDate reference date
  369.      * @param mu central attraction coefficient (m³/s²)
  370.      * @param orbitType orbit type to use for mapping
  371.      * @param positionAngleType angle type to use for propagation
  372.      * @param attitudeProvider attitude provider
  373.      * @param frame inertial frame
  374.      * @return new mapper
  375.      */
  376.     protected abstract FieldStateMapper<T> createMapper(FieldAbsoluteDate<T> referenceDate, T mu,
  377.                                                         OrbitType orbitType, PositionAngleType positionAngleType,
  378.                                                         AttitudeProvider attitudeProvider, Frame frame);

  380.     /** Get the differential equations to integrate (for main state only).
  381.      * @param integ numerical integrator to use for propagation.
  382.      * @return differential equations for main state
  383.      */
  384.     protected abstract MainStateEquations<T> getMainStateEquations(FieldODEIntegrator<T> integ);

  386.     /** {@inheritDoc} */
  387.     public FieldSpacecraftState<T> propagate(final FieldAbsoluteDate<T> target) {
  388.         if (getStartDate() == null) {
  389.             if (getInitialState() == null) {
  390.                 throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  391.             }
  392.             setStartDate(getInitialState().getDate());
  393.         }
  394.         return propagate(getStartDate(), target);
  395.     }

  397.     /** {@inheritDoc} */
  398.     public FieldSpacecraftState<T> propagate(final FieldAbsoluteDate<T> tStart, final FieldAbsoluteDate<T> tEnd) {

  400.         if (getInitialState() == null) {
  401.             throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  402.         }

  404.         // make sure the integrator will be reset properly even if we change its events handlers and step handlers
  405.         try (IntegratorResetter<T> resetter = new IntegratorResetter<>(integrator)) {

  407.             // Initialize additional states
  408.             initializeAdditionalStates(tEnd);

  410.             if (!tStart.equals(getInitialState().getDate())) {
  411.                 // if propagation start date is not initial date,
  412.                 // propagate from initial to start date without event detection
  413.                 try (IntegratorResetter<T> startResetter = new IntegratorResetter<>(integrator)) {
  414.                     integrateDynamics(tStart);
  415.                 }
  416.             }

  418.             // set up events added by user
  419.             setUpUserEventDetectors();

  421.             // set up step handlers
  422.             for (final FieldOrekitStepHandler<T> handler : getMultiplexer().getHandlers()) {
  423.                 integrator.addStepHandler(new FieldAdaptedStepHandler(handler));
  424.             }
  425.             for (final FieldStoringStepHandler generator : ephemerisGenerators) {
  426.                 generator.setEndDate(tEnd);
  427.                 integrator.addStepHandler(generator);
  428.             }

  430.             // propagate from start date to end date with event detection
  431.             return integrateDynamics(tEnd);

  433.         }

  435.     }

  437.     /** Propagation with or without event detection.
  438.      * @param tEnd target date to which orbit should be propagated
  439.      * @return state at end of propagation
  440.      */
  441.     private FieldSpacecraftState<T> integrateDynamics(final FieldAbsoluteDate<T> tEnd) {
  442.         try {

  444.             initializePropagation();

  446.             if (getInitialState().getDate().equals(tEnd)) {
  447.                 // don't extrapolate
  448.                 return getInitialState();
  449.             }
  450.             // space dynamics view
  451.             stateMapper = createMapper(getInitialState().getDate(), stateMapper.getMu(),
  452.                                        stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  453.                                        stateMapper.getAttitudeProvider(), getInitialState().getFrame());


  456.             // set propagation orbit type
  457.             //final FieldOrbit<T> initialOrbit = stateMapper.getOrbitType().convertType(getInitialState().getOrbit());
  458.             if (Double.isNaN(getMu().getReal())) {
  459.                 setMu(getInitialState().getMu());
  460.             }
  461.             if (getInitialState().getMass().getReal() <= 0.0) {
  462.                 throw new OrekitException(OrekitMessages.NOT_POSITIVE_SPACECRAFT_MASS,
  463.                                                getInitialState().getMass());
  464.             }

  466.             // convert space flight dynamics API to math API
  467.             final FieldSpacecraftState<T> initialIntegrationState = getInitialIntegrationState();
  468.             final FieldODEState<T> mathInitialState = createInitialState(initialIntegrationState);
  469.             final FieldExpandableODE<T> mathODE = createODE(integrator);

  471.             // mathematical integration
  472.             final FieldODEStateAndDerivative<T> mathFinalState;
  473.             beforeIntegration(initialIntegrationState, tEnd);
  474.             mathFinalState = integrator.integrate(mathODE, mathInitialState,
  475.                                                   tEnd.durationFrom(getInitialState().getDate()));

  477.             afterIntegration();

  479.             // get final state
  480.             FieldSpacecraftState<T> finalState =
  481.                             stateMapper.mapArrayToState(stateMapper.mapDoubleToDate(mathFinalState.getTime(), tEnd),
  482.                                                         mathFinalState.getPrimaryState(),
  483.                                                         mathFinalState.getPrimaryDerivative(),
  484.                                                         propagationType);
  485.             if (!additionalDerivativesProviders.isEmpty()) {
  486.                 final T[] secondary            = mathFinalState.getSecondaryState(1);
  487.                 final T[] secondaryDerivatives = mathFinalState.getSecondaryDerivative(1);
  488.                 for (FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  489.                     final String   name        = provider.getName();
  490.                     final int      offset      = secondaryOffsets.get(name);
  491.                     final int      dimension   = provider.getDimension();
  492.                     finalState = finalState.
  493.                                  addAdditionalState(name, Arrays.copyOfRange(secondary, offset, offset + dimension)).
  494.                                  addAdditionalStateDerivative(name, Arrays.copyOfRange(secondaryDerivatives, offset, offset + dimension));
  495.                 }
  496.             }
  497.             finalState = updateAdditionalStates(finalState);

  499.             if (resetAtEnd) {
  500.                 resetInitialState(finalState);
  501.                 setStartDate(finalState.getDate());
  502.             }

  504.             return finalState;

  506.         } catch (OrekitException pe) {
  507.             throw pe;
  508.         } catch (MathIllegalArgumentException | MathIllegalStateException me) {
  509.             throw OrekitException.unwrap(me);
  510.         }
  511.     }

  513.     /** Get the initial state for integration.
  514.      * @return initial state for integration
  515.      */
  516.     protected FieldSpacecraftState<T> getInitialIntegrationState() {
  517.         return getInitialState();
  518.     }

  520.     /** Create an initial state.
  521.      * @param initialState initial state in flight dynamics world
  522.      * @return initial state in mathematics world
  523.      */
  524.     private FieldODEState<T> createInitialState(final FieldSpacecraftState<T> initialState) {

  526.         // retrieve initial state
  527.         final T[] primary  = MathArrays.buildArray(initialState.getA().getField(), getBasicDimension());
  528.         stateMapper.mapStateToArray(initialState, primary, null);

  530.         if (secondaryOffsets.isEmpty()) {
  531.             // compute dimension of the secondary state
  532.             int offset = 0;
  533.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  534.                 secondaryOffsets.put(provider.getName(), offset);
  535.                 offset += provider.getDimension();
  536.             }
  537.             secondaryOffsets.put(SECONDARY_DIMENSION, offset);
  538.         }

  540.         return new FieldODEState<>(initialState.getA().getField().getZero(), primary, secondary(initialState));

  542.     }

  544.     /** Create secondary state.
  545.      * @param state spacecraft state
  546.      * @return secondary state
  547.      * @since 11.1
  548.      */
  549.     private T[][] secondary(final FieldSpacecraftState<T> state) {

  551.         if (secondaryOffsets.isEmpty()) {
  552.             return null;
  553.         }

  555.         final T[][] secondary = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  556.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  557.             final String name       = provider.getName();
  558.             final int    offset     = secondaryOffsets.get(name);
  559.             final T[]    additional = state.getAdditionalState(name);
  560.             System.arraycopy(additional, 0, secondary[0], offset, additional.length);
  561.         }

  563.         return secondary;

  565.     }

  567.     /** Create secondary state derivative.
  568.      * @param state spacecraft state
  569.      * @return secondary state derivative
  570.      * @since 11.1
  571.      */
  572.     private T[][] secondaryDerivative(final FieldSpacecraftState<T> state) {

  574.         if (secondaryOffsets.isEmpty()) {
  575.             return null;
  576.         }

  578.         final T[][] secondaryDerivative = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  579.         for (final FieldAdditionalDerivativesProvider<T> providcer : additionalDerivativesProviders) {
  580.             final String name       = providcer.getName();
  581.             final int    offset     = secondaryOffsets.get(name);
  582.             final T[]    additionalDerivative = state.getAdditionalStateDerivative(name);
  583.             System.arraycopy(additionalDerivative, 0, secondaryDerivative[0], offset, additionalDerivative.length);
  584.         }

  586.         return secondaryDerivative;

  588.     }

  590.     /** Create an ODE with all equations.
  591.      * @param integ numerical integrator to use for propagation.
  592.      * @return a new ode
  593.      */
  594.     private FieldExpandableODE<T> createODE(final FieldODEIntegrator<T> integ) {

  596.         final FieldExpandableODE<T> ode =
  597.                 new FieldExpandableODE<>(new ConvertedMainStateEquations(getMainStateEquations(integ)));

  599.         // secondary part of the ODE
  600.         if (!additionalDerivativesProviders.isEmpty()) {
  601.             ode.addSecondaryEquations(new ConvertedSecondaryStateEquations());
  602.         }

  604.         return ode;

  606.     }

  608.     /** Method called just before integration.
  609.      * <p>
  610.      * The default implementation does nothing, it may be specialized in subclasses.
  611.      * </p>
  612.      * @param initialState initial state
  613.      * @param tEnd target date at which state should be propagated
  614.      */
  615.     protected void beforeIntegration(final FieldSpacecraftState<T> initialState,
  616.                                      final FieldAbsoluteDate<T> tEnd) {
  617.         // do nothing by default
  618.     }

  620.     /** Method called just after integration.
  621.      * <p>
  622.      * The default implementation does nothing, it may be specialized in subclasses.
  623.      * </p>
  624.      */
  625.     protected void afterIntegration() {
  626.         // do nothing by default
  627.     }

  629.     /** Get state vector dimension without additional parameters.
  630.      * @return state vector dimension without additional parameters.
  631.      */
  632.     public int getBasicDimension() {
  633.         return 7;

  635.     }

  637.     /** Get the integrator used by the propagator.
  638.      * @return the integrator.
  639.      */
  640.     protected FieldODEIntegrator<T> getIntegrator() {
  641.         return integrator;
  642.     }

  644.     /** Convert a state from mathematical world to space flight dynamics world.
  645.      * @param os mathematical state
  646.      * @return space flight dynamics state
  647.      */
  648.     private FieldSpacecraftState<T> convert(final FieldODEStateAndDerivative<T> os) {

  650.         FieldSpacecraftState<T> s =
  651.                         stateMapper.mapArrayToState(os.getTime(),
  652.                                                     os.getPrimaryState(),
  653.                                                     os.getPrimaryDerivative(),
  654.                                                     propagationType);
  655.         if (os.getNumberOfSecondaryStates() > 0) {
  656.             final T[] secondary           = os.getSecondaryState(1);
  657.             final T[] secondaryDerivative = os.getSecondaryDerivative(1);
  658.             for (final FieldAdditionalDerivativesProvider<T> equations : additionalDerivativesProviders) {
  659.                 final String name      = equations.getName();
  660.                 final int    offset    = secondaryOffsets.get(name);
  661.                 final int    dimension = equations.getDimension();
  662.                 s = s.addAdditionalState(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  663.                 s = s.addAdditionalStateDerivative(name, Arrays.copyOfRange(secondaryDerivative, offset, offset + dimension));
  664.             }
  665.         }
  666.         s = updateAdditionalStates(s);

  668.         return s;

  670.     }

  672.     /** Convert a state from space flight dynamics world to mathematical world.
  673.      * @param state space flight dynamics state
  674.      * @return mathematical state
  675.      */
  676.     private FieldODEStateAndDerivative<T> convert(final FieldSpacecraftState<T> state) {

  678.         // retrieve initial state
  679.         final T[] primary    = MathArrays.buildArray(getField(), getBasicDimension());
  680.         final T[] primaryDot = MathArrays.buildArray(getField(), getBasicDimension());
  681.         stateMapper.mapStateToArray(state, primary, primaryDot);

  683.         // secondary part of the ODE
  684.         final T[][] secondary           = secondary(state);
  685.         final T[][] secondaryDerivative = secondaryDerivative(state);

  687.         return new FieldODEStateAndDerivative<>(stateMapper.mapDateToDouble(state.getDate()),
  688.                                                 primary, primaryDot,
  689.                                                 secondary, secondaryDerivative);

  691.     }

  693.     /** Differential equations for the main state (orbit, attitude and mass).
  694.      * @param <T> type of the field element
  695.      */
  696.     public interface MainStateEquations<T extends CalculusFieldElement<T>> {

  698.         /**
  699.          * Initialize the equations at the start of propagation. This method will be
  700.          * called before any calls to {@link #computeDerivatives(FieldSpacecraftState)}.
  701.          *
  702.          * <p> The default implementation of this method does nothing.
  703.          *
  704.          * @param initialState initial state information at the start of propagation.
  705.          * @param target       date of propagation. Not equal to {@code
  706.          *                     initialState.getDate()}.
  707.          */
  708.         void init(FieldSpacecraftState<T> initialState, FieldAbsoluteDate<T> target);

  710.         /** Compute differential equations for main state.
  711.          * @param state current state
  712.          * @return derivatives of main state
  713.          */
  714.         T[] computeDerivatives(FieldSpacecraftState<T> state);

  716.     }

  718.     /** Differential equations for the main state (orbit, attitude and mass), with converted API. */
  719.     private class ConvertedMainStateEquations implements FieldOrdinaryDifferentialEquation<T> {

  721.         /** Main state equations. */
  722.         private final MainStateEquations<T> main;

  724.         /** Simple constructor.
  725.          * @param main main state equations
  726.          */
  727.         ConvertedMainStateEquations(final MainStateEquations<T> main) {
  728.             this.main = main;
  729.             calls = 0;
  730.         }

  732.         /** {@inheritDoc} */
  733.         public int getDimension() {
  734.             return getBasicDimension();
  735.         }

  737.         @Override
  738.         public void init(final T t0, final T[] y0, final T finalTime) {
  739.             // update space dynamics view
  740.             FieldSpacecraftState<T> initialState = stateMapper.mapArrayToState(t0, y0, null, PropagationType.MEAN);
  741.             initialState = updateAdditionalStates(initialState);
  742.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  743.             main.init(initialState, target);
  744.         }
  745.         /** {@inheritDoc} */
  746.         public T[] computeDerivatives(final T t, final T[] y) {

  748.             // increment calls counter
  749.             ++calls;

  751.             // update space dynamics view
  752.             FieldSpacecraftState<T> currentState = stateMapper.mapArrayToState(t, y, null, PropagationType.MEAN);
  753.             currentState = updateAdditionalStates(currentState);

  755.             // compute main state differentials
  756.             return main.computeDerivatives(currentState);

  758.         }

  760.     }

  762.     /** Differential equations for the secondary state (Jacobians, user variables ...), with converted API. */
  763.     private class ConvertedSecondaryStateEquations implements FieldSecondaryODE<T> {

  765.         /** Dimension of the combined additional states. */
  766.         private final int combinedDimension;

  768.         /** Simple constructor.
  769.          */
  770.         ConvertedSecondaryStateEquations() {
  771.             this.combinedDimension = secondaryOffsets.get(SECONDARY_DIMENSION);
  772.         }

  774.         /** {@inheritDoc} */
  775.         @Override
  776.         public int getDimension() {
  777.             return combinedDimension;
  778.         }

  780.         /** {@inheritDoc} */
  781.         @Override
  782.         public void init(final T t0, final T[] primary0,
  783.                          final T[] secondary0, final T finalTime) {
  784.             // update space dynamics view
  785.             final FieldSpacecraftState<T> initialState = convert(t0, primary0, null, secondary0);

  787.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  788.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  789.                 provider.init(initialState, target);
  790.             }

  792.         }

  794.         /** {@inheritDoc} */
  795.         @Override
  796.         public T[] computeDerivatives(final T t, final T[] primary,
  797.                                       final T[] primaryDot, final T[] secondary) {

  799.             // update space dynamics view
  800.             // the integrable generators generate method will be called here,
  801.             // according to the generators yield order
  802.             FieldSpacecraftState<T> updated = convert(t, primary, primaryDot, secondary);

  804.             // set up queue for equations
  805.             final Queue<FieldAdditionalDerivativesProvider<T>> pending = new LinkedList<>(additionalDerivativesProviders);

  807.             // gather the derivatives from all additional equations, taking care of dependencies
  808.             final T[] secondaryDot = MathArrays.buildArray(t.getField(), combinedDimension);
  809.             int yieldCount = 0;
  810.             while (!pending.isEmpty()) {
  811.                 final FieldAdditionalDerivativesProvider<T> equations = pending.remove();
  812.                 if (equations.yields(updated)) {
  813.                     // these equations have to wait for another set,
  814.                     // we put them again in the pending queue
  815.                     pending.add(equations);
  816.                     if (++yieldCount >= pending.size()) {
  817.                         // all pending equations yielded!, they probably need data not yet initialized
  818.                         // we let the propagation proceed, if these data are really needed right now
  819.                         // an appropriate exception will be triggered when caller tries to access them
  820.                         break;
  821.                     }
  822.                 } else {
  823.                     // we can use these equations right now
  824.                     final String                      name           = equations.getName();
  825.                     final int                         offset         = secondaryOffsets.get(name);
  826.                     final int                         dimension      = equations.getDimension();
  827.                     final FieldCombinedDerivatives<T> derivatives    = equations.combinedDerivatives(updated);
  828.                     final T[]                         additionalPart = derivatives.getAdditionalDerivatives();
  829.                     final T[]                         mainPart       = derivatives.getMainStateDerivativesIncrements();
  830.                     System.arraycopy(additionalPart, 0, secondaryDot, offset, dimension);
  831.                     updated = updated.addAdditionalStateDerivative(name, additionalPart);
  832.                     if (mainPart != null) {
  833.                         // this equation does change the main state derivatives
  834.                         for (int i = 0; i < mainPart.length; ++i) {
  835.                             primaryDot[i] = primaryDot[i].add(mainPart[i]);
  836.                         }
  837.                     }
  838.                     yieldCount = 0;
  839.                 }
  840.             }

  842.             return secondaryDot;

  844.         }

  846.         /** Convert mathematical view to space view.
  847.          * @param t current value of the independent <I>time</I> variable
  848.          * @param primary array containing the current value of the primary state vector
  849.          * @param primaryDot array containing the derivative of the primary state vector
  850.          * @param secondary array containing the current value of the secondary state vector
  851.          * @return space view of the state
  852.          */
  853.         private FieldSpacecraftState<T> convert(final T t, final T[] primary,
  854.                                                 final T[] primaryDot, final T[] secondary) {

  856.             FieldSpacecraftState<T> initialState = stateMapper.mapArrayToState(t, primary, primaryDot, PropagationType.MEAN);

  858.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  859.                 final String name      = provider.getName();
  860.                 final int    offset    = secondaryOffsets.get(name);
  861.                 final int    dimension = provider.getDimension();
  862.                 initialState = initialState.addAdditionalState(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  863.             }

  865.             return updateAdditionalStates(initialState);

  867.         }

  869.     }

  871.     /** Adapt an {@link org.orekit.propagation.events.FieldEventDetector<T>}
  872.      * to Hipparchus {@link org.hipparchus.ode.events.FieldODEEventDetector<T>} interface.
  873.      * @param <T> class type for the generic version
  874.      * @author Fabien Maussion
  875.      */
  876.     private class FieldAdaptedEventDetector implements FieldODEEventDetector<T> {

  878.         /** Underlying event detector. */
  879.         private final FieldEventDetector<T> detector;

  881.         /** Underlying event handler.
  882.          * @since 12.0
  883.          */
  884.         private final FieldEventHandler<T> handler;

  886.         /** Time of the previous call to g. */
  887.         private T lastT;

  889.         /** Value from the previous call to g. */
  890.         private T lastG;

  892.         /** Build a wrapped event detector.
  893.          * @param detector event detector to wrap
  894.         */
  895.         FieldAdaptedEventDetector(final FieldEventDetector<T> detector) {
  896.             this.detector = detector;
  897.             this.handler  = detector.getHandler();
  898.             this.lastT    = getField().getZero().add(Double.NaN);
  899.             this.lastG    = getField().getZero().add(Double.NaN);
  900.         }

  902.         /** {@inheritDoc} */
  903.         @Override
  904.         public FieldAdaptableInterval<T> getMaxCheckInterval() {
  905.             return s -> detector.getMaxCheckInterval().currentInterval(convert(s));
  906.         }

  908.         /** {@inheritDoc} */
  909.         @Override
  910.         public int getMaxIterationCount() {
  911.             return detector.getMaxIterationCount();
  912.         }

  914.         /** {@inheritDoc} */
  915.         @Override
  916.         public FieldBracketingNthOrderBrentSolver<T> getSolver() {
  917.             final T zero = detector.getThreshold().getField().getZero();
  918.             return new FieldBracketingNthOrderBrentSolver<>(zero, detector.getThreshold(), zero, 5);
  919.         }

  921.         /** {@inheritDoc} */
  922.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  923.             detector.init(convert(s0), stateMapper.mapDoubleToDate(t));
  924.             this.lastT = getField().getZero().add(Double.NaN);
  925.             this.lastG = getField().getZero().add(Double.NaN);
  926.         }

  928.         /** {@inheritDoc} */
  929.         public T g(final FieldODEStateAndDerivative<T> s) {
  930.             if (!Precision.equals(lastT.getReal(), s.getTime().getReal(), 0)) {
  931.                 lastT = s.getTime();
  932.                 lastG = detector.g(convert(s));
  933.             }
  934.             return lastG;
  935.         }

  937.         /** {@inheritDoc} */
  938.         public FieldODEEventHandler<T> getHandler() {

  940.             return new FieldODEEventHandler<T>() {

  942.                 /** {@inheritDoc} */
  943.                 public Action eventOccurred(final FieldODEStateAndDerivative<T> s,
  944.                                             final FieldODEEventDetector<T> d,
  945.                                             final boolean increasing) {
  946.                     return handler.eventOccurred(convert(s), detector, increasing);
  947.                 }

  949.                 /** {@inheritDoc} */
  950.                 public FieldODEState<T> resetState(final FieldODEEventDetector<T> d,
  951.                                                    final FieldODEStateAndDerivative<T> s) {

  953.                     final FieldSpacecraftState<T> oldState = convert(s);
  954.                     final FieldSpacecraftState<T> newState = handler.resetState(detector, oldState);
  955.                     stateChanged(newState);

  957.                     // main part
  958.                     final T[] primary    = MathArrays.buildArray(getField(), s.getPrimaryStateDimension());
  959.                     stateMapper.mapStateToArray(newState, primary, null);

  961.                     // secondary part
  962.                     final T[][] secondary = MathArrays.buildArray(getField(), 1, additionalDerivativesProviders.size());
  963.                     for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  964.                         final String name      = provider.getName();
  965.                         final int    offset    = secondaryOffsets.get(name);
  966.                         final int    dimension = provider.getDimension();
  967.                         System.arraycopy(newState.getAdditionalState(name), 0, secondary[0], offset, dimension);
  968.                     }

  970.                     return new FieldODEState<>(newState.getDate().durationFrom(getStartDate()),
  971.                                                primary, secondary);
  972.                 }
  973.             };

  975.         }

  977.     }

  979.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepHandler<T>}
  980.      * to Hipparchus {@link FieldODEStepHandler<T>} interface.
  981.      * @author Luc Maisonobe
  982.      */
  983.     private class FieldAdaptedStepHandler implements FieldODEStepHandler<T> {

  985.         /** Underlying handler. */
  986.         private final FieldOrekitStepHandler<T> handler;

  988.         /** Build an instance.
  989.          * @param handler underlying handler to wrap
  990.          */
  991.         FieldAdaptedStepHandler(final FieldOrekitStepHandler<T> handler) {
  992.             this.handler = handler;
  993.         }

  995.         /** {@inheritDoc} */
  996.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  997.             handler.init(convert(s0), stateMapper.mapDoubleToDate(t));
  998.         }

  1000.         /** {@inheritDoc} */
  1001.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  1002.             handler.handleStep(new FieldAdaptedStepInterpolator(interpolator));
  1003.         }

  1005.         /** {@inheritDoc} */
  1006.         @Override
  1007.         public void finish(final FieldODEStateAndDerivative<T> finalState) {
  1008.             handler.finish(convert(finalState));
  1009.         }

  1011.     }

  1013.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepInterpolator<T>}
  1014.      * to Hipparchus {@link FieldODEStepInterpolator<T>} interface.
  1015.      * @author Luc Maisonobe
  1016.      */
  1017.     private class FieldAdaptedStepInterpolator implements FieldOrekitStepInterpolator<T> {

  1019.         /** Underlying raw rawInterpolator. */
  1020.         private final FieldODEStateInterpolator<T> mathInterpolator;

  1022.         /** Build an instance.
  1023.          * @param mathInterpolator underlying raw interpolator
  1024.          */
  1025.         FieldAdaptedStepInterpolator(final FieldODEStateInterpolator<T> mathInterpolator) {
  1026.             this.mathInterpolator = mathInterpolator;
  1027.         }

  1029.         /** {@inheritDoc}} */
  1030.         @Override
  1031.         public FieldSpacecraftState<T> getPreviousState() {
  1032.             return convert(mathInterpolator.getPreviousState());
  1033.         }

  1035.         /** {@inheritDoc}} */
  1036.         @Override
  1037.         public FieldSpacecraftState<T> getCurrentState() {
  1038.             return convert(mathInterpolator.getCurrentState());
  1039.         }

  1041.         /** {@inheritDoc}} */
  1042.         @Override
  1043.         public FieldSpacecraftState<T> getInterpolatedState(final FieldAbsoluteDate<T> date) {
  1044.             return convert(mathInterpolator.getInterpolatedState(date.durationFrom(getStartDate())));
  1045.         }

  1047.         /** Check is integration direction is forward in date.
  1048.          * @return true if integration is forward in date
  1049.          */
  1050.         public boolean isForward() {
  1051.             return mathInterpolator.isForward();
  1052.         }

  1054.         /** {@inheritDoc}} */
  1055.         @Override
  1056.         public FieldAdaptedStepInterpolator restrictStep(final FieldSpacecraftState<T> newPreviousState,
  1057.                                                          final FieldSpacecraftState<T> newCurrentState) {
  1058.             try {
  1059.                 final AbstractFieldODEStateInterpolator<T> aosi = (AbstractFieldODEStateInterpolator<T>) mathInterpolator;
  1060.                 return new FieldAdaptedStepInterpolator(aosi.restrictStep(convert(newPreviousState),
  1061.                                                                           convert(newCurrentState)));
  1062.             } catch (ClassCastException cce) {
  1063.                 // this should never happen
  1064.                 throw new OrekitInternalError(cce);
  1065.             }
  1066.         }

  1068.     }

  1070.     /** Specialized step handler storing interpolators for ephemeris generation.
  1071.      * @since 11.0
  1072.      */
  1073.     private class FieldStoringStepHandler implements FieldODEStepHandler<T>, FieldEphemerisGenerator<T> {

  1075.         /** Underlying raw mathematical model. */
  1076.         private FieldDenseOutputModel<T> model;

  1078.         /** the user supplied end date. Propagation may not end on this date. */
  1079.         private FieldAbsoluteDate<T> endDate;

  1081.         /** Generated ephemeris. */
  1082.         private FieldBoundedPropagator<T> ephemeris;

  1084.         /** Last interpolator handled by the object.*/
  1085.         private  FieldODEStateInterpolator<T> lastInterpolator;

  1087.         /** Set the end date.
  1088.          * @param endDate end date
  1089.          */
  1090.         public void setEndDate(final FieldAbsoluteDate<T> endDate) {
  1091.             this.endDate = endDate;
  1092.         }

  1094.         /** {@inheritDoc} */
  1095.         @Override
  1096.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  1097.             this.model = new FieldDenseOutputModel<>();
  1098.             model.init(s0, t);

  1100.             // ephemeris will be generated when last step is processed
  1101.             this.ephemeris = null;

  1103.             this.lastInterpolator = null;

  1105.         }

  1107.         /** {@inheritDoc} */
  1108.         @Override
  1109.         public FieldBoundedPropagator<T> getGeneratedEphemeris() {
  1110.             // Each time we try to get the ephemeris, rebuild it using the last data.
  1111.             buildEphemeris();
  1112.             return ephemeris;
  1113.         }

  1115.         /** {@inheritDoc} */
  1116.         @Override
  1117.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  1118.             model.handleStep(interpolator);
  1119.             lastInterpolator = interpolator;
  1120.         }

  1122.         /** {@inheritDoc} */
  1123.         @Override
  1124.         public void finish(final FieldODEStateAndDerivative<T> finalState) {
  1125.             buildEphemeris();
  1126.         }

  1128.         /** Method used to produce ephemeris at a given time.
  1129.          * Can be used at multiple times, updating the ephemeris to
  1130.          * its last state.
  1131.          */
  1132.         private void buildEphemeris() {
  1133.             // buildEphemeris was built in order to allow access to what was previously the finish method.
  1134.             // This now allows to call it through getGeneratedEphemeris, therefore through an external call,
  1135.             // which was not previously the case.

  1137.             // Update the model's finalTime with the last interpolator.
  1138.             model.finish(lastInterpolator.getCurrentState());

  1140.             // set up the boundary dates
  1141.             final T tI = model.getInitialTime();
  1142.             final T tF = model.getFinalTime();
  1143.             // tI is almost? always zero
  1144.             final FieldAbsoluteDate<T> startDate =
  1145.                             stateMapper.mapDoubleToDate(tI);
  1146.             final FieldAbsoluteDate<T> finalDate =
  1147.                             stateMapper.mapDoubleToDate(tF, this.endDate);
  1148.             final FieldAbsoluteDate<T> minDate;
  1149.             final FieldAbsoluteDate<T> maxDate;
  1150.             if (tF.getReal() < tI.getReal()) {
  1151.                 minDate = finalDate;
  1152.                 maxDate = startDate;
  1153.             } else {
  1154.                 minDate = startDate;
  1155.                 maxDate = finalDate;
  1156.             }

  1158.             // get the initial additional states that are not managed
  1159.             final FieldArrayDictionary<T> unmanaged = new FieldArrayDictionary<>(startDate.getField());
  1160.             for (final FieldArrayDictionary<T>.Entry initial : getInitialState().getAdditionalStatesValues().getData()) {
  1161.                 if (!isAdditionalStateManaged(initial.getKey())) {
  1162.                     // this additional state was in the initial state, but is unknown to the propagator
  1163.                     // we simply copy its initial value as is
  1164.                     unmanaged.put(initial.getKey(), initial.getValue());
  1165.                 }
  1166.             }

  1168.             // get the names of additional states managed by differential equations
  1169.             final String[] names      = new String[additionalDerivativesProviders.size()];
  1170.             final int[]    dimensions = new int[additionalDerivativesProviders.size()];
  1171.             for (int i = 0; i < names.length; ++i) {
  1172.                 names[i] = additionalDerivativesProviders.get(i).getName();
  1173.                 dimensions[i] = additionalDerivativesProviders.get(i).getDimension();
  1174.             }

  1176.             // create the ephemeris
  1177.             ephemeris = new FieldIntegratedEphemeris<>(startDate, minDate, maxDate,
  1178.                                                        stateMapper, propagationType, model,
  1179.                                                        unmanaged, getAdditionalStateProviders(),
  1180.                                                        names, dimensions);

  1182.         }

  1184.     }

  1186.     /** Wrapper for resetting an integrator handlers.
  1187.      * <p>
  1188.      * This class is intended to be used in a try-with-resource statement.
  1189.      * If propagator-specific event handlers and step handlers are added to
  1190.      * the integrator in the try block, they will be removed automatically
  1191.      * when leaving the block, so the integrator only keep its own handlers
  1192.      * between calls to {@link AbstractIntegratedPropagator#propagate(FieldAbsoluteDate, FieldAbsoluteDate).
  1193.      * </p>
  1194.      * @param <T> the type of the field elements
  1195.      * @since 11.0
  1196.      */
  1197.     private static class IntegratorResetter<T extends CalculusFieldElement<T>> implements AutoCloseable {

  1199.         /** Wrapped integrator. */
  1200.         private final FieldODEIntegrator<T> integrator;

  1202.         /** Initial event detectors list. */
  1203.         private final List<FieldODEEventDetector<T>> detectors;

  1205.         /** Initial step handlers list. */
  1206.         private final List<FieldODEStepHandler<T>> stepHandlers;

  1208.         /** Simple constructor.
  1209.          * @param integrator wrapped integrator
  1210.          */
  1211.         IntegratorResetter(final FieldODEIntegrator<T> integrator) {
  1212.             this.integrator   = integrator;
  1213.             this.detectors    = new ArrayList<>(integrator.getEventDetectors());
  1214.             this.stepHandlers = new ArrayList<>(integrator.getStepHandlers());
  1215.         }

  1217.         /** {@inheritDoc}
  1218.          * <p>
  1219.          * Reset event handlers and step handlers back to the initial list
  1220.          * </p>
  1221.          */
  1222.         @Override
  1223.         public void close() {

  1225.             // reset event handlers
  1226.             integrator.clearEventDetectors();
  1227.             detectors.forEach(integrator::addEventDetector);

  1229.             // reset step handlers
  1230.             integrator.clearStepHandlers();
  1231.             stepHandlers.forEach(integrator::addStepHandler);

  1233.         }

  1235.     }

  1237. }
Created with JaCoCo 0.8.11.202310140853