1use serde::{Serialize, Deserialize};
17
18pub fn nse(obs: &[f64], sim: &[f64]) -> f64 {
30 if obs.is_empty() || obs.len() != sim.len() {
31 return f64::NAN;
32 }
33 let mean_o = obs.iter().sum::<f64>() / obs.len() as f64;
34 let ss_res: f64 = obs.iter().zip(sim).map(|(o, s)| (o - s).powi(2)).sum();
35 let ss_tot: f64 = obs.iter().map(|o| (o - mean_o).powi(2)).sum();
36 if ss_tot < 1e-12 {
37 return f64::NAN;
38 }
39 1.0 - ss_res / ss_tot
40}
41
42pub fn kge(obs: &[f64], sim: &[f64]) -> f64 {
54 if obs.len() < 2 || obs.len() != sim.len() {
55 return f64::NAN;
56 }
57 let n = obs.len() as f64;
58 let mean_o = obs.iter().sum::<f64>() / n;
59 let mean_s = sim.iter().sum::<f64>() / n;
60 let std_o = (obs.iter().map(|o| (o - mean_o).powi(2)).sum::<f64>() / n).sqrt();
61 let std_s = (sim.iter().map(|s| (s - mean_s).powi(2)).sum::<f64>() / n).sqrt();
62 if std_o < 1e-12 || std_s < 1e-12 {
63 return f64::NAN;
64 }
65 let cov: f64 = obs.iter().zip(sim)
67 .map(|(o, s)| (o - mean_o) * (s - mean_s))
68 .sum::<f64>() / n;
69 let r = cov / (std_o * std_s);
70 let alpha = std_s / std_o;
71 let beta = mean_s / mean_o;
72 let ed = (r - 1.0).powi(2) + (alpha - 1.0).powi(2) + (beta - 1.0).powi(2);
73 1.0 - ed.sqrt()
74}
75
76pub fn rmse(obs: &[f64], sim: &[f64]) -> f64 {
83 if obs.is_empty() || obs.len() != sim.len() {
84 return f64::NAN;
85 }
86 let ssq: f64 = obs.iter().zip(sim).map(|(o, s)| (o - s).powi(2)).sum();
87 (ssq / obs.len() as f64).sqrt()
88}
89
90pub fn pbias(obs: &[f64], sim: &[f64]) -> f64 {
95 let sum_o: f64 = obs.iter().sum();
96 if sum_o.abs() < 1e-12 {
97 return f64::NAN;
98 }
99 let sum_s: f64 = sim.iter().sum();
100 100.0 * (sum_s - sum_o) / sum_o
101}
102
103pub fn r2(obs: &[f64], sim: &[f64]) -> f64 {
110 if obs.len() < 2 || obs.len() != sim.len() {
111 return f64::NAN;
112 }
113 let n = obs.len() as f64;
114 let mean_o = obs.iter().sum::<f64>() / n;
115 let mean_s = sim.iter().sum::<f64>() / n;
116 let ss_oo: f64 = obs.iter().map(|o| (o - mean_o).powi(2)).sum();
117 let ss_ss: f64 = sim.iter().map(|s| (s - mean_s).powi(2)).sum();
118 let ss_os: f64 = obs.iter().zip(sim).map(|(o, s)| (o - mean_o) * (s - mean_s)).sum();
119 if ss_oo < 1e-12 || ss_ss < 1e-12 {
120 return f64::NAN;
121 }
122 (ss_os / (ss_oo * ss_ss).sqrt()).powi(2)
123}
124
125pub fn dc_grade(dc: f64) -> &'static str {
131 if dc >= 0.90 { "甲" }
132 else if dc >= 0.70 { "乙" }
133 else if dc >= 0.50 { "丙" }
134 else { "不合格" }
135}
136
137#[derive(Clone, Debug, Serialize, Deserialize, Default)]
142pub struct GbtEventErrors {
143 pub peak_rel_err_pct: f64,
145 pub time_to_peak_err_steps: i64,
148 pub runoff_depth_rel_err_pct: f64,
152}
153
154#[derive(Clone, Debug, Serialize, Deserialize)]
159pub struct QualificationTolerance {
160 pub peak_rel_pct: f64,
162 pub time_to_peak_steps: i64,
164 pub runoff_depth_rel_pct: f64,
166}
167
168impl Default for QualificationTolerance {
169 fn default() -> Self {
172 Self { peak_rel_pct: 20.0, time_to_peak_steps: 1, runoff_depth_rel_pct: 20.0 }
173 }
174}
175
176pub fn event_errors(obs: &[f64], sim: &[f64], area_km2: f64, dt_h: f64) -> GbtEventErrors {
182 let mut e = GbtEventErrors::default();
183 if obs.is_empty() || sim.is_empty() || area_km2 <= 0.0 || dt_h <= 0.0 {
184 return e;
185 }
186 let (obs_pk, obs_idx) = argmax(obs);
187 let (sim_pk, sim_idx) = argmax(sim);
188 if obs_pk.abs() > 1e-9 {
189 e.peak_rel_err_pct = 100.0 * (sim_pk - obs_pk) / obs_pk;
190 }
191 e.time_to_peak_err_steps = sim_idx as i64 - obs_idx as i64;
192 let d_obs = runoff_depth_mm(obs, area_km2, dt_h);
193 let d_sim = runoff_depth_mm(sim, area_km2, dt_h);
194 if d_obs.abs() > 1e-9 {
195 e.runoff_depth_rel_err_pct = 100.0 * (d_sim - d_obs) / d_obs;
196 }
197 e
198}
199
200pub fn event_qualified(e: &GbtEventErrors, tol: &QualificationTolerance) -> bool {
203 e.peak_rel_err_pct.abs() <= tol.peak_rel_pct
204 && e.time_to_peak_err_steps.abs() <= tol.time_to_peak_steps
205 && e.runoff_depth_rel_err_pct.abs() <= tol.runoff_depth_rel_pct
206}
207
208#[derive(Clone, Debug, Serialize, Deserialize, Default)]
210pub struct QualificationReport {
211 pub total: usize,
213 pub qualified: usize,
215 pub rate_pct: f64,
217 pub grade: String,
220}
221
222pub fn qualified_rate(qualified_flags: &[bool]) -> QualificationReport {
227 let total = qualified_flags.len();
228 let qualified = qualified_flags.iter().filter(|&&q| q).count();
229 let rate_pct = if total == 0 {
230 0.0
231 } else {
232 100.0 * qualified as f64 / total as f64
233 };
234 QualificationReport {
235 total,
236 qualified,
237 rate_pct,
238 grade: qualification_grade(rate_pct).to_string(),
239 }
240}
241
242pub fn qualification_grade(rate_pct: f64) -> &'static str {
246 if rate_pct >= 85.0 { "甲" }
247 else if rate_pct >= 70.0 { "乙" }
248 else if rate_pct >= 60.0 { "丙" }
249 else { "不合格" }
250}
251
252pub fn scheme_grade(dc_grade: &str, qual_grade: &str) -> &'static str {
256 let rank = |g: &str| -> i32 {
257 match g { "甲" => 3, "乙" => 2, "丙" => 1, _ => 0 }
258 };
259 match rank(dc_grade).min(rank(qual_grade)) {
260 3 => "甲",
261 2 => "乙",
262 1 => "丙",
263 _ => "不合格",
264 }
265}
266
267#[derive(Clone, Debug, Serialize, Deserialize, Default)]
273pub struct MetricsReport {
274 pub nse: f64,
276 pub kge: f64,
278 pub rmse: f64,
280 pub pbias: f64,
282 pub r2: f64,
284 pub grade: String,
286 pub gbt: Option<GbtEventErrors>,
288 pub qualified: Option<bool>,
291}
292
293pub fn compute_metrics(obs: &[f64], sim: &[f64]) -> MetricsReport {
296 let n = nse(obs, sim);
297 MetricsReport {
298 nse: n,
299 kge: kge(obs, sim),
300 rmse: rmse(obs, sim),
301 pbias: pbias(obs, sim),
302 r2: r2(obs, sim),
303 grade: dc_grade(n).to_string(),
304 gbt: None,
305 qualified: None,
306 }
307}
308
309pub fn compute_metrics_gbt(
315 obs: &[f64],
316 sim: &[f64],
317 area_km2: f64,
318 dt_h: f64,
319 tol: &QualificationTolerance,
320) -> MetricsReport {
321 let mut m = compute_metrics(obs, sim);
322 let e = event_errors(obs, sim, area_km2, dt_h);
323 m.qualified = Some(event_qualified(&e, tol));
324 m.gbt = Some(e);
325 m
326}
327
328#[derive(Clone, Debug, Serialize, Deserialize, Default)]
332pub struct ProbabilisticReport {
333 pub crps: f64,
337 pub brier: f64,
340 pub pod: f64,
343 pub far: f64,
346 pub csi: f64,
349}
350
351pub fn ensemble_exceedance(ensemble: &[Vec<f64>], threshold: f64) -> Vec<f64> {
356 if ensemble.is_empty() {
357 return Vec::new();
358 }
359 let n_t = ensemble.iter().map(|m| m.len()).max().unwrap_or(0);
360 let m = ensemble.len() as f64;
361 (0..n_t)
362 .map(|t| {
363 let cnt = ensemble.iter()
364 .filter(|mem| mem.get(t).map_or(false, |v| *v > threshold))
365 .count() as f64;
366 cnt / m
367 })
368 .collect()
369}
370
371pub fn crps(ensemble: &[Vec<f64>], observed: &[f64]) -> f64 {
382 if ensemble.is_empty() || observed.is_empty() {
383 return f64::NAN;
384 }
385 let m = ensemble.len();
386 let mf = m as f64;
387 let mut sum = 0.0;
388 let mut count = 0usize;
389 for (t, &y) in observed.iter().enumerate() {
390 let vals: Vec<f64> = ensemble.iter().filter_map(|mem| mem.get(t).copied()).collect();
391 if vals.len() != m {
392 continue; }
394 let mae: f64 = vals.iter().map(|x| (x - y).abs()).sum::<f64>() / mf;
395 let mut pair = 0.0;
396 for i in 0..m {
397 for j in 0..m {
398 pair += (vals[i] - vals[j]).abs();
399 }
400 }
401 let spread = pair / (2.0 * mf * mf);
402 sum += (mae - spread).max(0.0);
403 count += 1;
404 }
405 if count == 0 { f64::NAN } else { sum / count as f64 }
406}
407
408pub fn brier(prob_exceed: &[f64], observed_exceed: &[bool]) -> f64 {
414 if prob_exceed.is_empty() || prob_exceed.len() != observed_exceed.len() {
415 return f64::NAN;
416 }
417 let n = prob_exceed.len() as f64;
418 prob_exceed.iter().zip(observed_exceed.iter())
419 .map(|(p, o)| (p - if *o { 1.0 } else { 0.0 }).powi(2))
420 .sum::<f64>() / n
421}
422
423pub fn pod_far_csi(forecast_exceed: &[bool], observed_exceed: &[bool]) -> (f64, f64, f64) {
431 let mut hits = 0.0; let mut misses = 0.0; let mut false_alarms = 0.0; for (f, o) in forecast_exceed.iter().zip(observed_exceed.iter()) {
435 match (*f, *o) {
436 (true, true) => hits += 1.0,
437 (false, true) => misses += 1.0,
438 (true, false) => false_alarms += 1.0,
439 (false, false) => {} }
441 }
442 let pod = if hits + misses > 0.0 { hits / (hits + misses) } else { f64::NAN };
443 let far = if hits + false_alarms > 0.0 { false_alarms / (hits + false_alarms) } else { f64::NAN };
444 let csi = if hits + misses + false_alarms > 0.0 {
445 hits / (hits + misses + false_alarms)
446 } else { f64::NAN };
447 (pod, far, csi)
448}
449
450pub fn compute_probabilistic(
457 ensemble: &[Vec<f64>],
458 observed: &[f64],
459 threshold: f64,
460) -> ProbabilisticReport {
461 let prob = ensemble_exceedance(ensemble, threshold);
462 let n = observed.len().min(prob.len());
463 let prob_aligned: Vec<f64> = prob.iter().take(n).copied().collect();
464 let obs_exceed: Vec<bool> = observed[..n].iter().map(|&q| q > threshold).collect();
465 let fcst_exceed: Vec<bool> = prob_aligned.iter().map(|&p| p > 0.5).collect();
466 let (pod, far, csi) = pod_far_csi(&fcst_exceed, &obs_exceed);
467 ProbabilisticReport {
468 crps: crps(ensemble, observed),
469 brier: brier(&prob_aligned, &obs_exceed),
470 pod, far, csi,
471 }
472}
473
474pub fn rank_histogram(ensemble: &[Vec<f64>], observed: &[f64]) -> Vec<usize> {
484 if ensemble.is_empty() || observed.is_empty() {
485 return Vec::new();
486 }
487 let m = ensemble.len();
488 let mut hist = vec![0usize; m + 1];
489 for (t, &y) in observed.iter().enumerate() {
490 let vals: Vec<f64> = ensemble.iter().filter_map(|mem| mem.get(t).copied()).collect();
491 if vals.len() != m {
492 continue;
493 }
494 let rank = vals.iter().filter(|&&x| x < y).count();
496 hist[rank] += 1;
497 }
498 hist
499}
500
501fn argmax(xs: &[f64]) -> (f64, usize) {
504 let mut best = f64::NEG_INFINITY;
505 let mut idx = 0;
506 for (i, &v) in xs.iter().enumerate() {
507 if v > best {
508 best = v;
509 idx = i;
510 }
511 }
512 (best, idx)
513}
514
515fn runoff_depth_mm(q: &[f64], area_km2: f64, dt_h: f64) -> f64 {
517 let sum_q: f64 = q.iter().sum();
518 sum_q * dt_h * 3.6 / area_km2
519}
520
521#[cfg(test)]
522mod tests {
523 use super::*;
524
525 #[test]
526 fn test_nse_perfect() {
527 let obs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
528 assert!((nse(&obs, &obs) - 1.0).abs() < 1e-10);
529 }
530
531 #[test]
532 fn test_nse_mean_prediction() {
533 let obs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
534 let sim = vec![3.0; 5]; assert!((nse(&obs, &sim) - 0.0).abs() < 1e-10);
536 }
537
538 #[test]
539 fn test_kge_perfect() {
540 let obs = vec![10.0, 20.0, 30.0, 40.0];
541 assert!((kge(&obs, &obs) - 1.0).abs() < 1e-10);
542 }
543
544 #[test]
545 fn test_rmse() {
546 let obs = vec![1.0, 2.0, 3.0];
547 let sim = vec![1.0, 2.0, 4.0];
548 assert!((rmse(&obs, &sim) - (1.0_f64 / 3.0).sqrt()).abs() < 1e-10);
550 }
551
552 #[test]
553 fn test_pbias() {
554 let obs = vec![100.0, 200.0];
555 let sim = vec![110.0, 220.0];
556 assert!((pbias(&obs, &sim) - 10.0).abs() < 1e-10);
558 }
559
560 #[test]
561 fn test_r2_perfect() {
562 let obs = vec![1.0, 2.0, 3.0, 4.0, 5.0];
563 assert!((r2(&obs, &obs) - 1.0).abs() < 1e-10);
564 }
565
566 #[test]
567 fn test_dc_grade() {
568 assert_eq!(dc_grade(0.95), "甲");
569 assert_eq!(dc_grade(0.85), "乙");
570 assert_eq!(dc_grade(0.60), "丙");
571 assert_eq!(dc_grade(0.30), "不合格");
572 }
573
574 #[test]
575 fn test_compute_metrics() {
576 let obs = vec![10.0, 20.0, 30.0, 40.0, 50.0];
577 let m = compute_metrics(&obs, &obs);
578 assert!((m.nse - 1.0).abs() < 1e-10);
579 assert_eq!(m.grade, "甲");
580 assert!(m.gbt.is_none() && m.qualified.is_none(), "compute_metrics 不应填 GB/T");
581 }
582
583 #[test]
584 fn test_event_errors_perfect() {
585 let obs = vec![10.0, 20.0, 30.0, 40.0, 50.0];
587 let e = event_errors(&obs, &obs, 1000.0, 1.0);
588 assert!(e.peak_rel_err_pct.abs() < 1e-9);
589 assert_eq!(e.time_to_peak_err_steps, 0);
590 assert!(e.runoff_depth_rel_err_pct.abs() < 1e-9);
591 }
592
593 #[test]
594 fn test_event_errors_peak_and_timing() {
595 let obs = vec![10.0, 20.0, 30.0, 40.0, 50.0];
597 let sim = vec![10.0, 20.0, 45.0, 30.0, 10.0];
598 let e = event_errors(&obs, &sim, 1000.0, 1.0);
599 assert!((e.peak_rel_err_pct - (-10.0)).abs() < 1e-6, "峰偏 -10%, 得 {}", e.peak_rel_err_pct);
600 assert_eq!(e.time_to_peak_err_steps, -2, "超前 2 步");
601 }
602
603 #[test]
604 fn test_event_qualified_boundary() {
605 let tol = QualificationTolerance::default();
606 let ok = GbtEventErrors { peak_rel_err_pct: 19.0, time_to_peak_err_steps: 1, runoff_depth_rel_err_pct: -15.0 };
608 assert!(event_qualified(&ok, &tol));
609 let bad = GbtEventErrors { peak_rel_err_pct: 21.0, time_to_peak_err_steps: 0, runoff_depth_rel_err_pct: 0.0 };
611 assert!(!event_qualified(&bad, &tol));
612 }
613
614 #[test]
615 fn test_qualified_rate_and_grade() {
616 let flags = vec![true; 9].into_iter().chain(std::iter::once(false)).collect::<Vec<_>>();
618 let r = qualified_rate(&flags);
619 assert_eq!(r.total, 10);
620 assert_eq!(r.qualified, 9);
621 assert!((r.rate_pct - 90.0).abs() < 1e-9);
622 assert_eq!(r.grade, "甲");
623 assert_eq!(qualification_grade(75.0), "乙");
624 assert_eq!(qualification_grade(65.0), "丙");
625 assert_eq!(qualification_grade(50.0), "不合格");
626 }
627
628 #[test]
629 fn test_scheme_grade_takes_lower() {
630 assert_eq!(scheme_grade("甲", "乙"), "乙"); assert_eq!(scheme_grade("丙", "甲"), "丙");
632 assert_eq!(scheme_grade("甲", "甲"), "甲");
633 assert_eq!(scheme_grade("乙", "不合格"), "不合格");
634 }
635
636 #[test]
637 fn test_compute_metrics_gbt_qualified() {
638 let obs = vec![10.0, 20.0, 30.0, 40.0, 50.0];
639 let m = compute_metrics_gbt(&obs, &obs, 1000.0, 1.0, &Default::default());
641 assert_eq!(m.qualified, Some(true));
642 assert!(m.gbt.is_some());
643 }
644
645 #[test]
646 fn test_crps_perfect_ensemble_zero() {
647 let obs = vec![10.0, 20.0, 30.0];
649 let ens = vec![obs.clone(), obs.clone(), obs.clone()];
650 assert!(crps(&ens, &obs).abs() < 1e-9);
651 }
652
653 #[test]
654 fn test_crps_single_member_is_mae_and_spread_lowers() {
655 let obs = vec![0.0];
656 assert!((crps(&[vec![10.0]], &obs) - 10.0).abs() < 1e-9);
658 assert!((crps(&[vec![0.0], vec![10.0]], &obs) - 2.5).abs() < 1e-9);
660 }
661
662 #[test]
663 fn test_brier_perfect_and_worst() {
664 let obs = vec![true, false, true];
665 assert!(brier(&[1.0, 0.0, 1.0], &obs).abs() < 1e-9); assert!((brier(&[0.0, 1.0, 0.0], &obs) - 1.0).abs() < 1e-9); }
668
669 #[test]
670 fn test_pod_far_csi_contingency() {
671 let fcst = vec![true, true, true, false, true, true, false, false];
673 let obs = vec![true, true, true, true, false, false, false, false];
674 let (pod, far, csi) = pod_far_csi(&fcst, &obs);
675 assert!((pod - 0.75).abs() < 1e-9, "POD=3/4, got {}", pod);
676 assert!((far - 0.4).abs() < 1e-9, "FAR=2/5, got {}", far);
677 assert!((csi - 0.5).abs() < 1e-9, "CSI=3/6, got {}", csi);
678 }
679
680 #[test]
681 fn test_ensemble_exceedance_fraction() {
682 let ens = vec![vec![10.0, 20.0, 5.0], vec![15.0, 5.0, 5.0], vec![20.0, 25.0, 5.0]];
683 let prob = ensemble_exceedance(&ens, 12.0);
684 assert!((prob[0] - 2.0 / 3.0).abs() < 1e-9);
686 assert!((prob[1] - 2.0 / 3.0).abs() < 1e-9);
687 assert!(prob[2].abs() < 1e-9);
688 }
689
690 #[test]
691 fn test_compute_probabilistic_end_to_end() {
692 let ens = vec![vec![12.0, 28.0], vec![8.0, 32.0]];
694 let obs = vec![10.0, 30.0];
695 let r = compute_probabilistic(&ens, &obs, 20.0);
696 assert!((r.pod - 1.0).abs() < 1e-9);
699 assert!(r.far.abs() < 1e-9);
700 assert!((r.csi - 1.0).abs() < 1e-9);
701 assert!(r.brier.abs() < 1e-9);
703 }
704
705 #[test]
706 fn test_rank_histogram_bins() {
707 let ens = vec![vec![1.0, 2.0], vec![3.0, 4.0]];
709 let obs = vec![2.0, 3.0];
710 let h = rank_histogram(&ens, &obs);
711 assert_eq!(h, vec![0, 2, 0], "两步都落 bin1, got {:?}", h);
712 let h2 = rank_histogram(&vec![vec![10.0], vec![20.0]], &[5.0]);
714 assert_eq!(h2, vec![1, 0, 0]);
715 }
716}