Struct nyx_space::dynamics::spacecraft::SpacecraftDynamics

pub struct SpacecraftDynamics<'a> {
    pub orbital_dyn: Arc<OrbitalDynamics<'a>>,
    pub force_models: Vec<Arc<dyn ForceModel + 'a>>,
    pub ctrl: Option<Arc<dyn ThrustControl + 'a>>,
    pub decrement_mass: bool,
}

Fields

orbital_dyn: Arc<OrbitalDynamics<'a>>

force_models: Vec<Arc<dyn ForceModel + 'a>>

ctrl: Option<Arc<dyn ThrustControl + 'a>>

decrement_mass: bool

Implementations

impl<'a> SpacecraftDynamics<'a>

pub fn with_ctrl(
    orbital_dyn: Arc<OrbitalDynamics<'a>>,
    ctrl: Arc<dyn ThrustControl + 'a>
) -> Arc<Self>

Initialize a Spacecraft with a set of orbital dynamics and a propulsion subsystem. By default, the mass of the vehicle will be decremented as propellant is consummed.

pub fn with_ctrl_no_decr(
    orbital_dyn: Arc<OrbitalDynamics<'a>>,
    ctrl: Arc<dyn ThrustControl + 'a>
) -> Arc<Self>

Initialize a Spacecraft with a set of orbital dynamics and a propulsion subsystem. Will not decrement the fuel mass as propellant is consummed.

pub fn new(orbital_dyn: Arc<OrbitalDynamics<'a>>) -> Arc<Self>

Initialize a Spacecraft with a set of orbital dynamics and with SRP enabled.

pub fn new_raw(orbital_dyn: Arc<OrbitalDynamics<'a>>) -> Self

Initialize a Spacecraft with a set of orbital dynamics and with SRP enabled.

pub fn from_model(
    orbital_dyn: Arc<OrbitalDynamics<'a>>,
    force_model: Arc<dyn ForceModel + 'a>
) -> Arc<Self>

Initialize new spacecraft dynamics with the provided orbital mechanics and with the provided force model.

pub fn from_models(
    orbital_dyn: Arc<OrbitalDynamics<'a>>,
    force_models: Vec<Arc<dyn ForceModel + 'a>>
) -> Arc<Self>

Initialize new spacecraft dynamics with a vector of force models.

pub fn add_model(&mut self, force_model: Arc<dyn ForceModel + 'a>)

Add a model to the currently defined spacecraft dynamics

pub fn with_model(self, force_model: Arc<dyn ForceModel + 'a>) -> Arc<Self>

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

pub fn ctrl_achieved(&self, state: &Spacecraft) -> Result<bool, NyxError>

A shortcut to spacecraft.ctrl if the control is defined

Trait Implementations

impl<'a> Clone for SpacecraftDynamics<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Dynamics for SpacecraftDynamics<'a>

type HyperdualSize = U7

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

type StateType = Spacecraft

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.

fn eom(
    &self,
    delta_t: f64,
    state: &VectorN<f64, U43>,
    ctx: &Spacecraft
) -> Result<VectorN<f64, U43>, 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_vec: &VectorN<Hyperdual<f64, Self::HyperdualSize>, U7>,
    ctx: &Self::StateType
) -> Result<(VectorN<f64, U7>, MatrixN<f64, U7>), 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.