Struct GroundAsset 

pub struct GroundAsset {
    pub latitude_deg: f64,
    pub longitude_deg: f64,
    pub height_km: f64,
    pub latitude_rate_deg_s: f64,
    pub longitude_rate_deg_s: f64,
    pub height_rate_km_s: f64,
    pub epoch: Epoch,
    pub frame: Frame,
    pub stm: Option<OMatrix<f64, Const<6>, Const<6>>>,
}

Represents a ground position/nav/timing receiver, e.g. a customer Note that we rebuild the Location structure from ANISE but without a terrain mask because the mask is not copyable and this PNTRx must be copyable to implement State.

Fields

latitude_deg: f64

longitude_deg: f64

height_km: f64

latitude_rate_deg_s: f64

longitude_rate_deg_s: f64

height_rate_km_s: f64

epoch: Epoch

frame: Frame

Frame on which this location rests

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

Implementations

impl GroundAsset

pub fn from_fixed( latitude_deg: f64, longitude_deg: f64, height_km: f64, epoch: Epoch, frame: Frame, ) -> Self

pub fn with_velocity_sez_m_s( self, vel_s_m_s: f64, vel_e_m_s: f64, vel_z_m_s: f64, ) -> Result<Self, Box<dyn Error>>

pub fn to_location(&self) -> Location

pub fn velocity_sez_m_s(&self) -> Result<OVector<f64, Const<3>>, PhysicsError>

Compute the velocity in m/s in the SEZ frame from the state data stored in latitude deg/s, longitude deg/s, and height in km/s for integration of EOMs

pub fn geodetic_to_cartesian_jacobian( &self, ) -> Result<Matrix6<f64>, PhysicsError>

pub fn great_circle_distance_km( &self, other: &Self, ) -> Result<f64, PhysicsError>

Computes the great circle (Haversine) distance between this asset and another in kilometers.

Note: This assumes a perfectly spherical body using the frame’s mean equatorial radius. It does not account for the ellipsoidal oblateness or the height_km of either asset.

Trait Implementations

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

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

Adds the provided state deviation to this orbit

type Output = GroundAsset

The resulting type after applying the + operator.

impl Clone for GroundAsset

fn clone(&self) -> GroundAsset

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GroundAsset

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

Formats the value using the given formatter.

impl Default for GroundAsset

fn default() -> Self

Returns the “default value” for a type.

impl Display for GroundAsset

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

Formats the value using the given formatter.

impl Interpolatable for GroundAsset

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

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).

impl LowerExp for GroundAsset

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

Formats the value using the given formatter.

impl PartialEq for GroundAsset

fn eq(&self, other: &GroundAsset) -> 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 ScalarSensitivityT<GroundAsset, GroundAsset, InterlinkTxSpacecraft> for ScalarSensitivity<GroundAsset, GroundAsset, InterlinkTxSpacecraft>

fn new( msr_type: MeasurementType, msr: &Measurement, rx: &GroundAsset, tx: &InterlinkTxSpacecraft, almanac: Arc<Almanac>, ) -> Result<Self, ODError>

First, we ensure that the transmitter vehicle is expressed in the same frame as the ground asset. Then we compute the AER as seen from the ground asset.

impl State for GroundAsset

fn set(&mut self, epoch: Epoch, vector: &OVector<f64, Const<42>>)

Vector is expected to be organized as such: [Latitude, Longitude, Height, ]

type Size = Const<6>

Size of the state and its STM

type VecLength = Const<{ 6 + 36 }>

fn to_vector(&self) -> OVector<f64, Self::VecLength>

Return this state as a vector for the propagation/estimation

fn orbit(&self) -> Orbit

Returns a copy of the orbit

fn epoch(&self) -> Epoch

Retrieve the Epoch

fn set_epoch(&mut self, epoch: Epoch)

Set the Epoch

fn reset_stm(&mut self)

Resets the STM, unimplemented by default.

