pub use hydro_core::{
Forcing, BasinInfo, Outlet, ModelType, MetricsReport, DynHydroModel, HydroModel,
compute_metrics, compute_metrics_gbt,
GbtEventErrors, QualificationTolerance, QualificationReport,
event_errors, event_qualified, qualified_rate, qualification_grade, scheme_grade,
ProbabilisticReport, crps, brier, pod_far_csi, ensemble_exceedance, compute_probabilistic,
rank_histogram,
};
pub use hydro_calib::{calibrate, ParamSpec, Objective, Method, CalibResult, SceConfig};
use hydro_xinanjiang::{XinanjiangModel, XinanjiangParams};
use hydro_topmodel::{TopmodelModel, TopmodelParams};
use hydro_swat::{SwatModel, SwatParams};
use hydro_apicont::{ApicontModel, ApicontParams};
use serde::{Serialize, Deserialize};
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ModelResult {
pub model_type: ModelType,
pub name: String,
pub discharge: Vec<f64>, pub metrics: Option<MetricsReport>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ComparisonResult {
pub results: Vec<ModelResult>,
pub time_steps: usize,
}
impl ComparisonResult {
pub fn best_nse(&self) -> Option<&ModelResult> {
self.results.iter()
.filter_map(|r| r.metrics.as_ref().map(|m| (r, m.nse)))
.max_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal))
.map(|(r, _)| r)
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct EnsembleStats {
pub mean: Vec<f64>,
pub median: Vec<f64>,
pub min: Vec<f64>,
pub max: Vec<f64>,
pub p25: Vec<f64>,
pub p75: Vec<f64>,
}
fn quantile(sorted: &[f64], q: f64) -> f64 {
if sorted.is_empty() {
return 0.0;
}
if sorted.len() == 1 {
return sorted[0];
}
let pos = q * (sorted.len() - 1) as f64;
let lo = pos.floor() as usize;
let hi = (lo + 1).min(sorted.len() - 1);
let frac = pos - lo as f64;
sorted[lo] + (sorted[hi] - sorted[lo]) * frac
}
pub fn ensemble_stats(res: &ComparisonResult) -> EnsembleStats {
let t = res.time_steps;
let mut mean = vec![0.0_f64; t];
let mut median = Vec::with_capacity(t);
let mut minv = Vec::with_capacity(t);
let mut maxv = Vec::with_capacity(t);
let mut p25 = Vec::with_capacity(t);
let mut p75 = Vec::with_capacity(t);
for step in 0..t {
let mut vals: Vec<f64> = res.results.iter()
.filter_map(|r| r.discharge.get(step).copied())
.collect();
if vals.is_empty() {
median.push(0.0); minv.push(0.0); maxv.push(0.0); p25.push(0.0); p75.push(0.0);
continue;
}
let n = vals.len();
mean[step] = vals.iter().sum::<f64>() / n as f64;
minv.push(vals.iter().cloned().fold(f64::INFINITY, f64::min));
maxv.push(vals.iter().cloned().fold(f64::NEG_INFINITY, f64::max));
vals.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
median.push(quantile(&vals, 0.5));
p25.push(quantile(&vals, 0.25));
p75.push(quantile(&vals, 0.75));
}
EnsembleStats { mean, median, min: minv, max: maxv, p25, p75 }
}
pub fn ensemble_probabilistic(
res: &ComparisonResult,
observed: &[f64],
threshold: f64,
) -> ProbabilisticReport {
let ensemble: Vec<Vec<f64>> = res.results.iter().map(|r| r.discharge.clone()).collect();
compute_probabilistic(&ensemble, observed, threshold)
}
pub fn ensemble_rank_histogram(res: &ComparisonResult, observed: &[f64]) -> Vec<usize> {
let ensemble: Vec<Vec<f64>> = res.results.iter().map(|r| r.discharge.clone()).collect();
rank_histogram(&ensemble, observed)
}
pub fn event_uh_forecast(rain_mm: &[f64], uh: &[f64], area_km2: f64, dt_h: f64) -> Vec<f64> {
let coef = area_km2 * 1000.0 / (dt_h * 3600.0); let n = rain_mm.len();
let mut q = vec![0.0; n];
for t in 0..n {
let kmax = uh.len().min(t + 1);
let mut s = 0.0;
for k in 0..kmax {
s += uh[k] * rain_mm[t - k];
}
q[t] = s * coef;
}
q
}
pub fn scs_unit_hydrograph(peak_t: usize, base_t: usize) -> Vec<f64> {
if base_t == 0 {
return Vec::new();
}
let p = peak_t.min(base_t.saturating_sub(1));
let mut uh = vec![0.0_f64; base_t];
for t in 0..base_t {
uh[t] = if t <= p {
t as f64 / p.max(1) as f64
} else {
(base_t - t) as f64 / (base_t - p).max(1) as f64
};
}
let sum: f64 = uh.iter().sum();
if sum > 0.0 {
for v in uh.iter_mut() {
*v /= sum;
}
}
uh
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Scenario {
pub basin: BasinInfo,
pub forcing: Vec<Forcing>,
pub dt_h: f64,
pub models: Vec<ModelType>,
pub observed: Option<Vec<f64>>,
pub params_overrides: Option<serde_json::Map<String, serde_json::Value>>,
}
pub fn create_model(mt: ModelType, params: &serde_json::Value) -> Box<dyn DynHydroModel> {
match mt {
ModelType::Xinanjiang => Box::new(XinanjiangModel::new(
serde_json::from_value(params.clone()).unwrap_or_default(),
)),
ModelType::Topmodel => Box::new(TopmodelModel::new(
serde_json::from_value(params.clone()).unwrap_or_default(),
)),
ModelType::Swat => Box::new(SwatModel::new(
serde_json::from_value(params.clone()).unwrap_or_default(),
)),
ModelType::Apicont => Box::new(ApicontModel::new(
serde_json::from_value(params.clone()).unwrap_or_default(),
)),
}
}
pub fn default_params(mt: ModelType) -> serde_json::Value {
match mt {
ModelType::Xinanjiang => serde_json::to_value(XinanjiangParams::default()).unwrap(),
ModelType::Topmodel => serde_json::to_value(TopmodelParams::default()).unwrap(),
ModelType::Swat => serde_json::to_value(SwatParams::default()).unwrap(),
ModelType::Apicont => serde_json::to_value(ApicontParams::default()).unwrap(),
}
}
pub fn run_model_default(mt: ModelType, forcing: &[Forcing], dt_h: f64) -> Vec<f64> {
let params = default_params(mt);
let mut m = create_model(mt, ¶ms);
forcing.iter().map(|f| {
m.step(f, dt_h);
m.discharge()
}).collect()
}
pub fn run_scenario(scenario: &Scenario) -> ComparisonResult {
let mut results = Vec::new();
for mt in &scenario.models {
let params = scenario.params_overrides.as_ref()
.and_then(|m| m.get(mt.name()))
.cloned()
.unwrap_or_else(|| default_params(*mt));
let mut model = create_model(*mt, ¶ms);
let mut discharge = Vec::with_capacity(scenario.forcing.len());
for f in &scenario.forcing {
model.step(f, scenario.dt_h);
discharge.push(model.discharge());
}
let metrics = scenario.observed.as_ref()
.filter(|obs| obs.len() == discharge.len())
.map(|obs| {
compute_metrics_gbt(
obs,
&discharge,
scenario.basin.area_km2,
scenario.dt_h,
&QualificationTolerance::default(),
)
});
results.push(ModelResult {
model_type: *mt,
name: mt.name().to_string(),
discharge,
metrics,
});
}
ComparisonResult { results, time_steps: scenario.forcing.len() }
}
#[cfg(test)]
mod tests {
use super::*;
fn make_scenario(models: Vec<ModelType>) -> Scenario {
let forcing: Vec<Forcing> = (0..48)
.map(|i| Forcing {
p_mm: if i < 6 { 25.0 } else { 0.0 },
pet_mm: 2.0,
t_c: 20.0,
})
.collect();
Scenario {
basin: BasinInfo {
id: "test".into(), name: "Test Basin".into(),
area_km2: 1000.0, outlet_lat: 30.0, outlet_lon: 120.0,
},
forcing, dt_h: 1.0, models,
observed: None, params_overrides: None,
}
}
#[test]
fn test_run_all_three_models() {
let s = make_scenario(vec![ModelType::Xinanjiang, ModelType::Topmodel, ModelType::Swat]);
let result = run_scenario(&s);
assert_eq!(result.results.len(), 3);
assert_eq!(result.time_steps, 48);
for r in &result.results {
assert_eq!(r.discharge.len(), 48);
let peak = r.discharge.iter().cloned().fold(0.0_f64, f64::max);
assert!(peak > 0.0, "{} should produce flow: peak={}", r.name, peak);
}
}
#[test]
fn test_comparison_with_observed() {
let s1 = make_scenario(vec![ModelType::Xinanjiang]);
let r1 = run_scenario(&s1);
let observed = r1.results[0].discharge.clone();
let s2 = Scenario { observed: Some(observed), ..make_scenario(vec![
ModelType::Xinanjiang, ModelType::Topmodel, ModelType::Swat,
]) };
let r2 = run_scenario(&s2);
let xaj = r2.results.iter().find(|r| r.model_type == ModelType::Xinanjiang).unwrap();
let nse = xaj.metrics.as_ref().unwrap().nse;
assert!(nse > 0.99, "XAJ NSE vs itself should be ~1: {}", nse);
}
#[test]
fn test_default_params() {
for mt in [ModelType::Xinanjiang, ModelType::Topmodel, ModelType::Swat] {
let p = default_params(mt);
assert!(p.is_object(), "default params for {:?} should be JSON object", mt);
}
}
#[test]
fn test_create_model_dyn() {
let m = create_model(ModelType::Xinanjiang, &default_params(ModelType::Xinanjiang));
assert_eq!(m.name(), "新安江");
let m = create_model(ModelType::Topmodel, &default_params(ModelType::Topmodel));
assert_eq!(m.name(), "TOPMODEL");
let m = create_model(ModelType::Swat, &default_params(ModelType::Swat));
assert_eq!(m.name(), "SWAT");
}
#[test]
fn test_ensemble_stats_two_members() {
let r = ComparisonResult {
results: vec![
ModelResult { model_type: ModelType::Xinanjiang, name: "A".into(),
discharge: vec![10.0, 20.0], metrics: None },
ModelResult { model_type: ModelType::Topmodel, name: "B".into(),
discharge: vec![30.0, 40.0], metrics: None },
],
time_steps: 2,
};
let s = ensemble_stats(&r);
assert!((s.mean[0] - 20.0).abs() < 1e-9, "mean0=(10+30)/2");
assert!((s.mean[1] - 30.0).abs() < 1e-9, "mean1=(20+40)/2");
assert!((s.min[0] - 10.0).abs() < 1e-9);
assert!((s.max[1] - 40.0).abs() < 1e-9);
assert!((s.median[0] - 20.0).abs() < 1e-9, "median of 10/30 interp =20");
assert_eq!(s.mean.len(), 2);
}
#[test]
fn test_scs_unit_hydrograph_normalized() {
let uh = scs_unit_hydrograph(2, 5);
assert_eq!(uh.len(), 5);
let sum: f64 = uh.iter().sum();
assert!((sum - 1.0).abs() < 1e-9, "UH 应归一化 Σ=1, got {}", sum);
let peak_idx = uh.iter().enumerate()
.max_by(|a, b| a.1.partial_cmp(b.1).unwrap()).unwrap().0;
assert_eq!(peak_idx, 2);
}
#[test]
fn test_event_uh_forecast_unit_pulse_and_lag() {
let q = event_uh_forecast(&[10.0; 4], &[1.0], 1000.0, 1.0);
let coef = 1000.0 * 1000.0 / 3600.0;
for v in &q {
assert!((v - 10.0 * coef).abs() < 1e-3, "稳态 q, got {}", v);
}
let q2 = event_uh_forecast(&[10.0, 0.0], &[0.5, 0.5], 1000.0, 1.0);
assert!((q2[0] - 0.5 * 10.0 * coef).abs() < 1e-3, "t0 half, got {}", q2[0]);
assert!((q2[1] - 0.5 * 10.0 * coef).abs() < 1e-3, "t1 delayed half, got {}", q2[1]);
}
}