Skip to main content

nexrad_model/data/
moment.rs

1use std::fmt::Debug;
2
3#[cfg(feature = "serde")]
4use serde::{Deserialize, Serialize};
5
6/// Moment data from a radial for a particular product where each value corresponds to a gate.
7#[derive(Clone, PartialEq)]
8#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
9pub struct MomentData {
10    scale: f32,
11    offset: f32,
12    values: Vec<u8>,
13}
14
15impl MomentData {
16    /// Create new moment data from fixed-point encoding.
17    pub fn from_fixed_point(scale: f32, offset: f32, values: Vec<u8>) -> Self {
18        Self {
19            scale,
20            offset,
21            values,
22        }
23    }
24
25    /// Values from this data moment corresponding to gates in the radial.
26    pub fn values(&self) -> Vec<MomentValue> {
27        let copied_values = self.values.iter().copied();
28
29        if self.scale == 0.0 {
30            return copied_values
31                .map(|raw_value| MomentValue::Value(raw_value as f32))
32                .collect();
33        }
34
35        copied_values
36            .map(|raw_value| match raw_value {
37                0 => MomentValue::BelowThreshold,
38                1 => MomentValue::RangeFolded,
39                _ => MomentValue::Value((raw_value as f32 - self.offset) / self.scale),
40            })
41            .collect()
42    }
43}
44
45impl Debug for MomentData {
46    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47        f.debug_struct("MomentData")
48            .field("values", &self.values())
49            .finish()
50    }
51}
52
53/// The data moment value for a product in a radial's gate. The value may be a floating-point number
54/// or a special case such as "below threshold" or "range folded".
55#[derive(Debug, Clone, Copy, PartialEq)]
56pub enum MomentValue {
57    /// The data moment value for a gate.
58    Value(f32),
59    /// The value for this gate was below the signal threshold.
60    BelowThreshold,
61    /// The value for this gate exceeded the maximum unambiguous range.
62    RangeFolded,
63}