nexrad-decode 0.1.2

Decoding functions and models for NEXRAD weather radar data.
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

use crate::messages::digital_radar_data::DataBlockId;
use crate::messages::primitive_aliases::{Integer2, Real4, ScaledInteger2};
use serde::Deserialize;
use std::fmt::Debug;

#[cfg(feature = "uom")]
use uom::si::f64::{Information, Length, Velocity};

/// A radial data moment block.
#[derive(Clone, PartialEq, Deserialize)]
pub struct RadialDataBlock {
    /// Data block identifier.
    pub data_block_id: DataBlockId,

    /// Size of data block in bytes.
    pub lrtup: Integer2,

    /// Unambiguous range, interval size, in km.
    pub unambiguous_range: ScaledInteger2,

    /// Noise level for the horizontal channel in dBm.
    pub horizontal_channel_noise_level: Real4,

    /// Noise level for the vertical channel in dBm.
    pub vertical_channel_noise_level: Real4,

    /// Nyquist velocity in m/s.
    pub nyquist_velocity: ScaledInteger2,

    /// Radial flags to support RPG processing.
    pub radial_flags: Integer2,

    /// Calibration constant for the horizontal channel in dBZ.
    pub horizontal_channel_calibration_constant: Real4,

    /// Calibration constant for the vertical channel in dBZ.
    pub vertical_channel_calibration_constant: Real4,
}

impl RadialDataBlock {
    /// Size of data block.
    #[cfg(feature = "uom")]
    pub fn lrtup(&self) -> Information {
        Information::new::<uom::si::information::byte>(self.lrtup as f64)
    }

    /// Unambiguous range, interval size.
    #[cfg(feature = "uom")]
    pub fn unambiguous_range(&self) -> Length {
        Length::new::<uom::si::length::kilometer>(self.unambiguous_range as f64)
    }

    /// Nyquist velocity.
    #[cfg(feature = "uom")]
    pub fn nyquist_velocity(&self) -> Velocity {
        Velocity::new::<uom::si::velocity::meter_per_second>(self.nyquist_velocity as f64 * 0.01)
    }
}

#[cfg(not(feature = "uom"))]
impl Debug for RadialDataBlock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("RadialDataBlock")
            .field("data_block_id", &self.data_block_id)
            .field("lrtup", &self.lrtup)
            .field("unambiguous_range", &self.unambiguous_range)
            .field(
                "horizontal_channel_noise_level",
                &self.horizontal_channel_noise_level,
            )
            .field(
                "vertical_channel_noise_level",
                &self.vertical_channel_noise_level,
            )
            .field("nyquist_velocity", &self.nyquist_velocity)
            .field("radial_flags", &self.radial_flags)
            .field(
                "horizontal_channel_calibration_constant",
                &self.horizontal_channel_calibration_constant,
            )
            .field(
                "vertical_channel_calibration_constant",
                &self.vertical_channel_calibration_constant,
            )
            .finish()
    }
}

#[cfg(feature = "uom")]
impl Debug for RadialDataBlock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("RadialDataBlock")
            .field("data_block_id", &self.data_block_id)
            .field("lrtup", &self.lrtup())
            .field("unambiguous_range", &self.unambiguous_range())
            .field(
                "horizontal_channel_noise_level",
                &self.horizontal_channel_noise_level,
            )
            .field(
                "vertical_channel_noise_level",
                &self.vertical_channel_noise_level,
            )
            .field("nyquist_velocity", &self.nyquist_velocity())
            .field("radial_flags", &self.radial_flags)
            .field(
                "horizontal_channel_calibration_constant",
                &self.horizontal_channel_calibration_constant,
            )
            .field(
                "vertical_channel_calibration_constant",
                &self.vertical_channel_calibration_constant,
            )
            .finish()
    }
}