gnss-rtk 0.8.0

GNSS position solver
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

use crate::{
    navigation::apriori::Apriori,
    prelude::{Almanac, Config, Duration, Epoch, Frame, Method, TimeScale},
    tests::{fuzz::FuzzTest, reference_apriori_at_ref_epoch, TestNumber},
};

use anise::constants::frames::IAU_EARTH_FRAME;

use rstest::*;

#[fixture]
fn build_almanac() -> Almanac {
    use crate::tests::almanac;
    almanac()
}

#[fixture]
fn build_earth_frame() -> Frame {
    use crate::tests::earth_frame;
    earth_frame()
}

#[fixture]
fn build_initial_apriori() -> Apriori {
    use crate::tests::reference_apriori_at_ref_epoch;
    reference_apriori_at_ref_epoch()
}

#[derive(Debug, Clone)]
pub struct FuzzTestSettings {
    /// Name of this test
    pub name: String,

    /// Timescale
    pub timescale: TimeScale,

    /// Total number of epochs
    pub num_epochs: TestNumber<usize>,

    /// Number of SV per epoch
    pub num_sv: TestNumber<usize>,

    /// Number of signals
    pub num_signals: TestNumber<usize>,

    /// navi [Method] to deploy
    pub method: Method,

    /// Uses apriori preset or not
    pub apriori: bool,

    /// True if default signal is L1 signal
    pub default_signal_is_l1: bool,

    /// Offset in [Timescale] for first epoch
    pub timescale_t0_offset_nanos: TestNumber<i128>,

    /// Sampling period
    pub sampling_period_nanos: TestNumber<i128>,
}

impl Default for FuzzTestSettings {
    fn default() -> Self {
        Self {
            name: "unamed".to_string(),
            timescale: Default::default(),
            num_sv: TestNumber::fixed(4),
            num_signals: TestNumber::fixed(1),
            method: Default::default(),
            apriori: false,
            default_signal_is_l1: true,
            num_epochs: TestNumber::fixed(128),
            sampling_period_nanos: TestNumber::fixed(30_000_000_000),
            timescale_t0_offset_nanos: TestNumber::fixed(1_000_000_000_000),
        }
    }
}

impl FuzzTestSettings {
    pub fn name(&self, name: &str) -> Self {
        let mut s = self.clone();
        s.name = name.to_string();
        s
    }

    pub fn navigation_method(&self, method: Method) -> Self {
        let mut s = self.clone();
        s.method = method;
        s
    }

    pub fn timescale(&self, ts: TimeScale) -> Self {
        let mut s = self.clone();
        s.timescale = ts;
        s
    }

    pub fn t0_offset_nanos(&self, offset_nanos: i128) -> Self {
        let mut s = self.clone();
        s.timescale_t0_offset_nanos = TestNumber::fixed(offset_nanos);
        s
    }

    // pub fn random_epochs(&self, min: usize, max: usize) -> Self {
    //     let mut s = self.clone();
    //     s.num_epochs = TestNumber::range_random(min..max);
    //     s
    // }

    pub fn total_epochs(&self, size: usize) -> Self {
        let mut s = self.clone();
        s.num_epochs = TestNumber::fixed(size);
        s
    }

    pub fn constant_num_sv(&self, num: usize) -> Self {
        let mut s = self.clone();
        s.num_sv = TestNumber::fixed(num);
        s
    }

    // pub fn num_sv_range(&self, min: usize, max: usize) -> Self {
    //     let mut s = self.clone();
    //     s.num_sv = TestNumber::range_random(min..max);
    //     s
    // }

    pub fn constant_num_signals(&self, num: usize) -> Self {
        let mut s = self.clone();
        s.num_signals = TestNumber::fixed(num);
        s
    }

    // pub fn num_signals_range(&self, min: usize, max: usize) -> Self {
    //     let mut s = self.clone();
    //     s.num_signals = TestNumber::range_random(min..max);
    //     s
    // }

    pub fn sampling_period(&self, dt: Duration) -> Self {
        let mut s = self.clone();
        s.sampling_period_nanos = TestNumber::fixed(dt.total_nanoseconds());
        s
    }

    pub fn uses_apriori(&self) -> Self {
        let mut s = self.clone();
        s.apriori = true;
        s
    }

    pub fn build(&self) -> FuzzTest {
        let almanac = build_almanac();

        let frame = almanac.frame_from_uid(IAU_EARTH_FRAME).unwrap_or_else(|e| {
            panic!("failed to deploy fuzz-test: {}", e);
        });

        let cfg = Config::default().with_navigation_method(self.method);

        let t0 = Epoch::from_duration(
            Duration::from_nanoseconds(self.timescale_t0_offset_nanos.value() as f64),
            self.timescale,
        );

        let num_epochs = self.num_epochs.value();

        FuzzTest {
            almanac,
            frame,
            t0,
            cfg,
            num_epochs,
            name: self.name.clone(),
            num_sv: self.num_sv.clone(),
            sampling_period_nanos: self.sampling_period_nanos.clone(),
            apriori: if self.apriori {
                Some(reference_apriori_at_ref_epoch())
            } else {
                None
            },
        }
    }
}