FieldAbstractIntegratedPropagator.java

  1. /* Copyright 2002-2025 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.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.attitudes.AttitudeProviderModifier;
  52. import org.orekit.errors.OrekitException;
  53. import org.orekit.errors.OrekitInternalError;
  54. import org.orekit.errors.OrekitMessages;
  55. import org.orekit.frames.Frame;
  56. import org.orekit.orbits.OrbitType;
  57. import org.orekit.orbits.PositionAngleType;
  58. import org.orekit.propagation.FieldAbstractPropagator;
  59. import org.orekit.propagation.FieldAdditionalDataProvider;
  60. import org.orekit.propagation.FieldBoundedPropagator;
  61. import org.orekit.propagation.FieldEphemerisGenerator;
  62. import org.orekit.propagation.FieldSpacecraftState;
  63. import org.orekit.propagation.PropagationType;
  64. import org.orekit.propagation.events.FieldEventDetector;
  65. import org.orekit.propagation.events.handlers.FieldEventHandler;
  66. import org.orekit.propagation.sampling.FieldOrekitStepHandler;
  67. import org.orekit.propagation.sampling.FieldOrekitStepInterpolator;
  68. import org.orekit.time.FieldAbsoluteDate;
  69. import org.orekit.utils.FieldDataDictionary;


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

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

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

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

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

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

  98.     /** Additional derivatives providers.
  99.      * @since 11.1
  100.      */
  101.     private final List<FieldAdditionalDerivativesProvider<T>> additionalDerivativesProviders;

  103.     /** Counter for differential equations calls. */
  104.     private int calls;

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

  109.     /**
  110.      * Attitude provider when evaluating derivatives. Can be a frozen one for performance.
  111.      * @since 12.1
  112.      */
  113.     private AttitudeProvider attitudeProviderForDerivatives;

  115.     /**
  116.      * Attitude provider with frozen rates, used when possible for performance.
  117.      * @since 13.1
  118.      */
  119.     private AttitudeProvider frozenAttitudeProvider;

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

  124.     /** Type of orbit to output (mean or osculating) <br/>
  125.      * <p>
  126.      * This is used only in the case of semi-analytical propagators where there is a clear separation between
  127.      * mean and short periodic elements. It is ignored by the Numerical propagator.
  128.      * </p>
  129.      */
  130.     private final PropagationType propagationType;

  132.     /** Build a new instance.
  133.      * @param integrator numerical integrator to use for propagation.
  134.      * @param propagationType type of orbit to output (mean or osculating).
  135.      * @param field Field used by default
  136.      */
  137.     protected FieldAbstractIntegratedPropagator(final Field<T> field, final FieldODEIntegrator<T> integrator, final PropagationType propagationType) {
  138.         super(field);
  139.         detectors                      = new ArrayList<>();
  140.         ephemerisGenerators            = new ArrayList<>();
  141.         additionalDerivativesProviders = new ArrayList<>();
  142.         this.secondaryOffsets          = new HashMap<>();
  143.         this.integrator                = integrator;
  144.         this.propagationType           = propagationType;
  145.         this.resetAtEnd                = true;
  146.     }

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

  164.     /** Getter for the resetting flag regarding initial state.
  165.      * @return resetting flag
  166.      * @since 12.0
  167.      */
  168.     public boolean getResetAtEnd() {
  169.         return this.resetAtEnd;
  170.     }

  172.     /**
  173.      * Getter for the frozen attitude provider, used for performance when possible.
  174.      * @return frozen attitude provider
  175.      * @since 13.1
  176.      */
  177.     protected AttitudeProvider getFrozenAttitudeProvider() {
  178.         return frozenAttitudeProvider;
  179.     }

  181.     /**
  182.      * Method called when initializing the attitude provider used when evaluating derivatives.
  183.      * @return attitude provider for derivatives
  184.      */
  185.     protected AttitudeProvider initializeAttitudeProviderForDerivatives() {
  186.         return getAttitudeProvider();
  187.     }

  189.     /** Initialize the mapper.
  190.      * @param field Field used by default
  191.      */
  192.     protected void initMapper(final Field<T> field) {
  193.         final T zero = field.getZero();
  194.         stateMapper = createMapper(null, zero.add(Double.NaN), null, null, null, null);
  195.     }

  197.     /** Get the integrator's name.
  198.      * @return name of underlying integrator
  199.      * @since 12.0
  200.      */
  201.     public String getIntegratorName() {
  202.         return integrator.getName();
  203.     }

  205.     /**  {@inheritDoc} */
  206.     @Override
  207.     public void setAttitudeProvider(final AttitudeProvider attitudeProvider) {
  208.         super.setAttitudeProvider(attitudeProvider);
  209.         frozenAttitudeProvider = AttitudeProviderModifier.getFrozenAttitudeProvider(attitudeProvider);
  210.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  211.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  212.                                    attitudeProvider, stateMapper.getFrame());
  213.     }

  215.     /** Set propagation orbit type.
  216.      * @param orbitType orbit type to use for propagation
  217.      */
  218.     protected void setOrbitType(final OrbitType orbitType) {
  219.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  220.                                    orbitType, stateMapper.getPositionAngleType(),
  221.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  222.     }

  224.     /** Get propagation parameter type.
  225.      * @return orbit type used for propagation
  226.      */
  227.     protected OrbitType getOrbitType() {
  228.         return stateMapper.getOrbitType();
  229.     }

  231.     /** Check if only the mean elements should be used in a semi-analytical propagation.
  232.      * @return {@link PropagationType MEAN} if only mean elements have to be used or
  233.      *         {@link PropagationType OSCULATING} if osculating elements have to be also used.
  234.      */
  235.     protected PropagationType isMeanOrbit() {
  236.         return propagationType;
  237.     }

  239.     /** Get the propagation type.
  240.      * @return propagation type.
  241.      * @since 11.3.2
  242.      */
  243.     public PropagationType getPropagationType() {
  244.         return propagationType;
  245.     }

  247.     /** Set position angle type.
  248.      * <p>
  249.      * The position parameter type is meaningful only if {@link
  250.      * #getOrbitType() propagation orbit type}
  251.      * support it. As an example, it is not meaningful for propagation
  252.      * in {@link OrbitType#CARTESIAN Cartesian} parameters.
  253.      * </p>
  254.      * @param positionAngleType angle type to use for propagation
  255.      */
  256.     protected void setPositionAngleType(final PositionAngleType positionAngleType) {
  257.         stateMapper = createMapper(stateMapper.getReferenceDate(), stateMapper.getMu(),
  258.                                    stateMapper.getOrbitType(), positionAngleType,
  259.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  260.     }

  262.     /** Get propagation parameter type.
  263.      * @return angle type to use for propagation
  264.      */
  265.     protected PositionAngleType getPositionAngleType() {
  266.         return stateMapper.getPositionAngleType();
  267.     }

  269.     /** Set the central attraction coefficient μ.
  270.      * @param mu central attraction coefficient (m³/s²)
  271.      */
  272.     public void setMu(final T mu) {
  273.         stateMapper = createMapper(stateMapper.getReferenceDate(), mu,
  274.                                    stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  275.                                    stateMapper.getAttitudeProvider(), stateMapper.getFrame());
  276.     }

  278.     /** Get the central attraction coefficient μ.
  279.      * @return mu central attraction coefficient (m³/s²)
  280.      * @see #setMu(CalculusFieldElement)
  281.      */
  282.     public T getMu() {
  283.         return stateMapper.getMu();
  284.     }

  286.     /** Get the number of calls to the differential equations computation method.
  287.      * <p>The number of calls is reset each time the {@link #propagate(FieldAbsoluteDate)}
  288.      * method is called.</p>
  289.      * @return number of calls to the differential equations computation method
  290.      */
  291.     public int getCalls() {
  292.         return calls;
  293.     }

  295.     /** {@inheritDoc} */
  296.     @Override
  297.     public boolean isAdditionalDataManaged(final String name) {

  299.         // first look at already integrated data
  300.         if (super.isAdditionalDataManaged(name)) {
  301.             return true;
  302.         }

  304.         // then look at states we integrate ourselves
  305.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  306.             if (provider.getName().equals(name)) {
  307.                 return true;
  308.             }
  309.         }

  311.         return false;
  312.     }

  314.     /** {@inheritDoc} */
  315.     @Override
  316.     public String[] getManagedAdditionalData() {
  317.         final String[] alreadyIntegrated = super.getManagedAdditionalData();
  318.         final String[] managed = new String[alreadyIntegrated.length + additionalDerivativesProviders.size()];
  319.         System.arraycopy(alreadyIntegrated, 0, managed, 0, alreadyIntegrated.length);
  320.         for (int i = 0; i < additionalDerivativesProviders.size(); ++i) {
  321.             managed[i + alreadyIntegrated.length] = additionalDerivativesProviders.get(i).getName();
  322.         }
  323.         return managed;
  324.     }

  326.     /** Add a provider for user-specified state derivatives to be integrated along with the orbit propagation.
  327.      * @param provider provider for additional derivatives
  328.      * @see #addAdditionalDataProvider(FieldAdditionalDataProvider)
  329.      * @since 11.1
  330.      */
  331.     public void addAdditionalDerivativesProvider(final FieldAdditionalDerivativesProvider<T> provider) {
  332.         // check if the name is already used
  333.         if (this.isAdditionalDataManaged(provider.getName())) {
  334.             // these derivatives are already registered, complain
  335.             throw new OrekitException(OrekitMessages.ADDITIONAL_STATE_NAME_ALREADY_IN_USE,
  336.                                       provider.getName());
  337.         }

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

  342.         secondaryOffsets.clear();

  344.     }

  346.     /** Get an unmodifiable list of providers for additional derivatives.
  347.      * @return providers for additional derivatives
  348.      * @since 11.1
  349.      */
  350.     public List<FieldAdditionalDerivativesProvider<T>> getAdditionalDerivativesProviders() {
  351.         return Collections.unmodifiableList(additionalDerivativesProviders);
  352.     }

  354.     /** {@inheritDoc} */
  355.     public <D extends FieldEventDetector<T>> void addEventDetector(final D detector) {
  356.         detectors.add(detector);
  357.     }

  359.     /** {@inheritDoc} */
  360.     public Collection<FieldEventDetector<T>> getEventDetectors() {
  361.         return Collections.unmodifiableCollection(detectors);
  362.     }

  364.     /** {@inheritDoc} */
  365.     public void clearEventsDetectors() {
  366.         detectors.clear();
  367.     }

  369.     /** Set up all user defined event detectors.
  370.      */
  371.     protected void setUpUserEventDetectors() {
  372.         for (final FieldEventDetector<T> detector : detectors) {
  373.             setUpEventDetector(integrator, detector);
  374.         }
  375.     }

  377.     /** Wrap an Orekit event detector and register it to the integrator.
  378.      * @param integ integrator into which event detector should be registered
  379.      * @param detector event detector to wrap
  380.      */
  381.     protected void setUpEventDetector(final FieldODEIntegrator<T> integ, final FieldEventDetector<T> detector) {
  382.         integ.addEventDetector(new FieldAdaptedEventDetector(detector));
  383.     }

  385.     /**
  386.      * Clear the ephemeris generators.
  387.      * @since 13.0
  388.      */
  389.     public void clearEphemerisGenerators() {
  390.         ephemerisGenerators.clear();
  391.     }

  393.     /** {@inheritDoc} */
  394.     @Override
  395.     public FieldEphemerisGenerator<T> getEphemerisGenerator() {
  396.         final FieldStoringStepHandler storingHandler = new FieldStoringStepHandler();
  397.         ephemerisGenerators.add(storingHandler);
  398.         return storingHandler;
  399.     }

  401.     /** Create a mapper between raw double components and spacecraft state.
  402.     /** Simple constructor.
  403.      * <p>
  404.      * The position parameter type is meaningful only if {@link
  405.      * #getOrbitType() propagation orbit type}
  406.      * support it. As an example, it is not meaningful for propagation
  407.      * in {@link OrbitType#CARTESIAN Cartesian} parameters.
  408.      * </p>
  409.      * @param referenceDate reference date
  410.      * @param mu central attraction coefficient (m³/s²)
  411.      * @param orbitType orbit type to use for mapping
  412.      * @param positionAngleType angle type to use for propagation
  413.      * @param attitudeProvider attitude provider
  414.      * @param frame inertial frame
  415.      * @return new mapper
  416.      */
  417.     protected abstract FieldStateMapper<T> createMapper(FieldAbsoluteDate<T> referenceDate, T mu,
  418.                                                         OrbitType orbitType, PositionAngleType positionAngleType,
  419.                                                         AttitudeProvider attitudeProvider, Frame frame);

  421.     /** Get the differential equations to integrate (for main state only).
  422.      * @param integ numerical integrator to use for propagation.
  423.      * @return differential equations for main state
  424.      */
  425.     protected abstract MainStateEquations<T> getMainStateEquations(FieldODEIntegrator<T> integ);

  427.     /** {@inheritDoc} */
  428.     @Override
  429.     public FieldSpacecraftState<T> propagate(final FieldAbsoluteDate<T> target) {
  430.         if (getStartDate() == null) {
  431.             if (getInitialState() == null) {
  432.                 throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  433.             }
  434.             setStartDate(getInitialState().getDate());
  435.         }
  436.         return propagate(getStartDate(), target);
  437.     }

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

  442.         if (getInitialState() == null) {
  443.             throw new OrekitException(OrekitMessages.INITIAL_STATE_NOT_SPECIFIED_FOR_ORBIT_PROPAGATION);
  444.         }

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

  449.             // Initialize additional states
  450.             initializeAdditionalData(tEnd);

  452.             if (!tStart.equals(getInitialState().getDate())) {
  453.                 // if propagation start date is not initial date,
  454.                 // propagate from initial to start date without event detection
  455.                 try (IntegratorResetter<T> startResetter = new IntegratorResetter<>(integrator)) {
  456.                     integrateDynamics(tStart);
  457.                 }
  458.             }

  460.             // set up events added by user
  461.             setUpUserEventDetectors();

  463.             // set up step handlers
  464.             for (final FieldOrekitStepHandler<T> handler : getMultiplexer().getHandlers()) {
  465.                 integrator.addStepHandler(new FieldAdaptedStepHandler(handler));
  466.             }
  467.             for (final FieldStoringStepHandler generator : ephemerisGenerators) {
  468.                 generator.setEndDate(tEnd);
  469.                 integrator.addStepHandler(generator);
  470.             }

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

  475.             // Finalize event detectors
  476.             getEventDetectors().forEach(detector -> detector.finish(state));

  478.             return state;
  479.         }

  481.     }

  483.     /** Reset initial state with a given propagation type.
  484.      *
  485.      * <p> By default this method returns the same as method resetInitialState(FieldSpacecraftState)
  486.      * <p> Its purpose is mostly to be derived in FieldDSSTPropagator
  487.      *
  488.      * @param state new initial state to consider
  489.      * @param stateType type of the new state (mean or osculating)
  490.      * @since 12.1.3
  491.      */
  492.     public void resetInitialState(final FieldSpacecraftState<T> state, final PropagationType stateType) {
  493.         // Default behavior, do not take propagation type into account
  494.         resetInitialState(state);
  495.     }

  497.     /** Propagation with or without event detection.
  498.      * @param tEnd target date to which orbit should be propagated
  499.      * @return state at end of propagation
  500.      */
  501.     private FieldSpacecraftState<T> integrateDynamics(final FieldAbsoluteDate<T> tEnd) {
  502.         try {

  504.             initializePropagation();

  506.             if (getInitialState().getDate().equals(tEnd)) {
  507.                 // don't extrapolate
  508.                 return getInitialState();
  509.             }
  510.             // space dynamics view
  511.             stateMapper = createMapper(getInitialState().getDate(), stateMapper.getMu(),
  512.                                        stateMapper.getOrbitType(), stateMapper.getPositionAngleType(),
  513.                                        stateMapper.getAttitudeProvider(), getInitialState().getFrame());

  515.             // set propagation orbit type
  516.             if (Double.isNaN(getMu().getReal()) && getInitialState().isOrbitDefined()) {
  517.                 setMu(getInitialState().getOrbit().getMu());
  518.             }

  520.             if (getInitialState().getMass().getReal() <= 0.0) {
  521.                 throw new OrekitException(OrekitMessages.NOT_POSITIVE_SPACECRAFT_MASS,
  522.                                                getInitialState().getMass());
  523.             }

  525.             // convert space flight dynamics API to math API
  526.             final FieldSpacecraftState<T> initialIntegrationState = getInitialIntegrationState();
  527.             final FieldODEState<T> mathInitialState = createInitialState(initialIntegrationState);
  528.             final FieldExpandableODE<T> mathODE = createODE(integrator);

  530.             // mathematical integration
  531.             final FieldODEStateAndDerivative<T> mathFinalState;
  532.             beforeIntegration(initialIntegrationState, tEnd);
  533.             mathFinalState = integrator.integrate(mathODE, mathInitialState,
  534.                                                   tEnd.durationFrom(getInitialState().getDate()));

  536.             afterIntegration();

  538.             // get final state
  539.             FieldSpacecraftState<T> finalState =
  540.                             stateMapper.mapArrayToState(stateMapper.mapDoubleToDate(mathFinalState.getTime(), tEnd),
  541.                                                         mathFinalState.getPrimaryState(),
  542.                                                         mathFinalState.getPrimaryDerivative(),
  543.                                                         propagationType);

  545.             finalState = updateAdditionalStatesAndDerivatives(finalState, mathFinalState);

  547.             if (resetAtEnd) {
  548.                 resetInitialState(finalState, propagationType);
  549.                 setStartDate(finalState.getDate());
  550.             }

  552.             return finalState;

  554.         } catch (OrekitException pe) {
  555.             throw pe;
  556.         } catch (MathIllegalArgumentException | MathIllegalStateException me) {
  557.             throw OrekitException.unwrap(me);
  558.         }
  559.     }

  561.     /**
  562.      * Returns an updated version of the inputted state with additional states, including
  563.      * from derivatives providers.
  564.      * @param originalState input state
  565.      * @param os ODE state and derivative
  566.      * @return new state
  567.      * @since 12.1
  568.      */
  569.     private FieldSpacecraftState<T> updateAdditionalStatesAndDerivatives(final FieldSpacecraftState<T> originalState,
  570.                                                                          final FieldODEStateAndDerivative<T> os) {
  571.         FieldSpacecraftState<T> updatedState = originalState;
  572.         if (os.getNumberOfSecondaryStates() > 0) {
  573.             final T[] secondary           = os.getSecondaryState(1);
  574.             final T[] secondaryDerivative = os.getSecondaryDerivative(1);
  575.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  576.                 final String name      = provider.getName();
  577.                 final int    offset    = secondaryOffsets.get(name);
  578.                 final int    dimension = provider.getDimension();
  579.                 updatedState = updatedState.addAdditionalData(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  580.                 updatedState = updatedState.addAdditionalStateDerivative(name, Arrays.copyOfRange(secondaryDerivative, offset, offset + dimension));
  581.             }
  582.         }
  583.         return updateAdditionalData(updatedState);
  584.     }

  586.     /** Get the initial state for integration.
  587.      * @return initial state for integration
  588.      */
  589.     protected FieldSpacecraftState<T> getInitialIntegrationState() {
  590.         return getInitialState();
  591.     }

  593.     /** Create an initial state.
  594.      * @param initialState initial state in flight dynamics world
  595.      * @return initial state in mathematics world
  596.      */
  597.     private FieldODEState<T> createInitialState(final FieldSpacecraftState<T> initialState) {

  599.         // retrieve initial state
  600.         final T[] primary  = MathArrays.buildArray(initialState.getMass().getField(), getBasicDimension());
  601.         stateMapper.mapStateToArray(initialState, primary, null);

  603.         if (secondaryOffsets.isEmpty()) {
  604.             // compute dimension of the secondary state
  605.             int offset = 0;
  606.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  607.                 secondaryOffsets.put(provider.getName(), offset);
  608.                 offset += provider.getDimension();
  609.             }
  610.             secondaryOffsets.put(SECONDARY_DIMENSION, offset);
  611.         }

  613.         return new FieldODEState<>(initialState.getMass().getField().getZero(), primary, secondary(initialState));

  615.     }

  617.     /** Create secondary state.
  618.      * @param state spacecraft state
  619.      * @return secondary state
  620.      * @since 11.1
  621.      */
  622.     private T[][] secondary(final FieldSpacecraftState<T> state) {

  624.         if (secondaryOffsets.isEmpty()) {
  625.             return null;
  626.         }

  628.         final T[][] secondary = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  629.         for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  630.             final String name       = provider.getName();
  631.             final int    offset     = secondaryOffsets.get(name);
  632.             final T[]    additional = state.getAdditionalState(name);
  633.             System.arraycopy(additional, 0, secondary[0], offset, additional.length);
  634.         }

  636.         return secondary;

  638.     }

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

  646.         final FieldExpandableODE<T> ode =
  647.                 new FieldExpandableODE<>(new ConvertedMainStateEquations(getMainStateEquations(integ)));

  649.         // secondary part of the ODE
  650.         if (!additionalDerivativesProviders.isEmpty()) {
  651.             ode.addSecondaryEquations(new ConvertedSecondaryStateEquations());
  652.         }

  654.         return ode;

  656.     }

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

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

  679.     /** Get state vector dimension without additional parameters.
  680.      * @return state vector dimension without additional parameters.
  681.      */
  682.     public int getBasicDimension() {
  683.         return 7;

  685.     }

  687.     /** Get the integrator used by the propagator.
  688.      * @return the integrator.
  689.      */
  690.     protected FieldODEIntegrator<T> getIntegrator() {
  691.         return integrator;
  692.     }

  694.     /** Convert a state from mathematical world to space flight dynamics world without additional data and derivatives.
  695.      * @param os mathematical state
  696.      * @return space flight dynamics state
  697.      */
  698.     private FieldSpacecraftState<T> convertToOrekitWithoutAdditional(final FieldODEStateAndDerivative<T> os) {
  699.         return stateMapper.mapArrayToState(os.getTime(),
  700.                 os.getPrimaryState(),
  701.                 os.getPrimaryDerivative(),
  702.                 propagationType);
  703.     }

  705.     /** Convert a state from mathematical world to space flight dynamics world.
  706.      * @param os mathematical state
  707.      * @return space flight dynamics state
  708.      */
  709.     private FieldSpacecraftState<T> convertToOrekit(final FieldODEStateAndDerivative<T> os) {

  711.         FieldSpacecraftState<T> s = convertToOrekitWithoutAdditional(os);

  713.         if (os.getNumberOfSecondaryStates() > 0) {
  714.             final T[] secondary           = os.getSecondaryState(1);
  715.             final T[] secondaryDerivative = os.getSecondaryDerivative(1);
  716.             for (final FieldAdditionalDerivativesProvider<T> equations : additionalDerivativesProviders) {
  717.                 final String name      = equations.getName();
  718.                 final int    offset    = secondaryOffsets.get(name);
  719.                 final int    dimension = equations.getDimension();
  720.                 s = s.addAdditionalData(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  721.                 s = s.addAdditionalStateDerivative(name, Arrays.copyOfRange(secondaryDerivative, offset, offset + dimension));
  722.             }
  723.         }
  724.         return updateAdditionalData(s);

  726.     }

  728.     /** Differential equations for the main state (orbit, attitude and mass).
  729.      * @param <T> type of the field element
  730.      */
  731.     public interface MainStateEquations<T extends CalculusFieldElement<T>> {

  733.         /**
  734.          * Initialize the equations at the start of propagation. This method will be
  735.          * called before any calls to {@link #computeDerivatives(FieldSpacecraftState)}.
  736.          *
  737.          * <p> The default implementation of this method does nothing.
  738.          *
  739.          * @param initialState initial state information at the start of propagation.
  740.          * @param target       date of propagation. Not equal to {@code
  741.          *                     initialState.getDate()}.
  742.          */
  743.         void init(FieldSpacecraftState<T> initialState, FieldAbsoluteDate<T> target);

  745.         /** Compute differential equations for main state.
  746.          * @param state current state
  747.          * @return derivatives of main state
  748.          */
  749.         T[] computeDerivatives(FieldSpacecraftState<T> state);

  751.     }

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

  756.         /** Main state equations. */
  757.         private final MainStateEquations<T> main;

  759.         /** Simple constructor.
  760.          * @param main main state equations
  761.          */
  762.         ConvertedMainStateEquations(final MainStateEquations<T> main) {
  763.             this.main = main;
  764.             calls = 0;
  765.         }

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

  772.         @Override
  773.         public void init(final T t0, final T[] y0, final T finalTime) {
  774.             // update space dynamics view
  775.             FieldSpacecraftState<T> initialState = stateMapper.mapArrayToState(t0, y0, null, PropagationType.MEAN);
  776.             initialState = updateAdditionalData(initialState);
  777.             initialState = updateStatesFromAdditionalDerivativesIfKnown(initialState);
  778.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  779.             main.init(initialState, target);
  780.             attitudeProviderForDerivatives = initializeAttitudeProviderForDerivatives();
  781.         }

  783.         /**
  784.          * Returns an updated version of the inputted state, with additional states from
  785.          * derivatives providers as given in the stored initial state.
  786.          * @param originalState input state
  787.          * @return new state
  788.          * @since 12.1
  789.          */
  790.         private FieldSpacecraftState<T> updateStatesFromAdditionalDerivativesIfKnown(final FieldSpacecraftState<T> originalState) {
  791.             FieldSpacecraftState<T> updatedState = originalState;
  792.             final FieldSpacecraftState<T> storedInitialState = getInitialState();
  793.             final T originalTime = stateMapper.mapDateToDouble(originalState.getDate());
  794.             if (storedInitialState != null && stateMapper.mapDateToDouble(storedInitialState.getDate()).subtract(originalTime).isZero()) {
  795.                 for (final FieldAdditionalDerivativesProvider<T> provider: additionalDerivativesProviders) {
  796.                     final String name = provider.getName();
  797.                     final T[] value = storedInitialState.getAdditionalState(name);
  798.                     updatedState = updatedState.addAdditionalData(name, value);
  799.                 }
  800.             }
  801.             return updatedState;
  802.         }

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

  807.             // increment calls counter
  808.             ++calls;

  810.             // update space dynamics view
  811.             stateMapper.setAttitudeProvider(attitudeProviderForDerivatives);
  812.             FieldSpacecraftState<T> currentState = stateMapper.mapArrayToState(t, y, null, PropagationType.MEAN);
  813.             stateMapper.setAttitudeProvider(getAttitudeProvider());
  814.             currentState = updateAdditionalData(currentState);

  816.             // compute main state differentials
  817.             return main.computeDerivatives(currentState);

  819.         }

  821.     }

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

  826.         /** Dimension of the combined additional states. */
  827.         private final int combinedDimension;

  829.         /** Simple constructor.
  830.          */
  831.         ConvertedSecondaryStateEquations() {
  832.             this.combinedDimension = secondaryOffsets.get(SECONDARY_DIMENSION);
  833.         }

  835.         /** {@inheritDoc} */
  836.         @Override
  837.         public int getDimension() {
  838.             return combinedDimension;
  839.         }

  841.         /** {@inheritDoc} */
  842.         @Override
  843.         public void init(final T t0, final T[] primary0,
  844.                          final T[] secondary0, final T finalTime) {
  845.             // update space dynamics view
  846.             final FieldSpacecraftState<T> initialState = convert(t0, primary0, null, secondary0);

  848.             final FieldAbsoluteDate<T> target = stateMapper.mapDoubleToDate(finalTime);
  849.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  850.                 provider.init(initialState, target);
  851.             }

  853.         }

  855.         /** {@inheritDoc} */
  856.         @Override
  857.         public T[] computeDerivatives(final T t, final T[] primary,
  858.                                       final T[] primaryDot, final T[] secondary) {

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

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

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

  903.             return secondaryDot;

  905.         }

  907.         /** Convert mathematical view to space view.
  908.          * @param t current value of the independent <I>time</I> variable
  909.          * @param primary array containing the current value of the primary state vector
  910.          * @param primaryDot array containing the derivative of the primary state vector
  911.          * @param secondary array containing the current value of the secondary state vector
  912.          * @return space view of the state
  913.          */
  914.         private FieldSpacecraftState<T> convert(final T t, final T[] primary,
  915.                                                 final T[] primaryDot, final T[] secondary) {

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

  919.             for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  920.                 final String name      = provider.getName();
  921.                 final int    offset    = secondaryOffsets.get(name);
  922.                 final int    dimension = provider.getDimension();
  923.                 initialState = initialState.addAdditionalData(name, Arrays.copyOfRange(secondary, offset, offset + dimension));
  924.             }

  926.             return updateAdditionalData(initialState);

  928.         }

  930.     }

  932.     /** Adapt an {@link org.orekit.propagation.events.FieldEventDetector<T>}
  933.      * to Hipparchus {@link org.hipparchus.ode.events.FieldODEEventDetector<T>} interface.
  934.      * @author Fabien Maussion
  935.      */
  936.     private class FieldAdaptedEventDetector implements FieldODEEventDetector<T> {

  938.         /** Underlying event detector. */
  939.         private final FieldEventDetector<T> detector;

  941.         /** Underlying event handler.
  942.          * @since 12.0
  943.          */
  944.         private final FieldEventHandler<T> handler;

  946.         /** Time of the previous call to g. */
  947.         private T lastT;

  949.         /** Value from the previous call to g. */
  950.         private T lastG;

  952.         /** Build a wrapped event detector.
  953.          * @param detector event detector to wrap
  954.         */
  955.         FieldAdaptedEventDetector(final FieldEventDetector<T> detector) {
  956.             this.detector = detector;
  957.             this.handler  = detector.getHandler();
  958.             this.lastT    = getField().getZero().add(Double.NaN);
  959.             this.lastG    = getField().getZero().add(Double.NaN);
  960.         }

  962.         /** {@inheritDoc} */
  963.         @Override
  964.         public FieldAdaptableInterval<T> getMaxCheckInterval() {
  965.             return (state, isForward) -> detector.getMaxCheckInterval().currentInterval(convertToOrekitForEventFunction(state), isForward);
  966.         }

  968.         /** {@inheritDoc} */
  969.         @Override
  970.         public int getMaxIterationCount() {
  971.             return detector.getMaxIterationCount();
  972.         }

  974.         /** {@inheritDoc} */
  975.         @Override
  976.         public FieldBracketingNthOrderBrentSolver<T> getSolver() {
  977.             final T zero = detector.getThreshold().getField().getZero();
  978.             return new FieldBracketingNthOrderBrentSolver<>(zero, detector.getThreshold(), zero, 5);
  979.         }

  981.         /** {@inheritDoc} */
  982.         @Override
  983.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  984.             detector.init(convertToOrekit(s0), stateMapper.mapDoubleToDate(t));
  985.             this.lastT = getField().getZero().add(Double.NaN);
  986.             this.lastG = getField().getZero().add(Double.NaN);
  987.         }

  989.         /** {@inheritDoc} */
  990.         @Override
  991.         public void reset(final FieldODEStateAndDerivative<T> intermediateState, final T finalTime) {
  992.             detector.reset(convertToOrekit(intermediateState), stateMapper.mapDoubleToDate(finalTime));
  993.             this.lastT = getField().getZero().add(Double.NaN);
  994.             this.lastG = getField().getZero().add(Double.NaN);
  995.         }

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

  1006.         /**
  1007.          * Convert state from Hipparchus to Orekit format.
  1008.          * @param s state vector
  1009.          * @return Orekit state
  1010.          */
  1011.         private FieldSpacecraftState<T> convertToOrekitForEventFunction(final FieldODEStateAndDerivative<T> s) {
  1012.             if (!this.detector.dependsOnTimeOnly()) {
  1013.                 return convertToOrekit(s);
  1014.             } else {
  1015.                 // event function only needs time
  1016.                 stateMapper.setAttitudeProvider(getFrozenAttitudeProvider());
  1017.                 final FieldSpacecraftState<T> converted = convertToOrekitWithoutAdditional(s);
  1018.                 stateMapper.setAttitudeProvider(getAttitudeProvider());
  1019.                 return converted;
  1020.             }
  1021.         }

  1023.         /** {@inheritDoc} */
  1024.         public FieldODEEventHandler<T> getHandler() {

  1026.             return new FieldODEEventHandler<T>() {

  1028.                 /** {@inheritDoc} */
  1029.                 public Action eventOccurred(final FieldODEStateAndDerivative<T> s,
  1030.                                             final FieldODEEventDetector<T> d,
  1031.                                             final boolean increasing) {
  1032.                     return handler.eventOccurred(convertToOrekit(s), detector, increasing);
  1033.                 }

  1035.                 /** {@inheritDoc} */
  1036.                 @Override
  1037.                 public FieldODEState<T> resetState(final FieldODEEventDetector<T> d,
  1038.                                                    final FieldODEStateAndDerivative<T> s) {

  1040.                     final FieldSpacecraftState<T> oldState = convertToOrekit(s);
  1041.                     final FieldSpacecraftState<T> newState = handler.resetState(detector, oldState);
  1042.                     stateChanged(newState);

  1044.                     // main part
  1045.                     final T[] primary    = MathArrays.buildArray(getField(), s.getPrimaryStateDimension());
  1046.                     stateMapper.mapStateToArray(newState, primary, null);

  1048.                     // secondary part
  1049.                     final T[][] secondary = MathArrays.buildArray(getField(), 1, additionalDerivativesProviders.size());
  1050.                     for (final FieldAdditionalDerivativesProvider<T> provider : additionalDerivativesProviders) {
  1051.                         final String name      = provider.getName();
  1052.                         final int    offset    = secondaryOffsets.get(name);
  1053.                         final int    dimension = provider.getDimension();
  1054.                         System.arraycopy(newState.getAdditionalState(name), 0, secondary[0], offset, dimension);
  1055.                     }

  1057.                     return new FieldODEState<>(newState.getDate().durationFrom(getStartDate()),
  1058.                                                primary, secondary);
  1059.                 }
  1060.             };

  1062.         }

  1064.     }

  1066.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepHandler<T>}
  1067.      * to Hipparchus {@link FieldODEStepHandler<T>} interface.
  1068.      * @author Luc Maisonobe
  1069.      */
  1070.     private class FieldAdaptedStepHandler implements FieldODEStepHandler<T> {

  1072.         /** Underlying handler. */
  1073.         private final FieldOrekitStepHandler<T> handler;

  1075.         /** Build an instance.
  1076.          * @param handler underlying handler to wrap
  1077.          */
  1078.         FieldAdaptedStepHandler(final FieldOrekitStepHandler<T> handler) {
  1079.             this.handler = handler;
  1080.         }

  1082.         /** {@inheritDoc} */
  1083.         @Override
  1084.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  1085.             handler.init(convertToOrekit(s0), stateMapper.mapDoubleToDate(t));
  1086.         }

  1088.         /** {@inheritDoc} */
  1089.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  1090.             handler.handleStep(new FieldAdaptedStepInterpolator(interpolator));
  1091.         }

  1093.         /** {@inheritDoc} */
  1094.         @Override
  1095.         public void finish(final FieldODEStateAndDerivative<T> finalState) {
  1096.             handler.finish(convertToOrekit(finalState));
  1097.         }

  1099.     }

  1101.     /** Adapt an {@link org.orekit.propagation.sampling.FieldOrekitStepInterpolator<T>}
  1102.      * to Hipparchus {@link FieldODEStateInterpolator<T>} interface.
  1103.      * @author Luc Maisonobe
  1104.      */
  1105.     private class FieldAdaptedStepInterpolator implements FieldOrekitStepInterpolator<T> {

  1107.         /** Underlying raw rawInterpolator. */
  1108.         private final FieldODEStateInterpolator<T> mathInterpolator;

  1110.         /** Build an instance.
  1111.          * @param mathInterpolator underlying raw interpolator
  1112.          */
  1113.         FieldAdaptedStepInterpolator(final FieldODEStateInterpolator<T> mathInterpolator) {
  1114.             this.mathInterpolator = mathInterpolator;
  1115.         }

  1117.         /** {@inheritDoc}} */
  1118.         @Override
  1119.         public FieldSpacecraftState<T> getPreviousState() {
  1120.             return convertToOrekit(mathInterpolator.getPreviousState());
  1121.         }

  1123.         /** {@inheritDoc}} */
  1124.         @Override
  1125.         public FieldSpacecraftState<T> getCurrentState() {
  1126.             return convertToOrekit(mathInterpolator.getCurrentState());
  1127.         }

  1129.         /** {@inheritDoc}} */
  1130.         @Override
  1131.         public FieldSpacecraftState<T> getInterpolatedState(final FieldAbsoluteDate<T> date) {
  1132.             return convertToOrekit(mathInterpolator.getInterpolatedState(date.durationFrom(getStartDate())));
  1133.         }

  1135.         /** Check is integration direction is forward in date.
  1136.          * @return true if integration is forward in date
  1137.          */
  1138.         public boolean isForward() {
  1139.             return mathInterpolator.isForward();
  1140.         }

  1142.         /** {@inheritDoc}} */
  1143.         @Override
  1144.         public FieldAdaptedStepInterpolator restrictStep(final FieldSpacecraftState<T> newPreviousState,
  1145.                                                          final FieldSpacecraftState<T> newCurrentState) {
  1146.             try {
  1147.                 final AbstractFieldODEStateInterpolator<T> aosi = (AbstractFieldODEStateInterpolator<T>) mathInterpolator;
  1148.                 return new FieldAdaptedStepInterpolator(aosi.restrictStep(convertFromOrekit(newPreviousState),
  1149.                         convertFromOrekit(newCurrentState)));
  1150.             } catch (ClassCastException cce) {
  1151.                 // this should never happen
  1152.                 throw new OrekitInternalError(cce);
  1153.             }
  1154.         }

  1156.         /** Convert a state from space flight dynamics world to mathematical world.
  1157.          * @param state space flight dynamics state
  1158.          * @return mathematical state
  1159.          */
  1160.         private FieldODEStateAndDerivative<T> convertFromOrekit(final FieldSpacecraftState<T> state) {

  1162.             // retrieve initial state
  1163.             final T[] primary    = MathArrays.buildArray(getField(), getBasicDimension());
  1164.             final T[] primaryDot = MathArrays.buildArray(getField(), getBasicDimension());
  1165.             stateMapper.mapStateToArray(state, primary, primaryDot);

  1167.             // secondary part of the ODE
  1168.             final T[][] secondary           = secondary(state);
  1169.             final T[][] secondaryDerivative = secondaryDerivative(state);

  1171.             return new FieldODEStateAndDerivative<>(stateMapper.mapDateToDouble(state.getDate()),
  1172.                     primary, primaryDot,
  1173.                     secondary, secondaryDerivative);

  1175.         }

  1177.         /** Create secondary state derivative.
  1178.          * @param state spacecraft state
  1179.          * @return secondary state derivative
  1180.          * @since 11.1
  1181.          */
  1182.         private T[][] secondaryDerivative(final FieldSpacecraftState<T> state) {

  1184.             if (secondaryOffsets.isEmpty()) {
  1185.                 return null;
  1186.             }

  1188.             final T[][] secondaryDerivative = MathArrays.buildArray(state.getDate().getField(), 1, secondaryOffsets.get(SECONDARY_DIMENSION));
  1189.             for (final FieldAdditionalDerivativesProvider<T> providcer : additionalDerivativesProviders) {
  1190.                 final String name       = providcer.getName();
  1191.                 final int    offset     = secondaryOffsets.get(name);
  1192.                 final T[]    additionalDerivative = state.getAdditionalStateDerivative(name);
  1193.                 System.arraycopy(additionalDerivative, 0, secondaryDerivative[0], offset, additionalDerivative.length);
  1194.             }

  1196.             return secondaryDerivative;

  1198.         }

  1200.     }

  1202.     /** Specialized step handler storing interpolators for ephemeris generation.
  1203.      * @since 11.0
  1204.      */
  1205.     private class FieldStoringStepHandler implements FieldODEStepHandler<T>, FieldEphemerisGenerator<T> {

  1207.         /** Underlying raw mathematical model. */
  1208.         private FieldDenseOutputModel<T> model;

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

  1213.         /** Generated ephemeris. */
  1214.         private FieldBoundedPropagator<T> ephemeris;

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

  1219.         /** Set the end date.
  1220.          * @param endDate end date
  1221.          */
  1222.         public void setEndDate(final FieldAbsoluteDate<T> endDate) {
  1223.             this.endDate = endDate;
  1224.         }

  1226.         /** {@inheritDoc} */
  1227.         @Override
  1228.         public void init(final FieldODEStateAndDerivative<T> s0, final T t) {
  1229.             this.model = new FieldDenseOutputModel<>();
  1230.             model.init(s0, t);

  1232.             // ephemeris will be generated when last step is processed
  1233.             this.ephemeris = null;

  1235.             this.lastInterpolator = null;

  1237.         }

  1239.         /** {@inheritDoc} */
  1240.         @Override
  1241.         public FieldBoundedPropagator<T> getGeneratedEphemeris() {
  1242.             // Each time we try to get the ephemeris, rebuild it using the last data.
  1243.             buildEphemeris();
  1244.             return ephemeris;
  1245.         }

  1247.         /** {@inheritDoc} */
  1248.         @Override
  1249.         public void handleStep(final FieldODEStateInterpolator<T> interpolator) {
  1250.             model.handleStep(interpolator);
  1251.             lastInterpolator = interpolator;
  1252.         }

  1254.         /** {@inheritDoc} */
  1255.         @Override
  1256.         public void finish(final FieldODEStateAndDerivative<T> finalState) {
  1257.             buildEphemeris();
  1258.         }

  1260.         /** Method used to produce ephemeris at a given time.
  1261.          * Can be used at multiple times, updating the ephemeris to
  1262.          * its last state.
  1263.          */
  1264.         private void buildEphemeris() {
  1265.             // buildEphemeris was built in order to allow access to what was previously the finish method.
  1266.             // This now allows to call it through getGeneratedEphemeris, therefore through an external call,
  1267.             // which was not previously the case.

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

  1272.             // set up the boundary dates
  1273.             final T tI = model.getInitialTime();
  1274.             final T tF = model.getFinalTime();
  1275.             // tI is almost? always zero
  1276.             final FieldAbsoluteDate<T> startDate =
  1277.                             stateMapper.mapDoubleToDate(tI);
  1278.             final FieldAbsoluteDate<T> finalDate =
  1279.                             stateMapper.mapDoubleToDate(tF, this.endDate);
  1280.             final FieldAbsoluteDate<T> minDate;
  1281.             final FieldAbsoluteDate<T> maxDate;
  1282.             if (tF.getReal() < tI.getReal()) {
  1283.                 minDate = finalDate;
  1284.                 maxDate = startDate;
  1285.             } else {
  1286.                 minDate = startDate;
  1287.                 maxDate = finalDate;
  1288.             }

  1290.             // get the initial additional data that are not managed
  1291.             final FieldDataDictionary<T> unmanaged = new FieldDataDictionary<>(startDate.getField());
  1292.             for (final FieldDataDictionary<T>.Entry initial : getInitialState().getAdditionalDataValues().getData()) {
  1293.                 if (!FieldAbstractIntegratedPropagator.this.isAdditionalDataManaged(initial.getKey())) {
  1294.                     // this additional state was in the initial state, but is unknown to the propagator
  1295.                     // we simply copy its initial value as is
  1296.                     unmanaged.put(initial.getKey(), initial.getValue());
  1297.                 }
  1298.             }

  1300.             // get the names of additional states managed by differential equations
  1301.             final String[] names      = new String[additionalDerivativesProviders.size()];
  1302.             final int[]    dimensions = new int[additionalDerivativesProviders.size()];
  1303.             for (int i = 0; i < names.length; ++i) {
  1304.                 names[i] = additionalDerivativesProviders.get(i).getName();
  1305.                 dimensions[i] = additionalDerivativesProviders.get(i).getDimension();
  1306.             }

  1308.             // create the ephemeris
  1309.             ephemeris = new FieldIntegratedEphemeris<>(startDate, minDate, maxDate,
  1310.                                                        stateMapper, getAttitudeProvider(), propagationType, model,
  1311.                                                        unmanaged, getAdditionalDataProviders(),
  1312.                                                        names, dimensions);

  1314.         }

  1316.     }

  1318.     /** Wrapper for resetting an integrator handlers.
  1319.      * <p>
  1320.      * This class is intended to be used in a try-with-resource statement.
  1321.      * If propagator-specific event handlers and step handlers are added to
  1322.      * the integrator in the try block, they will be removed automatically
  1323.      * when leaving the block, so the integrator only keep its own handlers
  1324.      * between calls to {@link FieldAbstractIntegratedPropagator#propagate(FieldAbsoluteDate, FieldAbsoluteDate).
  1325.      * </p>
  1326.      * @param <T> the type of the field elements
  1327.      * @since 11.0
  1328.      */
  1329.     private static class IntegratorResetter<T extends CalculusFieldElement<T>> implements AutoCloseable {

  1331.         /** Wrapped integrator. */
  1332.         private final FieldODEIntegrator<T> integrator;

  1334.         /** Initial event detectors list. */
  1335.         private final List<FieldODEEventDetector<T>> detectors;

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

  1340.         /** Simple constructor.
  1341.          * @param integrator wrapped integrator
  1342.          */
  1343.         IntegratorResetter(final FieldODEIntegrator<T> integrator) {
  1344.             this.integrator   = integrator;
  1345.             this.detectors    = new ArrayList<>(integrator.getEventDetectors());
  1346.             this.stepHandlers = new ArrayList<>(integrator.getStepHandlers());
  1347.         }

  1349.         /** {@inheritDoc}
  1350.          * <p>
  1351.          * Reset event handlers and step handlers back to the initial list
  1352.          * </p>
  1353.          */
  1354.         @Override
  1355.         public void close() {

  1357.             // reset event handlers
  1358.             integrator.clearEventDetectors();
  1359.             detectors.forEach(integrator::addEventDetector);

  1361.             // reset step handlers
  1362.             integrator.clearStepHandlers();
  1363.             stepHandlers.forEach(integrator::addStepHandler);

  1365.         }

  1367.     }

  1369. }
Created with JaCoCo 0.8.12.202403310830