use crate::domain::{
CarbonIntensity, CrossBorderFlows, EmissionFactors, GenerationMix, Methodology,
acv_ademe_consumption_intensity, acv_ademe_intensity,
};
#[derive(Debug, Clone, Copy)]
pub struct MethodologyContext<'a> {
pub mix: &'a GenerationMix,
pub cross_border: Option<&'a CrossBorderFlows>,
pub factors: &'a EmissionFactors,
pub td_loss: f64,
pub published: Option<CarbonIntensity>,
}
pub trait MethodologyCalculator {
fn methodology(&self) -> Methodology;
fn intensity(&self, ctx: &MethodologyContext<'_>) -> Option<CarbonIntensity>;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct RteDirect;
impl MethodologyCalculator for RteDirect {
fn methodology(&self) -> Methodology {
Methodology::rte_direct()
}
fn intensity(&self, ctx: &MethodologyContext<'_>) -> Option<CarbonIntensity> {
ctx.published
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct AcvAdemeProduction;
impl MethodologyCalculator for AcvAdemeProduction {
fn methodology(&self) -> Methodology {
Methodology::acv_ademe()
}
fn intensity(&self, ctx: &MethodologyContext<'_>) -> Option<CarbonIntensity> {
acv_ademe_intensity(ctx.mix, ctx.factors)
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct AcvAdemeConsumption;
impl MethodologyCalculator for AcvAdemeConsumption {
fn methodology(&self) -> Methodology {
Methodology::acv_ademe_consumption()
}
fn intensity(&self, ctx: &MethodologyContext<'_>) -> Option<CarbonIntensity> {
let flows = ctx.cross_border?;
acv_ademe_consumption_intensity(ctx.mix, flows, ctx.factors, ctx.td_loss)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::{CrossBorderFlow, Neighbor};
fn national_mix() -> GenerationMix {
GenerationMix {
nucleaire: 38815.0,
gaz: 666.0,
charbon: 0.0,
fioul: 34.0,
hydraulique: 8893.0,
eolien: 2555.0,
solaire: 1050.0,
bioenergies: 1006.0,
pompage: -76.0,
echanges: -11574.0,
thermique: None,
}
}
fn ctx<'a>(
mix: &'a GenerationMix,
flows: Option<&'a CrossBorderFlows>,
factors: &'a EmissionFactors,
published: Option<CarbonIntensity>,
) -> MethodologyContext<'a> {
MethodologyContext {
mix,
cross_border: flows,
factors,
td_loss: 0.0,
published,
}
}
#[test]
fn rte_direct_reports_published_value() {
let mix = national_mix();
let factors = EmissionFactors::acv_ademe_v1();
let published = CarbonIntensity::new(21.0);
let got = RteDirect.intensity(&ctx(&mix, None, &factors, published));
assert_eq!(got, published);
assert!(
RteDirect
.intensity(&ctx(&mix, None, &factors, None))
.is_none()
);
}
#[test]
fn production_matches_free_function() {
let mix = national_mix();
let factors = EmissionFactors::acv_ademe_v1();
let via_trait = AcvAdemeProduction
.intensity(&ctx(&mix, None, &factors, None))
.unwrap();
let direct = acv_ademe_intensity(&mix, &factors).unwrap();
assert_eq!(via_trait.value(), direct.value());
}
#[test]
fn consumption_needs_cross_border_context() {
let mix = national_mix();
let factors = EmissionFactors::acv_ademe_v1();
assert!(
AcvAdemeConsumption
.intensity(&ctx(&mix, None, &factors, None))
.is_none()
);
}
#[test]
fn carbon_import_raises_intensity_above_production() {
let mix = national_mix();
let factors = EmissionFactors::acv_ademe_v1();
let production = acv_ademe_intensity(&mix, &factors).unwrap();
let flows = CrossBorderFlows::new(vec![CrossBorderFlow {
neighbor: Neighbor::Germany,
flow_mw: 4000.0,
neighbor_intensity: CarbonIntensity::new(400.0).unwrap(),
}]);
let consumption = AcvAdemeConsumption
.intensity(&ctx(&mix, Some(&flows), &factors, None))
.unwrap();
assert!(
consumption.value() > production.value(),
"conso {} devrait dépasser prod {}",
consumption.value(),
production.value()
);
}
#[test]
fn net_export_keeps_intensity_near_production() {
let mix = national_mix();
let factors = EmissionFactors::acv_ademe_v1();
let production = acv_ademe_intensity(&mix, &factors).unwrap();
let flows = CrossBorderFlows::new(vec![CrossBorderFlow {
neighbor: Neighbor::GreatBritain,
flow_mw: -3000.0,
neighbor_intensity: CarbonIntensity::new(250.0).unwrap(),
}]);
let consumption = AcvAdemeConsumption
.intensity(&ctx(&mix, Some(&flows), &factors, None))
.unwrap();
assert!(
(consumption.value() - production.value()).abs() < 0.01,
"conso {} devrait égaler prod {} (export à l'intensité de prod)",
consumption.value(),
production.value()
);
}
#[test]
fn td_losses_uplift_intensity() {
let mix = national_mix();
let factors = EmissionFactors::acv_ademe_v1();
let flows = CrossBorderFlows::new(vec![CrossBorderFlow {
neighbor: Neighbor::Germany,
flow_mw: 2000.0,
neighbor_intensity: CarbonIntensity::new(400.0).unwrap(),
}]);
let no_loss = MethodologyContext {
td_loss: 0.0,
..ctx(&mix, Some(&flows), &factors, None)
};
let with_loss = MethodologyContext {
td_loss: 0.072,
..ctx(&mix, Some(&flows), &factors, None)
};
let base = AcvAdemeConsumption.intensity(&no_loss).unwrap().value();
let uplifted = AcvAdemeConsumption.intensity(&with_loss).unwrap().value();
assert!((uplifted - base * 1.072).abs() < 1e-6);
}
}