Struct nyx_space::dynamics::orbital::OrbitalDynamics

pub struct OrbitalDynamics<'a> {
    pub accel_models: Vec<Arc<dyn AccelModel + Sync + 'a>>,
}

OrbitalDynamics provides the equations of motion for any celestial dynamic, without state transition matrix computation.

Fields

accel_models: Vec<Arc<dyn AccelModel + Sync + 'a>>

Implementations

impl<'a> OrbitalDynamics<'a>

pub fn point_masses(bodies: &[Bodies], cosm: Arc<Cosm>) -> Arc<Self>

Initialize point mass dynamics given the EXB IDs and a Cosm

pub fn two_body() -> Arc<Self>

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

pub fn new(accel_models: Vec<Arc<dyn AccelModel + Sync + 'a>>) -> Arc<Self>

Initialize orbital dynamics with a list of acceleration models

pub fn new_raw(accel_models: Vec<Arc<dyn AccelModel + Sync + 'a>>) -> Self

Initialize orbital dynamics with a list of acceleration models, without encapsulating it in an Arc Use this only if you need to mutate the dynamics as you’ll need to wrap it in an Arc before propagation.

pub fn from_model(accel_model: Arc<dyn AccelModel + Sync + 'a>) -> Arc<Self>

Initialize new orbital mechanics with the provided model. Note: Orbital dynamics always include two body dynamics, these cannot be turned off.

pub fn add_model(&mut self, accel_model: Arc<dyn AccelModel + Sync + 'a>)

Add a model to the currently defined orbital dynamics

pub fn with_model(
    self,
    accel_model: Arc<dyn AccelModel + Sync + 'a>
) -> Arc<Self>

Clone these dynamics and add a model to the currently defined orbital dynamics

Trait Implementations

impl<'a> Clone for OrbitalDynamics<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Dynamics for OrbitalDynamics<'a>

type HyperdualSize = U7

The state of the associated hyperdual state, almost always StateType + U1

type StateType = Orbit

fn eom(
    &self,
    delta_t_s: f64,
    state: &VectorN<f64, U42>,
    ctx: &Orbit
) -> Result<VectorN<f64, U42>, NyxError>

Defines the equations of motion for these dynamics, or a combination of provided dynamics. The time delta_t is in seconds PAST the context epoch. The state vector is the state which changes for every intermediate step of the integration. The state context is the state of what is being propagated, it should allow rebuilding a new state context from the provided state vector.

fn dual_eom(
    &self,
    _delta_t_s: f64,
    state: &VectorN<Hyperdual<f64, U7>, U6>,
    ctx: &Orbit
) -> Result<(Vector6<f64>, Matrix6<f64>), NyxError>

Defines the equations of motion for Dual numbers for these dynamics. All dynamics need to allow for automatic differentiation. However, if differentiation is not supported, then the dynamics should prevent initialization with a context which has an STM defined.

fn eom_grad(
    &self,
    delta_t_s: f64,
    state_vec: &VectorN<f64, <Self::StateType as State>::Size>,
    state_ctx: &Self::StateType
) -> Result<(VectorN<f64, <Self::StateType as State>::Size>, MatrixN<f64, <Self::StateType as State>::Size>), NyxError> where
    DefaultAllocator: Allocator<f64, <Self::StateType as State>::Size> + Allocator<f64, <Self::StateType as State>::Size, <Self::StateType as State>::Size> + Allocator<f64, Self::HyperdualSize> + Allocator<Hyperdual<f64, Self::HyperdualSize>, <Self::StateType as State>::Size>,
    Owned<f64, Self::HyperdualSize>: Copy, 

Computes both the state and the gradient of the dynamics. This function is pre-implemented.

fn finally(
    &self,
    next_state: Self::StateType
) -> Result<Self::StateType, NyxError>

Optionally performs some final changes after each successful integration of the equations of motion. For example, this can be used to update the GNC mode.