Package org.orekit.propagation.analytical

Class FieldAbstractAnalyticalPropagator<T extends CalculusFieldElement<T>>

    • Constructor Detail

      • FieldAbstractAnalyticalPropagator

        protected FieldAbstractAnalyticalPropagator​(Field<T> field,
                                            AttitudeProvider attitudeProvider)
        Build a new instance.
        Parameters:
        attitudeProvider - provider for attitude computation
        field - field used as default

    • Method Detail

      • getEphemerisGenerator

        public FieldEphemerisGenerator<T> getEphemerisGenerator()
        Set up an ephemeris generator that will monitor the propagation for building an ephemeris from it once completed.

        This generator can be used when the user needs fast random access to the orbit state at any time between the initial and target times. A typical example is the implementation of search and iterative algorithms that may navigate forward and backward inside the propagation range before finding their result even if the propagator used is integration-based and only goes from one initial time to one target time.

        Beware that when used with integration-based propagators, the generator will store all intermediate results. It is therefore memory intensive for long integration-based ranges and high precision/short time steps. When used with analytical propagators, the generator only stores start/stop time and a reference to the analytical propagator itself to call it back as needed, so it is less memory intensive.

        The returned ephemeris generator will be initially empty, it will be filled with propagation data when a subsequent call to either propagate(target) or propagate(start, target) is called. The proper way to use this method is therefore to do: 

           FieldEphemerisGenerator<T> generator = propagator.getEphemerisGenerator();
   propagator.propagate(target);
   FieldBoundedPropagator<T> ephemeris = generator.getGeneratedEphemeris();
        Specified by:
        getEphemerisGenerator in interface FieldPropagator<T extends CalculusFieldElement<T>>
        Returns:
        ephemeris generator

      • propagate

        public FieldSpacecraftState<T> propagate​(FieldAbsoluteDate<T> start,
                                         FieldAbsoluteDate<T> target)
        Propagate from a start date towards a target date.

        Those propagators use a start date and a target date to compute the propagated state. For propagators using event detection mechanism, if the provided start date is different from the initial state date, a first, simple propagation is performed, without processing any event computation. Then complete propagation is performed from start date to target date.

        Specified by:
        propagate in interface FieldPropagator<T extends CalculusFieldElement<T>>
        Parameters:
        start - start date from which orbit state should be propagated
        target - target date to which orbit state should be propagated
        Returns:
        propagated state

      • acceptStep

        protected FieldSpacecraftState<T> acceptStep​(org.orekit.propagation.analytical.FieldAbstractAnalyticalPropagator.FieldBasicStepInterpolator interpolator,
                                             FieldAbsoluteDate<T> target)
                                      throws MathRuntimeException
        Accept a step, triggering events and step handlers.
        Parameters:
        interpolator - interpolator for the current step
        target - final propagation time
        Returns:
        state at the end of the step
        Throws:
        MathRuntimeException - if an event cannot be located

      • getMass

        protected abstract T getMass​(FieldAbsoluteDate<T> date)
        Get the mass.
        Parameters:
        date - target date for the orbit
        Returns:
        mass mass

      • resetIntermediateState

        protected abstract void resetIntermediateState​(FieldSpacecraftState<T> state,
                                               boolean forward)
        Reset an intermediate state.
        Parameters:
        state - new intermediate state to consider
        forward - if true, the intermediate state is valid for propagations after itself

      • propagateOrbit

        protected abstract FieldOrbit<T> propagateOrbit​(FieldAbsoluteDate<T> date,
                                                T[] parameters)
        Extrapolate an orbit up to a specific target date.
        Parameters:
        date - target date for the orbit
        parameters - model parameters
        Returns:
        extrapolated parameters