Struct nyx_space::od::noise::gauss_markov::GaussMarkov

pub struct GaussMarkov {
    pub tau: Duration,
    pub bias_sigma: f64,
    pub steady_state_sigma: f64,
    pub bias: Option<f64>,
    pub epoch: Option<Epoch>,
}

A first order Gauss-Markov process for modeling biases as described in section 5.2.4 of the NASA Best Practices for Navigation Filters (D’Souza et al.).

The process is defined by the following stochastic differential equation:

\dot{b(t)} = -1/τ * b(t) + w(t)

Programmatically, it’s calculated as follows:

b(t + Δt) = b(t) * exp(-Δt / τ) + q * (1 - exp(-Δt / τ)) * w(t)

Where w(t) ~ 𝓝(0, σ_{ss}) is a zero-mean white noise process with standard deviation σ_ss, the steady state sigma.

Important

If the time constant is greater than 366 days, then the process is actually modeled as a white noise process. This allows the users to model a white noise process without having to change the process type.

Fields

tau: Duration

The time constant, tau gives the correlation time, or the time over which the intensity of the time correlation will fade to 1/e of its prior value. (This is sometimes incorrectly referred to as the “half-life” of the process.)

bias_sigma: f64

Standard deviation (or covariance) of the zero-mean white noise of the initial bias, noted σ_b.

steady_state_sigma: f64

The steady-state sigma is the zero-mean white noise as t → ∞, noted σ_q, and sometimes called the “constant”.

bias: Option<f64>

Latest bias, unset prior to the sample call and one will be generated from a zero mean normal distribution with standard deviation bias_sigma.

epoch: Option<Epoch>

Epoch of the latest sample of the process.

Implementations

impl GaussMarkov

pub fn new( tau: Duration, bias_sigma: f64, steady_state_sigma: f64 ) -> Result<Self, ConfigError>

Create a new first order Gauss-Markov process.

Arguments

• tau - The time constant, tau gives the correlation time, or the time over which the intensity of the time correlation will fade to 1/e of its prior value.
• bias_sigma - Standard deviation (or covariance) of the zero-mean white noise of the initial bias.
• steady_state_sigma - The steady-state sigma is the zero-mean white noise as t → ∞, noted q, and sometimes called the “constant”.

pub fn white_noise(sigma: f64) -> Self

Create a new GaussMarkov process as if it were purely a white noise (zero mean), i.e. without any time correlation.

pub fn next_bias<R: Rng>(&mut self, epoch: Epoch, rng: &mut R) -> f64

Return the next bias sample.

pub const ZERO: Self = _

Zero noise Gauss-Markov process.

pub fn default_range_km() -> Self

Typical noise on the ranging data from a non-high-precision ground station.

pub fn default_doppler_km_s() -> Self

Typical noise on the Doppler data from a non-high-precision ground station.

pub fn high_precision_range_km() -> Self

Example noise on the ranging data from a high-precision ground station, e.g. NASA Deep Space Network (DSN).

pub fn high_precision_doppler_km_s() -> Self

Example noise on the Doppler data from a high-precision ground station, e.g. NASA Deep Space Network (DSN).

pub fn from_pr_n0(pr_n0: f64, bandwidth_hz: f64) -> Self

Initializes a new Gauss Markov process as a time-uncorrelated white noise process, using only the Pr/N0 value and the bandwidth. This returns a white noise sigma in kilometers.

Equation

σ = c / (2 * B * √(Pr/N0))

Where c is the speed of light, B is the bandwidth in Hz, and the Pr/N0 is the signal-to-noise ratio.

pub fn from_default(kind: String) -> Result<Self, NyxError>

Initializes a new Gauss Markov process for the provided kind of model.

Available models are: Range, Doppler, RangeHP, Doppler HP (HP stands for high precision).

impl GaussMarkov

pub fn simulate( &self, path: String, runs: Option<u32>, unit: Option<String> ) -> Result<(), NyxError>

Simulate a Gauss Markov model and store the bias in a parquet file. Python: call as simulate(path, runs=25, unit=None) where the path is the output Parquet file, runs is the number of runs, and unit is the unit of the bias, reflected only in the headers of the parquet file.

The unit is only used in the headers of the parquet file.

This will simulate the model with “runs” different seeds, sampling the process 500 times for a duration of 5 times the time constant.

pub fn is_white(&self) -> bool

Returns whether or not this Gauss Markov process is modeled as white noise.

Trait Implementations

impl Clone for GaussMarkov

fn clone(&self) -> GaussMarkov

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConfigRepr for GaussMarkov

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<BTreeMap<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

fn loads_named(data: &str) -> Result<BTreeMap<String, Self>, ConfigError>

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

impl Debug for GaussMarkov

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GaussMarkov

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GaussMarkov

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

Formats the value using the given formatter.

impl Mul<f64> for GaussMarkov

fn mul(self, rhs: f64) -> Self::Output

Scale the Gauss Markov process by a constant, maintaining the same time constant.

type Output = GaussMarkov

The resulting type after applying the * operator.

impl PartialEq for GaussMarkov

fn eq(&self, other: &GaussMarkov) -> 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 GaussMarkov

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for GaussMarkov

impl StructuralPartialEq for GaussMarkov