Struct nyx_space::od::ui::ODProcess

pub struct ODProcess<'a, D: Dynamics, E: ErrorCtrl, Msr: Measurement<StateSize = <S as State>::Size>, N: MeasurementDevice<S, Msr>, T: EkfTrigger, A: DimName, S: EstimateFrom<D::StateType>, K: Filter<S, A, Msr::MeasurementSize>> where
    D::StateType: Add<VectorN<f64, <S as State>::Size>, Output = D::StateType>,
    DefaultAllocator: Allocator<f64, <D::StateType as State>::Size> + Allocator<f64, <S as State>::Size> + Allocator<f64, <D::StateType as State>::PropVecSize> + Allocator<f64, Msr::MeasurementSize> + Allocator<f64, Msr::MeasurementSize, Msr::StateSize> + Allocator<f64, Msr::StateSize> + Allocator<f64, Msr::MeasurementSize, Msr::MeasurementSize> + Allocator<f64, Msr::MeasurementSize, <D::StateType as State>::Size> + Allocator<f64, <D::StateType as State>::Size, Msr::MeasurementSize> + Allocator<f64, <D::StateType as State>::Size, <D::StateType as State>::Size> + Allocator<f64, <S as State>::Size, <S as State>::Size> + Allocator<f64, A> + Allocator<f64, A, A> + Allocator<f64, <D::StateType as State>::Size, A> + Allocator<f64, A, <D::StateType as State>::Size> + Allocator<f64, <S as State>::Size, A> + Allocator<f64, A, <S as State>::Size>,  {
    pub prop: PropInstance<'a, D, E>,
    pub kf: K,
    pub devices: Vec<N>,
    pub simultaneous_msr: bool,
    pub estimates: Vec<K::Estimate>,
    pub residuals: Vec<Residual<Msr::MeasurementSize>>,
    pub ekf_trigger: T,
    // some fields omitted
}

An orbit determination process. Note that everything passed to this structure is moved.

Fields

prop: PropInstance<'a, D, E>

PropInstance used for the estimation

kf: K

Kalman filter itself

devices: Vec<N>

List of measurement devices used

simultaneous_msr: bool

Whether or not these devices can make simultaneous measurements of the spacecraft

estimates: Vec<K::Estimate>

Vector of estimates available after a pass

residuals: Vec<Residual<Msr::MeasurementSize>>

Vector of residuals available after a pass

ekf_trigger: T

Implementations

impl<'a, D: Dynamics, E: ErrorCtrl, Msr: Measurement<StateSize = <S as State>::Size>, N: MeasurementDevice<S, Msr>, T: EkfTrigger, A: DimName, S: EstimateFrom<D::StateType>, K: Filter<S, A, Msr::MeasurementSize>> ODProcess<'a, D, E, Msr, N, T, A, S, K> where
    D::StateType: Add<VectorN<f64, <S as State>::Size>, Output = D::StateType>,
    DefaultAllocator: Allocator<f64, <D::StateType as State>::Size> + Allocator<f64, Msr::MeasurementSize> + Allocator<f64, Msr::MeasurementSize, Msr::StateSize> + Allocator<f64, Msr::StateSize> + Allocator<f64, Msr::MeasurementSize, Msr::MeasurementSize> + Allocator<f64, Msr::MeasurementSize, <D::StateType as State>::Size> + Allocator<f64, Msr::MeasurementSize, <S as State>::Size> + Allocator<f64, <D::StateType as State>::Size, Msr::MeasurementSize> + Allocator<f64, <S as State>::Size, Msr::MeasurementSize> + Allocator<f64, <D::StateType as State>::Size, <D::StateType as State>::Size> + Allocator<f64, <D::StateType as State>::PropVecSize> + Allocator<f64, A> + Allocator<f64, A, A> + Allocator<f64, <D::StateType as State>::Size, A> + Allocator<f64, A, <D::StateType as State>::Size> + Allocator<f64, <S as State>::Size> + Allocator<f64, <S as State>::Size, <S as State>::Size> + Allocator<f64, <S as State>::Size, A> + Allocator<f64, A, <S as State>::Size>, 

pub fn ekf(
    prop: PropInstance<'a, D, E>,
    kf: K,
    devices: Vec<N>,
    simultaneous_msr: bool,
    num_expected_msr: usize,
    trigger: T
) -> Self

pub fn default_ekf(
    prop: PropInstance<'a, D, E>,
    kf: K,
    devices: Vec<N>,
    trigger: T
) -> Self

pub fn smooth(
    &mut self,
    condition: SmoothingArc
) -> Result<Vec<K::Estimate>, NyxError>

Allows to smooth the provided estimates. Returns the smoothed estimates or an error.

Estimates must be ordered in chronological order. This function will smooth the estimates from the last in the list to the first one.

pub fn iterate(
    &mut self,
    measurements: &[Msr],
    condition: SmoothingArc
) -> Result<(), NyxError>

Allows iterating on the filter solution. Requires specifying a smoothing condition to know where to stop the smoothing.

pub fn process_measurements(
    &mut self,
    measurements: &[Msr]
) -> Result<(), NyxError>

Allows processing all measurements with covariance mapping.

Important notes: + the measurements have be to mapped to a fixed time corresponding to the step of the propagator

pub fn map_covar(&mut self, end_epoch: Epoch) -> Result<(), NyxError>

Allows for covariance mapping without processing measurements

pub fn to_nav_traj(&self) -> Result<Traj<S>, NyxError> where
    DefaultAllocator: Allocator<f64, <S as State>::PropVecSize>, 

Builds the navigation trajectory for the estimated state only (no covariance until https://gitlab.com/nyx-space/nyx/-/issues/199!)

impl<'a, D: Dynamics, E: ErrorCtrl, Msr: Measurement<StateSize = <S as State>::Size>, N: MeasurementDevice<S, Msr>, A: DimName, S: EstimateFrom<D::StateType>, K: Filter<S, A, Msr::MeasurementSize>> ODProcess<'a, D, E, Msr, N, CkfTrigger, A, S, K> where
    D::StateType: Add<VectorN<f64, <S as State>::Size>, Output = D::StateType>,
    DefaultAllocator: Allocator<f64, <D::StateType as State>::Size> + Allocator<f64, <D::StateType as State>::PropVecSize> + Allocator<f64, Msr::MeasurementSize> + Allocator<f64, Msr::MeasurementSize, Msr::StateSize> + Allocator<f64, Msr::StateSize> + Allocator<f64, Msr::MeasurementSize, Msr::MeasurementSize> + Allocator<f64, Msr::MeasurementSize, <D::StateType as State>::Size> + Allocator<f64, <D::StateType as State>::Size, Msr::MeasurementSize> + Allocator<f64, <S as State>::Size, Msr::MeasurementSize> + Allocator<f64, Msr::MeasurementSize, <S as State>::Size> + Allocator<f64, <D::StateType as State>::Size, <D::StateType as State>::Size> + Allocator<f64, <S as State>::Size> + Allocator<f64, <S as State>::Size, <S as State>::Size> + Allocator<f64, A> + Allocator<f64, A, A> + Allocator<f64, <D::StateType as State>::Size, A> + Allocator<f64, A, <D::StateType as State>::Size> + Allocator<f64, <S as State>::Size, A> + Allocator<f64, A, <S as State>::Size>, 

pub fn ckf(
    prop: PropInstance<'a, D, E>,
    kf: K,
    devices: Vec<N>,
    simultaneous_msr: bool,
    num_expected_msr: usize
) -> Self

pub fn default_ckf(prop: PropInstance<'a, D, E>, kf: K, devices: Vec<N>) -> Self