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 FieldAdditionalDerivativesProvider}.
  92.      * @since 11.1
  93.      */
  94.     private final Map<String, Integer> secondaryOffsets;

  96.     /** Additional derivatives providers.
  97.      * @since 11.1
  98.      */
  99.     private final 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.     /**
  108.      * Attitude provider when evaluating derivatives. Can be a frozen one for performance.
  109.      * @since 12.1
  110.      */
  111.     private AttitudeProvider attitudeProviderForDerivatives;

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

  116.     /** Type of orbit to output (mean or osculating) <br/>
  117.      * <p>
  118.      * This is used only in the case of semi-analytical propagators where there is a clear separation between
  119.      * mean and short periodic elements. It is ignored by the Numerical propagator.
  120.      * </p>
  121.      */
  122.     private final PropagationType propagationType;

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

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

  156.     /** Getter for the resetting flag regarding initial state.
  157.      * @return resetting flag
  158.      * @since 12.0
  159.      */
  160.     public boolean getResetAtEnd() {
  161.         return this.resetAtEnd;
  162.     }

  164.     /**
  165.      * Method called when initializing the attitude provider used when evaluating derivatives.
  166.      * @return attitude provider for derivatives
  167.      */
  168.     protected AttitudeProvider initializeAttitudeProviderForDerivatives() {
  169.         return getAttitudeProvider();
  170.     }

  172.     /** Initialize the mapper.
  173.      * @param field Field used by default
  174.      */
  175.     protected void initMapper(final Field<T> field) {
  176.         final T zero = field.getZero();
  177.         stateMapper = createMapper(null, zero.add(Double.NaN), null, null, null, null);
  178.     }

  180.     /** Get the integrator's name.
  181.      * @return name of underlying integrator
  182.      * @since 12.0
  183.      */
  184.     public String getIntegratorName() {
  185.         return integrator.getName();
  186.     }

  188.     /**  {@inheritDoc} */
  189.     @Override
  190.     public void setAttitudeProvider(final AttitudeProvider attitudeProvider) {
  191.         super.setAttitudeProvider(attitudeProvider);
  192.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  193.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  194.                                    attitudeProvider, stateMapper.getFrame());
  195.     }

  197.     /** Set propagation orbit type.
  198.      * @param orbitType orbit type to use for propagation
  199.      */
  200.     protected void setOrbitType(final OrbitType orbitType) {
  201.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  202.                                    orbitType, stateMapper.getPositionAngleType(),
  203.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  204.     }

  206.     /** Get propagation parameter type.
  207.      * @return orbit type used for propagation
  208.      */
  209.     protected OrbitType getOrbitType() {
  210.         return stateMapper.getOrbitType();
  211.     }

  213.     /** Check if only the mean elements should be used in a semi-analytical propagation.
  214.      * @return {@link PropagationType MEAN} if only mean elements have to be used or
  215.      *         {@link PropagationType OSCULATING} if osculating elements have to be also used.
  216.      */
  217.     protected PropagationType isMeanOrbit() {
  218.         return propagationType;
  219.     }

  221.     /** Get the propagation type.
  222.      * @return propagation type.
  223.      * @since 11.3.2
  224.      */
  225.     public PropagationType getPropagationType() {
  226.         return propagationType;
  227.     }

  229.     /** Set position angle type.
  230.      * <p>
  231.      * The position parameter type is meaningful only if {@link
  232.      * #getOrbitType() propagation orbit type}
  233.      * support it. As an example, it is not meaningful for propagation
  234.      * in {@link OrbitType#CARTESIAN Cartesian} parameters.
  235.      * </p>
  236.      * @param positionAngleType angle type to use for propagation
  237.      */
  238.     protected void setPositionAngleType(final PositionAngleType positionAngleType) {
  239.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  240.                                    stateMapper.getOrbitType(), positionAngleType,
  241.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  242.     }

  244.     /** Get propagation parameter type.
  245.      * @return angle type to use for propagation
  246.      */
  247.     protected PositionAngleType getPositionAngleType() {
  248.         return stateMapper.getPositionAngleType();
  249.     }

  251.     /** Set the central attraction coefficient μ.
  252.      * @param mu central attraction coefficient (m³/s²)
  253.      */
  254.     public void setMu(final T mu) {
  255.         stateMapper = createMapper(stateMapper.getReferenceDate(), mu,
  256.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  257.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  258.     }

  260.     /** Get the central attraction coefficient μ.
  261.      * @return mu central attraction coefficient (m³/s²)
  262.      * @see #setMu(CalculusFieldElement)
  263.      */
  264.     public T getMu() {
  265.         return stateMapper.getMu();
  266.     }

  268.     /** Get the number of calls to the differential equations computation method.
  269.      * <p>The number of calls is reset each time the {@link #propagate(FieldAbsoluteDate)}
  270.      * method is called.</p>
  271.      * @return number of calls to the differential equations computation method
  272.      */
  273.     public int getCalls() {
  274.         return calls;
  275.     }

  277.     /** {@inheritDoc} */
  278.     @Override
  279.     public boolean isAdditionalStateManaged(final String name) {

  281.         // first look at already integrated states
  282.         if (super.isAdditionalStateManaged(name)) {
  283.             return true;
  284.         }

  286.         // then look at states we integrate ourselves
  287.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  288.             if (provider.getName().equals(name)) {
  289.                 return true;
  290.             }
  291.         }

  293.         return false;
  294.     }

  296.     /** {@inheritDoc} */
  297.     @Override
  298.     public String[] getManagedAdditionalStates() {
  299.         final String[] alreadyIntegrated = super.getManagedAdditionalStates();
  300.         final String[] managed = new String[alreadyIntegrated.length + additionalDerivativesProviders.size()];
  301.         System.arraycopy(alreadyIntegrated, 0, managed, 0, alreadyIntegrated.length);
  302.         for (int i = 0; i < additionalDerivativesProviders.size(); ++i) {
  303.             managed[i + alreadyIntegrated.length] = additionalDerivativesProviders.get(i).getName();
  304.         }
  305.         return managed;
  306.     }

  308.     /** Add a provider for user-specified state derivatives to be integrated along with the orbit propagation.
  309.      * @param provider provider for additional derivatives
  310.      * @see #addAdditionalStateProvider(org.orekit.propagation.FieldAdditionalStateProvider)
  311.      * @since 11.1
  312.      */
  313.     public void addAdditionalDerivativesProvider(final FieldAdditionalDerivativesProvider<T> provider) {
  314.         // check if the name is already used
  315.         if (isAdditionalStateManaged(provider.getName())) {
  316.             // these derivatives are already registered, complain
  317.             throw new OrekitException(OrekitMessages.ADDITIONAL_STATE_NAME_ALREADY_IN_USE,
  318.                                       provider.getName());
  319.         }

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

  324.         secondaryOffsets.clear();

  326.     }

  328.     /** Get an unmodifiable list of providers for additional derivatives.
  329.      * @return providers for additional derivatives
  330.      * @since 11.1
  331.      */
  332.     public List<FieldAdditionalDerivativesProvider<T>> getAdditionalDerivativesProviders() {
  333.         return Collections.unmodifiableList(additionalDerivativesProviders);
  334.     }

  336.     /** {@inheritDoc} */
  337.     public <D extends FieldEventDetector<T>> void addEventDetector(final D detector) {
  338.         detectors.add(detector);
  339.     }

  341.     /** {@inheritDoc} */
  342.     public Collection<FieldEventDetector<T>> getEventsDetectors() {
  343.         return Collections.unmodifiableCollection(detectors);
  344.     }

  346.     /** {@inheritDoc} */
  347.     public void clearEventsDetectors() {
  348.         detectors.clear();
  349.     }

  351.     /** Set up all user defined event detectors.
  352.      */
  353.     protected void setUpUserEventDetectors() {
  354.         for (final FieldEventDetector<T> detector : detectors) {
  355.             setUpEventDetector(integrator, detector);
  356.         }
  357.     }

  359.     /** Wrap an Orekit event detector and register it to the integrator.
  360.      * @param integ integrator into which event detector should be registered
  361.      * @param detector event detector to wrap
  362.      */
  363.     protected void setUpEventDetector(final FieldODEIntegrator<T> integ, final FieldEventDetector<T> detector) {
  364.         integ.addEventDetector(new FieldAdaptedEventDetector(detector));
  365.     }

  367.     /** {@inheritDoc} */
  368.     @Override
  369.     public FieldEphemerisGenerator<T> getEphemerisGenerator() {
  370.         final FieldStoringStepHandler storingHandler = new FieldStoringStepHandler();
  371.         ephemerisGenerators.add(storingHandler);
  372.         return storingHandler;
  373.     }

  375.     /** Create a mapper between raw double components and spacecraft state.
  376.     /** Simple constructor.
  377.      * <p>
  378.      * The position parameter type is meaningful only if {@link
  379.      * #getOrbitType() propagation orbit type}
  380.      * support it. As an example, it is not meaningful for propagation
  381.      * in {@link OrbitType#CARTESIAN Cartesian} parameters.
  382.      * </p>
  383.      * @param referenceDate reference date
  384.      * @param mu central attraction coefficient (m³/s²)
  385.      * @param orbitType orbit type to use for mapping
  386.      * @param positionAngleType angle type to use for propagation
  387.      * @param attitudeProvider attitude provider
  388.      * @param frame inertial frame
  389.      * @return new mapper
  390.      */
  391.     protected abstract FieldStateMapper<T> createMapper(FieldAbsoluteDate<T> referenceDate, T mu,
  392.                                                         OrbitType orbitType, PositionAngleType positionAngleType,
  393.                                                         AttitudeProvider attitudeProvider, Frame frame);

  395.     /** Get the differential equations to integrate (for main state only).
  396.      * @param integ numerical integrator to use for propagation.
  397.      * @return differential equations for main state
  398.      */
  399.     protected abstract MainStateEquations<T> getMainStateEquations(FieldODEIntegrator<T> integ);

  401.     /** {@inheritDoc} */
  402.     @Override
  403.     public FieldSpacecraftState<T> propagate(final FieldAbsoluteDate<T> target) {
  404.         if (getStartDate() == null) {
  405.             if (getInitialState() == null) {
  406.                 throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  407.             }
  408.             setStartDate(getInitialState().getDate());
  409.         }
  410.         return propagate(getStartDate(), target);
  411.     }

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

  416.         if (getInitialState() == null) {
  417.             throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  418.         }

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

  423.             // Initialize additional states
  424.             initializeAdditionalStates(tEnd);

  426.             if (!tStart.equals(getInitialState().getDate())) {
  427.                 // if propagation start date is not initial date,
  428.                 // propagate from initial to start date without event detection
  429.                 try (IntegratorResetter<T> startResetter = new IntegratorResetter<>(integrator)) {
  430.                     integrateDynamics(tStart);
  431.                 }
  432.             }

  434.             // set up events added by user
  435.             setUpUserEventDetectors();

  437.             // set up step handlers
  438.             for (final FieldOrekitStepHandler<T> handler : getMultiplexer().getHandlers()) {
  439.                 integrator.addStepHandler(new FieldAdaptedStepHandler(handler));
  440.             }
  441.             for (final FieldStoringStepHandler generator : ephemerisGenerators) {
  442.                 generator.setEndDate(tEnd);
  443.                 integrator.addStepHandler(generator);
  444.             }

  446.             // propagate from start date to end date with event detection
  447.             final FieldSpacecraftState<T> state = integrateDynamics(tEnd);

  449.             // Finalize event detectors
  450.             getEventsDetectors().forEach(detector -> detector.finish(state));

  452.             return state;
  453.         }

  455.     }

  457.     /** Reset initial state with a given propagation type.
  458.      *
  459.      * <p> By default this method returns the same as method resetInitialState(FieldSpacecraftState)
  460.      * <p> Its purpose is mostly to be derived in FieldDSSTPropagator
  461.      *
  462.      * @param state new initial state to consider
  463.      * @param stateType type of the new state (mean or osculating)
  464.      * @since 12.1.3
  465.      */
  466.     public void resetInitialState(final FieldSpacecraftState<T> state, final PropagationType stateType) {
  467.         // Default behavior, do not take propagation type into account
  468.         resetInitialState(state);
  469.     }

  471.     /** Propagation with or without event detection.
  472.      * @param tEnd target date to which orbit should be propagated
  473.      * @return state at end of propagation
  474.      */
  475.     private FieldSpacecraftState<T> integrateDynamics(final FieldAbsoluteDate<T> tEnd) {
  476.         try {

  478.             initializePropagation();

  480.             if (getInitialState().getDate().equals(tEnd)) {
  481.                 // don't extrapolate
  482.                 return getInitialState();
  483.             }
  484.             // space dynamics view
  485.             stateMapper = createMapper(getInitialState().getDate(), stateMapper.getMu(),
  486.                                        stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  487.                                        stateMapper.getAttitudeProvider(), getInitialState().getFrame());

  489.             // set propagation orbit type
  490.             if (Double.isNaN(getMu().getReal())) {
  491.                 setMu(getInitialState().getMu());
  492.             }
  493.             if (getInitialState().getMass().getReal() <= 0.0) {
  494.                 throw new OrekitException(OrekitMessages.NOT_POSITIVE_SPACECRAFT_MASS,
  495.                                                getInitialState().getMass());
  496.             }

  498.             // convert space flight dynamics API to math API
  499.             final FieldSpacecraftState<T> initialIntegrationState = getInitialIntegrationState();
  500.             final FieldODEState<T> mathInitialState = createInitialState(initialIntegrationState);
  501.             final FieldExpandableODE<T> mathODE = createODE(integrator);

  503.             // mathematical integration
  504.             final FieldODEStateAndDerivative<T> mathFinalState;
  505.             beforeIntegration(initialIntegrationState, tEnd);
  506.             mathFinalState = integrator.integrate(mathODE, mathInitialState,
  507.                                                   tEnd.durationFrom(getInitialState().getDate()));

  509.             afterIntegration();

  511.             // get final state
  512.             FieldSpacecraftState<T> finalState =
  513.                             stateMapper.mapArrayToState(stateMapper.mapDoubleToDate(mathFinalState.getTime(), tEnd),
  514.                                                         mathFinalState.getPrimaryState(),
  515.                                                         mathFinalState.getPrimaryDerivative(),
  516.                                                         propagationType);

  518.             finalState = updateAdditionalStatesAndDerivatives(finalState, mathFinalState);

  520.             if (resetAtEnd) {
  521.                 resetInitialState(finalState, propagationType);
  522.                 setStartDate(finalState.getDate());
  523.             }

  525.             return finalState;

  527.         } catch (OrekitException pe) {
  528.             throw pe;
  529.         } catch (MathIllegalArgumentException | MathIllegalStateException me) {
  530.             throw OrekitException.unwrap(me);
  531.         }
  532.     }

  534.     /**
  535.      * Returns an updated version of the inputted state with additional states, including
  536.      * from derivatives providers.
  537.      * @param originalState input state
  538.      * @param os ODE state and derivative
  539.      * @return new state
  540.      * @since 12.1
  541.      */
  542.     private FieldSpacecraftState<T> updateAdditionalStatesAndDerivatives(final FieldSpacecraftState<T> originalState,
  543.                                                                          final FieldODEStateAndDerivative<T> os) {
  544.         FieldSpacecraftState<T> updatedState = originalState;
  545.         if (os.getNumberOfSecondaryStates() > 0) {
  546.             final T[] secondary           = os.getSecondaryState(1);
  547.             final T[] secondaryDerivative = os.getSecondaryDerivative(1);
  548.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  549.                 final String name      = provider.getName();
  550.                 final int    offset    = secondaryOffsets.get(name);
  551.                 final int    dimension = provider.getDimension();
  552.                 updatedState = updatedState.addAdditionalState(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  553.                 updatedState = updatedState.addAdditionalStateDerivative(name, Arrays.copyOfRange(secondaryDerivative, offset, offset + dimension));
  554.             }
  555.         }
  556.         return updateAdditionalStates(updatedState);
  557.     }

  559.     /** Get the initial state for integration.
  560.      * @return initial state for integration
  561.      */
  562.     protected FieldSpacecraftState<T> getInitialIntegrationState() {
  563.         return getInitialState();
  564.     }

  566.     /** Create an initial state.
  567.      * @param initialState initial state in flight dynamics world
  568.      * @return initial state in mathematics world
  569.      */
  570.     private FieldODEState<T> createInitialState(final FieldSpacecraftState<T> initialState) {

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

  576.         if (secondaryOffsets.isEmpty()) {
  577.             // compute dimension of the secondary state
  578.             int offset = 0;
  579.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  580.                 secondaryOffsets.put(provider.getName(), offset);
  581.                 offset += provider.getDimension();
  582.             }
  583.             secondaryOffsets.put(SECONDARY_DIMENSION, offset);
  584.         }

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

  588.     }

  590.     /** Create secondary state.
  591.      * @param state spacecraft state
  592.      * @return secondary state
  593.      * @since 11.1
  594.      */
  595.     private T[][] secondary(final FieldSpacecraftState<T> state) {

  597.         if (secondaryOffsets.isEmpty()) {
  598.             return null;
  599.         }

  601.         final T[][] secondary = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  602.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  603.             final String name       = provider.getName();
  604.             final int    offset     = secondaryOffsets.get(name);
  605.             final T[]    additional = state.getAdditionalState(name);
  606.             System.arraycopy(additional, 0, secondary[0], offset, additional.length);
  607.         }

  609.         return secondary;

  611.     }

  613.     /** Create secondary state derivative.
  614.      * @param state spacecraft state
  615.      * @return secondary state derivative
  616.      * @since 11.1
  617.      */
  618.     private T[][] secondaryDerivative(final FieldSpacecraftState<T> state) {

  620.         if (secondaryOffsets.isEmpty()) {
  621.             return null;
  622.         }

  624.         final T[][] secondaryDerivative = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  625.         for (final FieldAdditionalDerivativesProvider<T> providcer : additionalDerivativesProviders) {
  626.             final String name       = providcer.getName();
  627.             final int    offset     = secondaryOffsets.get(name);
  628.             final T[]    additionalDerivative = state.getAdditionalStateDerivative(name);
  629.             System.arraycopy(additionalDerivative, 0, secondaryDerivative[0], offset, additionalDerivative.length);
  630.         }

  632.         return secondaryDerivative;

  634.     }

  636.     /** Create an ODE with all equations.
  637.      * @param integ numerical integrator to use for propagation.
  638.      * @return a new ode
  639.      */
  640.     private FieldExpandableODE<T> createODE(final FieldODEIntegrator<T> integ) {

  642.         final FieldExpandableODE<T> ode =
  643.                 new FieldExpandableODE<>(new ConvertedMainStateEquations(getMainStateEquations(integ)));

  645.         // secondary part of the ODE
  646.         if (!additionalDerivativesProviders.isEmpty()) {
  647.             ode.addSecondaryEquations(new ConvertedSecondaryStateEquations());
  648.         }

  650.         return ode;

  652.     }

  654.     /** Method called just before integration.
  655.      * <p>
  656.      * The default implementation does nothing, it may be specialized in subclasses.
  657.      * </p>
  658.      * @param initialState initial state
  659.      * @param tEnd target date at which state should be propagated
  660.      */
  661.     protected void beforeIntegration(final FieldSpacecraftState<T> initialState,
  662.                                      final FieldAbsoluteDate<T> tEnd) {
  663.         // do nothing by default
  664.     }

  666.     /** Method called just after integration.
  667.      * <p>
  668.      * The default implementation does nothing, it may be specialized in subclasses.
  669.      * </p>
  670.      */
  671.     protected void afterIntegration() {
  672.         // do nothing by default
  673.     }

  675.     /** Get state vector dimension without additional parameters.
  676.      * @return state vector dimension without additional parameters.
  677.      */
  678.     public int getBasicDimension() {
  679.         return 7;

  681.     }

  683.     /** Get the integrator used by the propagator.
  684.      * @return the integrator.
  685.      */
  686.     protected FieldODEIntegrator<T> getIntegrator() {
  687.         return integrator;
  688.     }

  690.     /** Convert a state from mathematical world to space flight dynamics world.
  691.      * @param os mathematical state
  692.      * @return space flight dynamics state
  693.      */
  694.     private FieldSpacecraftState<T> convert(final FieldODEStateAndDerivative<T> os) {

  696.         FieldSpacecraftState<T> s =
  697.                         stateMapper.mapArrayToState(os.getTime(),
  698.                                                     os.getPrimaryState(),
  699.                                                     os.getPrimaryDerivative(),
  700.                                                     propagationType);
  701.         if (os.getNumberOfSecondaryStates() > 0) {
  702.             final T[] secondary           = os.getSecondaryState(1);
  703.             final T[] secondaryDerivative = os.getSecondaryDerivative(1);
  704.             for (final FieldAdditionalDerivativesProvider<T> equations : additionalDerivativesProviders) {
  705.                 final String name      = equations.getName();
  706.                 final int    offset    = secondaryOffsets.get(name);
  707.                 final int    dimension = equations.getDimension();
  708.                 s = s.addAdditionalState(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  709.                 s = s.addAdditionalStateDerivative(name, Arrays.copyOfRange(secondaryDerivative, offset, offset + dimension));
  710.             }
  711.         }
  712.         s = updateAdditionalStates(s);

  714.         return s;

  716.     }

  718.     /** Convert a state from space flight dynamics world to mathematical world.
  719.      * @param state space flight dynamics state
  720.      * @return mathematical state
  721.      */
  722.     private FieldODEStateAndDerivative<T> convert(final FieldSpacecraftState<T> state) {

  724.         // retrieve initial state
  725.         final T[] primary    = MathArrays.buildArray(getField(), getBasicDimension());
  726.         final T[] primaryDot = MathArrays.buildArray(getField(), getBasicDimension());
  727.         stateMapper.mapStateToArray(state, primary, primaryDot);

  729.         // secondary part of the ODE
  730.         final T[][] secondary           = secondary(state);
  731.         final T[][] secondaryDerivative = secondaryDerivative(state);

  733.         return new FieldODEStateAndDerivative<>(stateMapper.mapDateToDouble(state.getDate()),
  734.                                                 primary, primaryDot,
  735.                                                 secondary, secondaryDerivative);

  737.     }

  739.     /** Differential equations for the main state (orbit, attitude and mass).
  740.      * @param <T> type of the field element
  741.      */
  742.     public interface MainStateEquations<T extends CalculusFieldElement<T>> {

  744.         /**
  745.          * Initialize the equations at the start of propagation. This method will be
  746.          * called before any calls to {@link #computeDerivatives(FieldSpacecraftState)}.
  747.          *
  748.          * <p> The default implementation of this method does nothing.
  749.          *
  750.          * @param initialState initial state information at the start of propagation.
  751.          * @param target       date of propagation. Not equal to {@code
  752.          *                     initialState.getDate()}.
  753.          */
  754.         void init(FieldSpacecraftState<T> initialState, FieldAbsoluteDate<T> target);

  756.         /** Compute differential equations for main state.
  757.          * @param state current state
  758.          * @return derivatives of main state
  759.          */
  760.         T[] computeDerivatives(FieldSpacecraftState<T> state);

  762.     }

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

  767.         /** Main state equations. */
  768.         private final MainStateEquations<T> main;

  770.         /** Simple constructor.
  771.          * @param main main state equations
  772.          */
  773.         ConvertedMainStateEquations(final MainStateEquations<T> main) {
  774.             this.main = main;
  775.             calls = 0;
  776.         }

  778.         /** {@inheritDoc} */
  779.         public int getDimension() {
  780.             return getBasicDimension();
  781.         }

  783.         @Override
  784.         public void init(final T t0, final T[] y0, final T finalTime) {
  785.             // update space dynamics view
  786.             FieldSpacecraftState<T> initialState = stateMapper.mapArrayToState(t0, y0, null, PropagationType.MEAN);
  787.             initialState = updateAdditionalStates(initialState);
  788.             initialState = updateStatesFromAdditionalDerivativesIfKnown(initialState);
  789.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  790.             main.init(initialState, target);
  791.             attitudeProviderForDerivatives = initializeAttitudeProviderForDerivatives();
  792.         }

  794.         /**
  795.          * Returns an updated version of the inputted state, with additional states from
  796.          * derivatives providers as given in the stored initial state.
  797.          * @param originalState input state
  798.          * @return new state
  799.          * @since 12.1
  800.          */
  801.         private FieldSpacecraftState<T> updateStatesFromAdditionalDerivativesIfKnown(final FieldSpacecraftState<T> originalState) {
  802.             FieldSpacecraftState<T> updatedState = originalState;
  803.             final FieldSpacecraftState<T> storedInitialState = getInitialState();
  804.             final T originalTime = stateMapper.mapDateToDouble(originalState.getDate());
  805.             if (storedInitialState != null && stateMapper.mapDateToDouble(storedInitialState.getDate()).subtract(originalTime).isZero()) {
  806.                 for (final FieldAdditionalDerivativesProvider<T> provider: additionalDerivativesProviders) {
  807.                     final String name = provider.getName();
  808.                     final T[] value = storedInitialState.getAdditionalState(name);
  809.                     updatedState = updatedState.addAdditionalState(name, value);
  810.                 }
  811.             }
  812.             return updatedState;
  813.         }

  815.         /** {@inheritDoc} */
  816.         public T[] computeDerivatives(final T t, final T[] y) {

  818.             // increment calls counter
  819.             ++calls;

  821.             // update space dynamics view
  822.             stateMapper.setAttitudeProvider(attitudeProviderForDerivatives);
  823.             FieldSpacecraftState<T> currentState = stateMapper.mapArrayToState(t, y, null, PropagationType.MEAN);
  824.             stateMapper.setAttitudeProvider(getAttitudeProvider());
  825.             currentState = updateAdditionalStates(currentState);

  827.             // compute main state differentials
  828.             return main.computeDerivatives(currentState);

  830.         }

  832.     }

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

  837.         /** Dimension of the combined additional states. */
  838.         private final int combinedDimension;

  840.         /** Simple constructor.
  841.          */
  842.         ConvertedSecondaryStateEquations() {
  843.             this.combinedDimension = secondaryOffsets.get(SECONDARY_DIMENSION);
  844.         }

  846.         /** {@inheritDoc} */
  847.         @Override
  848.         public int getDimension() {
  849.             return combinedDimension;
  850.         }

  852.         /** {@inheritDoc} */
  853.         @Override
  854.         public void init(final T t0, final T[] primary0,
  855.                          final T[] secondary0, final T finalTime) {
  856.             // update space dynamics view
  857.             final FieldSpacecraftState<T> initialState = convert(t0, primary0, null, secondary0);

  859.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  860.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  861.                 provider.init(initialState, target);
  862.             }

  864.         }

  866.         /** {@inheritDoc} */
  867.         @Override
  868.         public T[] computeDerivatives(final T t, final T[] primary,
  869.                                       final T[] primaryDot, final T[] secondary) {

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

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

  879.             // gather the derivatives from all additional equations, taking care of dependencies
  880.             final T[] secondaryDot = MathArrays.buildArray(t.getField(), combinedDimension);
  881.             int yieldCount = 0;
  882.             while (!pending.isEmpty()) {
  883.                 final FieldAdditionalDerivativesProvider<T> equations = pending.remove();
  884.                 if (equations.yields(updated)) {
  885.                     // these equations have to wait for another set,
  886.                     // we put them again in the pending queue
  887.                     pending.add(equations);
  888.                     if (++yieldCount >= pending.size()) {
  889.                         // all pending equations yielded!, they probably need data not yet initialized
  890.                         // we let the propagation proceed, if these data are really needed right now
  891.                         // an appropriate exception will be triggered when caller tries to access them
  892.                         break;
  893.                     }
  894.                 } else {
  895.                     // we can use these equations right now
  896.                     final String                      name           = equations.getName();
  897.                     final int                         offset         = secondaryOffsets.get(name);
  898.                     final int                         dimension      = equations.getDimension();
  899.                     final FieldCombinedDerivatives<T> derivatives    = equations.combinedDerivatives(updated);
  900.                     final T[]                         additionalPart = derivatives.getAdditionalDerivatives();
  901.                     final T[]                         mainPart       = derivatives.getMainStateDerivativesIncrements();
  902.                     System.arraycopy(additionalPart, 0, secondaryDot, offset, dimension);
  903.                     updated = updated.addAdditionalStateDerivative(name, additionalPart);
  904.                     if (mainPart != null) {
  905.                         // this equation does change the main state derivatives
  906.                         for (int i = 0; i < mainPart.length; ++i) {
  907.                             primaryDot[i] = primaryDot[i].add(mainPart[i]);
  908.                         }
  909.                     }
  910.                     yieldCount = 0;
  911.                 }
  912.             }

  914.             return secondaryDot;

  916.         }

  918.         /** Convert mathematical view to space view.
  919.          * @param t current value of the independent <I>time</I> variable
  920.          * @param primary array containing the current value of the primary state vector
  921.          * @param primaryDot array containing the derivative of the primary state vector
  922.          * @param secondary array containing the current value of the secondary state vector
  923.          * @return space view of the state
  924.          */
  925.         private FieldSpacecraftState<T> convert(final T t, final T[] primary,
  926.                                                 final T[] primaryDot, final T[] secondary) {

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

  930.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  931.                 final String name      = provider.getName();
  932.                 final int    offset    = secondaryOffsets.get(name);
  933.                 final int    dimension = provider.getDimension();
  934.                 initialState = initialState.addAdditionalState(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  935.             }

  937.             return updateAdditionalStates(initialState);

  939.         }

  941.     }

  943.     /** Adapt an {@link org.orekit.propagation.events.FieldEventDetector<T>}
  944.      * to Hipparchus {@link org.hipparchus.ode.events.FieldODEEventDetector<T>} interface.
  945.      * @author Fabien Maussion
  946.      */
  947.     private class FieldAdaptedEventDetector implements FieldODEEventDetector<T> {

  949.         /** Underlying event detector. */
  950.         private final FieldEventDetector<T> detector;

  952.         /** Underlying event handler.
  953.          * @since 12.0
  954.          */
  955.         private final FieldEventHandler<T> handler;

  957.         /** Time of the previous call to g. */
  958.         private T lastT;

  960.         /** Value from the previous call to g. */
  961.         private T lastG;

  963.         /** Build a wrapped event detector.
  964.          * @param detector event detector to wrap
  965.         */
  966.         FieldAdaptedEventDetector(final FieldEventDetector<T> detector) {
  967.             this.detector = detector;
  968.             this.handler  = detector.getHandler();
  969.             this.lastT    = getField().getZero().add(Double.NaN);
  970.             this.lastG    = getField().getZero().add(Double.NaN);
  971.         }

  973.         /** {@inheritDoc} */
  974.         @Override
  975.         public FieldAdaptableInterval<T> getMaxCheckInterval() {
  976.             return s -> detector.getMaxCheckInterval().currentInterval(convert(s));
  977.         }

  979.         /** {@inheritDoc} */
  980.         @Override
  981.         public int getMaxIterationCount() {
  982.             return detector.getMaxIterationCount();
  983.         }

  985.         /** {@inheritDoc} */
  986.         @Override
  987.         public FieldBracketingNthOrderBrentSolver<T> getSolver() {
  988.             final T zero = detector.getThreshold().getField().getZero();
  989.             return new FieldBracketingNthOrderBrentSolver<>(zero, detector.getThreshold(), zero, 5);
  990.         }

  992.         /** {@inheritDoc} */
  993.         @Override
  994.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  995.             detector.init(convert(s0), stateMapper.mapDoubleToDate(t));
  996.             this.lastT = getField().getZero().add(Double.NaN);
  997.             this.lastG = getField().getZero().add(Double.NaN);
  998.         }

  1000.         /** {@inheritDoc} */
  1001.         public T g(final FieldODEStateAndDerivative<T> s) {
  1002.             if (!Precision.equals(lastT.getReal(), s.getTime().getReal(), 0)) {
  1003.                 lastT = s.getTime();
  1004.                 lastG = detector.g(convert(s));
  1005.             }
  1006.             return lastG;
  1007.         }

  1009.         /** {@inheritDoc} */
  1010.         public FieldODEEventHandler<T> getHandler() {

  1012.             return new FieldODEEventHandler<T>() {

  1014.                 /** {@inheritDoc} */
  1015.                 public Action eventOccurred(final FieldODEStateAndDerivative<T> s,
  1016.                                             final FieldODEEventDetector<T> d,
  1017.                                             final boolean increasing) {
  1018.                     return handler.eventOccurred(convert(s), detector, increasing);
  1019.                 }

  1021.                 /** {@inheritDoc} */
  1022.                 @Override
  1023.                 public FieldODEState<T> resetState(final FieldODEEventDetector<T> d,
  1024.                                                    final FieldODEStateAndDerivative<T> s) {

  1026.                     final FieldSpacecraftState<T> oldState = convert(s);
  1027.                     final FieldSpacecraftState<T> newState = handler.resetState(detector, oldState);
  1028.                     stateChanged(newState);

  1030.                     // main part
  1031.                     final T[] primary    = MathArrays.buildArray(getField(), s.getPrimaryStateDimension());
  1032.                     stateMapper.mapStateToArray(newState, primary, null);

  1034.                     // secondary part
  1035.                     final T[][] secondary = MathArrays.buildArray(getField(), 1, additionalDerivativesProviders.size());
  1036.                     for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  1037.                         final String name      = provider.getName();
  1038.                         final int    offset    = secondaryOffsets.get(name);
  1039.                         final int    dimension = provider.getDimension();
  1040.                         System.arraycopy(newState.getAdditionalState(name), 0, secondary[0], offset, dimension);
  1041.                     }

  1043.                     return new FieldODEState<>(newState.getDate().durationFrom(getStartDate()),
  1044.                                                primary, secondary);
  1045.                 }
  1046.             };

  1048.         }

  1050.     }

  1052.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepHandler<T>}
  1053.      * to Hipparchus {@link FieldODEStepHandler<T>} interface.
  1054.      * @author Luc Maisonobe
  1055.      */
  1056.     private class FieldAdaptedStepHandler implements FieldODEStepHandler<T> {

  1058.         /** Underlying handler. */
  1059.         private final FieldOrekitStepHandler<T> handler;

  1061.         /** Build an instance.
  1062.          * @param handler underlying handler to wrap
  1063.          */
  1064.         FieldAdaptedStepHandler(final FieldOrekitStepHandler<T> handler) {
  1065.             this.handler = handler;
  1066.         }

  1068.         /** {@inheritDoc} */
  1069.         @Override
  1070.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  1071.             handler.init(convert(s0), stateMapper.mapDoubleToDate(t));
  1072.         }

  1074.         /** {@inheritDoc} */
  1075.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  1076.             handler.handleStep(new FieldAdaptedStepInterpolator(interpolator));
  1077.         }

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

  1085.     }

  1087.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepInterpolator<T>}
  1088.      * to Hipparchus {@link FieldODEStepInterpolator<T>} interface.
  1089.      * @author Luc Maisonobe
  1090.      */
  1091.     private class FieldAdaptedStepInterpolator implements FieldOrekitStepInterpolator<T> {

  1093.         /** Underlying raw rawInterpolator. */
  1094.         private final FieldODEStateInterpolator<T> mathInterpolator;

  1096.         /** Build an instance.
  1097.          * @param mathInterpolator underlying raw interpolator
  1098.          */
  1099.         FieldAdaptedStepInterpolator(final FieldODEStateInterpolator<T> mathInterpolator) {
  1100.             this.mathInterpolator = mathInterpolator;
  1101.         }

  1103.         /** {@inheritDoc}} */
  1104.         @Override
  1105.         public FieldSpacecraftState<T> getPreviousState() {
  1106.             return convert(mathInterpolator.getPreviousState());
  1107.         }

  1109.         /** {@inheritDoc}} */
  1110.         @Override
  1111.         public FieldSpacecraftState<T> getCurrentState() {
  1112.             return convert(mathInterpolator.getCurrentState());
  1113.         }

  1115.         /** {@inheritDoc}} */
  1116.         @Override
  1117.         public FieldSpacecraftState<T> getInterpolatedState(final FieldAbsoluteDate<T> date) {
  1118.             return convert(mathInterpolator.getInterpolatedState(date.durationFrom(getStartDate())));
  1119.         }

  1121.         /** Check is integration direction is forward in date.
  1122.          * @return true if integration is forward in date
  1123.          */
  1124.         public boolean isForward() {
  1125.             return mathInterpolator.isForward();
  1126.         }

  1128.         /** {@inheritDoc}} */
  1129.         @Override
  1130.         public FieldAdaptedStepInterpolator restrictStep(final FieldSpacecraftState<T> newPreviousState,
  1131.                                                          final FieldSpacecraftState<T> newCurrentState) {
  1132.             try {
  1133.                 final AbstractFieldODEStateInterpolator<T> aosi = (AbstractFieldODEStateInterpolator<T>) mathInterpolator;
  1134.                 return new FieldAdaptedStepInterpolator(aosi.restrictStep(convert(newPreviousState),
  1135.                                                                           convert(newCurrentState)));
  1136.             } catch (ClassCastException cce) {
  1137.                 // this should never happen
  1138.                 throw new OrekitInternalError(cce);
  1139.             }
  1140.         }

  1142.     }

  1144.     /** Specialized step handler storing interpolators for ephemeris generation.
  1145.      * @since 11.0
  1146.      */
  1147.     private class FieldStoringStepHandler implements FieldODEStepHandler<T>, FieldEphemerisGenerator<T> {

  1149.         /** Underlying raw mathematical model. */
  1150.         private FieldDenseOutputModel<T> model;

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

  1155.         /** Generated ephemeris. */
  1156.         private FieldBoundedPropagator<T> ephemeris;

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

  1161.         /** Set the end date.
  1162.          * @param endDate end date
  1163.          */
  1164.         public void setEndDate(final FieldAbsoluteDate<T> endDate) {
  1165.             this.endDate = endDate;
  1166.         }

  1168.         /** {@inheritDoc} */
  1169.         @Override
  1170.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  1171.             this.model = new FieldDenseOutputModel<>();
  1172.             model.init(s0, t);

  1174.             // ephemeris will be generated when last step is processed
  1175.             this.ephemeris = null;

  1177.             this.lastInterpolator = null;

  1179.         }

  1181.         /** {@inheritDoc} */
  1182.         @Override
  1183.         public FieldBoundedPropagator<T> getGeneratedEphemeris() {
  1184.             // Each time we try to get the ephemeris, rebuild it using the last data.
  1185.             buildEphemeris();
  1186.             return ephemeris;
  1187.         }

  1189.         /** {@inheritDoc} */
  1190.         @Override
  1191.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  1192.             model.handleStep(interpolator);
  1193.             lastInterpolator = interpolator;
  1194.         }

  1196.         /** {@inheritDoc} */
  1197.         @Override
  1198.         public void finish(final FieldODEStateAndDerivative<T> finalState) {
  1199.             buildEphemeris();
  1200.         }

  1202.         /** Method used to produce ephemeris at a given time.
  1203.          * Can be used at multiple times, updating the ephemeris to
  1204.          * its last state.
  1205.          */
  1206.         private void buildEphemeris() {
  1207.             // buildEphemeris was built in order to allow access to what was previously the finish method.
  1208.             // This now allows to call it through getGeneratedEphemeris, therefore through an external call,
  1209.             // which was not previously the case.

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

  1214.             // set up the boundary dates
  1215.             final T tI = model.getInitialTime();
  1216.             final T tF = model.getFinalTime();
  1217.             // tI is almost? always zero
  1218.             final FieldAbsoluteDate<T> startDate =
  1219.                             stateMapper.mapDoubleToDate(tI);
  1220.             final FieldAbsoluteDate<T> finalDate =
  1221.                             stateMapper.mapDoubleToDate(tF, this.endDate);
  1222.             final FieldAbsoluteDate<T> minDate;
  1223.             final FieldAbsoluteDate<T> maxDate;
  1224.             if (tF.getReal() < tI.getReal()) {
  1225.                 minDate = finalDate;
  1226.                 maxDate = startDate;
  1227.             } else {
  1228.                 minDate = startDate;
  1229.                 maxDate = finalDate;
  1230.             }

  1232.             // get the initial additional states that are not managed
  1233.             final FieldArrayDictionary<T> unmanaged = new FieldArrayDictionary<>(startDate.getField());
  1234.             for (final FieldArrayDictionary<T>.Entry initial : getInitialState().getAdditionalStatesValues().getData()) {
  1235.                 if (!isAdditionalStateManaged(initial.getKey())) {
  1236.                     // this additional state was in the initial state, but is unknown to the propagator
  1237.                     // we simply copy its initial value as is
  1238.                     unmanaged.put(initial.getKey(), initial.getValue());
  1239.                 }
  1240.             }

  1242.             // get the names of additional states managed by differential equations
  1243.             final String[] names      = new String[additionalDerivativesProviders.size()];
  1244.             final int[]    dimensions = new int[additionalDerivativesProviders.size()];
  1245.             for (int i = 0; i < names.length; ++i) {
  1246.                 names[i] = additionalDerivativesProviders.get(i).getName();
  1247.                 dimensions[i] = additionalDerivativesProviders.get(i).getDimension();
  1248.             }

  1250.             // create the ephemeris
  1251.             ephemeris = new FieldIntegratedEphemeris<>(startDate, minDate, maxDate,
  1252.                                                        stateMapper, propagationType, model,
  1253.                                                        unmanaged, getAdditionalStateProviders(),
  1254.                                                        names, dimensions);

  1256.         }

  1258.     }

  1260.     /** Wrapper for resetting an integrator handlers.
  1261.      * <p>
  1262.      * This class is intended to be used in a try-with-resource statement.
  1263.      * If propagator-specific event handlers and step handlers are added to
  1264.      * the integrator in the try block, they will be removed automatically
  1265.      * when leaving the block, so the integrator only keep its own handlers
  1266.      * between calls to {@link AbstractIntegratedPropagator#propagate(FieldAbsoluteDate, FieldAbsoluteDate).
  1267.      * </p>
  1268.      * @param <T> the type of the field elements
  1269.      * @since 11.0
  1270.      */
  1271.     private static class IntegratorResetter<T extends CalculusFieldElement<T>> implements AutoCloseable {

  1273.         /** Wrapped integrator. */
  1274.         private final FieldODEIntegrator<T> integrator;

  1276.         /** Initial event detectors list. */
  1277.         private final List<FieldODEEventDetector<T>> detectors;

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

  1282.         /** Simple constructor.
  1283.          * @param integrator wrapped integrator
  1284.          */
  1285.         IntegratorResetter(final FieldODEIntegrator<T> integrator) {
  1286.             this.integrator   = integrator;
  1287.             this.detectors    = new ArrayList<>(integrator.getEventDetectors());
  1288.             this.stepHandlers = new ArrayList<>(integrator.getStepHandlers());
  1289.         }

  1291.         /** {@inheritDoc}
  1292.          * <p>
  1293.          * Reset event handlers and step handlers back to the initial list
  1294.          * </p>
  1295.          */
  1296.         @Override
  1297.         public void close() {

  1299.             // reset event handlers
  1300.             integrator.clearEventDetectors();
  1301.             detectors.forEach(integrator::addEventDetector);

  1303.             // reset step handlers
  1304.             integrator.clearStepHandlers();
  1305.             stepHandlers.forEach(integrator::addStepHandler);

  1307.         }

  1309.     }

  1311. }
Created with JaCoCo 0.8.12.202403310830