Class PythonFieldPropagator<T extends CalculusFieldElement<T>>

    • Constructor Detail

      • PythonFieldPropagator

        public PythonFieldPropagator()
    • Method Detail

      • pythonExtension

        public void pythonExtension​(long pythonObject)
        Part of JCC Python interface to object
      • pythonExtension

        public long pythonExtension()
        Part of JCC Python interface to object
      • pythonDecRef

        public void pythonDecRef()
        Part of JCC Python interface to object
      • setMasterMode_TF

        public void setMasterMode_TF​(T h,
                                     FieldOrekitFixedStepHandler<T> handler)
        Set the propagator to master mode with fixed steps.

        This mode is used when the user needs to have some custom function called at the end of each finalized step during integration. The (master) propagator integration loop calls the (slave) application callback methods at each finalized step.

        Parameters:
        h - fixed stepsize (s)
        handler - handler called at the end of each finalized step
        See Also:
        #setSlaveMode(), #setMasterMode(FieldOrekitStepHandler), #setEphemerisMode(), #getMode(), #MASTER_MODE
      • 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
      • isAdditionalStateManaged

        public boolean isAdditionalStateManaged​(String name)
        Check if an additional state is managed.

        Managed states are states for which the propagators know how to compute its evolution. They correspond to additional states for which an additional state provider has been registered by calling the addAdditionalStateProvider method. If the propagator is an integrator-based propagator, the states for which a set of additional equations has been registered by calling the addAdditionalEquations method are also counted as managed additional states.

        Additional states that are present in the initial state but have no evolution method registered are not considered as managed states. These unmanaged additional states are not lost during propagation, though. Their value will simply be copied unchanged throughout propagation.

        Specified by:
        isAdditionalStateManaged in interface FieldPropagator<T extends CalculusFieldElement<T>>
        Parameters:
        name - name of the additional state
        Returns:
        true if the additional state is managed
      • propagate

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

        Simple propagators use only the target date as the specification for computing the propagated state. More feature rich propagators can consider other information and provide different operating modes or G-stop facilities to stop at pinpointed events occurrences. In these cases, the target date is only a hint, not a mandatory objective.

        Specified by:
        propagate in interface FieldPropagator<T extends CalculusFieldElement<T>>
        Parameters:
        target - target date towards which orbit state should be propagated
        Returns:
        propagated state
      • 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
      • propagate_FF

        public FieldSpacecraftState<T> propagate_FF​(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.

        Parameters:
        start - start date from which orbit state should be propagated
        target - target date to which orbit state should be propagated
        Returns:
        propagated state