tokenfabrikker/tests/test_parametere.py
Kjell Tore Guttormsen a63f66c416
feat(kode): add the levelised equations, the parameter reader and the draws
One pure function per equation for chapters 1 to 3 of the specification
(S1-S21, S36, S43-S47), a strict reader for the frozen parameter file with
checksum, validation and unit conversion, and the 10 000 Monte Carlo draws of
the 87 drawn quantities, stored in data/ and reproducible bit for bit.

Tests: unit tests and edge cases per equation, the reader, the draws, and
known answers from Argonne, NOU 2026: 4, Epoch and NVE with the sources' own
assumptions. Five comparisons miss the 5 % tolerance and are kept as strict
expected failures with the measured deviation. No result for the hypothesis
is computed. ruff ALL and mypy strict pass.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 10:08:47 +01:00

276 lines
10 KiB
Python

"""The parameter file is the frozen one, is read strictly, and is converted to the right units."""
from __future__ import annotations
import copy
import json
import re
from collections import Counter
from pathlib import Path
from typing import Any
import pytest
from tokenfabrikker import parametere as pm
ROT = Path(__file__).resolve().parents[1]
@pytest.fixture(scope="module")
def raa() -> dict[str, Any]:
data: dict[str, Any] = json.loads(pm.STANDARDSTI.read_text(encoding="utf-8"))
return data
@pytest.fixture(scope="module")
def sett() -> pm.Parametersett:
return pm.les_parametere()
def _endret(raa: dict[str, Any], parameter_id: str) -> tuple[dict[str, Any], dict[str, Any]]:
"""A deep copy of the file and the entry with this id inside the copy."""
kopi = copy.deepcopy(raa)
post = next(p for p in kopi["parametere"] if p["id"] == parameter_id)
return kopi, post
# ------------------------------------------------------------------- the freeze
def test_sjekksummen_er_den_i_forhaandsregistreringen() -> None:
tekst = (ROT / "FORHANDSREGISTRERING.md").read_text(encoding="utf-8")
funnet = re.search(r"SHA-256: `([0-9a-f]{64})`", tekst)
assert funnet is not None
assert funnet.group(1) == pm.FROSSEN_SHA256
assert pm.sjekksum() == pm.FROSSEN_SHA256
def test_en_endret_fil_avvises(tmp_path: Path) -> None:
kopi = tmp_path / "parametere.json"
kopi.write_bytes(pm.STANDARDSTI.read_bytes().replace(b'"verdi": 2027', b'"verdi": 2030'))
with pytest.raises(pm.ParameterError, match="not the frozen parameter file"):
pm.les_parametere(kopi)
assert pm.les_parametere(kopi, krev_frossen=False).fast("T0") == 2030
def test_antall_og_status_som_i_forhaandsregistreringen(sett: pm.Parametersett) -> None:
"""124 parameters: 80 with source, 1 derived, 35 open assumptions, 8 choices of set-up."""
assert len(sett.parametere) == 124
assert Counter(p.status for p in sett.parametere) == {
"kilde": 80,
"avledet": 1,
"åpen forutsetning": 35,
"modellvalg": 8,
}
def test_tabellen_i_spesifikasjonen_har_de_samme_parameterne(sett: pm.Parametersett) -> None:
tekst = (ROT / "modell" / "spesifikasjon.md").read_text(encoding="utf-8")
tabell = tekst.split("<!-- PARAMETERTABELL START -->")[1].split("<!-- PARAMETERTABELL SLUTT")[0]
ider = re.findall(r"^\| `([^`]+)` \|", tabell, flags=re.MULTILINE)
assert ider == [p.id for p in sett.parametere]
# ------------------------------------------------------------ strict validation
def test_ukjent_felt_overst_er_feil(raa: dict[str, Any]) -> None:
kopi = copy.deepcopy(raa)
kopi["kommentar"] = "x"
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['kommentar'\]"):
pm.tolk_parametere(kopi)
def test_ukjent_felt_i_parameter_er_feil(raa: dict[str, Any]) -> None:
kopi, post = _endret(raa, "c_N_ref")
post["verdi"] = 140000
with pytest.raises(pm.ParameterError, match=r"c_N_ref.*unknown field"):
pm.tolk_parametere(kopi)
def test_ukjent_felt_i_fordeling_er_feil(raa: dict[str, Any]) -> None:
kopi, post = _endret(raa, "c_N_ref")
post["fordeling"]["modus"] = 140000
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['modus'\]"):
pm.tolk_parametere(kopi)
def test_manglende_felt_er_feil(raa: dict[str, Any]) -> None:
kopi, post = _endret(raa, "tau_N")
del post["fordeling"]["modus"]
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['modus'\]"):
pm.tolk_parametere(kopi)
kopi, post = _endret(raa, "tau_N")
del post["merknad"]
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['merknad'\]"):
pm.tolk_parametere(kopi)
@pytest.mark.parametrize(
("felt", "verdi", "melding"),
[
("enhet", "kr/kWh", "unknown unit"),
("status", "antatt", "unknown status"),
("poster", ["K3-20"], "malformed source entries"),
("poster", [], "requires at least one source entry"),
],
)
def test_ukjent_enhet_status_og_post_er_feil(
raa: dict[str, Any], felt: str, verdi: object, melding: str
) -> None:
kopi, post = _endret(raa, "c_N_ref")
post[felt] = verdi
with pytest.raises(pm.ParameterError, match=melding):
pm.tolk_parametere(kopi)
def test_ukjent_fordelingstype_er_feil(raa: dict[str, Any]) -> None:
kopi, post = _endret(raa, "c_N_ref")
post["fordeling"]["type"] = "normal"
with pytest.raises(pm.ParameterError, match="unknown distribution type 'normal'"):
pm.tolk_parametere(kopi)
@pytest.mark.parametrize(
("parameter_id", "felt", "verdi", "melding"),
[
("tau_N", "modus", 20.0, "does not hold"),
("c_N_ref", "lav", 171500, "range is empty"),
("tau_N", "form", 6, "PERT shape"),
("phi_U", "lav", 0.0, "must be positive"),
("o_xi", "sigma", -1.0, "must be positive"),
("o_xi", "avkorting", "trekk på nytt", "truncation must be"),
("L_H", "vekter", [0.2, 0.2, 0.2, 0.2, 0.3], "weights sum to"),
("L_H", "vekter", [0.5, 0.5], "same, non-zero length"),
("c_N_ref", "lav", "109000", "expected a number"),
("c_N_ref", "lav", True, "expected a number"),
],
)
def test_ugyldig_fordeling_er_feil(
raa: dict[str, Any], parameter_id: str, felt: str, verdi: object, melding: str
) -> None:
kopi, post = _endret(raa, parameter_id)
post["fordeling"][felt] = verdi
with pytest.raises(pm.ParameterError, match=melding):
pm.tolk_parametere(kopi)
def test_duplikater_er_feil(raa: dict[str, Any], tmp_path: Path) -> None:
kopi = copy.deepcopy(raa)
kopi["parametere"].append(copy.deepcopy(kopi["parametere"][5]))
with pytest.raises(pm.ParameterError, match="duplicate parameter id"):
pm.tolk_parametere(kopi)
fil = tmp_path / "p.json"
fil.write_text('{"versjon": "1", "versjon": "2"}', encoding="utf-8")
with pytest.raises(pm.ParameterError, match="duplicate key 'versjon'"):
pm.les_parametere(fil, krev_frossen=False)
def test_ugyldig_json_og_feil_antall_trekninger(raa: dict[str, Any], tmp_path: Path) -> None:
fil = tmp_path / "p.json"
fil.write_text("{", encoding="utf-8")
with pytest.raises(pm.ParameterError, match="not valid JSON"):
pm.les_parametere(fil, krev_frossen=False)
kopi = copy.deepcopy(raa)
kopi["monte_carlo"]["antall_trekninger"] = 5000
with pytest.raises(pm.ParameterError, match="N_trekk differs"):
pm.tolk_parametere(kopi)
kopi = copy.deepcopy(raa)
kopi["monte_carlo"]["metode"] = "LHS"
with pytest.raises(pm.ParameterError, match="monte_carlo: unknown field"):
pm.tolk_parametere(kopi)
def test_sammensatt_parameter_maa_ha_alle_feltene(raa: dict[str, Any]) -> None:
kopi, post = _endret(raa, "vind")
post["fordeling"]["degradering"] = {"type": "fast", "verdi": 0.0042}
with pytest.raises(pm.ParameterError, match="a composite must have the fields"):
pm.tolk_parametere(kopi)
kopi, post = _endret(raa, "pris_balanse")
post["enhet"] = "TWh; øre/kWh (2025-kroner)"
with pytest.raises(pm.ParameterError, match="expected a table with unit"):
pm.tolk_parametere(kopi)
# -------------------------------------------------------------- unit conversion
@pytest.mark.parametrize(
("navn", "enhet", "faktor"),
[
("c_N_ref", "kr/kW", 1e3),
("f_N", "kr/kW per år", 1e3),
("v_N", "kr/MWh", 1.0),
("D_avv", "mill. kr/MW", 1e6),
("K_U", "mrd. kr", 1e9),
("D_fors", "mill. kr", 1e6),
("c_H0", "mill. kr/MW IT", 1e6),
("o_D", "mill. kr/MW IT per år", 1e6),
("c_linje", "mill. kr/km", 1e6),
("c_fast", "kr/MW per år", 1.0),
("S0", "TWh", 1e6),
("g_fornybar", "TWh per år", 1e6),
("G_server", "GW per år", 1e3),
("u_kjerne", "g CO2e/kWh", 1e-3),
("eta_N", "tonn uran per TWh", 1e-6),
("vind.investering", "kr/kW", 1e3),
("vind.drift", "kr/MWh", 1.0),
("havvind.drift", "kr/kW per år", 1e3),
("vann.fullasttimer", "t/år", 1.0),
],
)
def test_enhetsfaktorer(sett: pm.Parametersett, navn: str, enhet: str, faktor: float) -> None:
storrelse = sett.storrelse(navn)
assert (storrelse.enhet, storrelse.faktor) == (enhet, faktor)
def test_faste_verdier_i_ligningenes_enheter(sett: pm.Parametersett) -> None:
assert sett.fast("P_ref") == 1000.0
assert sett.fast("c_linje") == pytest.approx(13.4e6)
assert sett.fast("D_fors") == pytest.approx(8.202e9)
assert sett.fast("o_D_v") == pytest.approx(3.21e6)
assert sett.fast("G_server") == 25_000.0
assert sett.fast("havvind.drift") == 900_000.0
assert sett.fast("vind.levetid") == 30.0
assert sett.fast("SNKS_snitt") == pytest.approx(536.3e9)
with pytest.raises(pm.ParameterError, match="not a fixed scalar"):
sett.fast("c_N_ref")
with pytest.raises(KeyError):
sett.storrelse("finnes_ikke")
def test_lister_og_tabeller(sett: pm.Parametersett) -> None:
assert sett.liste("stige") == (1.0, 5.0, 10.0, 20.0, 40.0)
assert sett.liste("P_u_sett")[0] == 5.0
assert sett.liste("P_u_sett")[-1] == 1000.0
assert sett.karbonpris()["sentral"][2030] == 2377.0
assert sett.karbonpris()["lav"][2100] == 8547.0
petroleum = sett.petroleumsinntekt()
assert petroleum[2022] == pytest.approx(1285.223e9)
assert sum(petroleum.values()) / 10 == pytest.approx(482.4e9, rel=1e-3)
with pytest.raises(pm.ParameterError, match="not a table"):
sett.tabell("c_N_ref")
def test_prisene_regnes_om_til_2025_kroner_per_mwh(sett: pm.Parametersett) -> None:
scenarioer = sett.pris_balanse()
assert len(scenarioer) == 12
svakest = scenarioer[-1]
assert svakest.navn.startswith("N11")
assert svakest.balanse == pytest.approx(-3.6e6)
assert svakest.pris["NO1"] == pytest.approx(76.8 * 10 * 137.7 / 129.6)
assert set(svakest.pris) == {"NO1", "NO2", "NO3", "NO4", "NO5", "Norge"}
def test_alle_storrelser_og_rekkefolgen(sett: pm.Parametersett) -> None:
"""136 scalar quantities with the composites split; 87 of them are drawn, in file order."""
assert len(sett.storrelser()) == 136
stokastiske = [s.navn for s in sett.stokastiske()]
assert len(stokastiske) == 87
assert stokastiske[:4] == ["c_N_ref", "w_xi", "u_xi", "o_xi"]
assert stokastiske[-1] == "eps_e"
plass = stokastiske.index("vann.investering")
assert stokastiske[plass : plass + 2] == ["vann.investering", "vann.drift"]
assert sett.monte_carlo.froe == 20261111
assert sett.monte_carlo.antall_trekninger == 10_000
assert len(sett.foelsomheter) == 29