Class FieldDSSTPropagator<T extends CalculusFieldElement<T>>

    • Constructor Detail

      • FieldDSSTPropagator

        public FieldDSSTPropagator​(Field<T> field,
                                   FieldODEIntegrator<T> integrator,
                                   PropagationType propagationType,
                                   AttitudeProvider attitudeProvider)
        Create a new instance of DSSTPropagator.

        After creation, there are no perturbing forces at all. This means that if addForceModel is not called after creation, the integrated orbit will follow a Keplerian evolution only.

        Parameters:
        field - field used by default
        integrator - numerical integrator to use for propagation.
        propagationType - type of orbit to output (mean or osculating).
        attitudeProvider - attitude law to use.
        Since:
        10.1
      • FieldDSSTPropagator

        public FieldDSSTPropagator​(Field<T> field,
                                   FieldODEIntegrator<T> integrator,
                                   AttitudeProvider attitudeProvider)
        Create a new instance of DSSTPropagator.

        After creation, there are no perturbing forces at all. This means that if addForceModel is not called after creation, the integrated orbit will follow a Keplerian evolution only. Only the mean orbits will be generated.

        Parameters:
        field - fied used by default
        integrator - numerical integrator to use for propagation.
        attitudeProvider - attitude law to use.
        Since:
        10.1
    • Method Detail

      • setInitialState

        public void setInitialState​(FieldSpacecraftState<T> initialState)
        Set the initial state with osculating orbital elements.
        Parameters:
        initialState - initial state (defined with osculating elements)
      • setInitialState

        public void setInitialState​(FieldSpacecraftState<T> initialState,
                                    PropagationType stateType)
        Set the initial state.
        Parameters:
        initialState - initial state
        stateType - defined if the orbital state is defined with osculating or mean elements
      • setSelectedCoefficients

        public void setSelectedCoefficients​(Set<String> selectedCoefficients)
        Set the selected short periodic coefficients that must be stored as additional states.
        Parameters:
        selectedCoefficients - short periodic coefficients that must be stored as additional states (null means no coefficients are selected, empty set means all coefficients are selected)
      • getSelectedCoefficients

        public Set<String> getSelectedCoefficients()
        Get the selected short periodic coefficients that must be stored as additional states.
        Returns:
        short periodic coefficients that must be stored as additional states (null means no coefficients are selected, empty set means all coefficients are selected)
      • initialIsOsculating

        public boolean initialIsOsculating()
        Check if the initial state is provided in osculating elements.
        Returns:
        true if initial state is provided in osculating elements
      • removeForceModels

        public void removeForceModels()
        Remove all perturbing force models from the global perturbation model (except central attraction).

        Once all perturbing forces have been removed (and as long as no new force model is added), the integrated orbit will follow a Keplerian evolution only.

        See Also:
        addForceModel(DSSTForceModel)
      • computeOsculatingState

        public static <T extends CalculusFieldElement<T>> FieldSpacecraftState<T> computeOsculatingState​(FieldSpacecraftState<T> mean,
                                                                                                         AttitudeProvider attitudeProvider,
                                                                                                         Collection<DSSTForceModel> forces)
        Conversion from mean to osculating orbit.

        Compute osculating state in a DSST sense, corresponding to the mean SpacecraftState in input, and according to the Force models taken into account.

        Since the osculating state is obtained by adding short-periodic variation of each force model, the resulting output will depend on the force models parameterized in input.

        Type Parameters:
        T - type of the elements
        Parameters:
        mean - Mean state to convert
        forces - Forces to take into account
        attitudeProvider - attitude provider (may be null if there are no Gaussian force models like atmospheric drag, radiation pressure or specific user-defined models)
        Returns:
        osculating state in a DSST sense
      • computeMeanState

        public static <T extends CalculusFieldElement<T>> FieldSpacecraftState<T> computeMeanState​(FieldSpacecraftState<T> osculating,
                                                                                                   AttitudeProvider attitudeProvider,
                                                                                                   Collection<DSSTForceModel> forceModel)
        Conversion from osculating to mean orbit.

        Compute mean state in a DSST sense, corresponding to the osculating SpacecraftState in input, and according to the Force models taken into account.

        Since the osculating state is obtained with the computation of short-periodic variation of each force model, the resulting output will depend on the force models parameterized in input.

        The computation is done through a fixed-point iteration process.

        Type Parameters:
        T - type of the elements
        Parameters:
        osculating - Osculating state to convert
        attitudeProvider - attitude provider (may be null if there are no Gaussian force models like atmospheric drag, radiation pressure or specific user-defined models)
        forceModel - Forces to take into account
        Returns:
        mean state in a DSST sense
      • computeMeanState

        public static <T extends CalculusFieldElement<T>> FieldSpacecraftState<T> computeMeanState​(FieldSpacecraftState<T> osculating,
                                                                                                   AttitudeProvider attitudeProvider,
                                                                                                   Collection<DSSTForceModel> forceModel,
                                                                                                   double epsilon,
                                                                                                   int maxIterations)
        Conversion from osculating to mean orbit.

        Compute mean state in a DSST sense, corresponding to the osculating SpacecraftState in input, and according to the Force models taken into account.

        Since the osculating state is obtained with the computation of short-periodic variation of each force model, the resulting output will depend on the force models parameterized in input.

        The computation is done through a fixed-point iteration process.

        Type Parameters:
        T - type of the elements
        Parameters:
        osculating - Osculating state to convert
        attitudeProvider - attitude provider (may be null if there are no Gaussian force models like atmospheric drag, radiation pressure or specific user-defined models)
        forceModel - Forces to take into account
        epsilon - convergence threshold for mean parameters conversion
        maxIterations - maximum iterations for mean parameters conversion
        Returns:
        mean state in a DSST sense
        Since:
        10.1
      • setSatelliteRevolution

        public void setSatelliteRevolution​(int satelliteRevolution)
        Override the default value of the parameter.

        By default, if the initial orbit is defined as osculating, it will be averaged over 2 satellite revolutions. This can be changed by using this method.

        Parameters:
        satelliteRevolution - number of satellite revolutions to use for converting osculating to mean elements
      • getSatelliteRevolution

        public int getSatelliteRevolution()
        Get the number of satellite revolutions to use for converting osculating to mean elements.
        Returns:
        number of satellite revolutions to use for converting osculating to mean elements
      • tolerances

        public static <T extends CalculusFieldElement<T>> double[][] tolerances​(T dP,
                                                                                FieldOrbit<T> orbit)
        Estimate tolerance vectors for an AdaptativeStepsizeIntegrator.

        The errors are estimated from partial derivatives properties of orbits, starting from a scalar position error specified by the user. Considering the energy conservation equation V = sqrt(mu (2/r - 1/a)), we get at constant energy (i.e. on a Keplerian trajectory):

          V r² |dV| = mu |dr|
          

        So we deduce a scalar velocity error consistent with the position error. From here, we apply orbits Jacobians matrices to get consistent errors on orbital parameters.

        The tolerances are only orders of magnitude, and integrator tolerances are only local estimates, not global ones. So some care must be taken when using these tolerances. Setting 1mm as a position error does NOT mean the tolerances will guarantee a 1mm error position after several orbits integration.

        Type Parameters:
        T - elements type
        Parameters:
        dP - user specified position error (m)
        orbit - reference orbit
        Returns:
        a two rows array, row 0 being the absolute tolerance error and row 1 being the relative tolerance error
      • tolerances

        public static <T extends CalculusFieldElement<T>> double[][] tolerances​(T dP,
                                                                                T dV,
                                                                                FieldOrbit<T> orbit)
        Estimate tolerance vectors for an AdaptativeStepsizeIntegrator.

        The errors are estimated from partial derivatives properties of orbits, starting from scalar position and velocity errors specified by the user.

        The tolerances are only orders of magnitude, and integrator tolerances are only local estimates, not global ones. So some care must be taken when using these tolerances. Setting 1mm as a position error does NOT mean the tolerances will guarantee a 1mm error position after several orbits integration.

        Type Parameters:
        T - elements type
        Parameters:
        dP - user specified position error (m)
        dV - user specified velocity error (m/s)
        orbit - reference orbit
        Returns:
        a two rows array, row 0 being the absolute tolerance error and row 1 being the relative tolerance error
        Since:
        10.3