Struct nyx_space::cosmic::Spacecraft

pub struct Spacecraft {
    pub orbit: Orbit,
    pub dry_mass_kg: f64,
    pub fuel_mass_kg: f64,
    pub srp: SrpConfig,
    pub drag: DragConfig,
    pub thruster: Option<Thruster>,
    pub mode: GuidanceMode,
    pub stm: Option<OMatrix<f64, Const<9>, Const<9>>>,
}

A spacecraft state, composed of its orbit, its dry and fuel (wet) masses (in kg), its SRP configuration, its drag configuration, its thruster configuration, and its guidance mode.

Optionally, the spacecraft state can also store the state transition matrix from the start of the propagation until the current time (i.e. trajectory STM, not step-size STM).

Fields

orbit: Orbit

Initial orbit the vehicle is in

dry_mass_kg: f64

Dry mass, i.e. mass without fuel, in kg

fuel_mass_kg: f64

Fuel mass (if fuel mass is negative, thrusting will fail, unless configured to break laws of physics)

srp: SrpConfig

Solar Radiation Pressure configuration for this spacecraft

drag: DragConfig

thruster: Option<Thruster>

mode: GuidanceMode

Any extra information or extension that is needed for specific guidance laws

stm: Option<OMatrix<f64, Const<9>, Const<9>>>

Optionally stores the state transition matrix from the start of the propagation until the current time (i.e. trajectory STM, not step-size STM)

Implementations

impl Spacecraft

pub fn new( orbit: Orbit, dry_mass_kg: f64, fuel_mass_kg: f64, srp_area_m2: f64, drag_area_m2: f64, cr: f64, cd: f64 ) -> Self

Initialize a spacecraft state from all of its parameters

pub fn from_thruster( orbit: Orbit, dry_mass_kg: f64, fuel_mass_kg: f64, thruster: Thruster, mode: GuidanceMode ) -> Self

Initialize a spacecraft state from only a thruster and mass. Use this when designing guidance laws while ignoring drag and SRP.

pub fn from_srp_defaults( orbit: Orbit, dry_mass_kg: f64, srp_area_m2: f64 ) -> Self

Initialize a spacecraft state from the SRP default 1.8 for coefficient of reflectivity (fuel mass and drag parameters nullified!)

pub fn from_drag_defaults( orbit: Orbit, dry_mass_kg: f64, drag_area_m2: f64 ) -> Self

Initialize a spacecraft state from the SRP default 1.8 for coefficient of drag (fuel mass and SRP parameters nullified!)

pub fn with_dv(self, dv: Vector3<f64>) -> Self

pub fn with_dry_mass(self, dry_mass_kg: f64) -> Self

Returns a copy of the state with a new dry mass

pub fn with_fuel_mass(self, fuel_mass_kg: f64) -> Self

Returns a copy of the state with a new fuel mass

pub fn with_srp(self, srp_area_m2: f64, cr: f64) -> Self

Returns a copy of the state with a new SRP area and CR

pub fn with_srp_area(self, srp_area_m2: f64) -> Self

Returns a copy of the state with a new SRP area

pub fn with_cr(self, cr: f64) -> Self

Returns a copy of the state with a new coefficient of reflectivity

pub fn with_drag(self, drag_area_m2: f64, cd: f64) -> Self

Returns a copy of the state with a new drag area and CD

pub fn with_drag_area(self, drag_area_m2: f64) -> Self

Returns a copy of the state with a new SRP area

pub fn with_cd(self, cd: f64) -> Self

Returns a copy of the state with a new coefficient of drag

pub fn with_orbit(self, orbit: Orbit) -> Self

Returns a copy of the state with a new orbit

pub fn rss(&self, other: &Self) -> (f64, f64, f64)

Returns the root sum square error between this spacecraft and the other, in kilometers for the position, kilometers per second in velocity, and kilograms in fuel

pub fn enable_stm(&mut self)

Sets the STM of this state of identity, which also enables computation of the STM for spacecraft navigation

pub fn with_stm(self) -> Self

Copies the current state but sets the STM to identity

pub fn mass_kg(&self) -> f64

Returns the total mass in kilograms

pub fn with_guidance_mode(self, mode: GuidanceMode) -> Self

Returns a copy of the state with the provided guidance mode

pub fn mode(&self) -> GuidanceMode

pub fn mut_mode(&mut self, mode: GuidanceMode)

Trait Implementations

