use time::Duration;
use crate::domain::{
CarbonIntensity, CrossBorderFlows, CrossBorderSnapshot, GenerationMix, Measurement, Methodology,
};
pub const MAX_FLOW_CONTEXT_AGE: Duration = Duration::hours(1);
pub const TD_LOSS_FACTOR_V1: f64 = 0.072;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct EmissionFactors {
pub nucleaire: f64,
pub gaz: f64,
pub charbon: f64,
pub fioul: f64,
pub hydraulique: f64,
pub eolien: f64,
pub solaire: f64,
pub bioenergies: f64,
pub thermique: f64,
}
impl EmissionFactors {
pub const fn acv_ademe_v1() -> Self {
Self {
nucleaire: 6.0,
gaz: 406.0,
charbon: 1038.0,
fioul: 778.0,
hydraulique: 4.0,
eolien: 7.3,
solaire: 55.0,
bioenergies: 24.0,
thermique: 406.0,
}
}
}
fn production_emissions_output(mix: &GenerationMix, factors: &EmissionFactors) -> (f64, f64) {
let fossil = match mix.thermique {
Some(thermique) => [(thermique, factors.thermique)].to_vec(),
None => vec![
(mix.gaz, factors.gaz),
(mix.charbon, factors.charbon),
(mix.fioul, factors.fioul),
],
};
let mut terms = vec![
(mix.nucleaire, factors.nucleaire),
(mix.hydraulique, factors.hydraulique),
(mix.eolien, factors.eolien),
(mix.solaire, factors.solaire),
(mix.bioenergies, factors.bioenergies),
];
terms.extend(fossil);
let mut emissions = 0.0;
let mut production = 0.0;
for (output, factor) in terms {
let output = output.max(0.0);
emissions += output * factor;
production += output;
}
(emissions, production)
}
pub fn acv_ademe_intensity(
mix: &GenerationMix,
factors: &EmissionFactors,
) -> Option<CarbonIntensity> {
let (emissions, production) = production_emissions_output(mix, factors);
if production <= 0.0 {
return None;
}
CarbonIntensity::new(emissions / production)
}
pub fn acv_ademe_consumption_intensity(
mix: &GenerationMix,
flows: &CrossBorderFlows,
factors: &EmissionFactors,
td_loss: f64,
) -> Option<CarbonIntensity> {
let (prod_emissions, prod_mwh) = production_emissions_output(mix, factors);
if prod_mwh <= 0.0 {
return None;
}
let prod_intensity = prod_emissions / prod_mwh;
let imports_mwh = flows.imports_mw();
let exports_mwh = flows.exports_mw();
let imported_emissions = flows.imported_emissions();
let consumption = prod_mwh - exports_mwh + imports_mwh;
if consumption <= 0.0 {
return None;
}
let consumed_emissions = prod_emissions - exports_mwh * prod_intensity + imported_emissions;
let grid_intensity = consumed_emissions / consumption;
CarbonIntensity::new(grid_intensity * (1.0 + td_loss))
}
pub fn derive_acv_ademe(measurement: &Measurement) -> Option<Measurement> {
let mix = measurement.mix.as_ref()?;
let intensity = acv_ademe_intensity(mix, &EmissionFactors::acv_ademe_v1())?;
Some(Measurement {
at: measurement.at,
region: measurement.region,
intensity,
methodology: Methodology::acv_ademe(),
vintage: measurement.vintage,
mix: Some(*mix),
})
}
pub fn derive_consumption_series(
mix: &[Measurement],
snapshots: &[CrossBorderSnapshot],
factors: &EmissionFactors,
td_loss: f64,
) -> Vec<Measurement> {
let mut out = Vec::new();
let mut j = 0usize;
let mut current: Option<&CrossBorderSnapshot> = None;
for m in mix {
let Some(generation) = m.mix.as_ref() else {
continue;
};
while j < snapshots.len() && snapshots[j].at <= m.at {
current = Some(&snapshots[j]);
j += 1;
}
let Some(snapshot) = current else {
continue;
};
if m.at - snapshot.at > MAX_FLOW_CONTEXT_AGE {
continue;
}
if let Some(intensity) =
acv_ademe_consumption_intensity(generation, &snapshot.flows, factors, td_loss)
{
out.push(Measurement {
at: m.at,
region: m.region,
intensity,
methodology: Methodology::acv_ademe_consumption(),
vintage: m.vintage,
mix: Some(*generation),
});
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::Region;
use time::OffsetDateTime;
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,
}
}
#[test]
fn acv_intensity_is_plausible_and_excludes_pompage_echanges() {
let intensity =
acv_ademe_intensity(&national_mix(), &EmissionFactors::acv_ademe_v1()).unwrap();
assert!(
(intensity.value() - 12.56).abs() < 0.1,
"intensité = {}",
intensity.value()
);
}
#[test]
fn consumption_intensity_is_none_on_negative_net_transit() {
use crate::domain::{CrossBorderFlow, CrossBorderFlows, Neighbor};
let mix = GenerationMix {
nucleaire: 0.0,
gaz: 100.0,
charbon: 0.0,
fioul: 0.0,
hydraulique: 0.0,
eolien: 0.0,
solaire: 0.0,
bioenergies: 0.0,
pompage: 0.0,
echanges: 0.0,
thermique: None,
};
let flows = CrossBorderFlows::new(vec![
CrossBorderFlow {
neighbor: Neighbor::Switzerland,
flow_mw: 200.0,
neighbor_intensity: CarbonIntensity::new(6.0).unwrap(),
},
CrossBorderFlow {
neighbor: Neighbor::Spain,
flow_mw: -150.0,
neighbor_intensity: CarbonIntensity::new(200.0).unwrap(),
},
]);
let result =
acv_ademe_consumption_intensity(&mix, &flows, &EmissionFactors::acv_ademe_v1(), 0.0);
assert!(
result.is_none(),
"intensité consommation physiquement indéfinie (transit négatif) doit être None, pas 0 : {result:?}"
);
}
#[test]
fn empty_production_is_none() {
let empty = GenerationMix {
nucleaire: 0.0,
gaz: 0.0,
charbon: 0.0,
fioul: 0.0,
hydraulique: 0.0,
eolien: 0.0,
solaire: 0.0,
bioenergies: 0.0,
pompage: -10.0,
echanges: 50.0,
thermique: None,
};
assert!(acv_ademe_intensity(&empty, &EmissionFactors::acv_ademe_v1()).is_none());
}
#[test]
fn regional_thermique_aggregate_is_used() {
let regional = GenerationMix {
nucleaire: 0.0,
gaz: 0.0,
charbon: 0.0,
fioul: 0.0,
hydraulique: 110.0,
eolien: 373.0,
solaire: 0.0,
bioenergies: 45.0,
pompage: 0.0,
echanges: 1492.0, thermique: Some(0.0),
};
let intensity = acv_ademe_intensity(®ional, &EmissionFactors::acv_ademe_v1()).unwrap();
assert!(
(intensity.value() - 8.04).abs() < 0.1,
"intensité = {}",
intensity.value()
);
}
#[test]
fn derive_carries_metadata_and_sets_methodology() {
let source = Measurement {
at: OffsetDateTime::UNIX_EPOCH,
region: Region::National,
intensity: CarbonIntensity::new(15.0).unwrap(),
methodology: Methodology::rte_direct(),
vintage: crate::domain::Vintage::Consolidated,
mix: Some(national_mix()),
};
let derived = derive_acv_ademe(&source).unwrap();
assert_eq!(derived.methodology, Methodology::acv_ademe());
assert_eq!(derived.at, source.at);
assert_eq!(derived.region, Region::National);
assert_eq!(derived.vintage, crate::domain::Vintage::Consolidated);
assert!(derived.intensity.value() < source.intensity.value());
let no_mix = Measurement {
mix: None,
..source
};
assert!(derive_acv_ademe(&no_mix).is_none());
}
#[test]
fn consumption_series_joins_nearest_prior_snapshot_and_omits_uncovered() {
use crate::domain::{
CrossBorderFlow, CrossBorderFlows, CrossBorderSnapshot, Neighbor, Vintage,
};
let t0 = OffsetDateTime::UNIX_EPOCH;
let step = Duration::minutes(15);
let measure = |i: i32| Measurement {
at: t0 + step * i,
region: Region::National,
intensity: CarbonIntensity::new(12.0).unwrap(),
methodology: Methodology::acv_ademe(),
vintage: Vintage::Consolidated,
mix: Some(national_mix()),
};
let mix = [measure(0), measure(1), measure(2)];
let snapshots = [CrossBorderSnapshot {
at: t0 + step,
flows: CrossBorderFlows::new(vec![CrossBorderFlow {
neighbor: Neighbor::Germany,
flow_mw: 5000.0,
neighbor_intensity: CarbonIntensity::new(400.0).unwrap(),
}]),
}];
let series =
derive_consumption_series(&mix, &snapshots, &EmissionFactors::acv_ademe_v1(), 0.0);
assert_eq!(series.len(), 2, "t0 omis (sans contexte d'import)");
assert_eq!(series[0].at, t0 + step);
assert_eq!(series[0].methodology, Methodology::acv_ademe_consumption());
assert!(series[0].intensity.value() > 12.56);
}
#[test]
fn consumption_series_omits_slots_with_stale_import_context() {
use crate::domain::{
CrossBorderFlow, CrossBorderFlows, CrossBorderSnapshot, Neighbor, Vintage,
};
let t0 = OffsetDateTime::UNIX_EPOCH;
let measure = |offset: Duration| Measurement {
at: t0 + offset,
region: Region::National,
intensity: CarbonIntensity::new(12.0).unwrap(),
methodology: Methodology::acv_ademe(),
vintage: Vintage::Consolidated,
mix: Some(national_mix()),
};
let mix = [
measure(Duration::ZERO),
measure(Duration::hours(1)),
measure(Duration::hours(2)),
];
let snapshots = [CrossBorderSnapshot {
at: t0,
flows: CrossBorderFlows::new(vec![CrossBorderFlow {
neighbor: Neighbor::Germany,
flow_mw: 5000.0,
neighbor_intensity: CarbonIntensity::new(400.0).unwrap(),
}]),
}];
let series =
derive_consumption_series(&mix, &snapshots, &EmissionFactors::acv_ademe_v1(), 0.0);
assert_eq!(series.len(), 2, "t0+2 h omis (contexte d'import périmé)");
assert_eq!(series[0].at, t0);
assert_eq!(series[1].at, t0 + Duration::hours(1));
}
}