Struct nyx_space::dynamics::celestial::CelestialDynamicsStm

pub struct CelestialDynamicsStm<'a> {
    pub state: State,
    pub bodies: Vec<i32>,
    pub stm: Matrix6<f64>,
    pub cosm: Option<&'a Cosm>,
    pub correction: LTCorr,
    // some fields omitted
}

CelestialDynamicsStm provides the equations of motion for any celestial dynamic, with state transition matrix computation.

Fields

state: State

bodies: Vec<i32>

stm: Matrix6<f64>

cosm: Option<&'a Cosm>

correction: LTCorr

Methods

impl<'a> CelestialDynamicsStm<'a>

pub fn new(state: State, bodies: Vec<i32>, cosm: &'a Cosm) -> Self

Initialize third body dynamics given the EXB IDs and a Cosm

pub fn two_body(state: State) -> Self

Initializes a CelestialDynamicsStm which does not simulate the gravity pull of other celestial objects but the primary one.

pub fn as_state(&self) -> State

Provides a copy to the state.

pub fn set_orbital_state(&mut self, new_t: f64, new_state: &Vector6<f64>)

Used only to set the orbital state, useful for Extended Kalman Filters.

pub fn state_ctor(
    &self,
    t: f64,
    in_state: &VectorN<f64, U42>
) -> (State, Matrix6<f64>)

Rebuild the state and STM from the provided vector

Trait Implementations

impl<'a> AutoDiffDynamics for CelestialDynamicsStm<'a>

type HyperStateSize = U7

Defines the state size of the estimated state

type STMSize = U6

fn dual_eom(
    &self,
    t: f64,
    state: &VectorN<Hyperdual<f64, U7>, U6>
) -> (Vector6<f64>, Matrix6<f64>)

Defines the equations of motion for Dual numbers for these dynamics.

fn compute(
    &self,
    t: f64,
    state: &VectorN<f64, Self::STMSize>
) -> (VectorN<f64, Self::STMSize>, MatrixMN<f64, Self::STMSize, Self::STMSize>) where
    DefaultAllocator: Allocator<f64, Self::HyperStateSize> + Allocator<f64, Self::STMSize> + Allocator<f64, Self::STMSize, Self::STMSize> + Allocator<Hyperdual<f64, Self::HyperStateSize>, Self::STMSize>,
    Owned<f64, Self::HyperStateSize>: Copy, 

Computes both the state and the gradient of the dynamics. These may be accessed by the related getters.

impl<'a> Clone for CelestialDynamicsStm<'a>

fn clone(&self) -> CelestialDynamicsStm<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Dynamics for CelestialDynamicsStm<'a>

type StateSize = U42

Defines the state size for these dynamics. It must be imported from nalgebra.

type StateType = (State, Matrix6<f64>)

Defines the type which will be published on the propagator channel

fn time(&self) -> f64

Returns the relative time to the propagator. Use prop.dynamics.state.dt for absolute time

fn state_vector(&self) -> VectorN<f64, Self::StateSize>

Returns the current state of the dynamics as a vector so it can be integrated.

fn state(&self) -> Self::StateType

Returns the celestial state and the state transition matrix

fn set_state(&mut self, new_t: f64, new_state: &VectorN<f64, Self::StateSize>)

Updates the internal state of the dynamics.

fn eom(
    &self,
    t: f64,
    state: &VectorN<f64, Self::StateSize>
) -> VectorN<f64, Self::StateSize>

Defines the equations of motion for these dynamics, or a combination of provided dynamics.

impl<'a> Estimable<State> for CelestialDynamicsStm<'a>

type LinStateSize = U6

Defines the state size of the estimated state

fn to_measurement(&self, prop_state: &Self::StateType) -> (Epoch, State)

Converts the Dynamics' state type to a measurement to be ingested in a filter

fn extract_stm(&self, prop_state: &Self::StateType) -> Matrix6<f64>

Extracts the STM from the dynamics state

fn extract_estimated_state(
    &self,
    prop_state: &Self::StateType
) -> VectorN<f64, Self::LinStateSize>

Returns the estimated state

fn set_estimated_state(&mut self, new_state: VectorN<f64, Self::LinStateSize>)

Returns the estimated state

fn estimated_state(&self) -> VectorN<f64, Self::LinStateSize> where
    DefaultAllocator: Allocator<f64, Self::LinStateSize>, 

Returns the estimated state

fn stm(&self) -> MatrixMN<f64, Self::LinStateSize, Self::LinStateSize> where
    DefaultAllocator: Allocator<f64, Self::LinStateSize> + Allocator<f64, Self::LinStateSize, Self::LinStateSize>, 

Defines the gradient of the equations of motion for these dynamics.