use crate::domain::{
ErrorAccumulator, ErrorMetrics, Region, RenewableModel, RenewableSample, TimeRange,
calibrate_renewable,
};
use crate::ports::{IntensityRepository, WeatherRepository};
use super::ApplicationError;
#[derive(Debug, Clone, Copy)]
pub struct RenewableReport {
pub wind: ErrorMetrics,
pub wind_baseline: ErrorMetrics,
pub solar: ErrorMetrics,
pub solar_baseline: ErrorMetrics,
pub model: RenewableModel,
pub train: usize,
pub test: usize,
}
pub struct BacktestRenewable<R: IntensityRepository, W: WeatherRepository> {
repository: R,
weather: W,
}
impl<R: IntensityRepository, W: WeatherRepository> BacktestRenewable<R, W> {
pub fn new(repository: R, weather: W) -> Self {
Self {
repository,
weather,
}
}
pub async fn execute(&self, range: TimeRange) -> Result<RenewableReport, ApplicationError> {
let measurements = self
.repository
.range(Region::National, "rte-direct", range)
.await?;
let weather = self.weather.weather_range(range).await?;
let mut by_hour: std::collections::BTreeMap<i64, (f64, f64)> =
std::collections::BTreeMap::new();
for w in &weather {
let hour = w.valid_at.unix_timestamp().div_euclid(3600);
by_hour.insert(hour, (w.wind, w.irradiance));
}
let mut samples: Vec<RenewableSample> = Vec::new();
for m in &measurements {
let Some(mix) = m.mix.as_ref() else { continue };
let hour = m.at.unix_timestamp().div_euclid(3600);
if let Some(&(wind_kmh, irradiance_wm2)) = by_hour.get(&hour) {
samples.push(RenewableSample {
wind_kmh,
irradiance_wm2,
eolien_mw: mix.eolien,
solaire_mw: mix.solaire,
});
}
}
if samples.len() < 20 {
return Err(ApplicationError::InsufficientSeries);
}
let split = samples.len() * 7 / 10;
let (train, test) = samples.split_at(split);
let model = calibrate_renewable(train, RenewableModel::v1_uncalibrated())
.ok_or(ApplicationError::InsufficientSeries)?;
let wind_mean = mean(train.iter().map(|s| s.eolien_mw));
let solar_mean = mean(train.iter().map(|s| s.solaire_mw));
let (mut wind, mut wind_base, mut solar, mut solar_base) = (
ErrorAccumulator::default(),
ErrorAccumulator::default(),
ErrorAccumulator::default(),
ErrorAccumulator::default(),
);
for s in test {
wind.observe(model.estimate_wind_mw(s.wind_kmh), s.eolien_mw);
wind_base.observe(wind_mean, s.eolien_mw);
solar.observe(model.estimate_solar_mw(s.irradiance_wm2), s.solaire_mw);
solar_base.observe(solar_mean, s.solaire_mw);
}
Ok(RenewableReport {
wind: wind.metrics().ok_or(ApplicationError::InsufficientSeries)?,
wind_baseline: wind_base
.metrics()
.ok_or(ApplicationError::InsufficientSeries)?,
solar: solar
.metrics()
.ok_or(ApplicationError::InsufficientSeries)?,
solar_baseline: solar_base
.metrics()
.ok_or(ApplicationError::InsufficientSeries)?,
model,
train: train.len(),
test: test.len(),
})
}
}
fn mean(values: impl Iterator<Item = f64>) -> f64 {
let (sum, n) = values.fold((0.0, 0u64), |(s, n), v| (s + v, n + 1));
if n == 0 { 0.0 } else { sum / n as f64 }
}