impl Add<Matrix<f64, Const<6>, Const<1>, <DefaultAllocator as Allocator<f64, Const<6>>>::Buffer>> for Spacecraft

fn add(self, other: OVector<f64, Const<6>>) -> Self

Adds the provided state deviation to this orbit

type Output = Spacecraft

The resulting type after applying the + operator.

impl Add<Matrix<f64, Const<9>, Const<1>, <DefaultAllocator as Allocator<f64, Const<9>>>::Buffer>> for Spacecraft

fn add(self, other: OVector<f64, Const<9>>) -> Self

Adds the provided state deviation to this orbit

type Output = Spacecraft

The resulting type after applying the + operator.

impl Clone for Spacecraft

fn clone(&self) -> Spacecraft

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConfigRepr for Spacecraft

fn load<P>(path: P) -> Result<Self, ConfigError>

where P: AsRef<Path>,

Builds the configuration representation from the path to a yaml

fn load_many<P>(path: P) -> Result<Vec<Self>, ConfigError>

where P: AsRef<Path>,

Builds a sequence of “Selves” from the provided path to a yaml

fn load_named<P>(path: P) -> Result<HashMap<String, Self>, ConfigError>

where P: AsRef<Path>,

Builds a map of names to “selves” from the provided path to a yaml

fn loads_many(data: &str) -> Result<Vec<Self>, ConfigError>

Builds a sequence of “Selves” from the provided string of a yaml

impl Configurable for Spacecraft

type IntermediateRepr = Spacecraft

The intermediate representation needed to create Self or to serialize Self.

fn from_config( cfg: Self::IntermediateRepr, _cosm: Arc<Cosm> ) -> Result<Self, ConfigError>

where Self: Sized,

Creates a new instance of self from the configuration.

fn to_config(&self) -> Result<Self::IntermediateRepr, ConfigError>

Converts self into the intermediate representation which is serializable.

fn from_yaml<P: AsRef<Path>>( path: P, cosm: Arc<Cosm> ) -> Result<Self, ConfigError>

impl Debug for Spacecraft

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

Formats the value using the given formatter.

impl Default for Spacecraft

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Spacecraft

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Spacecraft

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

Formats the value using the given formatter.

impl EstimateFrom<Spacecraft, RangeDoppler> for Orbit

fn extract(from: Spacecraft) -> Self

From the state extract the state to be estimated

fn sensitivity( msr: &RangeDoppler, receiver: Self, transmitter: Self ) -> OMatrix<f64, <RangeDoppler as Measurement>::MeasurementSize, Self::Size>

where DefaultAllocator: Allocator<f64, <RangeDoppler as Measurement>::MeasurementSize, Self::Size>,

Returns the measurement sensitivity (often referred to as H tilde).

impl EstimateFrom<Spacecraft, RangeDoppler> for Spacecraft

fn extract(from: Spacecraft) -> Self

From the state extract the state to be estimated

fn sensitivity( _msr: &RangeDoppler, _receiver: Self, _transmitter: Orbit ) -> OMatrix<f64, <RangeDoppler as Measurement>::MeasurementSize, Self::Size>

where DefaultAllocator: Allocator<f64, <RangeDoppler as Measurement>::MeasurementSize, Self::Size>,

Returns the measurement sensitivity (often referred to as H tilde).

impl EventEvaluator<Spacecraft> for Event

fn eval(&self, state: &Spacecraft) -> f64

Evaluation of the event, must return a value corresponding to whether the state is before or after the event

fn epoch_precision(&self) -> Duration

fn value_precision(&self) -> f64

fn eval_string(&self, state: &Spacecraft) -> String

Returns a string representation of the event evaluation for the given state

fn eval_crossing(&self, prev_state: &S, next_state: &S) -> bool

impl EventEvaluator<Spacecraft> for PenumbraEvent

fn epoch_precision(&self) -> Duration

Stop searching when the time has converged to less than 0.1 seconds

fn value_precision(&self) -> f64

Finds the slightest penumbra within 2%(i.e. 98% in visibility)

fn eval(&self, sc: &Spacecraft) -> f64

Evaluation of the event, must return a value corresponding to whether the state is before or after the event

fn eval_string(&self, state: &Spacecraft) -> String

Returns a string representation of the event evaluation for the given state

fn eval_crossing(&self, prev_state: &S, next_state: &S) -> bool

impl EventEvaluator<Spacecraft> for UmbraEvent

