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>
276 lines
10 KiB
Python
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
|