blakeridgway/supercell-wx
1
0
Fork 0
mirror of https://github.com/ciphervance/supercell-wx.git synced 2025-10-30 03:40:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Modified RDA message clang-tidy cleanup

Browse source
This commit is contained in:
Dan Paulat 2025-05-12 23:24:49 -05:00
parent 2025698d88
commit fd6c224fc2
10 changed files with 1365 additions and 1310 deletions
Download patch file Download diff file Expand all files Collapse all files

12
wxdata/include/scwx/awips/message.hpp
View file

@ -13,12 +13,8 @@
# include <arpa/inet.h> # include <arpa/inet.h>
#endif #endif
namespace scwx namespace scwx::awips
{ {
namespace awips
{
class MessageImpl;
class Message class Message
{ {
@ -135,8 +131,8 @@ public:
} }
private: private:
std::unique_ptr<MessageImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace awips } // namespace scwx::awips
} // namespace scwx

88
wxdata/include/scwx/wsr88d/rda/digital_radar_data_generic.hpp
View file

@ -2,11 +2,7 @@
#include <scwx/wsr88d/rda/generic_radar_data.hpp> #include <scwx/wsr88d/rda/generic_radar_data.hpp>
namespace scwx namespace scwx::wsr88d::rda
{
namespace wsr88d
{
namespace rda
{ {
class DigitalRadarDataGeneric : public GenericRadarData class DigitalRadarDataGeneric : public GenericRadarData
@ -27,30 +23,31 @@ public:
DigitalRadarDataGeneric(DigitalRadarDataGeneric&&) noexcept; DigitalRadarDataGeneric(DigitalRadarDataGeneric&&) noexcept;
DigitalRadarDataGeneric& operator=(DigitalRadarDataGeneric&&) noexcept; DigitalRadarDataGeneric& operator=(DigitalRadarDataGeneric&&) noexcept;
std::string radar_identifier() const; [[nodiscard]] std::string radar_identifier() const;
std::uint32_t collection_time() const; [[nodiscard]] std::uint32_t collection_time() const override;
std::uint16_t modified_julian_date() const; [[nodiscard]] std::uint16_t modified_julian_date() const override;
std::uint16_t azimuth_number() const; [[nodiscard]] std::uint16_t azimuth_number() const override;
units::degrees<float> azimuth_angle() const; [[nodiscard]] units::degrees<float> azimuth_angle() const override;
std::uint8_t compression_indicator() const; [[nodiscard]] std::uint8_t compression_indicator() const;
std::uint16_t radial_length() const; [[nodiscard]] std::uint16_t radial_length() const;
std::uint8_t azimuth_resolution_spacing() const; [[nodiscard]] std::uint8_t azimuth_resolution_spacing() const;
std::uint8_t radial_status() const; [[nodiscard]] std::uint8_t radial_status() const;
std::uint16_t elevation_number() const; [[nodiscard]] std::uint16_t elevation_number() const override;
std::uint8_t cut_sector_number() const; [[nodiscard]] std::uint8_t cut_sector_number() const;
units::degrees<float> elevation_angle() const; [[nodiscard]] units::degrees<float> elevation_angle() const;
std::uint8_t radial_spot_blanking_status() const; [[nodiscard]] std::uint8_t radial_spot_blanking_status() const;
std::uint8_t azimuth_indexing_mode() const; [[nodiscard]] std::uint8_t azimuth_indexing_mode() const;
std::uint16_t data_block_count() const; [[nodiscard]] std::uint16_t data_block_count() const;
std::uint16_t volume_coverage_pattern_number() const; [[nodiscard]] std::uint16_t volume_coverage_pattern_number() const override;
std::shared_ptr<ElevationDataBlock> elevation_data_block() const; [[nodiscard]] std::shared_ptr<ElevationDataBlock>
std::shared_ptr<RadialDataBlock> radial_data_block() const; elevation_data_block() const;
std::shared_ptr<VolumeDataBlock> volume_data_block() const; [[nodiscard]] std::shared_ptr<RadialDataBlock> radial_data_block() const;
std::shared_ptr<GenericRadarData::MomentDataBlock> [[nodiscard]] std::shared_ptr<VolumeDataBlock> volume_data_block() const;
moment_data_block(DataBlockType type) const; [[nodiscard]] std::shared_ptr<GenericRadarData::MomentDataBlock>
moment_data_block(DataBlockType type) const override;
bool Parse(std::istream& is); bool Parse(std::istream& is) override;
static std::shared_ptr<DigitalRadarDataGeneric> static std::shared_ptr<DigitalRadarDataGeneric>
Create(Level2MessageHeader&& header, std::istream& is); Create(Level2MessageHeader&& header, std::istream& is);
@ -65,11 +62,14 @@ class DigitalRadarDataGeneric::DataBlock
protected: protected:
explicit DataBlock(const std::string& dataBlockType, explicit DataBlock(const std::string& dataBlockType,
const std::string& dataName); const std::string& dataName);
public:
virtual ~DataBlock(); virtual ~DataBlock();
DataBlock(const DataBlock&) = delete; DataBlock(const DataBlock&) = delete;
DataBlock& operator=(const DataBlock&) = delete; DataBlock& operator=(const DataBlock&) = delete;
protected:
DataBlock(DataBlock&&) noexcept; DataBlock(DataBlock&&) noexcept;
DataBlock& operator=(DataBlock&&) noexcept; DataBlock& operator=(DataBlock&&) noexcept;
@ -118,17 +118,17 @@ public:
MomentDataBlock(MomentDataBlock&&) noexcept; MomentDataBlock(MomentDataBlock&&) noexcept;
MomentDataBlock& operator=(MomentDataBlock&&) noexcept; MomentDataBlock& operator=(MomentDataBlock&&) noexcept;
std::uint16_t number_of_data_moment_gates() const; [[nodiscard]] std::uint16_t number_of_data_moment_gates() const override;
units::kilometers<float> data_moment_range() const; [[nodiscard]] units::kilometers<float> data_moment_range() const override;
std::int16_t data_moment_range_raw() const; [[nodiscard]] std::int16_t data_moment_range_raw() const override;
units::kilometers<float> data_moment_range_sample_interval() const; [[nodiscard]] units::kilometers<float> data_moment_range_sample_interval() const override;
std::uint16_t data_moment_range_sample_interval_raw() const; [[nodiscard]] std::uint16_t data_moment_range_sample_interval_raw() const override;
float snr_threshold() const; [[nodiscard]] float snr_threshold() const;
std::int16_t snr_threshold_raw() const; [[nodiscard]] std::int16_t snr_threshold_raw() const override;
std::uint8_t data_word_size() const; [[nodiscard]] std::uint8_t data_word_size() const override;
float scale() const; [[nodiscard]] float scale() const override;
float offset() const; [[nodiscard]] float offset() const override;
const void* data_moments() const; [[nodiscard]] const void* data_moments() const override;
static std::shared_ptr<MomentDataBlock> static std::shared_ptr<MomentDataBlock>
Create(const std::string& dataBlockType, Create(const std::string& dataBlockType,
@ -155,7 +155,7 @@ public:
RadialDataBlock(RadialDataBlock&&) noexcept; RadialDataBlock(RadialDataBlock&&) noexcept;
RadialDataBlock& operator=(RadialDataBlock&&) noexcept; RadialDataBlock& operator=(RadialDataBlock&&) noexcept;
float unambiguous_range() const; [[nodiscard]] float unambiguous_range() const;
static std::shared_ptr<RadialDataBlock> static std::shared_ptr<RadialDataBlock>
Create(const std::string& dataBlockType, Create(const std::string& dataBlockType,
@ -182,9 +182,9 @@ public:
VolumeDataBlock(VolumeDataBlock&&) noexcept; VolumeDataBlock(VolumeDataBlock&&) noexcept;
VolumeDataBlock& operator=(VolumeDataBlock&&) noexcept; VolumeDataBlock& operator=(VolumeDataBlock&&) noexcept;
float latitude() const; [[nodiscard]] float latitude() const;
float longitude() const; [[nodiscard]] float longitude() const;
std::uint16_t volume_coverage_pattern_number() const; [[nodiscard]] std::uint16_t volume_coverage_pattern_number() const;
static std::shared_ptr<VolumeDataBlock> static std::shared_ptr<VolumeDataBlock>
Create(const std::string& dataBlockType, Create(const std::string& dataBlockType,
@ -198,6 +198,4 @@ private:
bool Parse(std::istream& is); bool Parse(std::istream& is);
}; };
} // namespace rda } // namespace scwx::wsr88d::rda
} // namespace wsr88d
} // namespace scwx

508
wxdata/include/scwx/wsr88d/rda/performance_maintenance_data.hpp
View file

@ -2,14 +2,8 @@
#include <scwx/wsr88d/rda/level2_message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx::wsr88d::rda
{ {
namespace wsr88d
{
namespace rda
{
class PerformanceMaintenanceDataImpl;
class PerformanceMaintenanceData : public Level2Message class PerformanceMaintenanceData : public Level2Message
{ {
@ -24,261 +18,261 @@ public:
PerformanceMaintenanceData(PerformanceMaintenanceData&&) noexcept; PerformanceMaintenanceData(PerformanceMaintenanceData&&) noexcept;
PerformanceMaintenanceData& operator=(PerformanceMaintenanceData&&) noexcept; PerformanceMaintenanceData& operator=(PerformanceMaintenanceData&&) noexcept;
uint16_t loop_back_set_status() const; [[nodiscard]] std::uint16_t loop_back_set_status() const;
uint32_t t1_output_frames() const; [[nodiscard]] std::uint32_t t1_output_frames() const;
uint32_t t1_input_frames() const; [[nodiscard]] std::uint32_t t1_input_frames() const;
uint32_t router_memory_used() const; [[nodiscard]] std::uint32_t router_memory_used() const;
uint32_t router_memory_free() const; [[nodiscard]] std::uint32_t router_memory_free() const;
uint16_t router_memory_utilization() const; [[nodiscard]] std::uint16_t router_memory_utilization() const;
uint16_t route_to_rpg() const; [[nodiscard]] std::uint16_t route_to_rpg() const;
uint16_t t1_port_status() const; [[nodiscard]] std::uint16_t t1_port_status() const;
uint16_t router_dedicated_ethernet_port_status() const; [[nodiscard]] std::uint16_t router_dedicated_ethernet_port_status() const;
uint16_t router_commercial_ethernet_port_status() const; [[nodiscard]] std::uint16_t router_commercial_ethernet_port_status() const;
uint32_t csu_24hr_errored_seconds() const; [[nodiscard]] std::uint32_t csu_24hr_errored_seconds() const;
uint32_t csu_24hr_severely_errored_seconds() const; [[nodiscard]] std::uint32_t csu_24hr_severely_errored_seconds() const;
uint32_t csu_24hr_severely_errored_framing_seconds() const; [[nodiscard]] std::uint32_t
uint32_t csu_24hr_unavailable_seconds() const; csu_24hr_severely_errored_framing_seconds() const;
uint32_t csu_24hr_controlled_slip_seconds() const; [[nodiscard]] std::uint32_t csu_24hr_unavailable_seconds() const;
uint32_t csu_24hr_path_coding_violations() const; [[nodiscard]] std::uint32_t csu_24hr_controlled_slip_seconds() const;
uint32_t csu_24hr_line_errored_seconds() const; [[nodiscard]] std::uint32_t csu_24hr_path_coding_violations() const;
uint32_t csu_24hr_bursty_errored_seconds() const; [[nodiscard]] std::uint32_t csu_24hr_line_errored_seconds() const;
uint32_t csu_24hr_degraded_minutes() const; [[nodiscard]] std::uint32_t csu_24hr_bursty_errored_seconds() const;
uint32_t lan_switch_cpu_utilization() const; [[nodiscard]] std::uint32_t csu_24hr_degraded_minutes() const;
uint16_t lan_switch_memory_utilization() const; [[nodiscard]] std::uint32_t lan_switch_cpu_utilization() const;
uint16_t ifdr_chasis_temperature() const; [[nodiscard]] std::uint16_t lan_switch_memory_utilization() const;
uint16_t ifdr_fpga_temperature() const; [[nodiscard]] std::uint16_t ifdr_chasis_temperature() const;
uint16_t ntp_status() const; [[nodiscard]] std::uint16_t ifdr_fpga_temperature() const;
uint16_t ipc_status() const; [[nodiscard]] std::uint16_t ntp_status() const;
uint16_t commanded_channel_control() const; [[nodiscard]] std::uint16_t ipc_status() const;
uint16_t polarization() const; [[nodiscard]] std::uint16_t commanded_channel_control() const;
float ame_internal_temperature() const; [[nodiscard]] std::uint16_t polarization() const;
float ame_receiver_module_temperature() const; [[nodiscard]] float ame_internal_temperature() const;
float ame_bite_cal_module_temperature() const; [[nodiscard]] float ame_receiver_module_temperature() const;
uint16_t ame_peltier_pulse_width_modulation() const; [[nodiscard]] float ame_bite_cal_module_temperature() const;
uint16_t ame_peltier_status() const; [[nodiscard]] std::uint16_t ame_peltier_pulse_width_modulation() const;
uint16_t ame_a_d_converter_status() const; [[nodiscard]] std::uint16_t ame_peltier_status() const;
uint16_t ame_state() const; [[nodiscard]] std::uint16_t ame_a_d_converter_status() const;
float ame_3_3v_ps_voltage() const; [[nodiscard]] std::uint16_t ame_state() const;
float ame_5v_ps_voltage() const; [[nodiscard]] float ame_3_3v_ps_voltage() const;
float ame_6_5v_ps_voltage() const; [[nodiscard]] float ame_5v_ps_voltage() const;
float ame_15v_ps_voltage() const; [[nodiscard]] float ame_6_5v_ps_voltage() const;
float ame_48v_ps_voltage() const; [[nodiscard]] float ame_15v_ps_voltage() const;
float ame_stalo_power() const; [[nodiscard]] float ame_48v_ps_voltage() const;
float peltier_current() const; [[nodiscard]] float ame_stalo_power() const;
float adc_calibration_reference_voltage() const; [[nodiscard]] float peltier_current() const;
uint16_t ame_mode() const; [[nodiscard]] float adc_calibration_reference_voltage() const;
uint16_t ame_peltier_mode() const; [[nodiscard]] std::uint16_t ame_mode() const;
float ame_peltier_inside_fan_current() const; [[nodiscard]] std::uint16_t ame_peltier_mode() const;
float ame_peltier_outside_fan_current() const; [[nodiscard]] float ame_peltier_inside_fan_current() const;
float horizontal_tr_limiter_voltage() const; [[nodiscard]] float ame_peltier_outside_fan_current() const;
float vertical_tr_limiter_voltage() const; [[nodiscard]] float horizontal_tr_limiter_voltage() const;
float adc_calibration_offset_voltage() const; [[nodiscard]] float vertical_tr_limiter_voltage() const;
float adc_calibration_gain_correction() const; [[nodiscard]] float adc_calibration_offset_voltage() const;
uint16_t rcp_status() const; [[nodiscard]] float adc_calibration_gain_correction() const;
std::string rcp_string() const; [[nodiscard]] std::uint16_t rcp_status() const;
uint16_t spip_power_buttons() const; [[nodiscard]] std::string rcp_string() const;
float master_power_administrator_load() const; [[nodiscard]] std::uint16_t spip_power_buttons() const;
float expansion_power_administrator_load() const; [[nodiscard]] float master_power_administrator_load() const;
uint16_t _5vdc_ps() const; [[nodiscard]] float expansion_power_administrator_load() const;
uint16_t _15vdc_ps() const; [[nodiscard]] std::uint16_t _5vdc_ps() const;
uint16_t _28vdc_ps() const; [[nodiscard]] std::uint16_t _15vdc_ps() const;
uint16_t neg_15vdc_ps() const; [[nodiscard]] std::uint16_t _28vdc_ps() const;
uint16_t _45vdc_ps() const; [[nodiscard]] std::uint16_t neg_15vdc_ps() const;
uint16_t filament_ps_voltage() const; [[nodiscard]] std::uint16_t _45vdc_ps() const;
uint16_t vacuum_pump_ps_voltage() const; [[nodiscard]] std::uint16_t filament_ps_voltage() const;
uint16_t focus_coil_ps_voltage() const; [[nodiscard]] std::uint16_t vacuum_pump_ps_voltage() const;
uint16_t filament_ps() const; [[nodiscard]] std::uint16_t focus_coil_ps_voltage() const;
uint16_t klystron_warmup() const; [[nodiscard]] std::uint16_t filament_ps() const;
uint16_t transmitter_available() const; [[nodiscard]] std::uint16_t klystron_warmup() const;
uint16_t wg_switch_position() const; [[nodiscard]] std::uint16_t transmitter_available() const;
uint16_t wg_pfn_transfer_interlock() const; [[nodiscard]] std::uint16_t wg_switch_position() const;
uint16_t maintenance_mode() const; [[nodiscard]] std::uint16_t wg_pfn_transfer_interlock() const;
uint16_t maintenance_required() const; [[nodiscard]] std::uint16_t maintenance_mode() const;
uint16_t pfn_switch_position() const; [[nodiscard]] std::uint16_t maintenance_required() const;
uint16_t modulator_overload() const; [[nodiscard]] std::uint16_t pfn_switch_position() const;
uint16_t modulator_inv_current() const; [[nodiscard]] std::uint16_t modulator_overload() const;
uint16_t modulator_switch_fail() const; [[nodiscard]] std::uint16_t modulator_inv_current() const;
uint16_t main_power_voltage() const; [[nodiscard]] std::uint16_t modulator_switch_fail() const;
uint16_t charging_system_fail() const; [[nodiscard]] std::uint16_t main_power_voltage() const;
uint16_t inverse_diode_current() const; [[nodiscard]] std::uint16_t charging_system_fail() const;
uint16_t trigger_amplifier() const; [[nodiscard]] std::uint16_t inverse_diode_current() const;
uint16_t circulator_temperature() const; [[nodiscard]] std::uint16_t trigger_amplifier() const;
uint16_t spectrum_filter_pressure() const; [[nodiscard]] std::uint16_t circulator_temperature() const;
uint16_t wg_arc_vswr() const; [[nodiscard]] std::uint16_t spectrum_filter_pressure() const;
uint16_t cabinet_interlock() const; [[nodiscard]] std::uint16_t wg_arc_vswr() const;
uint16_t cabinet_air_temperature() const; [[nodiscard]] std::uint16_t cabinet_interlock() const;
uint16_t cabinet_airflow() const; [[nodiscard]] std::uint16_t cabinet_air_temperature() const;
uint16_t klystron_current() const; [[nodiscard]] std::uint16_t cabinet_airflow() const;
uint16_t klystron_filament_current() const; [[nodiscard]] std::uint16_t klystron_current() const;
uint16_t klystron_vacion_current() const; [[nodiscard]] std::uint16_t klystron_filament_current() const;
uint16_t klystron_air_temperature() const; [[nodiscard]] std::uint16_t klystron_vacion_current() const;
uint16_t klystron_airflow() const; [[nodiscard]] std::uint16_t klystron_air_temperature() const;
uint16_t modulator_switch_maintenance() const; [[nodiscard]] std::uint16_t klystron_airflow() const;
uint16_t post_charge_regulator_maintenance() const; [[nodiscard]] std::uint16_t modulator_switch_maintenance() const;
uint16_t wg_pressure_humidity() const; [[nodiscard]] std::uint16_t post_charge_regulator_maintenance() const;
uint16_t transmitter_overvoltage() const; [[nodiscard]] std::uint16_t wg_pressure_humidity() const;
uint16_t transmitter_overcurrent() const; [[nodiscard]] std::uint16_t transmitter_overvoltage() const;
uint16_t focus_coil_current() const; [[nodiscard]] std::uint16_t transmitter_overcurrent() const;
uint16_t focus_coil_airflow() const; [[nodiscard]] std::uint16_t focus_coil_current() const;
uint16_t oil_temperature() const; [[nodiscard]] std::uint16_t focus_coil_airflow() const;
uint16_t prf_limit() const; [[nodiscard]] std::uint16_t oil_temperature() const;
uint16_t transmitter_oil_level() const; [[nodiscard]] std::uint16_t prf_limit() const;
uint16_t transmitter_battery_charging() const; [[nodiscard]] std::uint16_t transmitter_oil_level() const;
uint16_t high_voltage_status() const; [[nodiscard]] std::uint16_t transmitter_battery_charging() const;
uint16_t transmitter_recycling_summary() const; [[nodiscard]] std::uint16_t high_voltage_status() const;
uint16_t transmitter_inoperable() const; [[nodiscard]] std::uint16_t transmitter_recycling_summary() const;
uint16_t transmitter_air_filter() const; [[nodiscard]] std::uint16_t transmitter_inoperable() const;
uint16_t zero_test_bit(unsigned i) const; [[nodiscard]] std::uint16_t transmitter_air_filter() const;
uint16_t one_test_bit(unsigned i) const; [[nodiscard]] std::uint16_t zero_test_bit(unsigned i) const;
uint16_t xmtr_spip_interface() const; [[nodiscard]] std::uint16_t one_test_bit(unsigned i) const;
uint16_t transmitter_summary_status() const; [[nodiscard]] std::uint16_t xmtr_spip_interface() const;
float transmitter_rf_power() const; [[nodiscard]] std::uint16_t transmitter_summary_status() const;
float horizontal_xmtr_peak_power() const; [[nodiscard]] float transmitter_rf_power() const;
float xmtr_peak_power() const; [[nodiscard]] float horizontal_xmtr_peak_power() const;
float vertical_xmtr_peak_power() const; [[nodiscard]] float xmtr_peak_power() const;
float xmtr_rf_avg_power() const; [[nodiscard]] float vertical_xmtr_peak_power() const;
uint32_t xmtr_recycle_count() const; [[nodiscard]] float xmtr_rf_avg_power() const;
float receiver_bias() const; [[nodiscard]] std::uint32_t xmtr_recycle_count() const;
float transmit_imbalance() const; [[nodiscard]] float receiver_bias() const;
float xmtr_power_meter_zero() const; [[nodiscard]] float transmit_imbalance() const;
uint16_t ac_unit1_compressor_shut_off() const; [[nodiscard]] float xmtr_power_meter_zero() const;
uint16_t ac_unit2_compressor_shut_off() const; [[nodiscard]] std::uint16_t ac_unit1_compressor_shut_off() const;
uint16_t generator_maintenance_required() const; [[nodiscard]] std::uint16_t ac_unit2_compressor_shut_off() const;
uint16_t generator_battery_voltage() const; [[nodiscard]] std::uint16_t generator_maintenance_required() const;
uint16_t generator_engine() const; [[nodiscard]] std::uint16_t generator_battery_voltage() const;
uint16_t generator_volt_frequency() const; [[nodiscard]] std::uint16_t generator_engine() const;
uint16_t power_source() const; [[nodiscard]] std::uint16_t generator_volt_frequency() const;
uint16_t transitional_power_source() const; [[nodiscard]] std::uint16_t power_source() const;
uint16_t generator_auto_run_off_switch() const; [[nodiscard]] std::uint16_t transitional_power_source() const;
uint16_t aircraft_hazard_lighting() const; [[nodiscard]] std::uint16_t generator_auto_run_off_switch() const;
uint16_t equipment_shelter_fire_detection_system() const; [[nodiscard]] std::uint16_t aircraft_hazard_lighting() const;
uint16_t equipment_shelter_fire_smoke() const; [[nodiscard]] std::uint16_t equipment_shelter_fire_detection_system() const;
uint16_t generator_shelter_fire_smoke() const; [[nodiscard]] std::uint16_t equipment_shelter_fire_smoke() const;
uint16_t utility_voltage_frequency() const; [[nodiscard]] std::uint16_t generator_shelter_fire_smoke() const;
uint16_t site_security_alarm() const; [[nodiscard]] std::uint16_t utility_voltage_frequency() const;
uint16_t security_equipment() const; [[nodiscard]] std::uint16_t site_security_alarm() const;
uint16_t security_system() const; [[nodiscard]] std::uint16_t security_equipment() const;
uint16_t receiver_connected_to_antenna() const; [[nodiscard]] std::uint16_t security_system() const;
uint16_t radome_hatch() const; [[nodiscard]] std::uint16_t receiver_connected_to_antenna() const;
uint16_t ac_unit1_filter_dirty() const; [[nodiscard]] std::uint16_t radome_hatch() const;
uint16_t ac_unit2_filter_dirty() const; [[nodiscard]] std::uint16_t ac_unit1_filter_dirty() const;
float equipment_shelter_temperature() const; [[nodiscard]] std::uint16_t ac_unit2_filter_dirty() const;
float outside_ambient_temperature() const; [[nodiscard]] float equipment_shelter_temperature() const;
float transmitter_leaving_air_temp() const; [[nodiscard]] float outside_ambient_temperature() const;
float ac_unit1_discharge_air_temp() const; [[nodiscard]] float transmitter_leaving_air_temp() const;
float generator_shelter_temperature() const; [[nodiscard]] float ac_unit1_discharge_air_temp() const;
float radome_air_temperature() const; [[nodiscard]] float generator_shelter_temperature() const;
float ac_unit2_discharge_air_temp() const; [[nodiscard]] float radome_air_temperature() const;
float spip_15v_ps() const; [[nodiscard]] float ac_unit2_discharge_air_temp() const;
float spip_neg_15v_ps() const; [[nodiscard]] float spip_15v_ps() const;
uint16_t spip_28v_ps_status() const; [[nodiscard]] float spip_neg_15v_ps() const;
float spip_5v_ps() const; [[nodiscard]] std::uint16_t spip_28v_ps_status() const;
uint16_t converted_generator_fuel_level() const; [[nodiscard]] float spip_5v_ps() const;
uint16_t elevation_pos_dead_limit() const; [[nodiscard]] std::uint16_t converted_generator_fuel_level() const;
uint16_t _150v_overvoltage() const; [[nodiscard]] std::uint16_t elevation_pos_dead_limit() const;
uint16_t _150v_undervoltage() const; [[nodiscard]] std::uint16_t _150v_overvoltage() const;
uint16_t elevation_servo_amp_inhibit() const; [[nodiscard]] std::uint16_t _150v_undervoltage() const;
uint16_t elevation_servo_amp_short_circuit() const; [[nodiscard]] std::uint16_t elevation_servo_amp_inhibit() const;
uint16_t elevation_servo_amp_overtemp() const; [[nodiscard]] std::uint16_t elevation_servo_amp_short_circuit() const;
uint16_t elevation_motor_overtemp() const; [[nodiscard]] std::uint16_t elevation_servo_amp_overtemp() const;
uint16_t elevation_stow_pin() const; [[nodiscard]] std::uint16_t elevation_motor_overtemp() const;
uint16_t elevation_housing_5v_ps() const; [[nodiscard]] std::uint16_t elevation_stow_pin() const;
uint16_t elevation_neg_dead_limit() const; [[nodiscard]] std::uint16_t elevation_housing_5v_ps() const;
uint16_t elevation_pos_normal_limit() const; [[nodiscard]] std::uint16_t elevation_neg_dead_limit() const;
uint16_t elevation_neg_normal_limit() const; [[nodiscard]] std::uint16_t elevation_pos_normal_limit() const;
uint16_t elevation_encoder_light() const; [[nodiscard]] std::uint16_t elevation_neg_normal_limit() const;
uint16_t elevation_gearbox_oil() const; [[nodiscard]] std::uint16_t elevation_encoder_light() const;
uint16_t elevation_handwheel() const; [[nodiscard]] std::uint16_t elevation_gearbox_oil() const;
uint16_t elevation_amp_ps() const; [[nodiscard]] std::uint16_t elevation_handwheel() const;
uint16_t azimuth_servo_amp_inhibit() const; [[nodiscard]] std::uint16_t elevation_amp_ps() const;
uint16_t azimuth_servo_amp_short_circuit() const; [[nodiscard]] std::uint16_t azimuth_servo_amp_inhibit() const;
uint16_t azimuth_servo_amp_overtemp() const; [[nodiscard]] std::uint16_t azimuth_servo_amp_short_circuit() const;
uint16_t azimuth_motor_overtemp() const; [[nodiscard]] std::uint16_t azimuth_servo_amp_overtemp() const;
uint16_t azimuth_stow_pin() const; [[nodiscard]] std::uint16_t azimuth_motor_overtemp() const;
uint16_t azimuth_housing_5v_ps() const; [[nodiscard]] std::uint16_t azimuth_stow_pin() const;
uint16_t azimuth_encoder_light() const; [[nodiscard]] std::uint16_t azimuth_housing_5v_ps() const;
uint16_t azimuth_gearbox_oil() const; [[nodiscard]] std::uint16_t azimuth_encoder_light() const;
uint16_t azimuth_bull_gear_oil() const; [[nodiscard]] std::uint16_t azimuth_gearbox_oil() const;
uint16_t azimuth_handwheel() const; [[nodiscard]] std::uint16_t azimuth_bull_gear_oil() const;
uint16_t azimuth_servo_amp_ps() const; [[nodiscard]] std::uint16_t azimuth_handwheel() const;
uint16_t servo() const; [[nodiscard]] std::uint16_t azimuth_servo_amp_ps() const;
uint16_t pedestal_interlock_switch() const; [[nodiscard]] std::uint16_t servo() const;
uint16_t coho_clock() const; [[nodiscard]] std::uint16_t pedestal_interlock_switch() const;
uint16_t rf_generator_frequency_select_oscillator() const; [[nodiscard]] std::uint16_t coho_clock() const;
uint16_t rf_generator_rf_stalo() const; [[nodiscard]] std::uint16_t rf_generator_frequency_select_oscillator() const;
uint16_t rf_generator_phase_shifted_coho() const; [[nodiscard]] std::uint16_t rf_generator_rf_stalo() const;
uint16_t _9v_receiver_ps() const; [[nodiscard]] std::uint16_t rf_generator_phase_shifted_coho() const;
uint16_t _5v_receiver_ps() const; [[nodiscard]] std::uint16_t _9v_receiver_ps() const;
uint16_t _18v_receiver_ps() const; [[nodiscard]] std::uint16_t _5v_receiver_ps() const;
uint16_t neg_9v_receiver_ps() const; [[nodiscard]] std::uint16_t _18v_receiver_ps() const;
uint16_t _5v_single_channel_rdaiu_ps() const; [[nodiscard]] std::uint16_t neg_9v_receiver_ps() const;
float horizontal_short_pulse_noise() const; [[nodiscard]] std::uint16_t _5v_single_channel_rdaiu_ps() const;
float horizontal_long_pulse_noise() const; [[nodiscard]] float horizontal_short_pulse_noise() const;
float horizontal_noise_temperature() const; [[nodiscard]] float horizontal_long_pulse_noise() const;
float vertical_short_pulse_noise() const; [[nodiscard]] float horizontal_noise_temperature() const;
float vertical_long_pulse_noise() const; [[nodiscard]] float vertical_short_pulse_noise() const;
float vertical_noise_temperature() const; [[nodiscard]] float vertical_long_pulse_noise() const;
float horizontal_linearity() const; [[nodiscard]] float vertical_noise_temperature() const;
float horizontal_dynamic_range() const; [[nodiscard]] float horizontal_linearity() const;
float horizontal_delta_dbz0() const; [[nodiscard]] float horizontal_dynamic_range() const;
float vertical_delta_dbz0() const; [[nodiscard]] float horizontal_delta_dbz0() const;
float kd_peak_measured() const; [[nodiscard]] float vertical_delta_dbz0() const;
float short_pulse_horizontal_dbz0() const; [[nodiscard]] float kd_peak_measured() const;
float long_pulse_horizontal_dbz0() const; [[nodiscard]] float short_pulse_horizontal_dbz0() const;
uint16_t velocity_processed() const; [[nodiscard]] float long_pulse_horizontal_dbz0() const;
uint16_t width_processed() const; [[nodiscard]] std::uint16_t velocity_processed() const;
uint16_t velocity_rf_gen() const; [[nodiscard]] std::uint16_t width_processed() const;
uint16_t width_rf_gen() const; [[nodiscard]] std::uint16_t velocity_rf_gen() const;
float horizontal_i0() const; [[nodiscard]] std::uint16_t width_rf_gen() const;
float vertical_i0() const; [[nodiscard]] float horizontal_i0() const;
float vertical_dynamic_range() const; [[nodiscard]] float vertical_i0() const;
float short_pulse_vertical_dbz0() const; [[nodiscard]] float vertical_dynamic_range() const;
float long_pulse_vertical_dbz0() const; [[nodiscard]] float short_pulse_vertical_dbz0() const;
float horizontal_power_sense() const; [[nodiscard]] float long_pulse_vertical_dbz0() const;
float vertical_power_sense() const; [[nodiscard]] float horizontal_power_sense() const;
float zdr_offset() const; [[nodiscard]] float vertical_power_sense() const;
float clutter_suppression_delta() const; [[nodiscard]] float zdr_offset() const;
float clutter_suppression_unfiltered_power() const; [[nodiscard]] float clutter_suppression_delta() const;
float clutter_suppression_filtered_power() const; [[nodiscard]] float clutter_suppression_unfiltered_power() const;
float vertical_linearity() const; [[nodiscard]] float clutter_suppression_filtered_power() const;
uint16_t state_file_read_status() const; [[nodiscard]] float vertical_linearity() const;
uint16_t state_file_write_status() const; [[nodiscard]] std::uint16_t state_file_read_status() const;
uint16_t bypass_map_file_read_status() const; [[nodiscard]] std::uint16_t state_file_write_status() const;
uint16_t bypass_map_file_write_status() const; [[nodiscard]] std::uint16_t bypass_map_file_read_status() const;
uint16_t current_adaptation_file_read_status() const; [[nodiscard]] std::uint16_t bypass_map_file_write_status() const;
uint16_t current_adaptation_file_write_status() const; [[nodiscard]] std::uint16_t current_adaptation_file_read_status() const;
uint16_t censor_zone_file_read_status() const; [[nodiscard]] std::uint16_t current_adaptation_file_write_status() const;
uint16_t censor_zone_file_write_status() const; [[nodiscard]] std::uint16_t censor_zone_file_read_status() const;
uint16_t remote_vcp_file_read_status() const; [[nodiscard]] std::uint16_t censor_zone_file_write_status() const;
uint16_t remote_vcp_file_write_status() const; [[nodiscard]] std::uint16_t remote_vcp_file_read_status() const;
uint16_t baseline_adaptation_file_read_status() const; [[nodiscard]] std::uint16_t remote_vcp_file_write_status() const;
uint16_t read_status_of_prf_sets() const; [[nodiscard]] std::uint16_t baseline_adaptation_file_read_status() const;
uint16_t clutter_filter_map_file_read_status() const; [[nodiscard]] std::uint16_t read_status_of_prf_sets() const;
uint16_t clutter_filter_map_file_write_status() const; [[nodiscard]] std::uint16_t clutter_filter_map_file_read_status() const;
uint16_t general_disk_io_error() const; [[nodiscard]] std::uint16_t clutter_filter_map_file_write_status() const;
uint8_t rsp_status() const; [[nodiscard]] std::uint16_t general_disk_io_error() const;
uint8_t cpu1_temperature() const; [[nodiscard]] std::uint8_t rsp_status() const;
uint8_t cpu2_temperature() const; [[nodiscard]] std::uint8_t cpu1_temperature() const;
uint16_t rsp_motherboard_power() const; [[nodiscard]] std::uint8_t cpu2_temperature() const;
uint16_t spip_comm_status() const; [[nodiscard]] std::uint16_t rsp_motherboard_power() const;
uint16_t hci_comm_status() const; [[nodiscard]] std::uint16_t spip_comm_status() const;
uint16_t signal_processor_command_status() const; [[nodiscard]] std::uint16_t hci_comm_status() const;
uint16_t ame_communication_status() const; [[nodiscard]] std::uint16_t signal_processor_command_status() const;
uint16_t rms_link_status() const; [[nodiscard]] std::uint16_t ame_communication_status() const;
uint16_t rpg_link_status() const; [[nodiscard]] std::uint16_t rms_link_status() const;
uint16_t interpanel_link_status() const; [[nodiscard]] std::uint16_t rpg_link_status() const;
uint32_t performance_check_time() const; [[nodiscard]] std::uint16_t interpanel_link_status() const;
uint16_t version() const; [[nodiscard]] std::uint32_t performance_check_time() const;
[[nodiscard]] std::uint16_t version() const;
bool Parse(std::istream& is); bool Parse(std::istream& is) override;
static std::shared_ptr<PerformanceMaintenanceData> static std::shared_ptr<PerformanceMaintenanceData>
Create(Level2MessageHeader&& header, std::istream& is); Create(Level2MessageHeader&& header, std::istream& is);
private: private:
std::unique_ptr<PerformanceMaintenanceDataImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace rda } // namespace scwx::wsr88d::rda
} // namespace wsr88d
} // namespace scwx

385
wxdata/include/scwx/wsr88d/rda/rda_adaptation_data.hpp
View file

@ -2,14 +2,8 @@
#include <scwx/wsr88d/rda/level2_message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx::wsr88d::rda
{ {
namespace wsr88d
{
namespace rda
{
class RdaAdaptationDataImpl;
class RdaAdaptationData : public Level2Message class RdaAdaptationData : public Level2Message
{ {
@ -23,200 +17,199 @@ public:
RdaAdaptationData(RdaAdaptationData&&) noexcept; RdaAdaptationData(RdaAdaptationData&&) noexcept;
RdaAdaptationData& operator=(RdaAdaptationData&&) noexcept; RdaAdaptationData& operator=(RdaAdaptationData&&) noexcept;
std::string adap_file_name() const; [[nodiscard]] std::string adap_file_name() const;
std::string adap_format() const; [[nodiscard]] std::string adap_format() const;
std::string adap_revision() const; [[nodiscard]] std::string adap_revision() const;
std::string adap_date() const; [[nodiscard]] std::string adap_date() const;
std::string adap_time() const; [[nodiscard]] std::string adap_time() const;
float lower_pre_limit() const; [[nodiscard]] float lower_pre_limit() const;
float az_lat() const; [[nodiscard]] float az_lat() const;
float upper_pre_limit() const; [[nodiscard]] float upper_pre_limit() const;
float el_lat() const; [[nodiscard]] float el_lat() const;
float parkaz() const; [[nodiscard]] float parkaz() const;
float parkel() const; [[nodiscard]] float parkel() const;
float a_fuel_conv(unsigned i) const; [[nodiscard]] float a_fuel_conv(unsigned i) const;
float a_min_shelter_temp() const; [[nodiscard]] float a_min_shelter_temp() const;
float a_max_shelter_temp() const; [[nodiscard]] float a_max_shelter_temp() const;
float a_min_shelter_ac_temp_diff() const; [[nodiscard]] float a_min_shelter_ac_temp_diff() const;
float a_max_xmtr_air_temp() const; [[nodiscard]] float a_max_xmtr_air_temp() const;
float a_max_rad_temp() const; [[nodiscard]] float a_max_rad_temp() const;
float a_max_rad_temp_rise() const; [[nodiscard]] float a_max_rad_temp_rise() const;
float lower_dead_limit() const; [[nodiscard]] float lower_dead_limit() const;
float upper_dead_limit() const; [[nodiscard]] float upper_dead_limit() const;
float a_min_gen_room_temp() const; [[nodiscard]] float a_min_gen_room_temp() const;
float a_max_gen_room_temp() const; [[nodiscard]] float a_max_gen_room_temp() const;
float spip_5v_reg_lim() const; [[nodiscard]] float spip_5v_reg_lim() const;
float spip_15v_reg_lim() const; [[nodiscard]] float spip_15v_reg_lim() const;
bool rpg_co_located() const; [[nodiscard]] bool rpg_co_located() const;
bool spec_filter_installed() const; [[nodiscard]] bool spec_filter_installed() const;
bool tps_installed() const; [[nodiscard]] bool tps_installed() const;
bool rms_installed() const; [[nodiscard]] bool rms_installed() const;
uint32_t a_hvdl_tst_int() const; [[nodiscard]] std::uint32_t a_hvdl_tst_int() const;
uint32_t a_rpg_lt_int() const; [[nodiscard]] std::uint32_t a_rpg_lt_int() const;
uint32_t a_min_stab_util_pwr_time() const; [[nodiscard]] std::uint32_t a_min_stab_util_pwr_time() const;
uint32_t a_gen_auto_exer_interval() const; [[nodiscard]] std::uint32_t a_gen_auto_exer_interval() const;
uint32_t a_util_pwr_sw_req_interval() const; [[nodiscard]] std::uint32_t a_util_pwr_sw_req_interval() const;
float a_low_fuel_level() const; [[nodiscard]] float a_low_fuel_level() const;
uint32_t config_chan_number() const; [[nodiscard]] std::uint32_t config_chan_number() const;
uint32_t redundant_chan_config() const; [[nodiscard]] std::uint32_t redundant_chan_config() const;
float atten_table(unsigned i) const; [[nodiscard]] float atten_table(unsigned i) const;
float path_losses(unsigned i) const; [[nodiscard]] float path_losses(unsigned i) const;
float h_coupler_xmt_loss() const; [[nodiscard]] float h_coupler_xmt_loss() const;
float h_coupler_cw_loss() const; [[nodiscard]] float h_coupler_cw_loss() const;
float v_coupler_xmt_loss() const; [[nodiscard]] float v_coupler_xmt_loss() const;
float ame_ts_bias() const; [[nodiscard]] float ame_ts_bias() const;
float v_coupler_cw_loss() const; [[nodiscard]] float v_coupler_cw_loss() const;
float pwr_sense_bias() const; [[nodiscard]] float pwr_sense_bias() const;
float ame_v_noise_enr() const; [[nodiscard]] float ame_v_noise_enr() const;
float chan_cal_diff() const; [[nodiscard]] float chan_cal_diff() const;
float v_ts_cw() const; [[nodiscard]] float v_ts_cw() const;
float h_rnscale(unsigned i) const; [[nodiscard]] float h_rnscale(unsigned i) const;
float atmos(unsigned i) const; [[nodiscard]] float atmos(unsigned i) const;
float el_index(unsigned i) const; [[nodiscard]] float el_index(unsigned i) const;
uint32_t tfreq_mhz() const; [[nodiscard]] std::uint32_t tfreq_mhz() const;
float base_data_tcn() const; [[nodiscard]] float base_data_tcn() const;
float refl_data_tover() const; [[nodiscard]] float refl_data_tover() const;
float tar_h_dbz0_lp() const; [[nodiscard]] float tar_h_dbz0_lp() const;
float tar_v_dbz0_lp() const; [[nodiscard]] float tar_v_dbz0_lp() const;
uint32_t init_phi_dp() const; [[nodiscard]] std::uint32_t init_phi_dp() const;
uint32_t norm_init_phi_dp() const; [[nodiscard]] std::uint32_t norm_init_phi_dp() const;
float lx_lp() const; [[nodiscard]] float lx_lp() const;
float lx_sp() const; [[nodiscard]] float lx_sp() const;
float meteor_param() const; [[nodiscard]] float meteor_param() const;
float antenna_gain() const; [[nodiscard]] float antenna_gain() const;
float vel_degrad_limit() const; [[nodiscard]] float vel_degrad_limit() const;
float wth_degrad_limit() const; [[nodiscard]] float wth_degrad_limit() const;
float h_noisetemp_dgrad_limit() const; [[nodiscard]] float h_noisetemp_dgrad_limit() const;
uint32_t h_min_noisetemp() const; [[nodiscard]] std::uint32_t h_min_noisetemp() const;
float v_noisetemp_dgrad_limit() const; [[nodiscard]] float v_noisetemp_dgrad_limit() const;
uint32_t v_min_noisetemp() const; [[nodiscard]] std::uint32_t v_min_noisetemp() const;
float kly_degrade_limit() const; [[nodiscard]] float kly_degrade_limit() const;
float ts_coho() const; [[nodiscard]] float ts_coho() const;
float h_ts_cw() const; [[nodiscard]] float h_ts_cw() const;
float ts_stalo() const; [[nodiscard]] float ts_stalo() const;
float ame_h_noise_enr() const; [[nodiscard]] float ame_h_noise_enr() const;
float xmtr_peak_pwr_high_limit() const; [[nodiscard]] float xmtr_peak_pwr_high_limit() const;
float xmtr_peak_pwr_low_limit() const; [[nodiscard]] float xmtr_peak_pwr_low_limit() const;
float h_dbz0_delta_limit() const; [[nodiscard]] float h_dbz0_delta_limit() const;
float threshold1() const; [[nodiscard]] float threshold1() const;
float threshold2() const; [[nodiscard]] float threshold2() const;
float clut_supp_dgrad_lim() const; [[nodiscard]] float clut_supp_dgrad_lim() const;
float range0_value() const; [[nodiscard]] float range0_value() const;
float xmtr_pwr_mtr_scale() const; [[nodiscard]] float xmtr_pwr_mtr_scale() const;
float v_dbz0_delta_limit() const; [[nodiscard]] float v_dbz0_delta_limit() const;
float tar_h_dbz0_sp() const; [[nodiscard]] float tar_h_dbz0_sp() const;
float tar_v_dbz0_sp() const; [[nodiscard]] float tar_v_dbz0_sp() const;
uint32_t deltaprf() const; [[nodiscard]] std::uint32_t deltaprf() const;
uint32_t tau_sp() const; [[nodiscard]] std::uint32_t tau_sp() const;
uint32_t tau_lp() const; [[nodiscard]] std::uint32_t tau_lp() const;
uint32_t nc_dead_value() const; [[nodiscard]] std::uint32_t nc_dead_value() const;
uint32_t tau_rf_sp() const; [[nodiscard]] std::uint32_t tau_rf_sp() const;
uint32_t tau_rf_lp() const; [[nodiscard]] std::uint32_t tau_rf_lp() const;
float seg1_lim() const; [[nodiscard]] float seg1_lim() const;
float slatsec() const; [[nodiscard]] float slatsec() const;
float slonsec() const; [[nodiscard]] float slonsec() const;
uint32_t slatdeg() const; [[nodiscard]] std::uint32_t slatdeg() const;
uint32_t slatmin() const; [[nodiscard]] std::uint32_t slatmin() const;
uint32_t slondeg() const; [[nodiscard]] std::uint32_t slondeg() const;
uint32_t slonmin() const; [[nodiscard]] std::uint32_t slonmin() const;
char slatdir() const; [[nodiscard]] char slatdir() const;
char slondir() const; [[nodiscard]] char slondir() const;
double dig_rcvr_clock_freq() const; [[nodiscard]] double dig_rcvr_clock_freq() const;
double coho_freq() const; [[nodiscard]] double coho_freq() const;
float az_correction_factor() const; [[nodiscard]] float az_correction_factor() const;
float el_correction_factor() const; [[nodiscard]] float el_correction_factor() const;
std::string site_name() const; [[nodiscard]] std::string site_name() const;
float ant_manual_setup_ielmin() const; [[nodiscard]] float ant_manual_setup_ielmin() const;
float ant_manual_setup_ielmax() const; [[nodiscard]] float ant_manual_setup_ielmax() const;
uint32_t ant_manual_setup_fazvelmax() const; [[nodiscard]] std::uint32_t ant_manual_setup_fazvelmax() const;
uint32_t ant_manual_setup_felvelmax() const; [[nodiscard]] std::uint32_t ant_manual_setup_felvelmax() const;
int32_t ant_manual_setup_ignd_hgt() const; [[nodiscard]] std::int32_t ant_manual_setup_ignd_hgt() const;
uint32_t ant_manual_setup_irad_hgt() const; [[nodiscard]] std::uint32_t ant_manual_setup_irad_hgt() const;
float az_pos_sustain_drive() const; [[nodiscard]] float az_pos_sustain_drive() const;
float az_neg_sustain_drive() const; [[nodiscard]] float az_neg_sustain_drive() const;
float az_nom_pos_drive_slope() const; [[nodiscard]] float az_nom_pos_drive_slope() const;
float az_nom_neg_drive_slope() const; [[nodiscard]] float az_nom_neg_drive_slope() const;
float az_feedback_slope() const; [[nodiscard]] float az_feedback_slope() const;
float el_pos_sustain_drive() const; [[nodiscard]] float el_pos_sustain_drive() const;
float el_neg_sustain_drive() const; [[nodiscard]] float el_neg_sustain_drive() const;
float el_nom_pos_drive_slope() const; [[nodiscard]] float el_nom_pos_drive_slope() const;
float el_nom_neg_drive_slope() const; [[nodiscard]] float el_nom_neg_drive_slope() const;
float el_feedback_slope() const; [[nodiscard]] float el_feedback_slope() const;
float el_first_slope() const; [[nodiscard]] float el_first_slope() const;
float el_second_slope() const; [[nodiscard]] float el_second_slope() const;
float el_third_slope() const; [[nodiscard]] float el_third_slope() const;
float el_droop_pos() const; [[nodiscard]] float el_droop_pos() const;
float el_off_neutral_drive() const; [[nodiscard]] float el_off_neutral_drive() const;
float az_intertia() const; [[nodiscard]] float az_intertia() const;
float el_inertia() const; [[nodiscard]] float el_inertia() const;
float az_stow_angle() const; [[nodiscard]] float az_stow_angle() const;
float el_stow_angle() const; [[nodiscard]] float el_stow_angle() const;
float az_encoder_alignment() const; [[nodiscard]] float az_encoder_alignment() const;
float el_encoder_alignment() const; [[nodiscard]] float el_encoder_alignment() const;
std::string refined_park() const; [[nodiscard]] std::string refined_park() const;
uint32_t rvp8nv_iwaveguide_length() const; [[nodiscard]] std::uint32_t rvp8nv_iwaveguide_length() const;
float v_rnscale(unsigned i) const; [[nodiscard]] float v_rnscale(unsigned i) const;
float vel_data_tover() const; [[nodiscard]] float vel_data_tover() const;
float width_data_tover() const; [[nodiscard]] float width_data_tover() const;
float doppler_range_start() const; [[nodiscard]] float doppler_range_start() const;
uint32_t max_el_index() const; [[nodiscard]] std::uint32_t max_el_index() const;
float seg2_lim() const; [[nodiscard]] float seg2_lim() const;
float seg3_lim() const; [[nodiscard]] float seg3_lim() const;
float seg4_lim() const; [[nodiscard]] float seg4_lim() const;
uint32_t nbr_el_segments() const; [[nodiscard]] std::uint32_t nbr_el_segments() const;
float h_noise_long() const; [[nodiscard]] float h_noise_long() const;
float ant_noise_temp() const; [[nodiscard]] float ant_noise_temp() const;
float h_noise_short() const; [[nodiscard]] float h_noise_short() const;
float h_noise_tolerance() const; [[nodiscard]] float h_noise_tolerance() const;
float min_h_dyn_range() const; [[nodiscard]] float min_h_dyn_range() const;
bool gen_installed() const; [[nodiscard]] bool gen_installed() const;
bool gen_exercise() const; [[nodiscard]] bool gen_exercise() const;
float v_noise_tolerance() const; [[nodiscard]] float v_noise_tolerance() const;
float min_v_dyn_range() const; [[nodiscard]] float min_v_dyn_range() const;
float zdr_offset_dgrad_lim() const; [[nodiscard]] float zdr_offset_dgrad_lim() const;
float baseline_zdr_offset() const; [[nodiscard]] float baseline_zdr_offset() const;
float v_noise_long() const; [[nodiscard]] float v_noise_long() const;
float v_noise_short() const; [[nodiscard]] float v_noise_short() const;
float zdr_data_tover() const; [[nodiscard]] float zdr_data_tover() const;
float phi_data_tover() const; [[nodiscard]] float phi_data_tover() const;
float rho_data_tover() const; [[nodiscard]] float rho_data_tover() const;
float stalo_power_dgrad_limit() const; [[nodiscard]] float stalo_power_dgrad_limit() const;
float stalo_power_maint_limit() const; [[nodiscard]] float stalo_power_maint_limit() const;
float min_h_pwr_sense() const; [[nodiscard]] float min_h_pwr_sense() const;
float min_v_pwr_sense() const; [[nodiscard]] float min_v_pwr_sense() const;
float h_pwr_sense_offset() const; [[nodiscard]] float h_pwr_sense_offset() const;
float v_pwr_sense_offset() const; [[nodiscard]] float v_pwr_sense_offset() const;
float ps_gain_ref() const; [[nodiscard]] float ps_gain_ref() const;
float rf_pallet_broad_loss() const; [[nodiscard]] float rf_pallet_broad_loss() const;
float ame_ps_tolerance() const; [[nodiscard]] float ame_ps_tolerance() const;
float ame_max_temp() const; [[nodiscard]] float ame_max_temp() const;
float ame_min_temp() const; [[nodiscard]] float ame_min_temp() const;
float rcvr_mod_max_temp() const; [[nodiscard]] float rcvr_mod_max_temp() const;
float rcvr_mod_min_temp() const; [[nodiscard]] float rcvr_mod_min_temp() const;
float bite_mod_max_temp() const; [[nodiscard]] float bite_mod_max_temp() const;
float bite_mod_min_temp() const; [[nodiscard]] float bite_mod_min_temp() const;
uint32_t default_polarization() const; [[nodiscard]] std::uint32_t default_polarization() const;
float tr_limit_dgrad_limit() const; [[nodiscard]] float tr_limit_dgrad_limit() const;
float tr_limit_fail_limit() const; [[nodiscard]] float tr_limit_fail_limit() const;
bool rfp_stepper_enabled() const; [[nodiscard]] bool rfp_stepper_enabled() const;
float ame_current_tolerance() const; [[nodiscard]] float ame_current_tolerance() const;
uint32_t h_only_polarization() const; [[nodiscard]] std::uint32_t h_only_polarization() const;
uint32_t v_only_polarization() const; [[nodiscard]] std::uint32_t v_only_polarization() const;
float sun_bias() const; [[nodiscard]] float sun_bias() const;
float a_min_shelter_temp_warn() const; [[nodiscard]] float a_min_shelter_temp_warn() const;
float power_meter_zero() const; [[nodiscard]] float power_meter_zero() const;
float txb_baseline() const; [[nodiscard]] float txb_baseline() const;
float txb_alarm_thresh() const; [[nodiscard]] float txb_alarm_thresh() const;
bool Parse(std::istream& is); bool Parse(std::istream& is) override;
static std::shared_ptr<RdaAdaptationData> static std::shared_ptr<RdaAdaptationData>
Create(Level2MessageHeader&& header, std::istream& is); Create(Level2MessageHeader&& header, std::istream& is);
private: private:
std::unique_ptr<RdaAdaptationDataImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace rda } // namespace scwx::wsr88d::rda
} // namespace wsr88d
} // namespace scwx

77
wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp
View file

@ -2,14 +2,8 @@
#include <scwx/wsr88d/rda/level2_message.hpp> #include <scwx/wsr88d/rda/level2_message.hpp>
namespace scwx namespace scwx::wsr88d::rda
{ {
namespace wsr88d
{
namespace rda
{
class RdaStatusDataImpl;
class RdaStatusData : public Level2Message class RdaStatusData : public Level2Message
{ {
@ -23,46 +17,45 @@ public:
RdaStatusData(RdaStatusData&&) noexcept; RdaStatusData(RdaStatusData&&) noexcept;
RdaStatusData& operator=(RdaStatusData&&) noexcept; RdaStatusData& operator=(RdaStatusData&&) noexcept;
uint16_t rda_status() const; [[nodiscard]] std::uint16_t rda_status() const;
uint16_t operability_status() const; [[nodiscard]] std::uint16_t operability_status() const;
uint16_t control_status() const; [[nodiscard]] std::uint16_t control_status() const;
uint16_t auxiliary_power_generator_state() const; [[nodiscard]] std::uint16_t auxiliary_power_generator_state() const;
uint16_t average_transmitter_power() const; [[nodiscard]] std::uint16_t average_transmitter_power() const;
float horizontal_reflectivity_calibration_correction() const; [[nodiscard]] float horizontal_reflectivity_calibration_correction() const;
uint16_t data_transmission_enabled() const; [[nodiscard]] std::uint16_t data_transmission_enabled() const;
uint16_t volume_coverage_pattern_number() const; [[nodiscard]] std::uint16_t volume_coverage_pattern_number() const;
uint16_t rda_control_authorization() const; [[nodiscard]] std::uint16_t rda_control_authorization() const;
uint16_t rda_build_number() const; [[nodiscard]] std::uint16_t rda_build_number() const;
uint16_t operational_mode() const; [[nodiscard]] std::uint16_t operational_mode() const;
uint16_t super_resolution_status() const; [[nodiscard]] std::uint16_t super_resolution_status() const;
uint16_t clutter_mitigation_decision_status() const; [[nodiscard]] std::uint16_t clutter_mitigation_decision_status() const;
uint16_t rda_scan_and_data_flags() const; [[nodiscard]] std::uint16_t rda_scan_and_data_flags() const;
uint16_t rda_alarm_summary() const; [[nodiscard]] std::uint16_t rda_alarm_summary() const;
uint16_t command_acknowledgement() const; [[nodiscard]] std::uint16_t command_acknowledgement() const;
uint16_t channel_control_status() const; [[nodiscard]] std::uint16_t channel_control_status() const;
uint16_t spot_blanking_status() const; [[nodiscard]] std::uint16_t spot_blanking_status() const;
uint16_t bypass_map_generation_date() const; [[nodiscard]] std::uint16_t bypass_map_generation_date() const;
uint16_t bypass_map_generation_time() const; [[nodiscard]] std::uint16_t bypass_map_generation_time() const;
uint16_t clutter_filter_map_generation_date() const; [[nodiscard]] std::uint16_t clutter_filter_map_generation_date() const;
uint16_t clutter_filter_map_generation_time() const; [[nodiscard]] std::uint16_t clutter_filter_map_generation_time() const;
float vertical_reflectivity_calibration_correction() const; [[nodiscard]] float vertical_reflectivity_calibration_correction() const;
uint16_t transition_power_source_status() const; [[nodiscard]] std::uint16_t transition_power_source_status() const;
uint16_t rms_control_status() const; [[nodiscard]] std::uint16_t rms_control_status() const;
uint16_t performance_check_status() const; [[nodiscard]] std::uint16_t performance_check_status() const;
uint16_t alarm_codes(unsigned i) const; [[nodiscard]] std::uint16_t alarm_codes(unsigned i) const;
uint16_t signal_processing_options() const; [[nodiscard]] std::uint16_t signal_processing_options() const;
uint16_t downloaded_pattern_number() const; [[nodiscard]] std::uint16_t downloaded_pattern_number() const;
uint16_t status_version() const; [[nodiscard]] std::uint16_t status_version() const;
bool Parse(std::istream& is); bool Parse(std::istream& is) override;
static std::shared_ptr<RdaStatusData> Create(Level2MessageHeader&& header, static std::shared_ptr<RdaStatusData> Create(Level2MessageHeader&& header,
std::istream& is); std::istream& is);
private: private:
std::unique_ptr<RdaStatusDataImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace rda } // namespace scwx::wsr88d::rda
} // namespace wsr88d
} // namespace scwx

15
wxdata/source/scwx/awips/message.cpp
View file

@ -9,17 +9,22 @@ namespace awips
static const std::string logPrefix_ = "scwx::awips::message"; static const std::string logPrefix_ = "scwx::awips::message";
static const auto logger_ = util::Logger::Create(logPrefix_); static const auto logger_ = util::Logger::Create(logPrefix_);
class MessageImpl class Message::Impl
{ {
public: public:
explicit MessageImpl() {}; explicit Impl() = default;
~MessageImpl() = default; ~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
}; };
Message::Message() : p(std::make_unique<MessageImpl>()) {} Message::Message() : p(std::make_unique<Impl>()) {}
Message::~Message() = default; Message::~Message() = default;
Message::Message(Message&&) noexcept = default; Message::Message(Message&&) noexcept = default;
Message& Message::operator=(Message&&) noexcept = default; Message& Message::operator=(Message&&) noexcept = default;
bool Message::ValidateMessage(std::istream& is, size_t bytesRead) const bool Message::ValidateMessage(std::istream& is, size_t bytesRead) const

141
wxdata/source/scwx/wsr88d/rda/digital_radar_data_generic.cpp
View file

@ -1,11 +1,7 @@
#include <scwx/wsr88d/rda/digital_radar_data_generic.hpp> #include <scwx/wsr88d/rda/digital_radar_data_generic.hpp>
#include <scwx/util/logger.hpp> #include <scwx/util/logger.hpp>
namespace scwx namespace scwx::wsr88d::rda
{
namespace wsr88d
{
namespace rda
{ {
static const std::string logPrefix_ = static const std::string logPrefix_ =
@ -27,9 +23,9 @@ static const std::unordered_map<std::string, DataBlockType> strToDataBlock_ {
class DigitalRadarDataGeneric::DataBlock::Impl class DigitalRadarDataGeneric::DataBlock::Impl
{ {
public: public:
explicit Impl(const std::string& dataBlockType, explicit Impl(std::string dataBlockType, std::string dataName) :
const std::string& dataName) : dataBlockType_ {std::move(dataBlockType)},
dataBlockType_ {dataBlockType}, dataName_ {dataName} dataName_ {std::move(dataName)}
{ {
} }
@ -51,7 +47,13 @@ DigitalRadarDataGeneric::DataBlock::operator=(DataBlock&&) noexcept = default;
class DigitalRadarDataGeneric::MomentDataBlock::Impl class DigitalRadarDataGeneric::MomentDataBlock::Impl
{ {
public: public:
explicit Impl() {} explicit Impl() = default;
~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
std::uint16_t numberOfDataMomentGates_ {0}; std::uint16_t numberOfDataMomentGates_ {0};
std::int16_t dataMomentRange_ {0}; std::int16_t dataMomentRange_ {0};
@ -89,7 +91,9 @@ DigitalRadarDataGeneric::MomentDataBlock::number_of_data_moment_gates() const
units::kilometers<float> units::kilometers<float>
DigitalRadarDataGeneric::MomentDataBlock::data_moment_range() const DigitalRadarDataGeneric::MomentDataBlock::data_moment_range() const
{ {
return units::kilometers<float> {p->dataMomentRange_ * 0.001f}; static constexpr float kScale_ = 0.001f;
return units::kilometers<float> {static_cast<float>(p->dataMomentRange_) *
kScale_};
} }
std::int16_t std::int16_t
@ -102,7 +106,9 @@ units::kilometers<float>
DigitalRadarDataGeneric::MomentDataBlock::data_moment_range_sample_interval() DigitalRadarDataGeneric::MomentDataBlock::data_moment_range_sample_interval()
const const
{ {
return units::kilometers<float> {p->dataMomentRangeSampleInterval_ * 0.001f}; static constexpr float kScale_ = 0.001f;
return units::kilometers<float> {
static_cast<float>(p->dataMomentRangeSampleInterval_) * kScale_};
} }
std::uint16_t DigitalRadarDataGeneric::MomentDataBlock:: std::uint16_t DigitalRadarDataGeneric::MomentDataBlock::
@ -113,7 +119,8 @@ std::uint16_t DigitalRadarDataGeneric::MomentDataBlock::
float DigitalRadarDataGeneric::MomentDataBlock::snr_threshold() const float DigitalRadarDataGeneric::MomentDataBlock::snr_threshold() const
{ {
return p->snrThreshold_ * 0.1f; static constexpr float kScale_ = 0.1f;
return static_cast<float>(p->snrThreshold_) * kScale_;
} }
std::int16_t DigitalRadarDataGeneric::MomentDataBlock::snr_threshold_raw() const std::int16_t DigitalRadarDataGeneric::MomentDataBlock::snr_threshold_raw() const
@ -138,14 +145,14 @@ float DigitalRadarDataGeneric::MomentDataBlock::offset() const
const void* DigitalRadarDataGeneric::MomentDataBlock::data_moments() const const void* DigitalRadarDataGeneric::MomentDataBlock::data_moments() const
{ {
const void* dataMoments; const void* dataMoments = nullptr;
switch (p->dataWordSize_) switch (p->dataWordSize_)
{ {
case 8: case 8: // NOLINT(cppcoreguidelines-avoid-magic-numbers)
dataMoments = p->momentGates8_.data(); dataMoments = p->momentGates8_.data();
break; break;
case 16: case 16: // NOLINT(cppcoreguidelines-avoid-magic-numbers)
dataMoments = p->momentGates16_.data(); dataMoments = p->momentGates16_.data();
break; break;
default: default:
@ -189,13 +196,15 @@ bool DigitalRadarDataGeneric::MomentDataBlock::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->scale_), 4); // 20-23 is.read(reinterpret_cast<char*>(&p->scale_), 4); // 20-23
is.read(reinterpret_cast<char*>(&p->offset_), 4); // 24-27 is.read(reinterpret_cast<char*>(&p->offset_), 4); // 24-27
p->numberOfDataMomentGates_ = ntohs(p->numberOfDataMomentGates_); p->numberOfDataMomentGates_ = ntohs(p->numberOfDataMomentGates_);
p->dataMomentRange_ = ntohs(p->dataMomentRange_); p->dataMomentRange_ = static_cast<std::int16_t>(ntohs(p->dataMomentRange_));
p->dataMomentRangeSampleInterval_ = ntohs(p->dataMomentRangeSampleInterval_); p->dataMomentRangeSampleInterval_ = ntohs(p->dataMomentRangeSampleInterval_);
p->tover_ = ntohs(p->tover_); p->tover_ = ntohs(p->tover_);
p->snrThreshold_ = ntohs(p->snrThreshold_); p->snrThreshold_ = static_cast<std::int16_t>(ntohs(p->snrThreshold_));
p->scale_ = awips::Message::SwapFloat(p->scale_); p->scale_ = awips::Message::SwapFloat(p->scale_);
p->offset_ = awips::Message::SwapFloat(p->offset_); p->offset_ = awips::Message::SwapFloat(p->offset_);
// NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
if (p->numberOfDataMomentGates_ <= 1840) if (p->numberOfDataMomentGates_ <= 1840)
{ {
@ -209,7 +218,7 @@ bool DigitalRadarDataGeneric::MomentDataBlock::Parse(std::istream& is)
{ {
p->momentGates16_.resize(p->numberOfDataMomentGates_); p->momentGates16_.resize(p->numberOfDataMomentGates_);
is.read(reinterpret_cast<char*>(p->momentGates16_.data()), is.read(reinterpret_cast<char*>(p->momentGates16_.data()),
p->numberOfDataMomentGates_ * 2); static_cast<std::streamsize>(p->numberOfDataMomentGates_) * 2);
awips::Message::SwapVector(p->momentGates16_); awips::Message::SwapVector(p->momentGates16_);
} }
else else
@ -225,13 +234,21 @@ bool DigitalRadarDataGeneric::MomentDataBlock::Parse(std::istream& is)
dataBlockValid = false; dataBlockValid = false;
} }
// NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
return dataBlockValid; return dataBlockValid;
} }
class DigitalRadarDataGeneric::VolumeDataBlock::Impl class DigitalRadarDataGeneric::VolumeDataBlock::Impl
{ {
public: public:
explicit Impl() {} explicit Impl() = default;
~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
std::uint16_t lrtup_ {0}; std::uint16_t lrtup_ {0};
std::uint8_t versionNumberMajor_ {0}; std::uint8_t versionNumberMajor_ {0};
@ -321,7 +338,7 @@ bool DigitalRadarDataGeneric::VolumeDataBlock::Parse(std::istream& is)
p->lrtup_ = ntohs(p->lrtup_); p->lrtup_ = ntohs(p->lrtup_);
p->latitude_ = awips::Message::SwapFloat(p->latitude_); p->latitude_ = awips::Message::SwapFloat(p->latitude_);
p->longitude_ = awips::Message::SwapFloat(p->longitude_); p->longitude_ = awips::Message::SwapFloat(p->longitude_);
p->siteHeight_ = ntohs(p->siteHeight_); p->siteHeight_ = static_cast<std::int16_t>(ntohs(p->siteHeight_));
p->feedhornHeight_ = ntohs(p->feedhornHeight_); p->feedhornHeight_ = ntohs(p->feedhornHeight_);
p->calibrationConstant_ = awips::Message::SwapFloat(p->calibrationConstant_); p->calibrationConstant_ = awips::Message::SwapFloat(p->calibrationConstant_);
p->horizontaShvTxPower_ = awips::Message::SwapFloat(p->horizontaShvTxPower_); p->horizontaShvTxPower_ = awips::Message::SwapFloat(p->horizontaShvTxPower_);
@ -333,6 +350,8 @@ bool DigitalRadarDataGeneric::VolumeDataBlock::Parse(std::istream& is)
p->volumeCoveragePatternNumber_ = ntohs(p->volumeCoveragePatternNumber_); p->volumeCoveragePatternNumber_ = ntohs(p->volumeCoveragePatternNumber_);
p->processingStatus_ = ntohs(p->processingStatus_); p->processingStatus_ = ntohs(p->processingStatus_);
// NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
if (p->lrtup_ >= 46) if (p->lrtup_ >= 46)
{ {
is.read(reinterpret_cast<char*>(&p->zdrBiasEstimateWeightedMean_), is.read(reinterpret_cast<char*>(&p->zdrBiasEstimateWeightedMean_),
@ -345,13 +364,21 @@ bool DigitalRadarDataGeneric::VolumeDataBlock::Parse(std::istream& is)
is.seekg(6, std::ios_base::cur); // 46-51 is.seekg(6, std::ios_base::cur); // 46-51
} }
// NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
return dataBlockValid; return dataBlockValid;
} }
class DigitalRadarDataGeneric::ElevationDataBlock::Impl class DigitalRadarDataGeneric::ElevationDataBlock::Impl
{ {
public: public:
explicit Impl() {} explicit Impl() = default;
~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
std::uint16_t lrtup_ {0}; std::uint16_t lrtup_ {0};
std::int16_t atmos_ {0}; std::int16_t atmos_ {0};
@ -397,7 +424,7 @@ bool DigitalRadarDataGeneric::ElevationDataBlock::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->calibrationConstant_), 4); // 8-11 is.read(reinterpret_cast<char*>(&p->calibrationConstant_), 4); // 8-11
p->lrtup_ = ntohs(p->lrtup_); p->lrtup_ = ntohs(p->lrtup_);
p->atmos_ = ntohs(p->atmos_); p->atmos_ = static_cast<std::int16_t>(ntohs(p->atmos_));
p->calibrationConstant_ = awips::Message::SwapFloat(p->calibrationConstant_); p->calibrationConstant_ = awips::Message::SwapFloat(p->calibrationConstant_);
return dataBlockValid; return dataBlockValid;
@ -406,7 +433,13 @@ bool DigitalRadarDataGeneric::ElevationDataBlock::Parse(std::istream& is)
class DigitalRadarDataGeneric::RadialDataBlock::Impl class DigitalRadarDataGeneric::RadialDataBlock::Impl
{ {
public: public:
explicit Impl() {} explicit Impl() = default;
~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
std::uint16_t lrtup_ {0}; std::uint16_t lrtup_ {0};
std::uint16_t unambigiousRange_ {0}; std::uint16_t unambigiousRange_ {0};
@ -433,7 +466,8 @@ DigitalRadarDataGeneric::RadialDataBlock::operator=(
float DigitalRadarDataGeneric::RadialDataBlock::unambiguous_range() const float DigitalRadarDataGeneric::RadialDataBlock::unambiguous_range() const
{ {
return p->unambigiousRange_ / 10.0f; static constexpr float kScale_ = 0.1f;
return static_cast<float>(p->unambigiousRange_) * kScale_;
} }
std::shared_ptr<DigitalRadarDataGeneric::RadialDataBlock> std::shared_ptr<DigitalRadarDataGeneric::RadialDataBlock>
@ -486,24 +520,31 @@ bool DigitalRadarDataGeneric::RadialDataBlock::Parse(std::istream& is)
class DigitalRadarDataGeneric::Impl class DigitalRadarDataGeneric::Impl
{ {
public: public:
explicit Impl() {}; explicit Impl() = default;
~Impl() = default; ~Impl() = default;
std::string radarIdentifier_ {}; Impl(const Impl&) = delete;
std::uint32_t collectionTime_ {0}; Impl& operator=(const Impl&) = delete;
std::uint16_t modifiedJulianDate_ {0}; Impl(const Impl&&) = delete;
std::uint16_t azimuthNumber_ {0}; Impl& operator=(const Impl&&) = delete;
float azimuthAngle_ {0.0f};
std::uint8_t compressionIndicator_ {0}; std::string radarIdentifier_ {};
std::uint16_t radialLength_ {0}; std::uint32_t collectionTime_ {0};
std::uint8_t azimuthResolutionSpacing_ {0}; std::uint16_t modifiedJulianDate_ {0};
std::uint8_t radialStatus_ {0}; std::uint16_t azimuthNumber_ {0};
std::uint8_t elevationNumber_ {0}; float azimuthAngle_ {0.0f};
std::uint8_t cutSectorNumber_ {0}; std::uint8_t compressionIndicator_ {0};
float elevationAngle_ {0.0f}; std::uint16_t radialLength_ {0};
std::uint8_t radialSpotBlankingStatus_ {0}; std::uint8_t azimuthResolutionSpacing_ {0};
std::uint8_t azimuthIndexingMode_ {0}; std::uint8_t radialStatus_ {0};
std::uint16_t dataBlockCount_ {0}; std::uint8_t elevationNumber_ {0};
std::uint8_t cutSectorNumber_ {0};
float elevationAngle_ {0.0f};
std::uint8_t radialSpotBlankingStatus_ {0};
std::uint8_t azimuthIndexingMode_ {0};
std::uint16_t dataBlockCount_ {0};
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
std::array<std::uint32_t, 10> dataBlockPointer_ {0}; std::array<std::uint32_t, 10> dataBlockPointer_ {0};
std::shared_ptr<VolumeDataBlock> volumeDataBlock_ {nullptr}; std::shared_ptr<VolumeDataBlock> volumeDataBlock_ {nullptr};
@ -679,6 +720,8 @@ bool DigitalRadarDataGeneric::Parse(std::istream& is)
p->elevationAngle_ = SwapFloat(p->elevationAngle_); p->elevationAngle_ = SwapFloat(p->elevationAngle_);
p->dataBlockCount_ = ntohs(p->dataBlockCount_); p->dataBlockCount_ = ntohs(p->dataBlockCount_);
// NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
if (p->azimuthNumber_ < 1 || p->azimuthNumber_ > 720) if (p->azimuthNumber_ < 1 || p->azimuthNumber_ > 720)
{ {
logger_->warn("Invalid azimuth number: {}", p->azimuthNumber_); logger_->warn("Invalid azimuth number: {}", p->azimuthNumber_);
@ -700,18 +743,22 @@ bool DigitalRadarDataGeneric::Parse(std::istream& is)
messageValid = false; messageValid = false;
} }
// NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
if (!messageValid) if (!messageValid)
{ {
p->dataBlockCount_ = 0; p->dataBlockCount_ = 0;
} }
is.read(reinterpret_cast<char*>(&p->dataBlockPointer_), is.read(reinterpret_cast<char*>(&p->dataBlockPointer_),
p->dataBlockCount_ * 4); static_cast<std::streamsize>(p->dataBlockCount_) * 4);
SwapArray(p->dataBlockPointer_, p->dataBlockCount_); SwapArray(p->dataBlockPointer_, p->dataBlockCount_);
for (uint16_t b = 0; b < p->dataBlockCount_; ++b) for (uint16_t b = 0; b < p->dataBlockCount_; ++b)
{ {
// Index already has bounds check
// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
is.seekg(isBegin + std::streamoff(p->dataBlockPointer_[b]), is.seekg(isBegin + std::streamoff(p->dataBlockPointer_[b]),
std::ios_base::beg); std::ios_base::beg);
@ -784,6 +831,4 @@ DigitalRadarDataGeneric::Create(Level2MessageHeader&& header, std::istream& is)
return message; return message;
} }
} // namespace rda } // namespace scwx::wsr88d::rda
} // namespace wsr88d
} // namespace scwx

906
wxdata/source/scwx/wsr88d/rda/performance_maintenance_data.cpp
View file

File diff suppressed because it is too large Load diff

372
wxdata/source/scwx/wsr88d/rda/rda_adaptation_data.cpp
View file

@ -1,11 +1,7 @@
#include <scwx/wsr88d/rda/rda_adaptation_data.hpp> #include <scwx/wsr88d/rda/rda_adaptation_data.hpp>
#include <scwx/util/logger.hpp> #include <scwx/util/logger.hpp>
namespace scwx namespace scwx::wsr88d::rda
{
namespace wsr88d
{
namespace rda
{ {
static const std::string logPrefix_ = "scwx::wsr88d::rda::rda_adaptation_data"; static const std::string logPrefix_ = "scwx::wsr88d::rda::rda_adaptation_data";
@ -13,30 +9,26 @@ static const auto logger_ = util::Logger::Create(logPrefix_);
struct AntManualSetup struct AntManualSetup
{ {
int32_t ielmin_; std::int32_t ielmin_ {0};
int32_t ielmax_; std::int32_t ielmax_ {0};
uint32_t fazvelmax_; std::uint32_t fazvelmax_ {0};
uint32_t felvelmax_; std::uint32_t felvelmax_ {0};
int32_t igndHgt_; std::int32_t igndHgt_ {0};
uint32_t iradHgt_; std::uint32_t iradHgt_ {0};
AntManualSetup() :
ielmin_ {0},
ielmax_ {0},
fazvelmax_ {0},
felvelmax_ {0},
igndHgt_ {0},
iradHgt_ {0}
{
}
}; };
class RdaAdaptationDataImpl class RdaAdaptationData::Impl
{ {
public: public:
explicit RdaAdaptationDataImpl() = default; explicit Impl() = default;
~RdaAdaptationDataImpl() = default; ~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
// NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
std::string adapFileName_ {}; std::string adapFileName_ {};
std::string adapFormat_ {}; std::string adapFormat_ {};
std::string adapRevision_ {}; std::string adapRevision_ {};
@ -65,27 +57,27 @@ public:
bool specFilterInstalled_ {false}; bool specFilterInstalled_ {false};
bool tpsInstalled_ {false}; bool tpsInstalled_ {false};
bool rmsInstalled_ {false}; bool rmsInstalled_ {false};
uint32_t aHvdlTstInt_ {0}; std::uint32_t aHvdlTstInt_ {0};
uint32_t aRpgLtInt_ {0}; std::uint32_t aRpgLtInt_ {0};
uint32_t aMinStabUtilPwrTime_ {0}; std::uint32_t aMinStabUtilPwrTime_ {0};
uint32_t aGenAutoExerInterval_ {0}; std::uint32_t aGenAutoExerInterval_ {0};
uint32_t aUtilPwrSwReqInterval_ {0}; std::uint32_t aUtilPwrSwReqInterval_ {0};
float aLowFuelLevel_ {0.0f}; float aLowFuelLevel_ {0.0f};
uint32_t configChanNumber_ {0}; std::uint32_t configChanNumber_ {0};
uint32_t redundantChanConfig_ {0}; std::uint32_t redundantChanConfig_ {0};
std::array<float, 104> attenTable_ {0.0f}; std::array<float, 104> attenTable_ {0.0f};
std::map<unsigned, float> pathLosses_ {}; std::map<unsigned, float> pathLosses_ {};
float vTsCw_ {0.0f}; float vTsCw_ {0.0f};
std::array<float, 13> hRnscale_ {0.0f}; std::array<float, 13> hRnscale_ {0.0f};
std::array<float, 13> atmos_ {0.0f}; std::array<float, 13> atmos_ {0.0f};
std::array<float, 12> elIndex_ {0.0f}; std::array<float, 12> elIndex_ {0.0f};
uint32_t tfreqMhz_ {0}; std::uint32_t tfreqMhz_ {0};
float baseDataTcn_ {0.0f}; float baseDataTcn_ {0.0f};
float reflDataTover_ {0.0f}; float reflDataTover_ {0.0f};
float tarHDbz0Lp_ {0.0f}; float tarHDbz0Lp_ {0.0f};
float tarVDbz0Lp_ {0.0f}; float tarVDbz0Lp_ {0.0f};
uint32_t initPhiDp_ {0}; std::uint32_t initPhiDp_ {0};
uint32_t normInitPhiDp_ {0}; std::uint32_t normInitPhiDp_ {0};
float lxLp_ {0.0f}; float lxLp_ {0.0f};
float lxSp_ {0.0f}; float lxSp_ {0.0f};
float meteorParam_ {0.0f}; float meteorParam_ {0.0f};
@ -93,9 +85,9 @@ public:
float velDegradLimit_ {0.0f}; float velDegradLimit_ {0.0f};
float wthDegradLimit_ {0.0f}; float wthDegradLimit_ {0.0f};
float hNoisetempDgradLimit_ {0.0f}; float hNoisetempDgradLimit_ {0.0f};
uint32_t hMinNoisetemp_ {0}; std::uint32_t hMinNoisetemp_ {0};
float vNoisetempDgradLimit_ {0.0f}; float vNoisetempDgradLimit_ {0.0f};
uint32_t vMinNoisetemp_ {0}; std::uint32_t vMinNoisetemp_ {0};
float klyDegradeLimit_ {0.0f}; float klyDegradeLimit_ {0.0f};
float tsCoho_ {0.0f}; float tsCoho_ {0.0f};
float hTsCw_ {0.0f}; float hTsCw_ {0.0f};
@ -112,19 +104,19 @@ public:
float vDbz0DeltaLimit_ {0.0f}; float vDbz0DeltaLimit_ {0.0f};
float tarHDbz0Sp_ {0.0f}; float tarHDbz0Sp_ {0.0f};
float tarVDbz0Sp_ {0.0f}; float tarVDbz0Sp_ {0.0f};
uint32_t deltaprf_ {0}; std::uint32_t deltaprf_ {0};
uint32_t tauSp_ {0}; std::uint32_t tauSp_ {0};
uint32_t tauLp_ {0}; std::uint32_t tauLp_ {0};
uint32_t ncDeadValue_ {0}; std::uint32_t ncDeadValue_ {0};
uint32_t tauRfSp_ {0}; std::uint32_t tauRfSp_ {0};
uint32_t tauRfLp_ {0}; std::uint32_t tauRfLp_ {0};
float seg1Lim_ {0.0f}; float seg1Lim_ {0.0f};
float slatsec_ {0.0f}; float slatsec_ {0.0f};
float slonsec_ {0.0f}; float slonsec_ {0.0f};
uint32_t slatdeg_ {0}; std::uint32_t slatdeg_ {0};
uint32_t slatmin_ {0}; std::uint32_t slatmin_ {0};
uint32_t slondeg_ {0}; std::uint32_t slondeg_ {0};
uint32_t slonmin_ {0}; std::uint32_t slonmin_ {0};
char slatdir_ {0}; char slatdir_ {0};
char slondir_ {0}; char slondir_ {0};
double digRcvrClockFreq_ {0.0}; double digRcvrClockFreq_ {0.0};
@ -155,16 +147,16 @@ public:
float azEncoderAlignment_ {0.0f}; float azEncoderAlignment_ {0.0f};
float elEncoderAlignment_ {0.0f}; float elEncoderAlignment_ {0.0f};
std::string refinedPark_ {}; std::string refinedPark_ {};
uint32_t rvp8nvIwaveguideLength_ {0}; std::uint32_t rvp8nvIwaveguideLength_ {0};
std::array<float, 13> vRnscale_ {0.0f}; std::array<float, 13> vRnscale_ {0.0f};
float velDataTover_ {0.0f}; float velDataTover_ {0.0f};
float widthDataTover_ {0.0f}; float widthDataTover_ {0.0f};
float dopplerRangeStart_ {0.0f}; float dopplerRangeStart_ {0.0f};
uint32_t maxElIndex_ {0}; std::uint32_t maxElIndex_ {0};
float seg2Lim_ {0.0f}; float seg2Lim_ {0.0f};
float seg3Lim_ {0.0f}; float seg3Lim_ {0.0f};
float seg4Lim_ {0.0f}; float seg4Lim_ {0.0f};
uint32_t nbrElSegments_ {0}; std::uint32_t nbrElSegments_ {0};
float hNoiseLong_ {0.0f}; float hNoiseLong_ {0.0f};
float antNoiseTemp_ {0.0f}; float antNoiseTemp_ {0.0f};
float hNoiseShort_ {0.0f}; float hNoiseShort_ {0.0f};
@ -196,22 +188,23 @@ public:
float rcvrModMinTemp_ {0.0f}; float rcvrModMinTemp_ {0.0f};
float biteModMaxTemp_ {0.0f}; float biteModMaxTemp_ {0.0f};
float biteModMinTemp_ {0.0f}; float biteModMinTemp_ {0.0f};
uint32_t defaultPolarization_ {0}; std::uint32_t defaultPolarization_ {0};
float trLimitDgradLimit_ {0.0f}; float trLimitDgradLimit_ {0.0f};
float trLimitFailLimit_ {0.0f}; float trLimitFailLimit_ {0.0f};
bool rfpStepperEnabled_ {false}; bool rfpStepperEnabled_ {false};
float ameCurrentTolerance_ {0.0f}; float ameCurrentTolerance_ {0.0f};
uint32_t hOnlyPolarization_ {0}; std::uint32_t hOnlyPolarization_ {0};
uint32_t vOnlyPolarization_ {0}; std::uint32_t vOnlyPolarization_ {0};
float sunBias_ {0.0f}; float sunBias_ {0.0f};
float aMinShelterTempWarn_ {0.0f}; float aMinShelterTempWarn_ {0.0f};
float powerMeterZero_ {0.0f}; float powerMeterZero_ {0.0f};
float txbBaseline_ {0.0f}; float txbBaseline_ {0.0f};
float txbAlarmThresh_ {0.0f}; float txbAlarmThresh_ {0.0f};
// NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
}; };
RdaAdaptationData::RdaAdaptationData() : RdaAdaptationData::RdaAdaptationData() :
Level2Message(), p(std::make_unique<RdaAdaptationDataImpl>()) Level2Message(), p(std::make_unique<Impl>())
{ {
} }
RdaAdaptationData::~RdaAdaptationData() = default; RdaAdaptationData::~RdaAdaptationData() = default;
@ -277,7 +270,7 @@ float RdaAdaptationData::parkel() const
float RdaAdaptationData::a_fuel_conv(unsigned i) const float RdaAdaptationData::a_fuel_conv(unsigned i) const
{ {
return p->aFuelConv_[i]; return p->aFuelConv_.at(i);
} }
float RdaAdaptationData::a_min_shelter_temp() const float RdaAdaptationData::a_min_shelter_temp() const
@ -360,27 +353,27 @@ bool RdaAdaptationData::rms_installed() const
return p->rmsInstalled_; return p->rmsInstalled_;
} }
uint32_t RdaAdaptationData::a_hvdl_tst_int() const std::uint32_t RdaAdaptationData::a_hvdl_tst_int() const
{ {
return p->aHvdlTstInt_; return p->aHvdlTstInt_;
} }
uint32_t RdaAdaptationData::a_rpg_lt_int() const std::uint32_t RdaAdaptationData::a_rpg_lt_int() const
{ {
return p->aRpgLtInt_; return p->aRpgLtInt_;
} }
uint32_t RdaAdaptationData::a_min_stab_util_pwr_time() const std::uint32_t RdaAdaptationData::a_min_stab_util_pwr_time() const
{ {
return p->aMinStabUtilPwrTime_; return p->aMinStabUtilPwrTime_;
} }
uint32_t RdaAdaptationData::a_gen_auto_exer_interval() const std::uint32_t RdaAdaptationData::a_gen_auto_exer_interval() const
{ {
return p->aGenAutoExerInterval_; return p->aGenAutoExerInterval_;
} }
uint32_t RdaAdaptationData::a_util_pwr_sw_req_interval() const std::uint32_t RdaAdaptationData::a_util_pwr_sw_req_interval() const
{ {
return p->aUtilPwrSwReqInterval_; return p->aUtilPwrSwReqInterval_;
} }
@ -390,19 +383,19 @@ float RdaAdaptationData::a_low_fuel_level() const
return p->aLowFuelLevel_; return p->aLowFuelLevel_;
} }
uint32_t RdaAdaptationData::config_chan_number() const std::uint32_t RdaAdaptationData::config_chan_number() const
{ {
return p->configChanNumber_; return p->configChanNumber_;
} }
uint32_t RdaAdaptationData::redundant_chan_config() const std::uint32_t RdaAdaptationData::redundant_chan_config() const
{ {
return p->redundantChanConfig_; return p->redundantChanConfig_;
} }
float RdaAdaptationData::atten_table(unsigned i) const float RdaAdaptationData::atten_table(unsigned i) const
{ {
return p->attenTable_[i]; return p->attenTable_.at(i);
} }
float RdaAdaptationData::path_losses(unsigned i) const float RdaAdaptationData::path_losses(unsigned i) const
@ -412,41 +405,49 @@ float RdaAdaptationData::path_losses(unsigned i) const
float RdaAdaptationData::h_coupler_xmt_loss() const float RdaAdaptationData::h_coupler_xmt_loss() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(29); return path_losses(29);
} }
float RdaAdaptationData::h_coupler_cw_loss() const float RdaAdaptationData::h_coupler_cw_loss() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(48); return path_losses(48);
} }
float RdaAdaptationData::v_coupler_xmt_loss() const float RdaAdaptationData::v_coupler_xmt_loss() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(49); return path_losses(49);
} }
float RdaAdaptationData::ame_ts_bias() const float RdaAdaptationData::ame_ts_bias() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(51); return path_losses(51);
} }
float RdaAdaptationData::v_coupler_cw_loss() const float RdaAdaptationData::v_coupler_cw_loss() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(53); return path_losses(53);
} }
float RdaAdaptationData::pwr_sense_bias() const float RdaAdaptationData::pwr_sense_bias() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(56); return path_losses(56);
} }
float RdaAdaptationData::ame_v_noise_enr() const float RdaAdaptationData::ame_v_noise_enr() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(57); return path_losses(57);
} }
float RdaAdaptationData::chan_cal_diff() const float RdaAdaptationData::chan_cal_diff() const
{ {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
return path_losses(70); return path_losses(70);
} }
@ -457,20 +458,20 @@ float RdaAdaptationData::v_ts_cw() const
float RdaAdaptationData::h_rnscale(unsigned i) const float RdaAdaptationData::h_rnscale(unsigned i) const
{ {
return p->hRnscale_[i]; return p->hRnscale_.at(i);
} }
float RdaAdaptationData::atmos(unsigned i) const float RdaAdaptationData::atmos(unsigned i) const
{ {
return p->atmos_[i]; return p->atmos_.at(i);
} }
float RdaAdaptationData::el_index(unsigned i) const float RdaAdaptationData::el_index(unsigned i) const
{ {
return p->elIndex_[i]; return p->elIndex_.at(i);
} }
uint32_t RdaAdaptationData::tfreq_mhz() const std::uint32_t RdaAdaptationData::tfreq_mhz() const
{ {
return p->tfreqMhz_; return p->tfreqMhz_;
} }
@ -495,12 +496,12 @@ float RdaAdaptationData::tar_v_dbz0_lp() const
return p->tarVDbz0Lp_; return p->tarVDbz0Lp_;
} }
uint32_t RdaAdaptationData::init_phi_dp() const std::uint32_t RdaAdaptationData::init_phi_dp() const
{ {
return p->initPhiDp_; return p->initPhiDp_;
} }
uint32_t RdaAdaptationData::norm_init_phi_dp() const std::uint32_t RdaAdaptationData::norm_init_phi_dp() const
{ {
return p->normInitPhiDp_; return p->normInitPhiDp_;
} }
@ -540,7 +541,7 @@ float RdaAdaptationData::h_noisetemp_dgrad_limit() const
return p->hNoisetempDgradLimit_; return p->hNoisetempDgradLimit_;
} }
uint32_t RdaAdaptationData::h_min_noisetemp() const std::uint32_t RdaAdaptationData::h_min_noisetemp() const
{ {
return p->hMinNoisetemp_; return p->hMinNoisetemp_;
} }
@ -550,7 +551,7 @@ float RdaAdaptationData::v_noisetemp_dgrad_limit() const
return p->vNoisetempDgradLimit_; return p->vNoisetempDgradLimit_;
} }
uint32_t RdaAdaptationData::v_min_noisetemp() const std::uint32_t RdaAdaptationData::v_min_noisetemp() const
{ {
return p->vMinNoisetemp_; return p->vMinNoisetemp_;
} }
@ -635,32 +636,32 @@ float RdaAdaptationData::tar_v_dbz0_sp() const
return p->tarVDbz0Sp_; return p->tarVDbz0Sp_;
} }
uint32_t RdaAdaptationData::deltaprf() const std::uint32_t RdaAdaptationData::deltaprf() const
{ {
return p->deltaprf_; return p->deltaprf_;
} }
uint32_t RdaAdaptationData::tau_sp() const std::uint32_t RdaAdaptationData::tau_sp() const
{ {
return p->tauSp_; return p->tauSp_;
} }
uint32_t RdaAdaptationData::tau_lp() const std::uint32_t RdaAdaptationData::tau_lp() const
{ {
return p->tauLp_; return p->tauLp_;
} }
uint32_t RdaAdaptationData::nc_dead_value() const std::uint32_t RdaAdaptationData::nc_dead_value() const
{ {
return p->ncDeadValue_; return p->ncDeadValue_;
} }
uint32_t RdaAdaptationData::tau_rf_sp() const std::uint32_t RdaAdaptationData::tau_rf_sp() const
{ {
return p->tauRfSp_; return p->tauRfSp_;
} }
uint32_t RdaAdaptationData::tau_rf_lp() const std::uint32_t RdaAdaptationData::tau_rf_lp() const
{ {
return p->tauRfLp_; return p->tauRfLp_;
} }
@ -680,22 +681,22 @@ float RdaAdaptationData::slonsec() const
return p->slonsec_; return p->slonsec_;
} }
uint32_t RdaAdaptationData::slatdeg() const std::uint32_t RdaAdaptationData::slatdeg() const
{ {
return p->slatdeg_; return p->slatdeg_;
} }
uint32_t RdaAdaptationData::slatmin() const std::uint32_t RdaAdaptationData::slatmin() const
{ {
return p->slatmin_; return p->slatmin_;
} }
uint32_t RdaAdaptationData::slondeg() const std::uint32_t RdaAdaptationData::slondeg() const
{ {
return p->slondeg_; return p->slondeg_;
} }
uint32_t RdaAdaptationData::slonmin() const std::uint32_t RdaAdaptationData::slonmin() const
{ {
return p->slonmin_; return p->slonmin_;
} }
@ -738,31 +739,31 @@ std::string RdaAdaptationData::site_name() const
float RdaAdaptationData::ant_manual_setup_ielmin() const float RdaAdaptationData::ant_manual_setup_ielmin() const
{ {
constexpr float SCALE = 360.0f / 65536.0f; constexpr float SCALE = 360.0f / 65536.0f;
return p->antManualSetup_.ielmin_ * SCALE; return static_cast<float>(p->antManualSetup_.ielmin_) * SCALE;
} }
float RdaAdaptationData::ant_manual_setup_ielmax() const float RdaAdaptationData::ant_manual_setup_ielmax() const
{ {
constexpr float SCALE = 360.0f / 65536.0f; constexpr float SCALE = 360.0f / 65536.0f;
return p->antManualSetup_.ielmax_ * SCALE; return static_cast<float>(p->antManualSetup_.ielmax_) * SCALE;
} }
uint32_t RdaAdaptationData::ant_manual_setup_fazvelmax() const std::uint32_t RdaAdaptationData::ant_manual_setup_fazvelmax() const
{ {
return p->antManualSetup_.fazvelmax_; return p->antManualSetup_.fazvelmax_;
} }
uint32_t RdaAdaptationData::ant_manual_setup_felvelmax() const std::uint32_t RdaAdaptationData::ant_manual_setup_felvelmax() const
{ {
return p->antManualSetup_.felvelmax_; return p->antManualSetup_.felvelmax_;
} }
int32_t RdaAdaptationData::ant_manual_setup_ignd_hgt() const std::int32_t RdaAdaptationData::ant_manual_setup_ignd_hgt() const
{ {
return p->antManualSetup_.igndHgt_; return p->antManualSetup_.igndHgt_;
} }
uint32_t RdaAdaptationData::ant_manual_setup_irad_hgt() const std::uint32_t RdaAdaptationData::ant_manual_setup_irad_hgt() const
{ {
return p->antManualSetup_.iradHgt_; return p->antManualSetup_.iradHgt_;
} }
@ -877,14 +878,14 @@ std::string RdaAdaptationData::refined_park() const
return p->refinedPark_; return p->refinedPark_;
} }
uint32_t RdaAdaptationData::rvp8nv_iwaveguide_length() const std::uint32_t RdaAdaptationData::rvp8nv_iwaveguide_length() const
{ {
return p->rvp8nvIwaveguideLength_; return p->rvp8nvIwaveguideLength_;
} }
float RdaAdaptationData::v_rnscale(unsigned i) const float RdaAdaptationData::v_rnscale(unsigned i) const
{ {
return p->vRnscale_[i]; return p->vRnscale_.at(i);
} }
float RdaAdaptationData::vel_data_tover() const float RdaAdaptationData::vel_data_tover() const
@ -902,7 +903,7 @@ float RdaAdaptationData::doppler_range_start() const
return p->dopplerRangeStart_; return p->dopplerRangeStart_;
} }
uint32_t RdaAdaptationData::max_el_index() const std::uint32_t RdaAdaptationData::max_el_index() const
{ {
return p->maxElIndex_; return p->maxElIndex_;
} }
@ -922,7 +923,7 @@ float RdaAdaptationData::seg4_lim() const
return p->seg4Lim_; return p->seg4Lim_;
} }
uint32_t RdaAdaptationData::nbr_el_segments() const std::uint32_t RdaAdaptationData::nbr_el_segments() const
{ {
return p->nbrElSegments_; return p->nbrElSegments_;
} }
@ -1082,7 +1083,7 @@ float RdaAdaptationData::bite_mod_min_temp() const
return p->biteModMinTemp_; return p->biteModMinTemp_;
} }
uint32_t RdaAdaptationData::default_polarization() const std::uint32_t RdaAdaptationData::default_polarization() const
{ {
return p->defaultPolarization_; return p->defaultPolarization_;
} }
@ -1107,12 +1108,12 @@ float RdaAdaptationData::ame_current_tolerance() const
return p->ameCurrentTolerance_; return p->ameCurrentTolerance_;
} }
uint32_t RdaAdaptationData::h_only_polarization() const std::uint32_t RdaAdaptationData::h_only_polarization() const
{ {
return p->hOnlyPolarization_; return p->hOnlyPolarization_;
} }
uint32_t RdaAdaptationData::v_only_polarization() const std::uint32_t RdaAdaptationData::v_only_polarization() const
{ {
return p->vOnlyPolarization_; return p->vOnlyPolarization_;
} }
@ -1146,9 +1147,10 @@ bool RdaAdaptationData::Parse(std::istream& is)
{ {
logger_->trace("Parsing RDA Adaptation Data (Message Type 18)"); logger_->trace("Parsing RDA Adaptation Data (Message Type 18)");
bool messageValid = true; bool messageValid = true;
size_t bytesRead = 0; std::size_t bytesRead = 0;
// NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers): Readability
p->adapFileName_.resize(12); p->adapFileName_.resize(12);
p->adapFormat_.resize(4); p->adapFormat_.resize(4);
p->adapRevision_.resize(4); p->adapRevision_.resize(4);
@ -1171,7 +1173,7 @@ bool RdaAdaptationData::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->parkel_), 4); // 64-67 is.read(reinterpret_cast<char*>(&p->parkel_), 4); // 64-67
is.read(reinterpret_cast<char*>(&p->aFuelConv_[0]), is.read(reinterpret_cast<char*>(&p->aFuelConv_[0]),
p->aFuelConv_.size() * 4); // 68-111 static_cast<std::streamsize>(p->aFuelConv_.size() * 4)); // 68-111
is.read(reinterpret_cast<char*>(&p->aMinShelterTemp_), 4); // 112-115 is.read(reinterpret_cast<char*>(&p->aMinShelterTemp_), 4); // 112-115
is.read(reinterpret_cast<char*>(&p->aMaxShelterTemp_), 4); // 116-119 is.read(reinterpret_cast<char*>(&p->aMaxShelterTemp_), 4); // 116-119
@ -1209,7 +1211,7 @@ bool RdaAdaptationData::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->redundantChanConfig_), 4); // 224-227 is.read(reinterpret_cast<char*>(&p->redundantChanConfig_), 4); // 224-227
is.read(reinterpret_cast<char*>(&p->attenTable_[0]), is.read(reinterpret_cast<char*>(&p->attenTable_[0]),
p->attenTable_.size() * 4); // 228-643 static_cast<std::streamsize>(p->attenTable_.size() * 4)); // 228-643
is.seekg(24, std::ios_base::cur); // 644-667 is.seekg(24, std::ios_base::cur); // 644-667
is.read(reinterpret_cast<char*>(&p->pathLosses_[7]), 4); // 668-671 is.read(reinterpret_cast<char*>(&p->pathLosses_[7]), 4); // 668-671
@ -1262,13 +1264,13 @@ bool RdaAdaptationData::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->vTsCw_), 4); // 936-939 is.read(reinterpret_cast<char*>(&p->vTsCw_), 4); // 936-939
is.read(reinterpret_cast<char*>(&p->hRnscale_[0]), is.read(reinterpret_cast<char*>(&p->hRnscale_[0]),
p->hRnscale_.size() * 4); // 940-991 static_cast<std::streamsize>(p->hRnscale_.size() * 4)); // 940-991
is.read(reinterpret_cast<char*>(&p->atmos_[0]), is.read(reinterpret_cast<char*>(&p->atmos_[0]),
p->atmos_.size() * 4); // 992-1043 static_cast<std::streamsize>(p->atmos_.size() * 4)); // 992-1043
is.read(reinterpret_cast<char*>(&p->elIndex_[0]), is.read(reinterpret_cast<char*>(&p->elIndex_[0]),
p->elIndex_.size() * 4); // 1044-1091 static_cast<std::streamsize>(p->elIndex_.size() * 4)); // 1044-1091
is.read(reinterpret_cast<char*>(&p->tfreqMhz_), 4); // 1092-1095 is.read(reinterpret_cast<char*>(&p->tfreqMhz_), 4); // 1092-1095
is.read(reinterpret_cast<char*>(&p->baseDataTcn_), 4); // 1096-1099 is.read(reinterpret_cast<char*>(&p->baseDataTcn_), 4); // 1096-1099
@ -1394,11 +1396,12 @@ bool RdaAdaptationData::Parse(std::istream& is)
4); // 8696-8699 4); // 8696-8699
is.read(reinterpret_cast<char*>(&p->vRnscale_[0]), is.read(reinterpret_cast<char*>(&p->vRnscale_[0]),
11 * 4); // 8700-8743 static_cast<std::streamsize>(11 * 4)); // 8700-8743
is.read(reinterpret_cast<char*>(&p->velDataTover_), 4); // 8744-8747 is.read(reinterpret_cast<char*>(&p->velDataTover_), 4); // 8744-8747
is.read(reinterpret_cast<char*>(&p->widthDataTover_), 4); // 8748-8751 is.read(reinterpret_cast<char*>(&p->widthDataTover_), 4); // 8748-8751
is.read(reinterpret_cast<char*>(&p->vRnscale_[11]), 2 * 4); // 8752-8759 is.read(reinterpret_cast<char*>(&p->vRnscale_[11]),
static_cast<std::streamsize>(2 * 4)); // 8752-8759
is.seekg(4, std::ios_base::cur); // 8760-8763 is.seekg(4, std::ios_base::cur); // 8760-8763
@ -1468,6 +1471,8 @@ bool RdaAdaptationData::Parse(std::istream& is)
bytesRead += 9468; bytesRead += 9468;
// NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
p->lowerPreLimit_ = SwapFloat(p->lowerPreLimit_); p->lowerPreLimit_ = SwapFloat(p->lowerPreLimit_);
p->azLat_ = SwapFloat(p->azLat_); p->azLat_ = SwapFloat(p->azLat_);
p->upperPreLimit_ = SwapFloat(p->upperPreLimit_); p->upperPreLimit_ = SwapFloat(p->upperPreLimit_);
@ -1507,84 +1512,87 @@ bool RdaAdaptationData::Parse(std::istream& is)
SwapArray(p->atmos_); SwapArray(p->atmos_);
SwapArray(p->elIndex_); SwapArray(p->elIndex_);
p->tfreqMhz_ = ntohl(p->tfreqMhz_); p->tfreqMhz_ = ntohl(p->tfreqMhz_);
p->baseDataTcn_ = SwapFloat(p->baseDataTcn_); p->baseDataTcn_ = SwapFloat(p->baseDataTcn_);
p->reflDataTover_ = SwapFloat(p->reflDataTover_); p->reflDataTover_ = SwapFloat(p->reflDataTover_);
p->tarHDbz0Lp_ = SwapFloat(p->tarHDbz0Lp_); p->tarHDbz0Lp_ = SwapFloat(p->tarHDbz0Lp_);
p->tarVDbz0Lp_ = SwapFloat(p->tarVDbz0Lp_); p->tarVDbz0Lp_ = SwapFloat(p->tarVDbz0Lp_);
p->initPhiDp_ = ntohl(p->initPhiDp_); p->initPhiDp_ = ntohl(p->initPhiDp_);
p->normInitPhiDp_ = ntohl(p->normInitPhiDp_); p->normInitPhiDp_ = ntohl(p->normInitPhiDp_);
p->lxLp_ = SwapFloat(p->lxLp_); p->lxLp_ = SwapFloat(p->lxLp_);
p->lxSp_ = SwapFloat(p->lxSp_); p->lxSp_ = SwapFloat(p->lxSp_);
p->meteorParam_ = SwapFloat(p->meteorParam_); p->meteorParam_ = SwapFloat(p->meteorParam_);
p->antennaGain_ = SwapFloat(p->antennaGain_); p->antennaGain_ = SwapFloat(p->antennaGain_);
p->velDegradLimit_ = SwapFloat(p->velDegradLimit_); p->velDegradLimit_ = SwapFloat(p->velDegradLimit_);
p->wthDegradLimit_ = SwapFloat(p->wthDegradLimit_); p->wthDegradLimit_ = SwapFloat(p->wthDegradLimit_);
p->hNoisetempDgradLimit_ = SwapFloat(p->hNoisetempDgradLimit_); p->hNoisetempDgradLimit_ = SwapFloat(p->hNoisetempDgradLimit_);
p->hMinNoisetemp_ = ntohl(p->hMinNoisetemp_); p->hMinNoisetemp_ = ntohl(p->hMinNoisetemp_);
p->vNoisetempDgradLimit_ = SwapFloat(p->vNoisetempDgradLimit_); p->vNoisetempDgradLimit_ = SwapFloat(p->vNoisetempDgradLimit_);
p->vMinNoisetemp_ = ntohl(p->vMinNoisetemp_); p->vMinNoisetemp_ = ntohl(p->vMinNoisetemp_);
p->klyDegradeLimit_ = SwapFloat(p->klyDegradeLimit_); p->klyDegradeLimit_ = SwapFloat(p->klyDegradeLimit_);
p->tsCoho_ = SwapFloat(p->tsCoho_); p->tsCoho_ = SwapFloat(p->tsCoho_);
p->hTsCw_ = SwapFloat(p->hTsCw_); p->hTsCw_ = SwapFloat(p->hTsCw_);
p->tsStalo_ = SwapFloat(p->tsStalo_); p->tsStalo_ = SwapFloat(p->tsStalo_);
p->ameHNoiseEnr_ = SwapFloat(p->ameHNoiseEnr_); p->ameHNoiseEnr_ = SwapFloat(p->ameHNoiseEnr_);
p->xmtrPeakPwrHighLimit_ = SwapFloat(p->xmtrPeakPwrHighLimit_); p->xmtrPeakPwrHighLimit_ = SwapFloat(p->xmtrPeakPwrHighLimit_);
p->xmtrPeakPwrLowLimit_ = SwapFloat(p->xmtrPeakPwrLowLimit_); p->xmtrPeakPwrLowLimit_ = SwapFloat(p->xmtrPeakPwrLowLimit_);
p->hDbz0DeltaLimit_ = SwapFloat(p->hDbz0DeltaLimit_); p->hDbz0DeltaLimit_ = SwapFloat(p->hDbz0DeltaLimit_);
p->threshold1_ = SwapFloat(p->threshold1_); p->threshold1_ = SwapFloat(p->threshold1_);
p->threshold2_ = SwapFloat(p->threshold2_); p->threshold2_ = SwapFloat(p->threshold2_);
p->clutSuppDgradLim_ = SwapFloat(p->clutSuppDgradLim_); p->clutSuppDgradLim_ = SwapFloat(p->clutSuppDgradLim_);
p->range0Value_ = SwapFloat(p->range0Value_); p->range0Value_ = SwapFloat(p->range0Value_);
p->xmtrPwrMtrScale_ = SwapFloat(p->xmtrPwrMtrScale_); p->xmtrPwrMtrScale_ = SwapFloat(p->xmtrPwrMtrScale_);
p->vDbz0DeltaLimit_ = SwapFloat(p->vDbz0DeltaLimit_); p->vDbz0DeltaLimit_ = SwapFloat(p->vDbz0DeltaLimit_);
p->tarHDbz0Sp_ = SwapFloat(p->tarHDbz0Sp_); p->tarHDbz0Sp_ = SwapFloat(p->tarHDbz0Sp_);
p->tarVDbz0Sp_ = SwapFloat(p->tarVDbz0Sp_); p->tarVDbz0Sp_ = SwapFloat(p->tarVDbz0Sp_);
p->deltaprf_ = ntohl(p->deltaprf_); p->deltaprf_ = ntohl(p->deltaprf_);
p->tauSp_ = ntohl(p->tauSp_); p->tauSp_ = ntohl(p->tauSp_);
p->tauLp_ = ntohl(p->tauLp_); p->tauLp_ = ntohl(p->tauLp_);
p->ncDeadValue_ = ntohl(p->ncDeadValue_); p->ncDeadValue_ = ntohl(p->ncDeadValue_);
p->tauRfSp_ = ntohl(p->tauRfSp_); p->tauRfSp_ = ntohl(p->tauRfSp_);
p->tauRfLp_ = ntohl(p->tauRfLp_); p->tauRfLp_ = ntohl(p->tauRfLp_);
p->seg1Lim_ = SwapFloat(p->seg1Lim_); p->seg1Lim_ = SwapFloat(p->seg1Lim_);
p->slatsec_ = SwapFloat(p->slatsec_); p->slatsec_ = SwapFloat(p->slatsec_);
p->slonsec_ = SwapFloat(p->slonsec_); p->slonsec_ = SwapFloat(p->slonsec_);
p->slatdeg_ = ntohl(p->slatdeg_); p->slatdeg_ = ntohl(p->slatdeg_);
p->slatmin_ = ntohl(p->slatmin_); p->slatmin_ = ntohl(p->slatmin_);
p->slondeg_ = ntohl(p->slondeg_); p->slondeg_ = ntohl(p->slondeg_);
p->slonmin_ = ntohl(p->slonmin_); p->slonmin_ = ntohl(p->slonmin_);
p->digRcvrClockFreq_ = SwapDouble(p->digRcvrClockFreq_); p->digRcvrClockFreq_ = SwapDouble(p->digRcvrClockFreq_);
p->cohoFreq_ = SwapDouble(p->cohoFreq_); p->cohoFreq_ = SwapDouble(p->cohoFreq_);
p->azCorrectionFactor_ = SwapFloat(p->azCorrectionFactor_); p->azCorrectionFactor_ = SwapFloat(p->azCorrectionFactor_);
p->elCorrectionFactor_ = SwapFloat(p->elCorrectionFactor_); p->elCorrectionFactor_ = SwapFloat(p->elCorrectionFactor_);
p->antManualSetup_.ielmin_ = ntohl(p->antManualSetup_.ielmin_); p->antManualSetup_.ielmin_ =
p->antManualSetup_.ielmax_ = ntohl(p->antManualSetup_.ielmax_); static_cast<std::int32_t>(ntohl(p->antManualSetup_.ielmin_));
p->antManualSetup_.ielmax_ =
static_cast<std::int32_t>(ntohl(p->antManualSetup_.ielmax_));
p->antManualSetup_.fazvelmax_ = ntohl(p->antManualSetup_.fazvelmax_); p->antManualSetup_.fazvelmax_ = ntohl(p->antManualSetup_.fazvelmax_);
p->antManualSetup_.felvelmax_ = ntohl(p->antManualSetup_.felvelmax_); p->antManualSetup_.felvelmax_ = ntohl(p->antManualSetup_.felvelmax_);
p->antManualSetup_.igndHgt_ = ntohl(p->antManualSetup_.igndHgt_); p->antManualSetup_.igndHgt_ =
p->antManualSetup_.iradHgt_ = ntohl(p->antManualSetup_.iradHgt_); static_cast<std::int32_t>(ntohl(p->antManualSetup_.igndHgt_));
p->azPosSustainDrive_ = SwapFloat(p->azPosSustainDrive_); p->antManualSetup_.iradHgt_ = ntohl(p->antManualSetup_.iradHgt_);
p->azNegSustainDrive_ = SwapFloat(p->azNegSustainDrive_); p->azPosSustainDrive_ = SwapFloat(p->azPosSustainDrive_);
p->azNomPosDriveSlope_ = SwapFloat(p->azNomPosDriveSlope_); p->azNegSustainDrive_ = SwapFloat(p->azNegSustainDrive_);
p->azNomNegDriveSlope_ = SwapFloat(p->azNomNegDriveSlope_); p->azNomPosDriveSlope_ = SwapFloat(p->azNomPosDriveSlope_);
p->azFeedbackSlope_ = SwapFloat(p->azFeedbackSlope_); p->azNomNegDriveSlope_ = SwapFloat(p->azNomNegDriveSlope_);
p->elPosSustainDrive_ = SwapFloat(p->elPosSustainDrive_); p->azFeedbackSlope_ = SwapFloat(p->azFeedbackSlope_);
p->elNegSustainDrive_ = SwapFloat(p->elNegSustainDrive_); p->elPosSustainDrive_ = SwapFloat(p->elPosSustainDrive_);
p->elNomPosDriveSlope_ = SwapFloat(p->elNomPosDriveSlope_); p->elNegSustainDrive_ = SwapFloat(p->elNegSustainDrive_);
p->elNomNegDriveSlope_ = SwapFloat(p->elNomNegDriveSlope_); p->elNomPosDriveSlope_ = SwapFloat(p->elNomPosDriveSlope_);
p->elFeedbackSlope_ = SwapFloat(p->elFeedbackSlope_); p->elNomNegDriveSlope_ = SwapFloat(p->elNomNegDriveSlope_);
p->elFirstSlope_ = SwapFloat(p->elFirstSlope_); p->elFeedbackSlope_ = SwapFloat(p->elFeedbackSlope_);
p->elSecondSlope_ = SwapFloat(p->elSecondSlope_); p->elFirstSlope_ = SwapFloat(p->elFirstSlope_);
p->elThirdSlope_ = SwapFloat(p->elThirdSlope_); p->elSecondSlope_ = SwapFloat(p->elSecondSlope_);
p->elDroopPos_ = SwapFloat(p->elDroopPos_); p->elThirdSlope_ = SwapFloat(p->elThirdSlope_);
p->elOffNeutralDrive_ = SwapFloat(p->elOffNeutralDrive_); p->elDroopPos_ = SwapFloat(p->elDroopPos_);
p->azIntertia_ = SwapFloat(p->azIntertia_); p->elOffNeutralDrive_ = SwapFloat(p->elOffNeutralDrive_);
p->elInertia_ = SwapFloat(p->elInertia_); p->azIntertia_ = SwapFloat(p->azIntertia_);
p->azStowAngle_ = SwapFloat(p->azStowAngle_); p->elInertia_ = SwapFloat(p->elInertia_);
p->elStowAngle_ = SwapFloat(p->elStowAngle_); p->azStowAngle_ = SwapFloat(p->azStowAngle_);
p->azEncoderAlignment_ = SwapFloat(p->azEncoderAlignment_); p->elStowAngle_ = SwapFloat(p->elStowAngle_);
p->elEncoderAlignment_ = SwapFloat(p->elEncoderAlignment_); p->azEncoderAlignment_ = SwapFloat(p->azEncoderAlignment_);
p->rvp8nvIwaveguideLength_ = ntohl(p->rvp8nvIwaveguideLength_); p->elEncoderAlignment_ = SwapFloat(p->elEncoderAlignment_);
p->rvp8nvIwaveguideLength_ = ntohl(p->rvp8nvIwaveguideLength_);
SwapArray(p->vRnscale_); SwapArray(p->vRnscale_);
@ -1660,6 +1668,4 @@ RdaAdaptationData::Create(Level2MessageHeader&& header, std::istream& is)
return message; return message;
} }
} // namespace rda } // namespace scwx::wsr88d::rda
} // namespace wsr88d
} // namespace scwx

