Enum ErrorControl

pub enum ErrorControl {
    RSSCartesianState,
    RSSCartesianStep,
    RSSState,
    RSSStep,
    LargestError,
    LargestState,
    LargestStep,
}

The Error Control manages how a propagator computes the error in the current step.

Variants

RSSCartesianState

An RSS state error control which effectively for the provided vector composed of two vectors of the same unit, both of size 3 (e.g. position + velocity).

RSSCartesianStep

An RSS step error control which effectively for the provided vector composed of two vectors of the same unit, both of size 3 (e.g. position + velocity).

RSSState

An RSS state error control: when in doubt, use this error controller, especially for high accurracy.

Here is the warning from GMAT R2016a on this error controller:

This is a more stringent error control method than [rss_step] that is often used as the default in other software such as STK. If you set [the] accuracy to a very small number, 1e-13 for example, and set the error control to [rss_step], integrator performance will be poor, for little if any improvement in the accuracy of the orbit integration. For more best practices of these integrators (which clone those in GMAT), please refer to the GMAT reference. (Source)[https://github.com/ChristopherRabotin/GMAT/blob/37201a6290e7f7b941bc98ee973a527a5857104b/src/base/forcemodel/ODEModel.cpp#L3004]

RSSStep

An RSS step error control which effectively computes the L2 norm of the provided Vector of size 3

Note that this error controller should be preferably be used only with slices of a state with the same units. For example, one should probably use this for position independently of using it for the velocity. (Source)[https://github.com/ChristopherRabotin/GMAT/blob/37201a6290e7f7b941bc98ee973a527a5857104b/src/base/forcemodel/ODEModel.cpp#L3045]

LargestError

A largest error control which effectively computes the largest error at each component

This is a standard error computation algorithm, but it’s arguably bad if the state’s components have different units. It calculates the largest local estimate of the error from the integration (error_est) given the difference in the candidate state and the previous state (state_delta). This error estimator is from the physical model estimator of GMAT (Source)[https://github.com/ChristopherRabotin/GMAT/blob/37201a6290e7f7b941bc98ee973a527a5857104b/src/base/forcemodel/PhysicalModel.cpp#L987]

LargestState

A largest state error control

(Source)[https://github.com/ChristopherRabotin/GMAT/blob/37201a6290e7f7b941bc98ee973a527a5857104b/src/base/forcemodel/ODEModel.cpp#L3018]

LargestStep

A largest step error control which effectively computes the L1 norm of the provided Vector of size 3

Note that this error controller should be preferably be used only with slices of a state with the same units. For example, one should probably use this for position independently of using it for the velocity. (Source)[https://github.com/ChristopherRabotin/GMAT/blob/37201a6290e7f7b941bc98ee973a527a5857104b/src/base/forcemodel/ODEModel.cpp#L3033]

Implementations

impl ErrorControl

pub fn estimate<N: DimName>( self, error_est: &OVector<f64, N>, candidate: &OVector<f64, N>, cur_state: &OVector<f64, N>, ) -> f64

where DefaultAllocator: Allocator<N>,

Computes the actual error of the current step.

The error_est is the estimated error computed from the difference in the two stages of of the RK propagator. The candidate variable is the candidate state, and cur_state is the current state. This function must return the error.

Trait Implementations

impl Clone for ErrorControl

fn clone(&self) -> ErrorControl

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ErrorControl

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ErrorControl

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ErrorControl

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ErrorControl

fn eq(&self, other: &ErrorControl) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ErrorControl

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ErrorControl

impl Eq for ErrorControl

impl StructuralPartialEq for ErrorControl