#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CostSource {
Ademe,
CourDesComptes,
Rte,
Irena,
Cre,
}
impl CostSource {
pub fn slug(self) -> &'static str {
match self {
CostSource::Ademe => "ademe",
CostSource::CourDesComptes => "cour-des-comptes",
CostSource::Rte => "rte",
CostSource::Irena => "irena",
CostSource::Cre => "cre",
}
}
pub fn label(self) -> &'static str {
match self {
CostSource::Ademe => "ADEME",
CostSource::CourDesComptes => "Cour des comptes",
CostSource::Rte => "RTE",
CostSource::Irena => "IRENA",
CostSource::Cre => "CRE",
}
}
pub fn attribution(self) -> &'static str {
match self {
CostSource::Ademe => {
"ADEME, « Coûts des énergies renouvelables et de récupération en France » \
(Licence Ouverte / Etalab 2.0) — chiffres-faits ré-encodés par carbon-fr"
}
CostSource::CourDesComptes => {
"Cour des comptes, rapports sur les coûts de la filière nucléaire \
(www.ccomptes.fr) — chiffres-faits ré-encodés ; réutilisation au titre du \
CRPA art. L321-1, source citée, sens non altéré"
}
CostSource::Rte => {
"RTE, « Futurs énergétiques 2050 » (Bilan prévisionnel, rte-france.com) — \
chiffres-faits ré-encodés ; valeur issue du rapport (mentions légales \
restrictives), non d'un jeu sous Licence Ouverte ; source citée, sens non altéré"
}
CostSource::Irena => {
"IRENA (2025), « Renewable power generation costs in 2024 », Abu Dhabi — \
LCOE MONDIAUX (moyennes pondérées + valeurs pays), USD 2024 convertis à \
0,9243 EUR/USD (moyenne annuelle 2024) ; licence IRENA permissive (sans clause \
NC), réutilisation y compris commerciale avec attribution ; chiffres-faits ré-encodés"
}
CostSource::Cre => {
"CRE, rapport sur les coûts du nucléaire existant (www.cre.fr) — coût complet \
du parc, chiffres-faits ré-encodés ; réutilisation des informations publiques \
(CRPA art. L321-1), source citée, sens non altéré"
}
}
}
pub fn geography(self) -> &'static str {
match self {
CostSource::Ademe | CostSource::CourDesComptes | CostSource::Rte | CostSource::Cre => {
"france"
}
CostSource::Irena => "monde",
}
}
pub fn from_slug(slug: &str) -> Option<CostSource> {
[
CostSource::Ademe,
CostSource::CourDesComptes,
CostSource::Rte,
CostSource::Irena,
CostSource::Cre,
]
.into_iter()
.find(|s| s.slug() == slug)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CostTechnology {
NucleaireExistant,
NucleaireNouveau,
SolairePv,
EolienTerrestre,
EolienMer,
Hydraulique,
Biomasse,
}
impl CostTechnology {
pub fn slug(self) -> &'static str {
match self {
CostTechnology::NucleaireExistant => "nucleaire-existant",
CostTechnology::NucleaireNouveau => "nucleaire-nouveau",
CostTechnology::SolairePv => "solaire-pv",
CostTechnology::EolienTerrestre => "eolien-terrestre",
CostTechnology::EolienMer => "eolien-mer",
CostTechnology::Hydraulique => "hydraulique",
CostTechnology::Biomasse => "biomasse",
}
}
pub fn label(self) -> &'static str {
match self {
CostTechnology::NucleaireExistant => "Nucléaire existant (amorti)",
CostTechnology::NucleaireNouveau => "Nucléaire nouveau (EPR2)",
CostTechnology::SolairePv => "Solaire photovoltaïque",
CostTechnology::EolienTerrestre => "Éolien terrestre",
CostTechnology::EolienMer => "Éolien en mer (posé)",
CostTechnology::Hydraulique => "Hydraulique",
CostTechnology::Biomasse => "Biomasse",
}
}
pub fn from_slug(slug: &str) -> Option<CostTechnology> {
[
CostTechnology::NucleaireExistant,
CostTechnology::NucleaireNouveau,
CostTechnology::SolairePv,
CostTechnology::EolienTerrestre,
CostTechnology::EolienMer,
CostTechnology::Hydraulique,
CostTechnology::Biomasse,
]
.into_iter()
.find(|t| t.slug() == slug)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Perimeter {
Plateau,
}
impl Perimeter {
pub fn slug(self) -> &'static str {
match self {
Perimeter::Plateau => "plateau",
}
}
pub fn label(self) -> &'static str {
match self {
Perimeter::Plateau => {
"Plateau — coûts au niveau de la centrale ; exclut les coûts système \
(back-up, réseau, stockage) et le démantèlement / les déchets de long terme ; \
non directement comparable entre filières pilotables et variables"
}
}
}
pub fn from_slug(slug: &str) -> Option<Perimeter> {
[Perimeter::Plateau].into_iter().find(|p| p.slug() == slug)
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct LcoeRange {
pub min: f64,
pub median: f64,
pub max: f64,
}
impl LcoeRange {
pub fn new(min: f64, median: f64, max: f64) -> Self {
let min = if min <= median { min } else { median };
let max = if max >= median { max } else { median };
Self { min, median, max }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct CostAssumptions {
pub discount_rate: Option<f64>,
pub lifetime_years: Option<u32>,
pub load_factor: Option<f64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CostBasis {
AccountingAmortized,
ProspectiveLcoe,
}
impl CostBasis {
pub fn slug(self) -> &'static str {
match self {
CostBasis::AccountingAmortized => "accounting-amortized",
CostBasis::ProspectiveLcoe => "prospective-lcoe",
}
}
pub fn label(self) -> &'static str {
match self {
CostBasis::AccountingAmortized => "Coût comptable (parc existant amorti)",
CostBasis::ProspectiveLcoe => "LCOE prospectif (moyen neuf)",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CostReferenceKey {
pub source: CostSource,
pub technology: CostTechnology,
pub perimeter: Perimeter,
pub vintage: u32,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CostEstimate {
pub key: CostReferenceKey,
pub basis: CostBasis,
pub range: LcoeRange,
pub assumptions: CostAssumptions,
}
#[derive(Debug, Clone, PartialEq)]
pub struct CostReferenceCatalog {
entries: Vec<CostEstimate>,
}
impl CostReferenceCatalog {
pub fn entries(&self) -> &[CostEstimate] {
&self.entries
}
pub fn filtered(
&self,
source: Option<CostSource>,
technology: Option<CostTechnology>,
perimeter: Option<Perimeter>,
vintage: Option<u32>,
) -> Vec<CostEstimate> {
self.entries
.iter()
.copied()
.filter(|e| source.is_none_or(|s| e.key.source == s))
.filter(|e| technology.is_none_or(|t| e.key.technology == t))
.filter(|e| perimeter.is_none_or(|p| e.key.perimeter == p))
.filter(|e| vintage.is_none_or(|v| e.key.vintage == v))
.collect()
}
}
pub const COST_REFERENCE_DISCLAIMER: &str = "Le LCOE (coût moyen actualisé de l'énergie) \
estime un coût moyen de production sur la durée de vie d'un moyen de production, sous hypothèses \
(taux d'actualisation, durée de vie, facteur de charge, périmètre). Le prix de marché (voir \
/v1/price) est un prix marginal de compensation horaire, fixé par la dernière unité appelée. Ces \
deux grandeurs sont de nature différente et ne sont pas censées être égales dans un marché à \
tarification marginale. carbon-fr ne calcule ni n'affiche aucun écart entre elles et ne formule \
aucun jugement. PORTÉE ET LIMITES : chaque valeur est une ESTIMATION sous hypothèses, issue d'une \
source citée. La plupart des filières ont DEUX sources (ex. ADEME + IRENA, Cour des comptes + CRE) : \
la fourchette affichée mêle alors la dispersion interne à une source ET l'écart entre sources. \
Précautions : les chiffres IRENA sont des LCOE MONDIAUX (souvent plus bas que les sources France — \
c'est la dispersion réelle, pas une erreur) ; certaines 2e sources ne fournissent qu'un point \
(min = max), pas une fourchette propre ; le nucléaire nouveau reste à une seule source (aucune 2e \
source primaire licence-compatible disponible). Le périmètre « plateau » couvre les coûts au niveau \
de la centrale et exclut, de part et d'autre, les coûts système (back-up de l'intermittence, réseau, \
stockage) ET le démantèlement et la gestion de long terme des déchets : il n'est donc PAS directement \
comparable entre filières pilotables et variables. Les millésimes sont hétérogènes (2021 à 2024), à \
interpréter avec prudence. Une hypothèse à `null` signifie « non publiée par la source », jamais une \
dimension retirée.";
pub fn cost_reference_catalog() -> CostReferenceCatalog {
let entries = vec![
CostEstimate {
key: CostReferenceKey {
source: CostSource::CourDesComptes,
technology: CostTechnology::NucleaireExistant,
perimeter: Perimeter::Plateau,
vintage: 2021,
},
basis: CostBasis::AccountingAmortized,
range: LcoeRange::new(49.0, 60.0, 75.0),
assumptions: CostAssumptions {
discount_rate: None,
lifetime_years: Some(50),
load_factor: Some(0.75),
},
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Rte,
technology: CostTechnology::NucleaireNouveau,
perimeter: Perimeter::Plateau,
vintage: 2021,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(100.0, 120.0, 150.0),
assumptions: CostAssumptions {
discount_rate: Some(0.04),
lifetime_years: Some(60),
load_factor: Some(0.65),
},
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Ademe,
technology: CostTechnology::SolairePv,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(45.0, 60.0, 90.0),
assumptions: CostAssumptions {
discount_rate: None,
lifetime_years: Some(25),
load_factor: Some(0.14),
},
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Ademe,
technology: CostTechnology::EolienTerrestre,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(50.0, 65.0, 90.0),
assumptions: CostAssumptions {
discount_rate: None,
lifetime_years: Some(25),
load_factor: Some(0.25),
},
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Ademe,
technology: CostTechnology::EolienMer,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(90.0, 110.0, 140.0),
assumptions: CostAssumptions {
discount_rate: None,
lifetime_years: Some(25),
load_factor: Some(0.40),
},
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Ademe,
technology: CostTechnology::Hydraulique,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(15.0, 50.0, 100.0),
assumptions: CostAssumptions {
discount_rate: None,
lifetime_years: Some(60),
load_factor: Some(0.40),
},
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Ademe,
technology: CostTechnology::Biomasse,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(90.0, 130.0, 200.0),
assumptions: CostAssumptions {
discount_rate: None,
lifetime_years: Some(20),
load_factor: Some(0.60),
},
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Cre,
technology: CostTechnology::NucleaireExistant,
perimeter: Perimeter::Plateau,
vintage: 2023,
},
basis: CostBasis::AccountingAmortized,
range: LcoeRange::new(57.3, 60.7, 63.4),
assumptions: CostAssumptions::default(),
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Irena,
technology: CostTechnology::SolairePv,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(30.5, 39.7, 40.0),
assumptions: CostAssumptions::default(),
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Irena,
technology: CostTechnology::EolienTerrestre,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(26.8, 31.4, 48.1),
assumptions: CostAssumptions::default(),
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Irena,
technology: CostTechnology::EolienMer,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(51.8, 73.0, 74.0),
assumptions: CostAssumptions::default(),
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Irena,
technology: CostTechnology::Hydraulique,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(52.7, 52.7, 52.7),
assumptions: CostAssumptions::default(),
},
CostEstimate {
key: CostReferenceKey {
source: CostSource::Irena,
technology: CostTechnology::Biomasse,
perimeter: Perimeter::Plateau,
vintage: 2024,
},
basis: CostBasis::ProspectiveLcoe,
range: LcoeRange::new(80.4, 80.4, 80.4),
assumptions: CostAssumptions::default(),
},
];
CostReferenceCatalog { entries }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn range_snaps_inconsistent_bounds_to_median() {
let r = LcoeRange::new(80.0, 60.0, 40.0);
assert_eq!(r.min, 60.0);
assert_eq!(r.max, 60.0);
assert!(r.min <= r.median && r.median <= r.max);
}
#[test]
fn catalog_keeps_nuclear_split_existing_and_new() {
let catalog = cost_reference_catalog();
let techs: Vec<_> = catalog.entries().iter().map(|e| e.key.technology).collect();
assert!(techs.contains(&CostTechnology::NucleaireExistant));
assert!(techs.contains(&CostTechnology::NucleaireNouveau));
}
#[test]
fn existing_nuclear_is_accounting_basis_not_prospective_lcoe() {
let catalog = cost_reference_catalog();
for e in catalog.entries() {
let expected = if e.key.technology == CostTechnology::NucleaireExistant {
CostBasis::AccountingAmortized
} else {
CostBasis::ProspectiveLcoe
};
assert_eq!(e.basis, expected, "base incorrecte pour {:?}", e.key);
}
}
const ALL_TECHS: [CostTechnology; 7] = [
CostTechnology::NucleaireExistant,
CostTechnology::NucleaireNouveau,
CostTechnology::SolairePv,
CostTechnology::EolienTerrestre,
CostTechnology::EolienMer,
CostTechnology::Hydraulique,
CostTechnology::Biomasse,
];
#[test]
fn ranges_consistent_uniform_perimeter_and_each_filiere_dispersed() {
let catalog = cost_reference_catalog();
for e in catalog.entries() {
assert!(
e.range.min <= e.range.max,
"{:?} : borne incohérente",
e.key
);
assert_eq!(
e.key.perimeter,
Perimeter::Plateau,
"périmètre non uniforme"
);
}
for tech in ALL_TECHS {
assert!(
catalog
.entries()
.iter()
.any(|e| e.key.technology == tech && e.range.min < e.range.max),
"aucune source dispersée pour {tech:?}"
);
}
}
#[test]
fn renewables_and_existing_nuclear_are_multi_source() {
let catalog = cost_reference_catalog();
let distinct_sources = |tech: CostTechnology| -> usize {
catalog
.entries()
.iter()
.filter(|e| e.key.technology == tech)
.map(|e| e.key.source)
.collect::<std::collections::HashSet<_>>()
.len()
};
for tech in ALL_TECHS {
let n = distinct_sources(tech);
if tech == CostTechnology::NucleaireNouveau {
assert_eq!(n, 1, "nucléaire nouveau attendu mono-source (assumé)");
} else {
assert!(n >= 2, "{tech:?} devrait avoir ≥ 2 sources, a {n}");
}
}
}
#[test]
fn filter_does_not_reorder_or_aggregate() {
let catalog = cost_reference_catalog();
let ademe = catalog.filtered(Some(CostSource::Ademe), None, None, None);
assert!(!ademe.is_empty());
assert!(ademe.iter().all(|e| e.key.source == CostSource::Ademe));
}
}