825 lines
21 KiB
Rust
825 lines
21 KiB
Rust
//! Band configuration tables. 1:1 port of
|
|
//! `lib/microwaveprop/propagation/band_config.ex`.
|
|
//!
|
|
//! Keep the data layout identical to the Elixir module; any numerical
|
|
//! drift here will show up immediately in golden-fixture scorer tests.
|
|
|
|
use std::sync::OnceLock;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum HumidityEffect {
|
|
Beneficial,
|
|
Harmful,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub struct Weights {
|
|
pub humidity: f64,
|
|
pub time_of_day: f64,
|
|
pub td_depression: f64,
|
|
pub refractivity: f64,
|
|
pub sky: f64,
|
|
pub season: f64,
|
|
pub wind: f64,
|
|
pub rain: f64,
|
|
pub pressure: f64,
|
|
pub pwat: f64,
|
|
}
|
|
|
|
impl Weights {
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub const fn new(
|
|
humidity: f64,
|
|
time_of_day: f64,
|
|
td_depression: f64,
|
|
refractivity: f64,
|
|
sky: f64,
|
|
season: f64,
|
|
wind: f64,
|
|
rain: f64,
|
|
pressure: f64,
|
|
pwat: f64,
|
|
) -> Self {
|
|
Self {
|
|
humidity,
|
|
time_of_day,
|
|
td_depression,
|
|
refractivity,
|
|
sky,
|
|
season,
|
|
wind,
|
|
rain,
|
|
pressure,
|
|
pwat,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Default weight vector fit by gradient descent on 5,000 QSOs
|
|
/// (2026-04-11). Used as fallback for bands that don't carry a `weights`
|
|
/// override.
|
|
pub const DEFAULT_WEIGHTS: Weights = Weights::new(
|
|
0.1243, // humidity
|
|
0.0496, // time_of_day
|
|
0.0978, // td_depression
|
|
0.1049, // refractivity
|
|
0.08, // sky
|
|
0.1112, // season
|
|
0.08, // wind
|
|
0.1362, // rain
|
|
0.1032, // pressure
|
|
0.1128, // pwat
|
|
);
|
|
|
|
/// Sunrise hour by month (1..=12) in local solar time. Index = month - 1.
|
|
pub const SUNRISE_TABLE: [f64; 12] = [
|
|
7.4, 7.3, 7.0, 6.7, 6.35, 6.25, 6.35, 6.65, 6.9, 7.1, 7.35, 7.45,
|
|
];
|
|
|
|
pub const HUMIDITY_BENEFICIAL_THRESHOLDS: &[(u8, i32)] =
|
|
&[(4, 55), (7, 70), (10, 82), (14, 90), (18, 95), (22, 88)];
|
|
pub const HUMIDITY_BENEFICIAL_DEFAULT: i32 = 75;
|
|
|
|
/// `(gradient_max, score_beneficial, score_harmful)`. First entry whose
|
|
/// `gradient_max` exceeds the observed gradient wins. Calibrated for
|
|
/// HRRR-derived gradients.
|
|
pub const REFRACTIVITY_THRESHOLDS: &[(i32, i32, i32)] = &[
|
|
(-200, 98, 85),
|
|
(-150, 92, 80),
|
|
(-100, 82, 72),
|
|
(-75, 68, 62),
|
|
(-55, 55, 55),
|
|
(-40, 48, 48),
|
|
];
|
|
pub const REFRACTIVITY_DEFAULT: (i32, i32) = (42, 42);
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct BandConfig {
|
|
pub freq_mhz: u32,
|
|
pub label: &'static str,
|
|
pub o2_db_km: f64,
|
|
pub h2o_coeff: f64,
|
|
pub humidity_effect: HumidityEffect,
|
|
pub humidity_penalty: f64,
|
|
pub rain_k: f64,
|
|
pub rain_alpha: f64,
|
|
/// Per-month base score for seasonal factor, index = month - 1.
|
|
pub seasonal_base: [i32; 12],
|
|
/// Per-month additive adjustment, index = month - 1.
|
|
pub seasonal_adj: [i32; 12],
|
|
pub typical_range_km: u32,
|
|
pub extended_range_km: u32,
|
|
pub exceptional_range_km: u32,
|
|
/// `None` falls back to `DEFAULT_WEIGHTS`.
|
|
pub weights: Option<Weights>,
|
|
}
|
|
|
|
impl BandConfig {
|
|
pub fn weights(&self) -> Weights {
|
|
self.weights.unwrap_or(DEFAULT_WEIGHTS)
|
|
}
|
|
}
|
|
|
|
/// Fixed-size literal helper; month values given as (month, score) pairs
|
|
/// in Elixir map form. Panics at construction if a month is out of range.
|
|
const fn months(v: [(u8, i32); 12]) -> [i32; 12] {
|
|
// Build by iterating; can't use const fn loop with indirect writes
|
|
// cleanly, so use a match per position.
|
|
let mut out = [0; 12];
|
|
let mut i = 0;
|
|
while i < 12 {
|
|
let (m, s) = v[i];
|
|
// Month values always 1..=12, stored at index month - 1 is the
|
|
// convention in Elixir — we rely on the literal being in month
|
|
// order here (it is in every band config).
|
|
assert!(m >= 1 && m <= 12);
|
|
out[(m - 1) as usize] = s;
|
|
i += 1;
|
|
}
|
|
out
|
|
}
|
|
|
|
const fn adj_from(values: &[(u8, i32)]) -> [i32; 12] {
|
|
let mut out = [0; 12];
|
|
let mut i = 0;
|
|
while i < values.len() {
|
|
let (m, s) = values[i];
|
|
assert!(m >= 1 && m <= 12);
|
|
out[(m - 1) as usize] = s;
|
|
i += 1;
|
|
}
|
|
out
|
|
}
|
|
|
|
// The seasonal_base tables are identical across many bands; pull out the
|
|
// common shape once so the 22 band definitions stay scannable.
|
|
const BASE_LOW_BAND: [i32; 12] = months([
|
|
(1, 38),
|
|
(2, 40),
|
|
(3, 22),
|
|
(4, 55),
|
|
(5, 68),
|
|
(6, 90),
|
|
(7, 95),
|
|
(8, 75),
|
|
(9, 78),
|
|
(10, 88),
|
|
(11, 78),
|
|
(12, 25),
|
|
]);
|
|
|
|
const BASE_50: [i32; 12] = months([
|
|
(1, 30),
|
|
(2, 32),
|
|
(3, 25),
|
|
(4, 50),
|
|
(5, 70),
|
|
(6, 95),
|
|
(7, 95),
|
|
(8, 70),
|
|
(9, 65),
|
|
(10, 70),
|
|
(11, 60),
|
|
(12, 25),
|
|
]);
|
|
|
|
const BASE_24G: [i32; 12] = months([
|
|
(1, 88),
|
|
(2, 84),
|
|
(3, 68),
|
|
(4, 62),
|
|
(5, 51),
|
|
(6, 34),
|
|
(7, 18),
|
|
(8, 18),
|
|
(9, 48),
|
|
(10, 68),
|
|
(11, 96),
|
|
(12, 88),
|
|
]);
|
|
|
|
const BASE_47G: [i32; 12] = months([
|
|
(1, 90),
|
|
(2, 88),
|
|
(3, 78),
|
|
(4, 68),
|
|
(5, 55),
|
|
(6, 38),
|
|
(7, 22),
|
|
(8, 22),
|
|
(9, 48),
|
|
(10, 74),
|
|
(11, 96),
|
|
(12, 90),
|
|
]);
|
|
|
|
const BASE_68G: [i32; 12] = months([
|
|
(1, 90),
|
|
(2, 88),
|
|
(3, 78),
|
|
(4, 65),
|
|
(5, 50),
|
|
(6, 32),
|
|
(7, 18),
|
|
(8, 18),
|
|
(9, 44),
|
|
(10, 70),
|
|
(11, 92),
|
|
(12, 90),
|
|
]);
|
|
|
|
const BASE_75G: [i32; 12] = months([
|
|
(1, 90),
|
|
(2, 90),
|
|
(3, 80),
|
|
(4, 68),
|
|
(5, 55),
|
|
(6, 38),
|
|
(7, 22),
|
|
(8, 22),
|
|
(9, 48),
|
|
(10, 74),
|
|
(11, 96),
|
|
(12, 90),
|
|
]);
|
|
|
|
const BASE_122G: [i32; 12] = months([
|
|
(1, 92),
|
|
(2, 90),
|
|
(3, 78),
|
|
(4, 62),
|
|
(5, 45),
|
|
(6, 28),
|
|
(7, 15),
|
|
(8, 15),
|
|
(9, 38),
|
|
(10, 68),
|
|
(11, 92),
|
|
(12, 92),
|
|
]);
|
|
|
|
const BASE_134G: [i32; 12] = months([
|
|
(1, 92),
|
|
(2, 90),
|
|
(3, 78),
|
|
(4, 65),
|
|
(5, 48),
|
|
(6, 30),
|
|
(7, 18),
|
|
(8, 18),
|
|
(9, 42),
|
|
(10, 70),
|
|
(11, 92),
|
|
(12, 92),
|
|
]);
|
|
|
|
const BASE_142G: [i32; 12] = months([
|
|
(1, 92),
|
|
(2, 90),
|
|
(3, 78),
|
|
(4, 65),
|
|
(5, 47),
|
|
(6, 28),
|
|
(7, 16),
|
|
(8, 16),
|
|
(9, 40),
|
|
(10, 68),
|
|
(11, 92),
|
|
(12, 92),
|
|
]);
|
|
|
|
const BASE_145G: [i32; 12] = months([
|
|
(1, 92),
|
|
(2, 90),
|
|
(3, 78),
|
|
(4, 64),
|
|
(5, 46),
|
|
(6, 27),
|
|
(7, 15),
|
|
(8, 15),
|
|
(9, 38),
|
|
(10, 66),
|
|
(11, 92),
|
|
(12, 92),
|
|
]);
|
|
|
|
const BASE_241G: [i32; 12] = months([
|
|
(1, 95),
|
|
(2, 92),
|
|
(3, 75),
|
|
(4, 55),
|
|
(5, 35),
|
|
(6, 15),
|
|
(7, 8),
|
|
(8, 8),
|
|
(9, 30),
|
|
(10, 65),
|
|
(11, 95),
|
|
(12, 95),
|
|
]);
|
|
|
|
const BASE_288G: [i32; 12] = months([
|
|
(1, 95),
|
|
(2, 92),
|
|
(3, 75),
|
|
(4, 55),
|
|
(5, 35),
|
|
(6, 14),
|
|
(7, 7),
|
|
(8, 7),
|
|
(9, 28),
|
|
(10, 64),
|
|
(11, 95),
|
|
(12, 95),
|
|
]);
|
|
|
|
const BASE_322G: [i32; 12] = months([
|
|
(1, 96),
|
|
(2, 92),
|
|
(3, 74),
|
|
(4, 52),
|
|
(5, 32),
|
|
(6, 12),
|
|
(7, 6),
|
|
(8, 6),
|
|
(9, 26),
|
|
(10, 62),
|
|
(11, 96),
|
|
(12, 96),
|
|
]);
|
|
|
|
const BASE_403G: [i32; 12] = months([
|
|
(1, 96),
|
|
(2, 92),
|
|
(3, 74),
|
|
(4, 52),
|
|
(5, 32),
|
|
(6, 12),
|
|
(7, 6),
|
|
(8, 6),
|
|
(9, 26),
|
|
(10, 62),
|
|
(11, 96),
|
|
(12, 96),
|
|
]);
|
|
|
|
const ADJ_NONE: [i32; 12] = [0; 12];
|
|
const ADJ_24G: [i32; 12] = adj_from(&[(5, -4), (6, -8), (7, -10), (8, -10), (9, -4)]);
|
|
|
|
fn bands() -> &'static [BandConfig] {
|
|
static CELL: OnceLock<Vec<BandConfig>> = OnceLock::new();
|
|
CELL.get_or_init(build_bands)
|
|
}
|
|
|
|
#[allow(clippy::too_many_lines)]
|
|
fn build_bands() -> Vec<BandConfig> {
|
|
use HumidityEffect::*;
|
|
vec![
|
|
BandConfig {
|
|
freq_mhz: 50,
|
|
label: "50 MHz",
|
|
o2_db_km: 0.0,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.0,
|
|
rain_alpha: 1.0,
|
|
seasonal_base: BASE_50,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 400,
|
|
extended_range_km: 1500,
|
|
exceptional_range_km: 4000,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 144,
|
|
label: "144 MHz",
|
|
o2_db_km: 0.0,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.0,
|
|
rain_alpha: 1.0,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 350,
|
|
extended_range_km: 900,
|
|
exceptional_range_km: 2500,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 222,
|
|
label: "222 MHz",
|
|
o2_db_km: 0.0,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.0,
|
|
rain_alpha: 1.0,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 320,
|
|
extended_range_km: 800,
|
|
exceptional_range_km: 2000,
|
|
weights: Some(Weights::new(
|
|
0.1593, 0.0350, 0.1250, 0.1401, 0.0706, 0.1276, 0.0706, 0.0120, 0.0681, 0.1916,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 432,
|
|
label: "432 MHz",
|
|
o2_db_km: 0.0,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.0,
|
|
rain_alpha: 1.0,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 300,
|
|
extended_range_km: 700,
|
|
exceptional_range_km: 1800,
|
|
weights: Some(Weights::new(
|
|
0.2061, 0.0329, 0.1200, 0.1186, 0.0663, 0.1106, 0.0663, 0.0113, 0.0809, 0.1870,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 902,
|
|
label: "902 MHz",
|
|
o2_db_km: 0.006,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.000,
|
|
rain_alpha: 1.0,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 400,
|
|
extended_range_km: 800,
|
|
exceptional_range_km: 1500,
|
|
weights: Some(Weights::new(
|
|
0.2201, 0.0437, 0.1102, 0.0888, 0.0783, 0.1197, 0.0783, 0.0133, 0.0839, 0.1635,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 1_296,
|
|
label: "1296 MHz",
|
|
o2_db_km: 0.006,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.000,
|
|
rain_alpha: 1.0,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 350,
|
|
extended_range_km: 700,
|
|
exceptional_range_km: 1200,
|
|
weights: Some(Weights::new(
|
|
0.2131, 0.0494, 0.0898, 0.1392, 0.0797, 0.1108, 0.0797, 0.0136, 0.0568, 0.1678,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 2_304,
|
|
label: "2304 MHz",
|
|
o2_db_km: 0.006,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.001,
|
|
rain_alpha: 1.15,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 300,
|
|
extended_range_km: 600,
|
|
exceptional_range_km: 1000,
|
|
weights: Some(Weights::new(
|
|
0.1941, 0.0387, 0.1385, 0.1638, 0.0625, 0.0868, 0.0625, 0.0336, 0.0432, 0.1762,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 3_400,
|
|
label: "3400 MHz",
|
|
o2_db_km: 0.006,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.002,
|
|
rain_alpha: 1.20,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 250,
|
|
extended_range_km: 550,
|
|
exceptional_range_km: 900,
|
|
weights: Some(Weights::new(
|
|
0.1996, 0.0398, 0.1251, 0.1310, 0.0642, 0.0893, 0.0642, 0.0489, 0.0568, 0.1811,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 5_760,
|
|
label: "5760 MHz",
|
|
o2_db_km: 0.007,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.005,
|
|
rain_alpha: 1.25,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 220,
|
|
extended_range_km: 500,
|
|
exceptional_range_km: 1000,
|
|
weights: Some(Weights::new(
|
|
0.1829, 0.0423, 0.1205, 0.0881, 0.0683, 0.0949, 0.0683, 0.0822, 0.0602, 0.1925,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 10_000,
|
|
label: "10 GHz",
|
|
o2_db_km: 0.007,
|
|
h2o_coeff: 0.0,
|
|
humidity_effect: Beneficial,
|
|
humidity_penalty: 0.0,
|
|
rain_k: 0.010,
|
|
rain_alpha: 1.28,
|
|
seasonal_base: BASE_LOW_BAND,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 200,
|
|
extended_range_km: 500,
|
|
exceptional_range_km: 1000,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 24_000,
|
|
label: "24 GHz",
|
|
o2_db_km: 0.02,
|
|
h2o_coeff: 0.002,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.6,
|
|
rain_k: 0.070,
|
|
rain_alpha: 1.07,
|
|
seasonal_base: BASE_24G,
|
|
seasonal_adj: ADJ_24G,
|
|
typical_range_km: 100,
|
|
extended_range_km: 250,
|
|
exceptional_range_km: 500,
|
|
weights: Some(Weights::new(
|
|
0.1481, 0.0532, 0.0360, 0.1250, 0.0477, 0.0729, 0.0477, 0.2147, 0.1203, 0.1344,
|
|
)),
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 47_000,
|
|
label: "47 GHz",
|
|
o2_db_km: 0.04,
|
|
h2o_coeff: 0.003,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.0,
|
|
rain_k: 0.187,
|
|
rain_alpha: 0.93,
|
|
seasonal_base: BASE_47G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 70,
|
|
extended_range_km: 150,
|
|
exceptional_range_km: 300,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 68_000,
|
|
label: "68 GHz",
|
|
o2_db_km: 0.90,
|
|
h2o_coeff: 0.007,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.4,
|
|
rain_k: 0.310,
|
|
rain_alpha: 0.86,
|
|
seasonal_base: BASE_68G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 40,
|
|
extended_range_km: 80,
|
|
exceptional_range_km: 150,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 75_000,
|
|
label: "75 GHz",
|
|
o2_db_km: 0.012,
|
|
h2o_coeff: 0.006,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.2,
|
|
rain_k: 0.345,
|
|
rain_alpha: 0.84,
|
|
seasonal_base: BASE_75G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 50,
|
|
extended_range_km: 120,
|
|
exceptional_range_km: 250,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 122_000,
|
|
label: "122 GHz",
|
|
o2_db_km: 0.80,
|
|
h2o_coeff: 0.010,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.0,
|
|
rain_k: 0.498,
|
|
rain_alpha: 0.77,
|
|
seasonal_base: BASE_122G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 30,
|
|
extended_range_km: 80,
|
|
exceptional_range_km: 140,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 134_000,
|
|
label: "134 GHz",
|
|
o2_db_km: 0.08,
|
|
h2o_coeff: 0.015,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.3,
|
|
rain_k: 0.520,
|
|
rain_alpha: 0.75,
|
|
seasonal_base: BASE_134G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 40,
|
|
extended_range_km: 100,
|
|
exceptional_range_km: 160,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 142_000,
|
|
label: "142 GHz",
|
|
o2_db_km: 0.05,
|
|
h2o_coeff: 0.025,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.4,
|
|
rain_k: 0.530,
|
|
rain_alpha: 0.74,
|
|
seasonal_base: BASE_142G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 35,
|
|
extended_range_km: 80,
|
|
exceptional_range_km: 160,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 145_000,
|
|
label: "145 GHz",
|
|
o2_db_km: 0.06,
|
|
h2o_coeff: 0.040,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 1.5,
|
|
rain_k: 0.535,
|
|
rain_alpha: 0.74,
|
|
seasonal_base: BASE_145G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 35,
|
|
extended_range_km: 80,
|
|
exceptional_range_km: 150,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 241_000,
|
|
label: "241 GHz",
|
|
o2_db_km: 0.08,
|
|
h2o_coeff: 0.30,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 3.0,
|
|
rain_k: 0.550,
|
|
rain_alpha: 0.70,
|
|
seasonal_base: BASE_241G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 10,
|
|
extended_range_km: 50,
|
|
exceptional_range_km: 115,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 288_000,
|
|
label: "288 GHz",
|
|
o2_db_km: 0.10,
|
|
h2o_coeff: 0.45,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 3.5,
|
|
rain_k: 0.560,
|
|
rain_alpha: 0.68,
|
|
seasonal_base: BASE_288G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 5,
|
|
extended_range_km: 15,
|
|
exceptional_range_km: 50,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 322_000,
|
|
label: "322 GHz",
|
|
o2_db_km: 0.12,
|
|
h2o_coeff: 0.55,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 4.0,
|
|
rain_k: 0.570,
|
|
rain_alpha: 0.66,
|
|
seasonal_base: BASE_322G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 5,
|
|
extended_range_km: 15,
|
|
exceptional_range_km: 40,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 403_000,
|
|
label: "403 GHz",
|
|
o2_db_km: 0.15,
|
|
h2o_coeff: 0.40,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 3.0,
|
|
rain_k: 0.580,
|
|
rain_alpha: 0.64,
|
|
seasonal_base: BASE_403G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 3,
|
|
extended_range_km: 10,
|
|
exceptional_range_km: 30,
|
|
weights: None,
|
|
},
|
|
BandConfig {
|
|
freq_mhz: 411_000,
|
|
label: "411 GHz",
|
|
o2_db_km: 0.15,
|
|
h2o_coeff: 0.42,
|
|
humidity_effect: Harmful,
|
|
humidity_penalty: 3.2,
|
|
rain_k: 0.580,
|
|
rain_alpha: 0.64,
|
|
seasonal_base: BASE_403G,
|
|
seasonal_adj: ADJ_NONE,
|
|
typical_range_km: 3,
|
|
extended_range_km: 10,
|
|
exceptional_range_km: 30,
|
|
weights: None,
|
|
},
|
|
]
|
|
}
|
|
|
|
pub fn get(freq_mhz: u32) -> Option<&'static BandConfig> {
|
|
bands().iter().find(|b| b.freq_mhz == freq_mhz)
|
|
}
|
|
|
|
pub fn all_bands() -> &'static [BandConfig] {
|
|
bands()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn expected_band_count() {
|
|
assert_eq!(all_bands().len(), 23);
|
|
}
|
|
|
|
#[test]
|
|
fn default_weights_sum_to_one() {
|
|
let w = DEFAULT_WEIGHTS;
|
|
let sum = w.humidity
|
|
+ w.time_of_day
|
|
+ w.td_depression
|
|
+ w.refractivity
|
|
+ w.sky
|
|
+ w.season
|
|
+ w.wind
|
|
+ w.rain
|
|
+ w.pressure
|
|
+ w.pwat;
|
|
// Elixir comment says "all 10 values sum to 1.0" — allow tiny FP slop.
|
|
assert!((sum - 1.0).abs() < 1e-9, "weights sum = {sum}");
|
|
}
|
|
|
|
#[test]
|
|
fn lookup_by_freq() {
|
|
let tenghz = get(10_000).unwrap();
|
|
assert_eq!(tenghz.label, "10 GHz");
|
|
assert_eq!(tenghz.humidity_effect, HumidityEffect::Beneficial);
|
|
assert!(get(99_999).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn band_with_weights_override_returns_override() {
|
|
let b = get(10_000).unwrap();
|
|
// 10 GHz has weights: None → defaults.
|
|
assert_eq!(b.weights().humidity, DEFAULT_WEIGHTS.humidity);
|
|
|
|
let b432 = get(432).unwrap();
|
|
assert!((b432.weights().humidity - 0.2061).abs() < 1e-9);
|
|
}
|
|
|
|
#[test]
|
|
fn seasonal_adj_24g_matches_elixir() {
|
|
let b = get(24_000).unwrap();
|
|
// Elixir: seasonal_adj: %{5 => -4, 6 => -8, 7 => -10, 8 => -10, 9 => -4}
|
|
assert_eq!(b.seasonal_adj[4], -4); // May
|
|
assert_eq!(b.seasonal_adj[6], -10); // July
|
|
assert_eq!(b.seasonal_adj[11], 0); // Dec untouched
|
|
}
|
|
}
|