fn epoch_precision(&self) -> Duration

Stop searching when the time has converged to less than 0.1 seconds

fn value_precision(&self) -> f64

Finds the darkest part of an eclipse within 2% of penumbra (i.e. 98% in shadow)

fn eval(&self, sc: &Spacecraft) -> f64

Evaluation of the event, must return a value corresponding to whether the state is before or after the event

fn eval_string(&self, state: &Spacecraft) -> String

Returns a string representation of the event evaluation for the given state

fn eval_crossing(&self, prev_state: &S, next_state: &S) -> bool

impl Interpolatable for Spacecraft

fn interpolate(self, epoch: Epoch, states: &[Self]) -> Result<Self, NyxError>

Interpolates a new state at the provided epochs given a slice of states.

fn frame(&self) -> Frame

Returns the frame of this state

fn set_frame(&mut self, frame: Frame)

Sets the frame of this state

fn export_params() -> Vec<StateParameter>

List of state parameters that will be exported to a trajectory file in addition to the epoch (provided in this different formats).

fn orbit(&self) -> &Orbit

Returns the orbit

impl LowerExp for Spacecraft

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

Formats the value using the given formatter.

impl LowerHex for Spacecraft

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

Formats the value using the given formatter.

impl PartialEq for Spacecraft

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Spacecraft

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl State for Spacecraft

fn as_vector(&self) -> Result<OVector<f64, Const<90>>, NyxError>

The vector is organized as such: [X, Y, Z, Vx, Vy, Vz, Cr, Cd, Fuel mass, STM(9x9)]

fn set( &mut self, epoch: Epoch, vector: &OVector<f64, Const<90>> ) -> Result<(), NyxError>

Vector is expected to be organized as such: [X, Y, Z, Vx, Vy, Vz, Cr, Cd, Fuel mass, STM(9x9)]

fn stm(&self) -> Result<OMatrix<f64, Self::Size, Self::Size>, NyxError>

diag(STM) = [X,Y,Z,Vx,Vy,Vz,Cr,Cd,Fuel] WARNING: Currently the STM assumes that the fuel mass is constant at ALL TIMES!

type Size = Const<9>

Size of the state and its STM

type VecLength = Const<90>

fn reset_stm(&mut self)

Return this state as a vector for the propagation/estimation By default, this is not implemented. This function must be implemented when filtering on this state.

fn zeros() -> Self

Initialize an empty state By default, this is not implemented. This function must be implemented when filtering on this state.

fn epoch(&self) -> Epoch

Retrieve the Epoch

fn set_epoch(&mut self, epoch: Epoch)

Set the Epoch

fn add(self, other: OVector<f64, Self::Size>) -> Self

By default, this is not implemented. This function must be implemented when filtering on this state.

fn value(&self, param: StateParameter) -> Result<f64, NyxError>

Return the value of the parameter, returns an error by default

fn set_value(&mut self, param: StateParameter, val: f64) -> Result<(), NyxError>

Allows setting the value of the given parameter. NOTE: Most parameters where the value is available CANNOT be also set for that parameter (it’s a much harder problem!)

fn unset_stm(&mut self)

Unsets the STM for this state

fn set_with_delta_seconds( self, delta_t_s: f64, vector: &OVector<f64, Self::VecLength> ) -> Self

where DefaultAllocator: Allocator<f64, Self::VecLength>,

Reconstruct a new State from the provided delta time in seconds compared to the current state and with the provided vector.

impl TrackingDeviceSim<Spacecraft, RangeDoppler> for GroundStation

fn measure( &mut self, epoch: Epoch, traj: &Traj<Spacecraft>, rng: Option<&mut Pcg64Mcg>, cosm: Arc<Cosm> ) -> Result<Option<RangeDoppler>, NyxError>

Perform a measurement from the ground station to the receiver (rx).

fn name(&self) -> String

Returns the name of this tracking data simulator

fn location(&self, epoch: Epoch, frame: Frame, cosm: &Cosm) -> Orbit

Returns the device location at the given epoch and in the given frame.

fn measure_instantaneous( &mut self, rx: Spacecraft, rng: Option<&mut Pcg64Mcg>, cosm: Arc<Cosm> ) -> Result<Option<RangeDoppler>, NyxError>

impl UpperExp for Spacecraft

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

Formats the value using the given formatter.

impl UpperHex for Spacecraft

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

Formats the value using the given formatter.

impl Copy for Spacecraft