171
wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp
View file

@ -1,209 +1,214 @@
#include <scwx/wsr88d/rda/rda_status_data.hpp> #include <scwx/wsr88d/rda/rda_status_data.hpp>
#include <scwx/util/logger.hpp> #include <scwx/util/logger.hpp>
namespace scwx namespace scwx::wsr88d::rda
{
namespace wsr88d
{
namespace rda
{ {
static const std::string logPrefix_ = "scwx::wsr88d::rda::rda_status_data"; static const std::string logPrefix_ = "scwx::wsr88d::rda::rda_status_data";
static const auto logger_ = util::Logger::Create(logPrefix_); static const auto logger_ = util::Logger::Create(logPrefix_);
class RdaStatusDataImpl class RdaStatusData::Impl
{ {
public: public:
explicit RdaStatusDataImpl() = default; explicit Impl() = default;
~RdaStatusDataImpl() = default; ~Impl() = default;
uint16_t rdaStatus_ {0}; Impl(const Impl&) = delete;
uint16_t operabilityStatus_ {0}; Impl& operator=(const Impl&) = delete;
uint16_t controlStatus_ {0}; Impl(const Impl&&) = delete;
uint16_t auxiliaryPowerGeneratorState_ {0}; Impl& operator=(const Impl&&) = delete;
uint16_t averageTransmitterPower_ {0};
int16_t horizontalReflectivityCalibrationCorrection_ {0}; std::uint16_t rdaStatus_ {0};
uint16_t dataTransmissionEnabled_ {0}; std::uint16_t operabilityStatus_ {0};
uint16_t volumeCoveragePatternNumber_ {0}; std::uint16_t controlStatus_ {0};
uint16_t rdaControlAuthorization_ {0}; std::uint16_t auxiliaryPowerGeneratorState_ {0};
uint16_t rdaBuildNumber_ {0}; std::uint16_t averageTransmitterPower_ {0};
uint16_t operationalMode_ {0}; std::int16_t horizontalReflectivityCalibrationCorrection_ {0};
uint16_t superResolutionStatus_ {0}; std::uint16_t dataTransmissionEnabled_ {0};
uint16_t clutterMitigationDecisionStatus_ {0}; std::uint16_t volumeCoveragePatternNumber_ {0};
uint16_t rdaScanAndDataFlags_ {0}; std::uint16_t rdaControlAuthorization_ {0};
uint16_t rdaAlarmSummary_ {0}; std::uint16_t rdaBuildNumber_ {0};
uint16_t commandAcknowledgement_ {0}; std::uint16_t operationalMode_ {0};
uint16_t channelControlStatus_ {0}; std::uint16_t superResolutionStatus_ {0};
uint16_t spotBlankingStatus_ {0}; std::uint16_t clutterMitigationDecisionStatus_ {0};
uint16_t bypassMapGenerationDate_ {0}; std::uint16_t rdaScanAndDataFlags_ {0};
uint16_t bypassMapGenerationTime_ {0}; std::uint16_t rdaAlarmSummary_ {0};
uint16_t clutterFilterMapGenerationDate_ {0}; std::uint16_t commandAcknowledgement_ {0};
uint16_t clutterFilterMapGenerationTime_ {0}; std::uint16_t channelControlStatus_ {0};
int16_t verticalReflectivityCalibrationCorrection_ {0}; std::uint16_t spotBlankingStatus_ {0};
uint16_t transitionPowerSourceStatus_ {0}; std::uint16_t bypassMapGenerationDate_ {0};
uint16_t rmsControlStatus_ {0}; std::uint16_t bypassMapGenerationTime_ {0};
uint16_t performanceCheckStatus_ {0}; std::uint16_t clutterFilterMapGenerationDate_ {0};
std::array<uint16_t, 14> alarmCodes_ {0}; std::uint16_t clutterFilterMapGenerationTime_ {0};
uint16_t signalProcessingOptions_ {0}; std::int16_t verticalReflectivityCalibrationCorrection_ {0};
uint16_t downloadedPatternNumber_ {0}; std::uint16_t transitionPowerSourceStatus_ {0};
uint16_t statusVersion_ {0}; std::uint16_t rmsControlStatus_ {0};
std::uint16_t performanceCheckStatus_ {0};
// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
std::array<std::uint16_t, 14> alarmCodes_ {0};
std::uint16_t signalProcessingOptions_ {0};
std::uint16_t downloadedPatternNumber_ {0};
std::uint16_t statusVersion_ {0};
}; };
RdaStatusData::RdaStatusData() : RdaStatusData::RdaStatusData() : Level2Message(), p(std::make_unique<Impl>()) {}
Level2Message(), p(std::make_unique<RdaStatusDataImpl>())
{
}
RdaStatusData::~RdaStatusData() = default; RdaStatusData::~RdaStatusData() = default;
RdaStatusData::RdaStatusData(RdaStatusData&&) noexcept = default; RdaStatusData::RdaStatusData(RdaStatusData&&) noexcept = default;
RdaStatusData& RdaStatusData::operator=(RdaStatusData&&) noexcept = default; RdaStatusData& RdaStatusData::operator=(RdaStatusData&&) noexcept = default;
uint16_t RdaStatusData::rda_status() const std::uint16_t RdaStatusData::rda_status() const
{ {
return p->rdaStatus_; return p->rdaStatus_;
} }
uint16_t RdaStatusData::operability_status() const std::uint16_t RdaStatusData::operability_status() const
{ {
return p->operabilityStatus_; return p->operabilityStatus_;
} }
uint16_t RdaStatusData::control_status() const std::uint16_t RdaStatusData::control_status() const
{ {
return p->controlStatus_; return p->controlStatus_;
} }
uint16_t RdaStatusData::auxiliary_power_generator_state() const std::uint16_t RdaStatusData::auxiliary_power_generator_state() const
{ {
return p->auxiliaryPowerGeneratorState_; return p->auxiliaryPowerGeneratorState_;
} }
uint16_t RdaStatusData::average_transmitter_power() const std::uint16_t RdaStatusData::average_transmitter_power() const
{ {
return p->averageTransmitterPower_; return p->averageTransmitterPower_;
} }
float RdaStatusData::horizontal_reflectivity_calibration_correction() const float RdaStatusData::horizontal_reflectivity_calibration_correction() const
{ {
return p->horizontalReflectivityCalibrationCorrection_ * 0.01f; constexpr float kScale_ = 0.01f;
return static_cast<float>(p->horizontalReflectivityCalibrationCorrection_) *
kScale_;
} }
uint16_t RdaStatusData::data_transmission_enabled() const std::uint16_t RdaStatusData::data_transmission_enabled() const
{ {
return p->dataTransmissionEnabled_; return p->dataTransmissionEnabled_;
} }
uint16_t RdaStatusData::volume_coverage_pattern_number() const std::uint16_t RdaStatusData::volume_coverage_pattern_number() const
{ {
return p->volumeCoveragePatternNumber_; return p->volumeCoveragePatternNumber_;
} }
uint16_t RdaStatusData::rda_control_authorization() const std::uint16_t RdaStatusData::rda_control_authorization() const
{ {
return p->rdaControlAuthorization_; return p->rdaControlAuthorization_;
} }
uint16_t RdaStatusData::rda_build_number() const std::uint16_t RdaStatusData::rda_build_number() const
{ {
return p->rdaBuildNumber_; return p->rdaBuildNumber_;
} }
uint16_t RdaStatusData::operational_mode() const std::uint16_t RdaStatusData::operational_mode() const
{ {
return p->operationalMode_; return p->operationalMode_;
} }
uint16_t RdaStatusData::super_resolution_status() const std::uint16_t RdaStatusData::super_resolution_status() const
{ {
return p->superResolutionStatus_; return p->superResolutionStatus_;
} }
uint16_t RdaStatusData::clutter_mitigation_decision_status() const std::uint16_t RdaStatusData::clutter_mitigation_decision_status() const
{ {
return p->clutterMitigationDecisionStatus_; return p->clutterMitigationDecisionStatus_;
} }
uint16_t RdaStatusData::rda_scan_and_data_flags() const std::uint16_t RdaStatusData::rda_scan_and_data_flags() const
{ {
return p->rdaScanAndDataFlags_; return p->rdaScanAndDataFlags_;
} }
uint16_t RdaStatusData::rda_alarm_summary() const std::uint16_t RdaStatusData::rda_alarm_summary() const
{ {
return p->rdaAlarmSummary_; return p->rdaAlarmSummary_;
} }
uint16_t RdaStatusData::command_acknowledgement() const std::uint16_t RdaStatusData::command_acknowledgement() const
{ {
return p->commandAcknowledgement_; return p->commandAcknowledgement_;
} }
uint16_t RdaStatusData::channel_control_status() const std::uint16_t RdaStatusData::channel_control_status() const
{ {
return p->channelControlStatus_; return p->channelControlStatus_;
} }
uint16_t RdaStatusData::spot_blanking_status() const std::uint16_t RdaStatusData::spot_blanking_status() const
{ {
return p->spotBlankingStatus_; return p->spotBlankingStatus_;
} }
uint16_t RdaStatusData::bypass_map_generation_date() const std::uint16_t RdaStatusData::bypass_map_generation_date() const
{ {
return p->bypassMapGenerationDate_; return p->bypassMapGenerationDate_;
} }
uint16_t RdaStatusData::bypass_map_generation_time() const std::uint16_t RdaStatusData::bypass_map_generation_time() const
{ {
return p->bypassMapGenerationTime_; return p->bypassMapGenerationTime_;
} }
uint16_t RdaStatusData::clutter_filter_map_generation_date() const std::uint16_t RdaStatusData::clutter_filter_map_generation_date() const
{ {
return p->clutterFilterMapGenerationDate_; return p->clutterFilterMapGenerationDate_;
} }
uint16_t RdaStatusData::clutter_filter_map_generation_time() const std::uint16_t RdaStatusData::clutter_filter_map_generation_time() const
{ {
return p->clutterFilterMapGenerationTime_; return p->clutterFilterMapGenerationTime_;
} }
float RdaStatusData::vertical_reflectivity_calibration_correction() const float RdaStatusData::vertical_reflectivity_calibration_correction() const
{ {
return p->verticalReflectivityCalibrationCorrection_ * 0.01f; constexpr float kScale_ = 0.01f;
return static_cast<float>(p->verticalReflectivityCalibrationCorrection_) *
kScale_;
} }
uint16_t RdaStatusData::transition_power_source_status() const std::uint16_t RdaStatusData::transition_power_source_status() const
{ {
return p->transitionPowerSourceStatus_; return p->transitionPowerSourceStatus_;
} }
uint16_t RdaStatusData::rms_control_status() const std::uint16_t RdaStatusData::rms_control_status() const
{ {
return p->rmsControlStatus_; return p->rmsControlStatus_;
} }
uint16_t RdaStatusData::performance_check_status() const std::uint16_t RdaStatusData::performance_check_status() const
{ {
return p->performanceCheckStatus_; return p->performanceCheckStatus_;
} }
uint16_t RdaStatusData::alarm_codes(unsigned i) const std::uint16_t RdaStatusData::alarm_codes(unsigned i) const
{ {
return p->alarmCodes_[i]; return p->alarmCodes_.at(i);
} }
uint16_t RdaStatusData::signal_processing_options() const std::uint16_t RdaStatusData::signal_processing_options() const
{ {
return p->signalProcessingOptions_; return p->signalProcessingOptions_;
} }
uint16_t RdaStatusData::downloaded_pattern_number() const std::uint16_t RdaStatusData::downloaded_pattern_number() const
{ {
return p->downloadedPatternNumber_; return p->downloadedPatternNumber_;
} }
uint16_t RdaStatusData::status_version() const std::uint16_t RdaStatusData::status_version() const
{ {
return p->statusVersion_; return p->statusVersion_;
} }
@ -215,6 +220,7 @@ bool RdaStatusData::Parse(std::istream& is)
bool messageValid = true; bool messageValid = true;
size_t bytesRead = 0; size_t bytesRead = 0;
// NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers): Readability
is.read(reinterpret_cast<char*>(&p->rdaStatus_), 2); // 1 is.read(reinterpret_cast<char*>(&p->rdaStatus_), 2); // 1
is.read(reinterpret_cast<char*>(&p->operabilityStatus_), 2); // 2 is.read(reinterpret_cast<char*>(&p->operabilityStatus_), 2); // 2
is.read(reinterpret_cast<char*>(&p->controlStatus_), 2); // 3 is.read(reinterpret_cast<char*>(&p->controlStatus_), 2); // 3
@ -249,7 +255,7 @@ bool RdaStatusData::Parse(std::istream& is)
is.read(reinterpret_cast<char*>(&p->rmsControlStatus_), 2); // 25 is.read(reinterpret_cast<char*>(&p->rmsControlStatus_), 2); // 25
is.read(reinterpret_cast<char*>(&p->performanceCheckStatus_), 2); // 26 is.read(reinterpret_cast<char*>(&p->performanceCheckStatus_), 2); // 26
is.read(reinterpret_cast<char*>(&p->alarmCodes_), is.read(reinterpret_cast<char*>(&p->alarmCodes_),
p->alarmCodes_.size() * 2); // 27-40 static_cast<std::streamsize>(p->alarmCodes_.size() * 2)); // 27-40
bytesRead += 80; bytesRead += 80;
p->rdaStatus_ = ntohs(p->rdaStatus_); p->rdaStatus_ = ntohs(p->rdaStatus_);
@ -257,8 +263,8 @@ bool RdaStatusData::Parse(std::istream& is)
p->controlStatus_ = ntohs(p->controlStatus_); p->controlStatus_ = ntohs(p->controlStatus_);
p->auxiliaryPowerGeneratorState_ = ntohs(p->auxiliaryPowerGeneratorState_); p->auxiliaryPowerGeneratorState_ = ntohs(p->auxiliaryPowerGeneratorState_);
p->averageTransmitterPower_ = ntohs(p->averageTransmitterPower_); p->averageTransmitterPower_ = ntohs(p->averageTransmitterPower_);
p->horizontalReflectivityCalibrationCorrection_ = p->horizontalReflectivityCalibrationCorrection_ = static_cast<std::int16_t>(
ntohs(p->horizontalReflectivityCalibrationCorrection_); ntohs(p->horizontalReflectivityCalibrationCorrection_));
p->dataTransmissionEnabled_ = ntohs(p->dataTransmissionEnabled_); p->dataTransmissionEnabled_ = ntohs(p->dataTransmissionEnabled_);
p->volumeCoveragePatternNumber_ = ntohs(p->volumeCoveragePatternNumber_); p->volumeCoveragePatternNumber_ = ntohs(p->volumeCoveragePatternNumber_);
p->rdaControlAuthorization_ = ntohs(p->rdaControlAuthorization_); p->rdaControlAuthorization_ = ntohs(p->rdaControlAuthorization_);
@ -278,15 +284,16 @@ bool RdaStatusData::Parse(std::istream& is)
ntohs(p->clutterFilterMapGenerationDate_); ntohs(p->clutterFilterMapGenerationDate_);
p->clutterFilterMapGenerationTime_ = p->clutterFilterMapGenerationTime_ =
ntohs(p->clutterFilterMapGenerationTime_); ntohs(p->clutterFilterMapGenerationTime_);
p->verticalReflectivityCalibrationCorrection_ = p->verticalReflectivityCalibrationCorrection_ = static_cast<std::int16_t>(
ntohs(p->verticalReflectivityCalibrationCorrection_); ntohs(p->verticalReflectivityCalibrationCorrection_));
p->transitionPowerSourceStatus_ = ntohs(p->transitionPowerSourceStatus_); p->transitionPowerSourceStatus_ = ntohs(p->transitionPowerSourceStatus_);
p->rmsControlStatus_ = ntohs(p->rmsControlStatus_); p->rmsControlStatus_ = ntohs(p->rmsControlStatus_);
p->performanceCheckStatus_ = ntohs(p->performanceCheckStatus_); p->performanceCheckStatus_ = ntohs(p->performanceCheckStatus_);
SwapArray(p->alarmCodes_); SwapArray(p->alarmCodes_);
// RDA Build 18.0 increased the size of the message from 80 to 120 bytes // RDA Build 18.0 increased the size of the message from 80 to 120 bytes
if (header().message_size() * 2 > Level2MessageHeader::SIZE + 80) if (static_cast<std::size_t>(header().message_size()) * 2 >
Level2MessageHeader::SIZE + 80)
{ {
is.read(reinterpret_cast<char*>(&p->signalProcessingOptions_), 2); // 41 is.read(reinterpret_cast<char*>(&p->signalProcessingOptions_), 2); // 41
is.seekg(34, std::ios_base::cur); // 42-58 is.seekg(34, std::ios_base::cur); // 42-58
@ -297,6 +304,8 @@ bool RdaStatusData::Parse(std::istream& is)
p->signalProcessingOptions_ = ntohs(p->signalProcessingOptions_); p->signalProcessingOptions_ = ntohs(p->signalProcessingOptions_);
p->statusVersion_ = ntohs(p->statusVersion_); p->statusVersion_ = ntohs(p->statusVersion_);
} }
// NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
if (!ValidateMessage(is, bytesRead)) if (!ValidateMessage(is, bytesRead))
{ {
@ -320,6 +329,4 @@ RdaStatusData::Create(Level2MessageHeader&& header, std::istream& is)
return message; return message;
} }
} // namespace rda } // namespace scwx::wsr88d::rda
} // namespace wsr88d
} // namespace scwx