FieldAbstractIntegratedPropagator.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.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.exception.MathIllegalArgumentException;
  32. import org.hipparchus.exception.MathIllegalStateException;
  33. import org.hipparchus.ode.FieldDenseOutputModel;
  34. import org.hipparchus.ode.FieldExpandableODE;
  35. import org.hipparchus.ode.FieldODEIntegrator;
  36. import org.hipparchus.ode.FieldODEState;
  37. import org.hipparchus.ode.FieldODEStateAndDerivative;
  38. import org.hipparchus.ode.FieldOrdinaryDifferentialEquation;
  39. import org.hipparchus.ode.FieldSecondaryODE;
  40. import org.hipparchus.ode.events.Action;
  41. import org.hipparchus.ode.events.FieldEventHandlerConfiguration;
  42. import org.hipparchus.ode.events.FieldODEEventHandler;
  43. import org.hipparchus.ode.sampling.AbstractFieldODEStateInterpolator;
  44. import org.hipparchus.ode.sampling.FieldODEStateInterpolator;
  45. import org.hipparchus.ode.sampling.FieldODEStepHandler;
  46. import org.hipparchus.util.MathArrays;
  47. import org.hipparchus.util.Precision;
  48. import org.orekit.attitudes.AttitudeProvider;
  49. import org.orekit.errors.OrekitException;
  50. import org.orekit.errors.OrekitInternalError;
  51. import org.orekit.errors.OrekitMessages;
  52. import org.orekit.frames.Frame;
  53. import org.orekit.orbits.OrbitType;
  54. import org.orekit.orbits.PositionAngle;
  55. import org.orekit.propagation.FieldAbstractPropagator;
  56. import org.orekit.propagation.FieldBoundedPropagator;
  57. import org.orekit.propagation.FieldEphemerisGenerator;
  58. import org.orekit.propagation.FieldSpacecraftState;
  59. import org.orekit.propagation.PropagationType;
  60. import org.orekit.propagation.events.FieldEventDetector;
  61. import org.orekit.propagation.sampling.FieldOrekitStepHandler;
  62. import org.orekit.propagation.sampling.FieldOrekitStepInterpolator;
  63. import org.orekit.time.FieldAbsoluteDate;
  64. import org.orekit.utils.FieldArrayDictionary;


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

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

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

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

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

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

  93.     /** Additional derivatives providers.
  94.      * @since 11.1
  95.      */
  96.     private List<FieldAdditionalDerivativesProvider<T>> additionalDerivativesProviders;

  98.     /** Counter for differential equations calls. */
  99.     private int calls;

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

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

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

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

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

  147.     /** Initialize the mapper.
  148.      * @param field Field used by default
  149.      */
  150.     protected void initMapper(final Field<T> field) {
  151.         final T zero = field.getZero();
  152.         stateMapper = createMapper(null, zero.add(Double.NaN), null, null, null, null);
  153.     }

  155.     /**  {@inheritDoc} */
  156.     public void setAttitudeProvider(final AttitudeProvider attitudeProvider) {
  157.         super.setAttitudeProvider(attitudeProvider);
  158.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  159.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  160.                                    attitudeProvider, stateMapper.getFrame());
  161.     }

  163.     /** Set propagation orbit type.
  164.      * @param orbitType orbit type to use for propagation
  165.      */
  166.     protected void setOrbitType(final OrbitType orbitType) {
  167.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  168.                                    orbitType, stateMapper.getPositionAngleType(),
  169.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  170.     }

  172.     /** Get propagation parameter type.
  173.      * @return orbit type used for propagation
  174.      */
  175.     protected OrbitType getOrbitType() {
  176.         return stateMapper.getOrbitType();
  177.     }

  179.     /** Check if only the mean elements should be used in a semianalitical propagation.
  180.      * @return {@link PropagationType MEAN} if only mean elements have to be used or
  181.      *         {@link PropagationType OSCULATING} if osculating elements have to be also used.
  182.      */
  183.     protected PropagationType isMeanOrbit() {
  184.         return propagationType;
  185.     }

  187.     /** Get the propagation type.
  188.      * @return propagation type.
  189.      * @since 11.3.2
  190.      */
  191.     public PropagationType getPropagationType() {
  192.         return propagationType;
  193.     }

  195.     /** Set position angle type.
  196.      * <p>
  197.      * The position parameter type is meaningful only if {@link
  198.      * #getOrbitType() propagation orbit type}
  199.      * support it. As an example, it is not meaningful for propagation
  200.      * in {@link OrbitType#CARTESIAN Cartesian} parameters.
  201.      * </p>
  202.      * @param positionAngleType angle type to use for propagation
  203.      */
  204.     protected void setPositionAngleType(final PositionAngle positionAngleType) {
  205.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  206.                                    stateMapper.getOrbitType(), positionAngleType,
  207.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  208.     }

  210.     /** Get propagation parameter type.
  211.      * @return angle type to use for propagation
  212.      */
  213.     protected PositionAngle getPositionAngleType() {
  214.         return stateMapper.getPositionAngleType();
  215.     }

  217.     /** Set the central attraction coefficient μ.
  218.      * @param mu central attraction coefficient (m³/s²)
  219.      */
  220.     public void setMu(final T mu) {
  221.         stateMapper = createMapper(stateMapper.getReferenceDate(), mu,
  222.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  223.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  224.     }

  226.     /** Get the central attraction coefficient μ.
  227.      * @return mu central attraction coefficient (m³/s²)
  228.      * @see #setMu(CalculusFieldElement)
  229.      */
  230.     public T getMu() {
  231.         return stateMapper.getMu();
  232.     }

  234.     /** Get the number of calls to the differential equations computation method.
  235.      * <p>The number of calls is reset each time the {@link #propagate(FieldAbsoluteDate)}
  236.      * method is called.</p>
  237.      * @return number of calls to the differential equations computation method
  238.      */
  239.     public int getCalls() {
  240.         return calls;
  241.     }

  243.     /** {@inheritDoc} */
  244.     @Override
  245.     public boolean isAdditionalStateManaged(final String name) {

  247.         // first look at already integrated states
  248.         if (super.isAdditionalStateManaged(name)) {
  249.             return true;
  250.         }

  252.         // then look at states we integrate ourselves
  253.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  254.             if (provider.getName().equals(name)) {
  255.                 return true;
  256.             }
  257.         }

  259.         return false;
  260.     }

  262.     /** {@inheritDoc} */
  263.     @Override
  264.     public String[] getManagedAdditionalStates() {
  265.         final String[] alreadyIntegrated = super.getManagedAdditionalStates();
  266.         final String[] managed = new String[alreadyIntegrated.length + additionalDerivativesProviders.size()];
  267.         System.arraycopy(alreadyIntegrated, 0, managed, 0, alreadyIntegrated.length);
  268.         for (int i = 0; i < additionalDerivativesProviders.size(); ++i) {
  269.             managed[i + alreadyIntegrated.length] = additionalDerivativesProviders.get(i).getName();
  270.         }
  271.         return managed;
  272.     }

  274.     /** Add a set of user-specified equations to be integrated along with the orbit propagation.
  275.      * @param additional additional equations
  276.      * @deprecated as of 11.1, replaced by {@link #addAdditionalDerivativesProvider(FieldAdditionalDerivativesProvider)}
  277.      */
  278.     @Deprecated
  279.     public void addAdditionalEquations(final FieldAdditionalEquations<T> additional) {
  280.         addAdditionalDerivativesProvider(new FieldAdditionalEquationsAdapter<>(additional, this::getInitialState));
  281.     }

  283.     /** Add a provider for user-specified state derivatives to be integrated along with the orbit propagation.
  284.      * @param provider provider for additional derivatives
  285.      * @see #addAdditionalStateProvider(org.orekit.propagation.FieldAdditionalStateProvider)
  286.      * @since 11.1
  287.      */
  288.     public void addAdditionalDerivativesProvider(final FieldAdditionalDerivativesProvider<T> provider) {
  289.         // check if the name is already used
  290.         if (isAdditionalStateManaged(provider.getName())) {
  291.             // these derivatives are already registered, complain
  292.             throw new OrekitException(OrekitMessages.ADDITIONAL_STATE_NAME_ALREADY_IN_USE,
  293.                                       provider.getName());
  294.         }

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

  299.         secondaryOffsets.clear();

  301.     }

  303.     /** Get an unmodifiable list of providers for additional derivatives.
  304.      * @return providers for additional derivatives
  305.      * @since 11.1
  306.      */
  307.     public List<FieldAdditionalDerivativesProvider<T>> getAdditionalDerivativesProviders() {
  308.         return Collections.unmodifiableList(additionalDerivativesProviders);
  309.     }

  311.     /** {@inheritDoc} */
  312.     public <D extends FieldEventDetector<T>> void addEventDetector(final D detector) {
  313.         detectors.add(detector);
  314.     }

  316.     /** {@inheritDoc} */
  317.     public Collection<FieldEventDetector<T>> getEventsDetectors() {
  318.         return Collections.unmodifiableCollection(detectors);
  319.     }

  321.     /** {@inheritDoc} */
  322.     public void clearEventsDetectors() {
  323.         detectors.clear();
  324.     }

  326.     /** Set up all user defined event detectors.
  327.      */
  328.     protected void setUpUserEventDetectors() {
  329.         for (final FieldEventDetector<T> detector : detectors) {
  330.             setUpEventDetector(integrator, detector);
  331.         }
  332.     }

  334.     /** Wrap an Orekit event detector and register it to the integrator.
  335.      * @param integ integrator into which event detector should be registered
  336.      * @param detector event detector to wrap
  337.      */
  338.     protected void setUpEventDetector(final FieldODEIntegrator<T> integ, final FieldEventDetector<T> detector) {
  339.         integ.addEventHandler(new FieldAdaptedEventDetector(detector),
  340.                               detector.getMaxCheckInterval().getReal(),
  341.                               detector.getThreshold().getReal(),
  342.                               detector.getMaxIterationCount());
  343.     }

  345.     /** {@inheritDoc} */
  346.     @Override
  347.     public FieldEphemerisGenerator<T> getEphemerisGenerator() {
  348.         final FieldStoringStepHandler storingHandler = new FieldStoringStepHandler();
  349.         ephemerisGenerators.add(storingHandler);
  350.         return storingHandler;
  351.     }

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

  373.     /** Get the differential equations to integrate (for main state only).
  374.      * @param integ numerical integrator to use for propagation.
  375.      * @return differential equations for main state
  376.      */
  377.     protected abstract MainStateEquations<T> getMainStateEquations(FieldODEIntegrator<T> integ);

  379.     /** {@inheritDoc} */
  380.     public FieldSpacecraftState<T> propagate(final FieldAbsoluteDate<T> target) {
  381.         if (getStartDate() == null) {
  382.             if (getInitialState() == null) {
  383.                 throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  384.             }
  385.             setStartDate(getInitialState().getDate());
  386.         }
  387.         return propagate(getStartDate(), target);
  388.     }

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

  393.         if (getInitialState() == null) {
  394.             throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  395.         }

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

  400.             // Initialize additional states
  401.             initializeAdditionalStates(tEnd);

  403.             if (!tStart.equals(getInitialState().getDate())) {
  404.                 // if propagation start date is not initial date,
  405.                 // propagate from initial to start date without event detection
  406.                 try (IntegratorResetter<T> startResetter = new IntegratorResetter<>(integrator)) {
  407.                     integrateDynamics(tStart);
  408.                 }
  409.             }

  411.             // set up events added by user
  412.             setUpUserEventDetectors();

  414.             // set up step handlers
  415.             for (final FieldOrekitStepHandler<T> handler : getMultiplexer().getHandlers()) {
  416.                 integrator.addStepHandler(new FieldAdaptedStepHandler(handler));
  417.             }
  418.             for (final FieldStoringStepHandler generator : ephemerisGenerators) {
  419.                 generator.setEndDate(tEnd);
  420.                 integrator.addStepHandler(generator);
  421.             }

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

  426.         }

  428.     }

  430.     /** Propagation with or without event detection.
  431.      * @param tEnd target date to which orbit should be propagated
  432.      * @return state at end of propagation
  433.      */
  434.     private FieldSpacecraftState<T> integrateDynamics(final FieldAbsoluteDate<T> tEnd) {
  435.         try {

  437.             initializePropagation();

  439.             if (getInitialState().getDate().equals(tEnd)) {
  440.                 // don't extrapolate
  441.                 return getInitialState();
  442.             }
  443.             // space dynamics view
  444.             stateMapper = createMapper(getInitialState().getDate(), stateMapper.getMu(),
  445.                                        stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  446.                                        stateMapper.getAttitudeProvider(), getInitialState().getFrame());


  449.             // set propagation orbit type
  450.             //final FieldOrbit<T> initialOrbit = stateMapper.getOrbitType().convertType(getInitialState().getOrbit());
  451.             if (Double.isNaN(getMu().getReal())) {
  452.                 setMu(getInitialState().getMu());
  453.             }
  454.             if (getInitialState().getMass().getReal() <= 0.0) {
  455.                 throw new OrekitException(OrekitMessages.SPACECRAFT_MASS_BECOMES_NEGATIVE,
  456.                                                getInitialState().getMass());
  457.             }

  459.             // convert space flight dynamics API to math API
  460.             final FieldSpacecraftState<T> initialIntegrationState = getInitialIntegrationState();
  461.             final FieldODEState<T> mathInitialState = createInitialState(initialIntegrationState);
  462.             final FieldExpandableODE<T> mathODE = createODE(integrator, mathInitialState);

  464.             // mathematical integration
  465.             final FieldODEStateAndDerivative<T> mathFinalState;
  466.             beforeIntegration(initialIntegrationState, tEnd);
  467.             mathFinalState = integrator.integrate(mathODE, mathInitialState,
  468.                                                   tEnd.durationFrom(getInitialState().getDate()));

  470.             afterIntegration();

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

  492.             if (resetAtEnd) {
  493.                 resetInitialState(finalState);
  494.                 setStartDate(finalState.getDate());
  495.             }

  497.             return finalState;

  499.         } catch (OrekitException pe) {
  500.             throw pe;
  501.         } catch (MathIllegalArgumentException | MathIllegalStateException me) {
  502.             throw OrekitException.unwrap(me);
  503.         }
  504.     }

  506.     /** Get the initial state for integration.
  507.      * @return initial state for integration
  508.      */
  509.     protected FieldSpacecraftState<T> getInitialIntegrationState() {
  510.         return getInitialState();
  511.     }

  513.     /** Create an initial state.
  514.      * @param initialState initial state in flight dynamics world
  515.      * @return initial state in mathematics world
  516.      */
  517.     private FieldODEState<T> createInitialState(final FieldSpacecraftState<T> initialState) {

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

  523.         if (secondaryOffsets.isEmpty()) {
  524.             // compute dimension of the secondary state
  525.             int offset = 0;
  526.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  527.                 secondaryOffsets.put(provider.getName(), offset);
  528.                 offset += provider.getDimension();
  529.             }
  530.             secondaryOffsets.put(SECONDARY_DIMENSION, offset);
  531.         }

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

  535.     }

  537.     /** Create secondary state.
  538.      * @param state spacecraft state
  539.      * @return secondary state
  540.      * @since 11.1
  541.      */
  542.     private T[][] secondary(final FieldSpacecraftState<T> state) {

  544.         if (secondaryOffsets.isEmpty()) {
  545.             return null;
  546.         }

  548.         final T[][] secondary = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  549.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  550.             final String name       = provider.getName();
  551.             final int    offset     = secondaryOffsets.get(name);
  552.             final T[]    additional = state.getAdditionalState(name);
  553.             System.arraycopy(additional, 0, secondary[0], offset, additional.length);
  554.         }

  556.         return secondary;

  558.     }

  560.     /** Create secondary state derivative.
  561.      * @param state spacecraft state
  562.      * @return secondary state derivative
  563.      * @since 11.1
  564.      */
  565.     private T[][] secondaryDerivative(final FieldSpacecraftState<T> state) {

  567.         if (secondaryOffsets.isEmpty()) {
  568.             return null;
  569.         }

  571.         final T[][] secondaryDerivative = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  572.         for (final FieldAdditionalDerivativesProvider<T> providcer : additionalDerivativesProviders) {
  573.             final String name       = providcer.getName();
  574.             final int    offset     = secondaryOffsets.get(name);
  575.             final T[]    additionalDerivative = state.getAdditionalStateDerivative(name);
  576.             System.arraycopy(additionalDerivative, 0, secondaryDerivative[0], offset, additionalDerivative.length);
  577.         }

  579.         return secondaryDerivative;

  581.     }

  583.     /** Create an ODE with all equations.
  584.      * @param integ numerical integrator to use for propagation.
  585.      * @param mathInitialState initial state
  586.      * @return a new ode
  587.      */
  588.     private FieldExpandableODE<T> createODE(final FieldODEIntegrator<T> integ,
  589.                                     final FieldODEState<T> mathInitialState) {

  591.         final FieldExpandableODE<T> ode =
  592.                 new FieldExpandableODE<>(new ConvertedMainStateEquations(getMainStateEquations(integ)));

  594.         // secondary part of the ODE
  595.         if (!additionalDerivativesProviders.isEmpty()) {
  596.             ode.addSecondaryEquations(new ConvertedSecondaryStateEquations());
  597.         }

  599.         return ode;

  601.     }

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

  615.     /** Method called just after integration.
  616.      * <p>
  617.      * The default implementation does nothing, it may be specialized in subclasses.
  618.      * </p>
  619.      */
  620.     protected void afterIntegration() {
  621.         // do nothing by default
  622.     }

  624.     /** Get state vector dimension without additional parameters.
  625.      * @return state vector dimension without additional parameters.
  626.      */
  627.     public int getBasicDimension() {
  628.         return 7;

  630.     }

  632.     /** Get the integrator used by the propagator.
  633.      * @return the integrator.
  634.      */
  635.     protected FieldODEIntegrator<T> getIntegrator() {
  636.         return integrator;
  637.     }

  639.     /** Convert a state from mathematical world to space flight dynamics world.
  640.      * @param os mathematical state
  641.      * @return space flight dynamics state
  642.      */
  643.     private FieldSpacecraftState<T> convert(final FieldODEStateAndDerivative<T> os) {

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

  663.         return s;

  665.     }

  667.     /** Convert a state from space flight dynamics world to mathematical world.
  668.      * @param state space flight dynamics state
  669.      * @return mathematical state
  670.      */
  671.     private FieldODEStateAndDerivative<T> convert(final FieldSpacecraftState<T> state) {

  673.         // retrieve initial state
  674.         final T[] primary    = MathArrays.buildArray(getField(), getBasicDimension());
  675.         final T[] primaryDot = MathArrays.buildArray(getField(), getBasicDimension());
  676.         stateMapper.mapStateToArray(state, primary, primaryDot);

  678.         // secondary part of the ODE
  679.         final T[][] secondary           = secondary(state);
  680.         final T[][] secondaryDerivative = secondaryDerivative(state);

  682.         return new FieldODEStateAndDerivative<>(stateMapper.mapDateToDouble(state.getDate()),
  683.                                                 primary, primaryDot,
  684.                                                 secondary, secondaryDerivative);

  686.     }

  688.     /** Differential equations for the main state (orbit, attitude and mass). */
  689.     public interface MainStateEquations<T extends CalculusFieldElement<T>> {

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

  703.         /** Compute differential equations for main state.
  704.          * @param state current state
  705.          * @return derivatives of main state
  706.          */
  707.         T[] computeDerivatives(FieldSpacecraftState<T> state);

  709.     }

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

  714.         /** Main state equations. */
  715.         private final MainStateEquations<T> main;

  717.         /** Simple constructor.
  718.          * @param main main state equations
  719.          */
  720.         ConvertedMainStateEquations(final MainStateEquations<T> main) {
  721.             this.main = main;
  722.             calls = 0;
  723.         }

  725.         /** {@inheritDoc} */
  726.         public int getDimension() {
  727.             return getBasicDimension();
  728.         }

  730.         @Override
  731.         public void init(final T t0, final T[] y0, final T finalTime) {
  732.             // update space dynamics view
  733.             FieldSpacecraftState<T> initialState = stateMapper.mapArrayToState(t0, y0, null, PropagationType.MEAN);
  734.             initialState = updateAdditionalStates(initialState);
  735.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  736.             main.init(initialState, target);
  737.         }
  738.         /** {@inheritDoc} */
  739.         public T[] computeDerivatives(final T t, final T[] y) {

  741.             // increment calls counter
  742.             ++calls;

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

  748.             // compute main state differentials
  749.             return main.computeDerivatives(currentState);

  751.         }

  753.     }

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

  758.         /** Dimension of the combined additional states. */
  759.         private final int combinedDimension;

  761.         /** Simple constructor.
  762.          */
  763.         ConvertedSecondaryStateEquations() {
  764.             this.combinedDimension = secondaryOffsets.get(SECONDARY_DIMENSION);
  765.         }

  767.         /** {@inheritDoc} */
  768.         @Override
  769.         public int getDimension() {
  770.             return combinedDimension;
  771.         }

  773.         /** {@inheritDoc} */
  774.         @Override
  775.         public void init(final T t0, final T[] primary0,
  776.                          final T[] secondary0, final T finalTime) {
  777.             // update space dynamics view
  778.             final FieldSpacecraftState<T> initialState = convert(t0, primary0, null, secondary0);

  780.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  781.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  782.                 provider.init(initialState, target);
  783.             }

  785.         }

  787.         /** {@inheritDoc} */
  788.         @Override
  789.         public T[] computeDerivatives(final T t, final T[] primary,
  790.                                       final T[] primaryDot, final T[] secondary) {

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

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

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

  835.             return secondaryDot;

  837.         }

  839.         /** Convert mathematical view to space view.
  840.          * @param t current value of the independent <I>time</I> variable
  841.          * @param primary array containing the current value of the primary state vector
  842.          * @param primaryDot array containing the derivative of the primary state vector
  843.          * @param secondary array containing the current value of the secondary state vector
  844.          * @return space view of the state
  845.          */
  846.         private FieldSpacecraftState<T> convert(final T t, final T[] primary,
  847.                                                 final T[] primaryDot, final T[] secondary) {

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

  851.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  852.                 final String name      = provider.getName();
  853.                 final int    offset    = secondaryOffsets.get(name);
  854.                 final int    dimension = provider.getDimension();
  855.                 initialState = initialState.addAdditionalState(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  856.             }

  858.             return updateAdditionalStates(initialState);

  860.         }

  862.     }

  864.     /** Adapt an {@link org.orekit.propagation.events.FieldEventDetector<T>}
  865.      * to Hipparchus {@link org.hipparchus.ode.events.FieldODEEventHandler<T>} interface.
  866.      * @param <T> class type for the generic version
  867.      * @author Fabien Maussion
  868.      */
  869.     private class FieldAdaptedEventDetector implements FieldODEEventHandler<T> {

  871.         /** Underlying event detector. */
  872.         private final FieldEventDetector<T> detector;

  874.         /** Time of the previous call to g. */
  875.         private T lastT;

  877.         /** Value from the previous call to g. */
  878.         private T lastG;

  880.         /** Build a wrapped event detector.
  881.          * @param detector event detector to wrap
  882.         */
  883.         FieldAdaptedEventDetector(final FieldEventDetector<T> detector) {
  884.             this.detector = detector;
  885.             this.lastT    = getField().getZero().add(Double.NaN);
  886.             this.lastG    = getField().getZero().add(Double.NaN);
  887.         }

  889.         /** {@inheritDoc} */
  890.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  891.             detector.init(convert(s0), stateMapper.mapDoubleToDate(t));
  892.             this.lastT = getField().getZero().add(Double.NaN);
  893.             this.lastG = getField().getZero().add(Double.NaN);
  894.         }

  896.         /** {@inheritDoc} */
  897.         public T g(final FieldODEStateAndDerivative<T> s) {
  898.             if (!Precision.equals(lastT.getReal(), s.getTime().getReal(), 0)) {
  899.                 lastT = s.getTime();
  900.                 lastG = detector.g(convert(s));
  901.             }
  902.             return lastG;
  903.         }

  905.         /** {@inheritDoc} */
  906.         public Action eventOccurred(final FieldODEStateAndDerivative<T> s, final boolean increasing) {
  907.             return detector.eventOccurred(convert(s), increasing);
  908.         }

  910.         /** {@inheritDoc} */
  911.         public FieldODEState<T> resetState(final FieldODEStateAndDerivative<T> s) {

  913.             final FieldSpacecraftState<T> oldState = convert(s);
  914.             final FieldSpacecraftState<T> newState = detector.resetState(oldState);
  915.             stateChanged(newState);

  917.             // main part
  918.             final T[] primary    = MathArrays.buildArray(getField(), s.getPrimaryStateDimension());
  919.             stateMapper.mapStateToArray(newState, primary, null);

  921.             // secondary part
  922.             final T[][] secondary = MathArrays.buildArray(getField(), 1, additionalDerivativesProviders.size());
  923.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  924.                 final String name      = provider.getName();
  925.                 final int    offset    = secondaryOffsets.get(name);
  926.                 final int    dimension = provider.getDimension();
  927.                 System.arraycopy(newState.getAdditionalState(name), 0, secondary[0], offset, dimension);
  928.             }

  930.             return new FieldODEState<>(newState.getDate().durationFrom(getStartDate()),
  931.                                        primary, secondary);
  932.         }

  934.     }

  936.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepHandler<T>}
  937.      * to Hipparchus {@link FieldODEStepHandler<T>} interface.
  938.      * @author Luc Maisonobe
  939.      */
  940.     private class FieldAdaptedStepHandler implements FieldODEStepHandler<T> {

  942.         /** Underlying handler. */
  943.         private final FieldOrekitStepHandler<T> handler;

  945.         /** Build an instance.
  946.          * @param handler underlying handler to wrap
  947.          */
  948.         FieldAdaptedStepHandler(final FieldOrekitStepHandler<T> handler) {
  949.             this.handler = handler;
  950.         }

  952.         /** {@inheritDoc} */
  953.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  954.             handler.init(convert(s0), stateMapper.mapDoubleToDate(t));
  955.         }

  957.         /** {@inheritDoc} */
  958.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  959.             handler.handleStep(new FieldAdaptedStepInterpolator(interpolator));
  960.         }

  962.         /** {@inheritDoc} */
  963.         @Override
  964.         public void finish(final FieldODEStateAndDerivative<T> finalState) {
  965.             handler.finish(convert(finalState));
  966.         }

  968.     }

  970.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepInterpolator<T>}
  971.      * to Hipparchus {@link FieldODEStepInterpolator<T>} interface.
  972.      * @author Luc Maisonobe
  973.      */
  974.     private class FieldAdaptedStepInterpolator implements FieldOrekitStepInterpolator<T> {

  976.         /** Underlying raw rawInterpolator. */
  977.         private final FieldODEStateInterpolator<T> mathInterpolator;

  979.         /** Build an instance.
  980.          * @param mathInterpolator underlying raw interpolator
  981.          */
  982.         FieldAdaptedStepInterpolator(final FieldODEStateInterpolator<T> mathInterpolator) {
  983.             this.mathInterpolator = mathInterpolator;
  984.         }

  986.         /** {@inheritDoc}} */
  987.         @Override
  988.         public FieldSpacecraftState<T> getPreviousState() {
  989.             return convert(mathInterpolator.getPreviousState());
  990.         }

  992.         /** {@inheritDoc}} */
  993.         @Override
  994.         public FieldSpacecraftState<T> getCurrentState() {
  995.             return convert(mathInterpolator.getCurrentState());
  996.         }

  998.         /** {@inheritDoc}} */
  999.         @Override
  1000.         public FieldSpacecraftState<T> getInterpolatedState(final FieldAbsoluteDate<T> date) {
  1001.             return convert(mathInterpolator.getInterpolatedState(date.durationFrom(getStartDate())));
  1002.         }

  1004.         /** Check is integration direction is forward in date.
  1005.          * @return true if integration is forward in date
  1006.          */
  1007.         public boolean isForward() {
  1008.             return mathInterpolator.isForward();
  1009.         }

  1011.         /** {@inheritDoc}} */
  1012.         @Override
  1013.         public FieldAdaptedStepInterpolator restrictStep(final FieldSpacecraftState<T> newPreviousState,
  1014.                                                          final FieldSpacecraftState<T> newCurrentState) {
  1015.             try {
  1016.                 final AbstractFieldODEStateInterpolator<T> aosi = (AbstractFieldODEStateInterpolator<T>) mathInterpolator;
  1017.                 return new FieldAdaptedStepInterpolator(aosi.restrictStep(convert(newPreviousState),
  1018.                                                                           convert(newCurrentState)));
  1019.             } catch (ClassCastException cce) {
  1020.                 // this should never happen
  1021.                 throw new OrekitInternalError(cce);
  1022.             }
  1023.         }

  1025.     }

  1027.     /** Specialized step handler storing interpolators for ephemeris generation.
  1028.      * @since 11.0
  1029.      */
  1030.     private class FieldStoringStepHandler implements FieldODEStepHandler<T>, FieldEphemerisGenerator<T> {

  1032.         /** Underlying raw mathematical model. */
  1033.         private FieldDenseOutputModel<T> model;

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

  1038.         /** Generated ephemeris. */
  1039.         private FieldBoundedPropagator<T> ephemeris;

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

  1044.         /** Set the end date.
  1045.          * @param endDate end date
  1046.          */
  1047.         public void setEndDate(final FieldAbsoluteDate<T> endDate) {
  1048.             this.endDate = endDate;
  1049.         }

  1051.         /** {@inheritDoc} */
  1052.         @Override
  1053.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  1054.             this.model = new FieldDenseOutputModel<>();
  1055.             model.init(s0, t);

  1057.             // ephemeris will be generated when last step is processed
  1058.             this.ephemeris = null;

  1060.             this.lastInterpolator = null;

  1062.         }

  1064.         /** {@inheritDoc} */
  1065.         @Override
  1066.         public FieldBoundedPropagator<T> getGeneratedEphemeris() {
  1067.             // Each time we try to get the ephemeris, rebuild it using the last data.
  1068.             buildEphemeris();
  1069.             return ephemeris;
  1070.         }

  1072.         /** {@inheritDoc} */
  1073.         @Override
  1074.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  1075.             model.handleStep(interpolator);
  1076.             lastInterpolator = interpolator;
  1077.         }

  1079.         /** {@inheritDoc} */
  1080.         @Override
  1081.         public void finish(final FieldODEStateAndDerivative<T> finalState) {
  1082.             buildEphemeris();
  1083.         }

  1085.         /** Method used to produce ephemeris at a given time.
  1086.          * Can be used at multiple times, updating the ephemeris to
  1087.          * its last state.
  1088.          */
  1089.         private void buildEphemeris() {
  1090.             // buildEphemeris was built in order to allow access to what was previously the finish method.
  1091.             // This now allows to call it through getGeneratedEphemeris, therefore through an external call,
  1092.             // which was not previously the case.

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

  1097.             // set up the boundary dates
  1098.             final T tI = model.getInitialTime();
  1099.             final T tF = model.getFinalTime();
  1100.             // tI is almost? always zero
  1101.             final FieldAbsoluteDate<T> startDate =
  1102.                             stateMapper.mapDoubleToDate(tI);
  1103.             final FieldAbsoluteDate<T> finalDate =
  1104.                             stateMapper.mapDoubleToDate(tF, this.endDate);
  1105.             final FieldAbsoluteDate<T> minDate;
  1106.             final FieldAbsoluteDate<T> maxDate;
  1107.             if (tF.getReal() < tI.getReal()) {
  1108.                 minDate = finalDate;
  1109.                 maxDate = startDate;
  1110.             } else {
  1111.                 minDate = startDate;
  1112.                 maxDate = finalDate;
  1113.             }

  1115.             // get the initial additional states that are not managed
  1116.             final FieldArrayDictionary<T> unmanaged = new FieldArrayDictionary<>(startDate.getField());
  1117.             for (final FieldArrayDictionary<T>.Entry initial : getInitialState().getAdditionalStatesValues().getData()) {
  1118.                 if (!isAdditionalStateManaged(initial.getKey())) {
  1119.                     // this additional state was in the initial state, but is unknown to the propagator
  1120.                     // we simply copy its initial value as is
  1121.                     unmanaged.put(initial.getKey(), initial.getValue());
  1122.                 }
  1123.             }

  1125.             // get the names of additional states managed by differential equations
  1126.             final String[] names      = new String[additionalDerivativesProviders.size()];
  1127.             final int[]    dimensions = new int[additionalDerivativesProviders.size()];
  1128.             for (int i = 0; i < names.length; ++i) {
  1129.                 names[i] = additionalDerivativesProviders.get(i).getName();
  1130.                 dimensions[i] = additionalDerivativesProviders.get(i).getDimension();
  1131.             }

  1133.             // create the ephemeris
  1134.             ephemeris = new FieldIntegratedEphemeris<>(startDate, minDate, maxDate,
  1135.                                                        stateMapper, propagationType, model,
  1136.                                                        unmanaged, getAdditionalStateProviders(),
  1137.                                                        names, dimensions);

  1139.         }

  1141.     }

  1143.     /** Wrapper for resetting an integrator handlers.
  1144.      * <p>
  1145.      * This class is intended to be used in a try-with-resource statement.
  1146.      * If propagator-specific event handlers and step handlers are added to
  1147.      * the integrator in the try block, they will be removed automatically
  1148.      * when leaving the block, so the integrator only keep its own handlers
  1149.      * between calls to {@link AbstractIntegratedPropagator#propagate(AbsoluteDate, AbsoluteDate).
  1150.      * </p>
  1151.      * @param <T> the type of the field elements
  1152.      * @since 11.0
  1153.      */
  1154.     private static class IntegratorResetter<T extends CalculusFieldElement<T>> implements AutoCloseable {

  1156.         /** Wrapped integrator. */
  1157.         private final FieldODEIntegrator<T> integrator;

  1159.         /** Initial event handlers list. */
  1160.         private final List<FieldEventHandlerConfiguration<T>> eventHandlersConfigurations;

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

  1165.         /** Simple constructor.
  1166.          * @param integrator wrapped integrator
  1167.          */
  1168.         IntegratorResetter(final FieldODEIntegrator<T> integrator) {
  1169.             this.integrator                  = integrator;
  1170.             this.eventHandlersConfigurations = new ArrayList<>(integrator.getEventHandlersConfigurations());
  1171.             this.stepHandlers                = new ArrayList<>(integrator.getStepHandlers());
  1172.         }

  1174.         /** {@inheritDoc}
  1175.          * <p>
  1176.          * Reset event handlers and step handlers back to the initial list
  1177.          * </p>
  1178.          */
  1179.         @Override
  1180.         public void close() {

  1182.             // reset event handlers
  1183.             integrator.clearEventHandlers();
  1184.             eventHandlersConfigurations.forEach(c -> integrator.addEventHandler(c.getEventHandler(),
  1185.                                                                                 c.getMaxCheckInterval(),
  1186.                                                                                 c.getConvergence().getReal(),
  1187.                                                                                 c.getMaxIterationCount(),
  1188.                                                                                 c.getSolver()));

  1190.             // reset step handlers
  1191.             integrator.clearStepHandlers();
  1192.             stepHandlers.forEach(stepHandler -> integrator.addStepHandler(stepHandler));

  1194.         }

  1196.     }

  1198. }
Created with JaCoCo 0.8.8.202204050719