fn unset_stm(&mut self)

Unsets the STM for this state

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

Return the state’s step state transition matrix. By default, this is not implemented. This function must be implemented when filtering on this state.

fn with_stm(self) -> Self

Copies the current state but sets the STM to identity

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, StateError>

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

fn zeros() -> Self

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

fn to_state_vector(&self) -> OVector<f64, Self::Size>

Returns strictly the state vector without any STM, if set.

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

where DefaultAllocator: Allocator<Self::VecLength>,

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

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

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 set_orbit(&mut self, _orbit: Orbit)

Modifies this state’s orbit

impl TrackerSensitivity<GroundAsset, GroundAsset> for InterlinkTxSpacecraft

where DefaultAllocator: Allocator<<Spacecraft as State>::Size> + Allocator<<Spacecraft as State>::VecLength> + Allocator<<Spacecraft as State>::Size, <Spacecraft as State>::Size>,

fn h_tilde<M: DimName>( &self, msr: &Measurement, msr_types: &IndexSet<MeasurementType>, rx: &GroundAsset, almanac: Arc<Almanac>, ) -> Result<OMatrix<f64, M, <GroundAsset as State>::Size>, ODError>

where DefaultAllocator: Allocator<M> + Allocator<M, <GroundAsset as State>::Size>,

Returns the sensitivity matrix of size MxS where M is the number of simultaneous measurements and S is the size of the state being solved for.

impl TrackingDevice<GroundAsset> for InterlinkTxSpacecraft

fn measure_instantaneous( &mut self, rx: GroundAsset, rng: Option<&mut Pcg64Mcg>, almanac: Arc<Almanac>, ) -> Result<Option<Measurement>, ODError>

Returns the Range and Doppler from pnt vehicle to ground asset (i.e. the opposed AER range and doppler data.)

fn measurement_covar( &self, msr_type: MeasurementType, epoch: Epoch, ) -> Result<f64, ODError>

Returns the measurement noise of this ground station.

Methodology

Noises are modeled using a [StochasticNoise] process, defined by the sigma on the turn-on bias and on the steady state noise. The measurement noise is computed assuming that all measurements are independent variables, i.e. the measurement matrix is a diagonal matrix. The first item in the diagonal is the range noise (in km), set to the square of the steady state sigma. The second item is the Doppler noise (in km/s), set to the square of the steady state sigma of that Gauss Markov process.

fn name(&self) -> String

Returns the name of this tracking data simulator

fn measurement_types(&self) -> &IndexSet<MeasurementType>

Returns the enabled measurement types for thie device.

fn location( &self, epoch: Epoch, frame: Frame, almanac: Arc<Almanac>, ) -> AlmanacResult<Orbit>

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

fn measure( &mut self, epoch: Epoch, traj: &Traj<GroundAsset>, rng: Option<&mut Pcg64Mcg>, almanac: Arc<Almanac>, ) -> Result<Option<Measurement>, ODError>

Performs a measurement of the input trajectory at the provided epoch (with integration times if relevant), and returns a measurement from itself to the input state. Returns None of the object is not visible. This trait function takes in a trajectory and epoch so it can properly simulate integration times for the measurements. If the random number generator is provided, it shall be used to add noise to the measurement.

fn measurement_bias( &self, msr_type: MeasurementType, _epoch: Epoch, ) -> Result<f64, ODError>

fn measurement_covar_matrix<M: DimName>( &self, msr_types: &IndexSet<MeasurementType>, epoch: Epoch, ) -> Result<OMatrix<f64, M, M>, ODError>

where DefaultAllocator: Allocator<M, M>,

fn measurement_bias_vector<M: DimName>( &self, msr_types: &IndexSet<MeasurementType>, epoch: Epoch, ) -> Result<OVector<f64, M>, ODError>

where DefaultAllocator: Allocator<M>,

impl Copy for GroundAsset

impl StructuralPartialEq for GroundAsset