tokenfabrikker/tests/test_parametere.py
Kjell Tore Guttormsen ea26cd4226
feat(trekninger): read parameter file 1.1 and store the new draws
The loader knows the new checksum and the units of the new quantities
(g CO2 per kWh, cubic metres per MWh). 10 000 draws of 91 quantities with the
same seed; the four new ones are the last columns. All columns have new
numbers, because the random numbers are laid out row by row. The stream for
yearly events is byte for byte the same; only its description records the new
checksum. Tests for the counts, the new quantities and the checksum in the
pre-registration. README, CHANGELOG and CLAUDE.md updated.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 23:07:09 +01:00

328 lines
13 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
import statistics
from collections import Counter
from pathlib import Path
from typing import Any, cast
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:
"""The freeze section lists the first checksum, then one per deviation; the last applies."""
tekst = (ROT / "FORHANDSREGISTRERING.md").read_text(encoding="utf-8")
avsnitt = tekst.split("## Parameterfrys")[1].split("\n## ")[0]
funnet = re.findall(r"SHA-256: `([0-9a-f]{64})`", avsnitt)
assert len(funnet) == 2
assert funnet[-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:
"""137 parameters: 87 with source, 1 derived, 40 open assumptions, 9 choices of set-up."""
assert len(sett.parametere) == 137
assert Counter(p.status for p in sett.parametere) == {
"kilde": 87,
"avledet": 1,
"åpen forutsetning": 40,
"modellvalg": 9,
}
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)
# in 2025 kroner the average is the denominator of M6, and the median lies between 2019
# and 2021 (clarification 53); in current prices it is 272.2 mrd. kr
faste = sett.petroleumsinntekt(faste_kroner=True)
assert faste[2025] == petroleum[2025]
assert faste[2016] == pytest.approx(124.779e9 * 137.7 / 103.6)
assert sum(faste.values()) / 10 == pytest.approx(sett.fast("SNKS_snitt"), rel=1e-4)
assert statistics.median(faste.values()) == pytest.approx(330.1e9, rel=1e-3)
assert statistics.median(petroleum.values()) == pytest.approx(272.2e9, 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_storrelsene_i_tillegget_til_retningen(sett: pm.Parametersett) -> None:
"""The quantities of chapter 17.8, added in the deviation from the freeze of 2026-11-12."""
assert [p.id for p in sett.parametere[124:]] == [
"P_m", "tau_1", "n_1", "eps_d", "d_kilde", "s_flytt", "s_trening", "u_alt",
"w_D_uttak", "w_N_uttak", "w_N_forbruk", "w_N_taarn", "w_D_sjo",
] # fmt: skip
assert sett.fast("P_m") == 100
assert sett.fast("eps_d") == 1
assert sett.fast("w_N_forbruk") == 0
assert sett.fast("w_D_sjo") == 98
spenn = {
n: sett.storrelse(n).fordeling.tall for n in ("tau_1", "n_1", "w_D_uttak", "w_N_uttak")
}
assert spenn == {
"tau_1": {"lav": 3, "hoy": 7},
"n_1": {"lav": 18, "hoy": 268},
"w_D_uttak": {"lav": 0.07, "hoy": 0.10},
"w_N_uttak": {"lav": 119, "hoy": 168},
}
assert sett.tabell("d_kilde") == {"2030": 0.119, "2035": 0.21}
flytt = cast("dict[str, float]", sett.tabell("s_flytt"))
trening = cast("dict[str, float]", sett.tabell("s_trening"))
bortfall = [
flytt[aar] * (1 - trening[ende]) for ende in ("hoy", "lav") for aar in ("2030", "2035")
]
assert bortfall == pytest.approx([0.188, 0.376, 0.32, 0.64])
utslipp = cast("dict[str, Any]", sett.tabell("u_alt"))
assert utslipp["hoved"] == {"2024": 430, "2030": 340, "2035": 270, "2040": 201.2, "2050": 131.2}
assert utslipp["hoved"]["2040"] == pytest.approx(270 * 187 / 251, abs=0.05)
assert utslipp["hoved"]["2050"] == pytest.approx(270 * 122 / 251, abs=0.05)
assert utslipp["lav"] == {"2025": 170, "2030": 90}
assert utslipp["hoy"] == {"lav": 410, "hoy": 626}
assert utslipp["null"] == 0
assert sett.storrelse("u_alt").faktor == pytest.approx(1e-3) # g per kWh -> tonnes per MWh
assert sett.tabell("w_N_taarn") == {"forbruk": [2.2, 2.5, 3.2], "uttak": [3.0, 4.2, 9.8]}
assert {
sett.parameter(i).status for i in ("tau_1", "n_1", "eps_d", "s_flytt", "w_N_forbruk")
} == {"åpen forutsetning"}
def test_alle_storrelser_og_rekkefolgen(sett: pm.Parametersett) -> None:
"""149 scalar quantities with the composites split; 91 of them are drawn, in file order."""
assert len(sett.storrelser()) == 149
stokastiske = [s.navn for s in sett.stokastiske()]
assert len(stokastiske) == 91
assert stokastiske[:4] == ["c_N_ref", "w_xi", "u_xi", "o_xi"]
assert stokastiske[86] == "eps_e"
assert stokastiske[87:] == ["tau_1", "n_1", "w_D_uttak", "w_N_uttak"]
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) == 37