use time::{Duration, OffsetDateTime};
use crate::domain::{GenerationMix, Measurement, Region};
pub const MAX_SPOT_STALENESS: Duration = Duration::hours(6);
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SpotPrice {
pub at: OffsetDateTime,
pub eur_per_mwh: f64,
}
impl SpotPrice {
pub fn new(at: OffsetDateTime, eur_per_mwh: f64) -> Option<Self> {
if eur_per_mwh.is_finite() {
Some(Self { at, eur_per_mwh })
} else {
None
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TrvReference {
pub vintage: &'static str,
pub turpe_eur_mwh: f64,
pub accise_eur_mwh: f64,
pub commercialisation_eur_mwh: f64,
pub tva_rate: f64,
}
impl TrvReference {
pub const fn trv_2026() -> Self {
Self {
vintage: "2026",
turpe_eur_mwh: 78.0,
accise_eur_mwh: 30.85,
commercialisation_eur_mwh: 18.11,
tva_rate: 0.20,
}
}
pub const fn trv_2026_h2() -> Self {
Self {
vintage: "2026-H2",
turpe_eur_mwh: 79.43,
accise_eur_mwh: 30.62,
commercialisation_eur_mwh: 18.11,
tva_rate: 0.20,
}
}
pub fn in_force_at(at: OffsetDateTime) -> Self {
if at.unix_timestamp() >= TRV_2026_H2_FROM_UNIX {
Self::trv_2026_h2()
} else {
Self::trv_2026()
}
}
}
const TRV_2026_H2_FROM_UNIX: i64 = 1_785_535_200;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum PriceComponentKind {
Energie,
Acheminement,
Accise,
Commercialisation,
Tva,
}
impl PriceComponentKind {
pub fn slug(self) -> &'static str {
match self {
PriceComponentKind::Energie => "energie",
PriceComponentKind::Acheminement => "acheminement",
PriceComponentKind::Accise => "accise",
PriceComponentKind::Commercialisation => "commercialisation",
PriceComponentKind::Tva => "tva",
}
}
pub fn label(self) -> &'static str {
match self {
PriceComponentKind::Energie => "Énergie (prix de marché spot)",
PriceComponentKind::Acheminement => "Acheminement (TURPE)",
PriceComponentKind::Accise => "Accise sur l'électricité",
PriceComponentKind::Commercialisation => "Commercialisation / résidu",
PriceComponentKind::Tva => "TVA",
}
}
pub fn source(self) -> &'static str {
match self {
PriceComponentKind::Energie => "Prix spot day-ahead — ENTSO-E Transparency Platform",
PriceComponentKind::Acheminement => "TURPE (Commission de régulation de l'énergie)",
PriceComponentKind::Accise => {
"Accise sur l'électricité (ex-TICFE/CSPE), loi de finances"
}
PriceComponentKind::Commercialisation => "Résidu de la construction du TRV (CRE)",
PriceComponentKind::Tva => "TVA (Code général des impôts)",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PriceComponent {
pub kind: PriceComponentKind,
pub amount_eur_mwh: f64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum Filiere {
Nucleaire,
Gaz,
Charbon,
Fioul,
Hydraulique,
Eolien,
Solaire,
Bioenergies,
Thermique,
}
impl Filiere {
pub fn slug(self) -> &'static str {
match self {
Filiere::Nucleaire => "nucleaire",
Filiere::Gaz => "gaz",
Filiere::Charbon => "charbon",
Filiere::Fioul => "fioul",
Filiere::Hydraulique => "hydraulique",
Filiere::Eolien => "eolien",
Filiere::Solaire => "solaire",
Filiere::Bioenergies => "bioenergies",
Filiere::Thermique => "thermique",
}
}
pub fn label(self) -> &'static str {
match self {
Filiere::Nucleaire => "Nucléaire",
Filiere::Gaz => "Gaz",
Filiere::Charbon => "Charbon",
Filiere::Fioul => "Fioul",
Filiere::Hydraulique => "Hydraulique",
Filiere::Eolien => "Éolien",
Filiere::Solaire => "Solaire",
Filiere::Bioenergies => "Bioénergies",
Filiere::Thermique => "Thermique fossile",
}
}
fn merit_order(self) -> u8 {
match self {
Filiere::Solaire => 0,
Filiere::Eolien => 1,
Filiere::Hydraulique => 2,
Filiere::Nucleaire => 3,
Filiere::Bioenergies => 4,
Filiere::Charbon => 6,
Filiere::Thermique => 7,
Filiere::Gaz => 7,
Filiere::Fioul => 8,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MixShare {
pub filiere: Filiere,
pub share: f64,
pub output_mw: f64,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MarginalTechnology {
pub filiere: Filiere,
pub estimated: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PriceContext {
pub shares: Vec<MixShare>,
pub marginal: Option<MarginalTechnology>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PriceBreakdown {
pub at: OffsetDateTime,
pub region: Region,
pub vintage: &'static str,
pub components: Vec<PriceComponent>,
pub context: PriceContext,
}
impl PriceBreakdown {
pub fn total_eur_mwh(&self) -> f64 {
self.components.iter().map(|c| c.amount_eur_mwh).sum()
}
}
fn mix_shares(mix: &GenerationMix) -> Vec<MixShare> {
let mut entries = vec![
(Filiere::Nucleaire, mix.nucleaire),
(Filiere::Hydraulique, mix.hydraulique),
(Filiere::Eolien, mix.eolien),
(Filiere::Solaire, mix.solaire),
(Filiere::Bioenergies, mix.bioenergies),
];
match mix.thermique {
Some(thermique) => entries.push((Filiere::Thermique, thermique)),
None => {
entries.push((Filiere::Gaz, mix.gaz));
entries.push((Filiere::Charbon, mix.charbon));
entries.push((Filiere::Fioul, mix.fioul));
}
}
let total: f64 = entries.iter().map(|(_, mw)| mw.max(0.0)).sum();
entries
.into_iter()
.filter_map(|(filiere, mw)| {
let output_mw = mw.max(0.0);
if output_mw <= 0.0 {
return None;
}
let share = if total > 0.0 { output_mw / total } else { 0.0 };
Some(MixShare {
filiere,
share,
output_mw,
})
})
.collect()
}
fn estimate_marginal(shares: &[MixShare]) -> Option<MarginalTechnology> {
let total: f64 = shares.iter().map(|s| s.output_mw).sum();
if total <= 0.0 {
return None;
}
let floor = (total * 0.005).max(50.0);
shares
.iter()
.filter(|s| s.output_mw >= floor)
.max_by_key(|s| s.filiere.merit_order())
.or_else(|| shares.iter().max_by_key(|s| s.filiere.merit_order()))
.map(|s| MarginalTechnology {
filiere: s.filiere,
estimated: true,
})
}
pub fn price_breakdown(
at: OffsetDateTime,
region: Region,
spot: &SpotPrice,
mix: &GenerationMix,
reference: &TrvReference,
) -> PriceBreakdown {
let energie = spot.eur_per_mwh;
let acheminement = reference.turpe_eur_mwh;
let accise = reference.accise_eur_mwh;
let commercialisation = reference.commercialisation_eur_mwh;
let base_ht = energie + acheminement + accise + commercialisation;
let tva = base_ht.max(0.0) * reference.tva_rate;
let components = vec![
PriceComponent {
kind: PriceComponentKind::Energie,
amount_eur_mwh: energie,
},
PriceComponent {
kind: PriceComponentKind::Acheminement,
amount_eur_mwh: acheminement,
},
PriceComponent {
kind: PriceComponentKind::Accise,
amount_eur_mwh: accise,
},
PriceComponent {
kind: PriceComponentKind::Commercialisation,
amount_eur_mwh: commercialisation,
},
PriceComponent {
kind: PriceComponentKind::Tva,
amount_eur_mwh: tva,
},
];
let shares = mix_shares(mix);
let marginal = estimate_marginal(&shares);
PriceBreakdown {
at,
region,
vintage: reference.vintage,
components,
context: PriceContext { shares, marginal },
}
}
pub fn price_series(
measurements: &[Measurement],
spots: &[SpotPrice],
reference_at: fn(OffsetDateTime) -> TrvReference,
) -> Vec<PriceBreakdown> {
let mut out = Vec::new();
let mut j = 0usize;
let mut current: Option<&SpotPrice> = None;
for m in measurements {
let Some(mix) = m.mix.as_ref() else {
continue;
};
while j < spots.len() && spots[j].at <= m.at {
current = Some(&spots[j]);
j += 1;
}
let Some(spot) = current else {
continue;
};
if m.at - spot.at > MAX_SPOT_STALENESS {
continue;
}
out.push(price_breakdown(
m.at,
m.region,
spot,
mix,
&reference_at(m.at),
));
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn trv_vintage_switches_at_paris_midnight_on_august_first() {
let before = OffsetDateTime::from_unix_timestamp(1_785_535_199).unwrap();
let at = OffsetDateTime::from_unix_timestamp(1_785_535_200).unwrap();
assert_eq!(TrvReference::in_force_at(before).vintage, "2026");
assert_eq!(TrvReference::in_force_at(at).vintage, "2026-H2");
assert_eq!(TrvReference::in_force_at(before), TrvReference::trv_2026());
let h2 = TrvReference::trv_2026_h2();
assert_eq!(h2.turpe_eur_mwh, 79.43);
assert_eq!(h2.accise_eur_mwh, 30.62);
let h1 = TrvReference::trv_2026();
assert_eq!((h1.turpe_eur_mwh, h1.accise_eur_mwh), (78.0, 30.85));
}
#[test]
fn price_series_applies_the_vintage_in_force_at_each_point() {
let t0 = OffsetDateTime::from_unix_timestamp(1_785_535_200 - 900).unwrap();
let t1 = OffsetDateTime::from_unix_timestamp(1_785_535_200).unwrap();
let point = |at| Measurement {
at,
region: Region::National,
intensity: crate::domain::CarbonIntensity::new(30.0).unwrap(),
methodology: crate::domain::Methodology::rte_direct(),
vintage: crate::domain::Vintage::Tr,
mix: Some(national_mix()),
};
let spots = vec![SpotPrice::new(t0, 60.0).unwrap()];
let series = price_series(&[point(t0), point(t1)], &spots, TrvReference::in_force_at);
let vintages: Vec<_> = series.iter().map(|b| b.vintage).collect();
assert_eq!(vintages, vec!["2026", "2026-H2"]);
let accise = |b: &PriceBreakdown| {
b.components
.iter()
.find(|c| c.kind == PriceComponentKind::Accise)
.map(|c| c.amount_eur_mwh)
};
assert_eq!(accise(&series[0]), Some(30.85));
assert_eq!(accise(&series[1]), Some(30.62));
}
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 spot_rejects_non_finite_but_allows_negative() {
let at = OffsetDateTime::UNIX_EPOCH;
assert!(SpotPrice::new(at, f64::NAN).is_none());
assert!(SpotPrice::new(at, -25.0).is_some(), "prix négatif valide");
}
#[test]
fn breakdown_energy_component_is_the_spot_price() {
let at = OffsetDateTime::UNIX_EPOCH;
let spot = SpotPrice::new(at, 72.0).unwrap();
let b = price_breakdown(
at,
Region::National,
&spot,
&national_mix(),
&TrvReference::trv_2026(),
);
let energie = b
.components
.iter()
.find(|c| c.kind == PriceComponentKind::Energie)
.unwrap();
assert_eq!(energie.amount_eur_mwh, 72.0);
}
#[test]
fn tva_is_applied_on_the_consumption_base() {
let at = OffsetDateTime::UNIX_EPOCH;
let r = TrvReference::trv_2026();
let spot = SpotPrice::new(at, 80.0).unwrap();
let b = price_breakdown(at, Region::National, &spot, &national_mix(), &r);
let base = 80.0 + r.turpe_eur_mwh + r.accise_eur_mwh + r.commercialisation_eur_mwh;
let tva = b
.components
.iter()
.find(|c| c.kind == PriceComponentKind::Tva)
.unwrap();
assert!((tva.amount_eur_mwh - base * r.tva_rate).abs() < 1e-9);
assert!((b.total_eur_mwh() - (base + base * r.tva_rate)).abs() < 1e-9);
}
#[test]
fn deeply_negative_spot_keeps_energy_visible_but_tva_nonnegative() {
let at = OffsetDateTime::UNIX_EPOCH;
let spot = SpotPrice::new(at, -200.0).unwrap();
let b = price_breakdown(
at,
Region::National,
&spot,
&national_mix(),
&TrvReference::trv_2026(),
);
let energie = b
.components
.iter()
.find(|c| c.kind == PriceComponentKind::Energie)
.unwrap();
let tva = b
.components
.iter()
.find(|c| c.kind == PriceComponentKind::Tva)
.unwrap();
assert_eq!(energie.amount_eur_mwh, -200.0, "énergie négative visible");
assert!(tva.amount_eur_mwh >= 0.0, "TVA jamais négative");
}
#[test]
fn marginal_estimate_picks_most_expensive_running_filiere() {
let shares = mix_shares(&national_mix());
let marginal = estimate_marginal(&shares).unwrap();
assert_eq!(marginal.filiere, Filiere::Gaz);
assert!(marginal.estimated);
}
#[test]
fn shares_exclude_pompage_and_sum_to_one() {
let shares = mix_shares(&national_mix());
let total: f64 = shares.iter().map(|s| s.share).sum();
assert!((total - 1.0).abs() < 1e-9, "somme des parts = {total}");
assert!(shares.iter().all(|s| s.filiere != Filiere::Charbon));
}
#[test]
fn series_joins_nearest_prior_spot_and_omits_uncovered() {
use crate::domain::{CarbonIntensity, Methodology, 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(40.0).unwrap(),
methodology: Methodology::rte_direct(),
vintage: Vintage::Consolidated,
mix: Some(national_mix()),
};
let measurements = [measure(0), measure(1), measure(2)];
let spots = [SpotPrice::new(t0 + step, 55.0).unwrap()];
let series = price_series(&measurements, &spots, |_| TrvReference::trv_2026());
assert_eq!(series.len(), 2, "t0 omis (sans prix spot antérieur)");
assert_eq!(series[0].at, t0 + step);
let energie = series[0]
.components
.iter()
.find(|c| c.kind == PriceComponentKind::Energie)
.unwrap();
assert_eq!(energie.amount_eur_mwh, 55.0);
}
#[test]
fn series_omits_slots_with_stale_spot() {
use crate::domain::{CarbonIntensity, Methodology, Vintage};
let t0 = OffsetDateTime::UNIX_EPOCH + Duration::days(30);
let measure = |offset: Duration| Measurement {
at: t0 + offset,
region: Region::National,
intensity: CarbonIntensity::new(40.0).unwrap(),
methodology: Methodology::rte_direct(),
vintage: Vintage::Consolidated,
mix: Some(national_mix()),
};
let measurements = [
measure(Duration::ZERO),
measure(Duration::hours(1)),
measure(Duration::hours(2)),
];
let spots = [
SpotPrice::new(t0 - Duration::days(7), 90.0).unwrap(),
SpotPrice::new(t0 + Duration::hours(2), 55.0).unwrap(),
];
let series = price_series(&measurements, &spots, |_| TrvReference::trv_2026());
assert_eq!(series.len(), 1, "créneaux à prix périmé omis");
assert_eq!(series[0].at, t0 + Duration::hours(2));
let energie = series[0]
.components
.iter()
.find(|c| c.kind == PriceComponentKind::Energie)
.unwrap();
assert_eq!(energie.amount_eur_mwh, 55.0);
}
}