doris-rs 0.1.0

DORIS RINEX file parsing and production
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

use crate::prelude::{ClockOffset, Epoch, EpochFlag, Key, Observable, ObservationKey, DORIS};

#[derive(Debug)]
pub struct StationObservationData {
    pub station: u16,
    pub value: f64,
    pub observable: Observable,
}

#[derive(Debug)]
pub enum TestData {
    ClockOffset(ClockOffset),
    StationObservation(StationObservationData),
}

pub struct TestPoint {
    pub epoch: Epoch,
    pub flag: EpochFlag,
    pub test_data: TestData,
}

impl TestPoint {
    pub fn to_record_key(&self) -> Key {
        Key {
            epoch: self.epoch,
            flag: self.flag,
        }
    }
}

pub fn is_null_doris(dut: &DORIS) {
    for (k, measurement) in dut.record.measurements.iter() {
        for (obs_k, observation) in measurement.observations.iter() {
            assert_eq!(observation.value, 0.0);
        }
    }
}

/// Tests all data points in this [DORIS] record
pub fn testbench(dut: &DORIS, testpoints: Vec<TestPoint>) {
    for testpoint in testpoints.iter() {
        let key = testpoint.to_record_key();

        // locate measurement
        let measurements = dut.record.measurements.get(&key).unwrap_or_else(|| {
            panic!("Missing measurement @ {:?}", key);
        });

        match &testpoint.test_data {
            TestData::ClockOffset(clock_offset) => {
                let sat_offset = measurements.satellite_clock_offset.unwrap_or_else(|| {
                    panic!("Unreported satellite clock offset @ {}", key.epoch);
                });

                assert_eq!(
                    sat_offset.extrapolated, clock_offset.extrapolated,
                    "incorrect clock offset interpretation @ {}",
                    key.epoch,
                );

                let error = (sat_offset.offset.total_nanoseconds()
                    - clock_offset.offset.total_nanoseconds())
                .abs();

                assert!(
                    error < 1,
                    "invalid clock offset reported @ {} (offset={} err={}ns)",
                    key.epoch,
                    sat_offset.offset,
                    error
                );
            },
            TestData::StationObservation(station_data) => {
                // match this station
                let station = dut
                    .header
                    .ground_station(station_data.station)
                    .unwrap_or_else(|| {
                        panic!(
                            "Station id={} not found at {}",
                            key.epoch, station_data.station
                        );
                    });

                // locate
                let obs_key = ObservationKey {
                    observable: station_data.observable,
                    station: station,
                };

                let observation = measurements.observations.get(&obs_key).unwrap_or_else(|| {
                    panic!(
                        "{} missing {} measurement for station D{:02}",
                        key.epoch, station_data.observable, station_data.station
                    );
                });

                // TODO (SNR)
                // assert_eq!(observation.snr, station_data;

                let error = (observation.value - station_data.value).abs();
                assert!(
                    error < 1.0E-3,
                    "invalid D{:02} {} measurement @ {} (value={}, error={})",
                    station_data.station,
                    key.epoch,
                    station_data.observable,
                    observation.value,
                    error
                );
            },
        }
    }
}