tokenfabrikker/tests/test_hendelser.py
Kjell Tore Guttormsen bca6496c0a
feat(utbygging): build out solution T in modules and add S48-S54
utbyggingsplan_trinnvis follows chapter 17.1: the grid balance of the
first stage, the payment condition for a module's power plants, S49,
and in T-K the two stocks of chips and the queue for replacements.
tidslinje gives MW IT in operation per type of power (S50). S48-S54
are pure functions in ligninger.py, and Inndata carries the new
quantities, the scenarios for the loss of demand and the paths of
u_alt. lag_plan returns a Trinnvisplan for T-F and T-K; regn_program
refuses T until it is taken through the cash flow.

Tested on made-up numbers only (59 new tests, hand-computed build-outs).
Nothing is computed for the hypothesis.

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

189 lines
7.6 KiB
Python

"""The stream for yearly events and the set of values for one draw.
These tests look at random numbers and parameter values only. No model result is computed.
"""
from __future__ import annotations
import json
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import hendelser, inndata, trekninger
from tokenfabrikker import parametere as pm
if TYPE_CHECKING:
from pathlib import Path
@pytest.fixture(scope="module")
def sett() -> pm.Parametersett:
return pm.les_parametere()
@pytest.fixture(scope="module")
def strom(sett: pm.Parametersett) -> hendelser.Hendelser:
return hendelser.trekk(sett)
# -------------------------------------------------------------------- the stream
def test_froet_staar_i_parameterfila(sett: pm.Parametersett) -> None:
assert hendelser.froe(sett) == 20261112
assert hendelser.froe(sett) != sett.monte_carlo.froe
def test_ett_tall_per_trekning_og_aar_etter_beslutningsaaret(strom: hendelser.Hendelser) -> None:
assert strom.aar == tuple(range(2028, 2101))
assert strom.tabell.shape == (10_000, 73)
assert strom.tabell.dtype == np.float64
assert ((strom.tabell >= 0.0) & (strom.tabell < 1.0)).all()
assert len(strom.rad(0)) == 73
def test_tallene_er_jevnt_fordelt(strom: hendelser.Hendelser) -> None:
"""730 000 numbers: mean 0.5 and a tenth in each tenth, within four standard errors."""
antall = strom.tabell.size
assert abs(float(strom.tabell.mean()) - 0.5) < 4 * (1 / 12) ** 0.5 / antall**0.5
andeler = np.histogram(strom.tabell, bins=10, range=(0.0, 1.0))[0] / antall
assert float(np.abs(andeler - 0.1).max()) < 4 * (0.1 * 0.9 / antall) ** 0.5
def test_aarene_er_ikke_korrelert_med_hverandre(strom: hendelser.Hendelser) -> None:
korrelasjon = np.asarray(np.corrcoef(strom.tabell[:, :10], rowvar=False), dtype=np.float64)
np.fill_diagonal(korrelasjon, 0.0)
assert float(np.abs(korrelasjon).max()) < 4 / 10_000**0.5
def test_strommen_er_en_annen_enn_parametertrekningene(
sett: pm.Parametersett, strom: hendelser.Hendelser
) -> None:
trukket = trekninger.trekk(sett)
assert abs(float(np.corrcoef(strom.tabell[:, 0], trukket.kolonne("phi_X"))[0, 1])) < 0.04
def test_samme_fro_gir_samme_strom(sett: pm.Parametersett, strom: hendelser.Hendelser) -> None:
assert np.array_equal(hendelser.trekk(sett).tabell, strom.tabell)
def test_den_lagrede_strommen_kan_gjenskapes(sett: pm.Parametersett) -> None:
assert hendelser.kontroller(sett) == ("identisk", 0.0)
def test_skriv_og_les(sett: pm.Parametersett, strom: hendelser.Hendelser, tmp_path: Path) -> None:
sha256 = hendelser.skriv(strom, sett, tmp_path)
lest = hendelser.les(tmp_path)
assert lest.aar == strom.aar
assert np.array_equal(lest.tabell, strom.tabell)
beskrivelse = json.loads((tmp_path / hendelser.BESKRIVELSESFIL).read_text(encoding="utf-8"))
assert beskrivelse["sha256_tabell"] == sha256
assert beskrivelse["froe"] == 20261112
assert beskrivelse["sha256_parametere"] == pm.FROSSEN_SHA256
assert hendelser.kontroller(sett, tmp_path) == ("identisk", 0.0)
def test_endret_tabell_oppdages(
sett: pm.Parametersett, strom: hendelser.Hendelser, tmp_path: Path
) -> None:
hendelser.skriv(strom, sett, tmp_path)
endret = strom.tabell.copy()
endret[0, 0] = 0.123
(tmp_path / hendelser.TABELLFIL).write_bytes(trekninger.tabellbytes(endret))
with pytest.raises(pm.ParameterError, match="does not match the checksum"):
hendelser.les(tmp_path)
def test_kommandolinja(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
assert hendelser.main(["lag", "--mappe", str(tmp_path)]) == 0
assert "10000 trekninger for 73 år skrevet" in capsys.readouterr().out
assert hendelser.main(["kontroll", "--mappe", str(tmp_path)]) == 0
assert capsys.readouterr().out.startswith("identisk")
# ---------------------------------------------------- the values of one draw
@pytest.fixture(scope="module")
def forste_trekning(sett: pm.Parametersett) -> inndata.Inndata:
return inndata.fra_trekning(sett, trekninger.les(), hendelser.les().rad(0), 0)
def test_verdiene_er_regnet_om_til_ligningenes_enheter(
sett: pm.Parametersett, forste_trekning: inndata.Inndata
) -> None:
"""Units only: kr/kW to kr/MW, TWh to MWh, GW to MW, mill. and mrd. kr to kr."""
inn = forste_trekning
assert 109_000e3 <= inn["c_N_ref"] <= 171_500e3
assert -15e6 <= inn["S0"] <= 19.6e6
assert inn["G_server"] == 25_000.0
assert inn["D_fors"] == 8202e6
assert 1625e9 <= inn["K_U"] <= 6217e9
assert 0.2e6 <= inn["g_fornybar"] <= 0.6e6
assert 10_100e3 <= inn["vind.investering"] <= 21_933e3
assert inn["havvind.drift"] == 900e3
assert inn["vind.drift"] == 120.0
assert (inn.heltall("T0"), inn.heltall("T_slutt")) == (2027, 2100)
assert inn.heltall("L_H") in {3, 4, 5, 6, 7}
assert inn.heltall("n_0") in range(1, 21)
for storrelse in sett.storrelser():
assert (storrelse.navn in inn.v) == (storrelse.fordeling.tabell is None)
def test_tabellene_og_designverdiene_foelger_parameterfila(
forste_trekning: inndata.Inndata,
) -> None:
inn = forste_trekning
assert inn.design == {"o_f_liten": 0.0465, "o_f_stor": 0.025, "o_p": 0.05, "beta_F": 0.1}
assert inn.P_u_sett == (5.0, 10.0, 20.0, 50.0, 100.0, 200.0, 300.0, 400.0, 500.0, 1000.0)
assert inn.psi == {"vind": 0.88, "vann": 1.26, "havvind": 0.96}
assert inn.kappa == {"vann": 0.88, "havvind": 0.0}
assert set(inn.linjer) == {"NO1", "NO2", "NO3", "NO4", "NO5", "Norge"}
assert inn.karbonpris[2026] == 1588.0
assert len(inn.u_eksport) == 73
def test_karbonprisen_er_lineaer_mellom_aarene_i_tabellen(
forste_trekning: inndata.Inndata,
) -> None:
inn = forste_trekning
assert inn.karbonpris_i(2030) == 2377.0
assert inn.karbonpris_i(2028) == pytest.approx((1588.0 + 2377.0) / 2)
assert inn.karbonpris_i(2045) == 3367.0
assert inn.karbonpris_i(2100) == 10956.0
assert inn.karbonpris_i(2025) == 1588.0
def test_stoerrelsene_for_tillegget_til_retningen_foelger_parameterfila(
forste_trekning: inndata.Inndata,
) -> None:
"""Chapter 17.8: units and tables only; nothing is computed with them."""
inn = forste_trekning
assert (inn["P_m"], inn["eps_d"], inn["w_N_forbruk"], inn["w_D_sjo"]) == (100.0, 1.0, 0.0, 98.0)
assert 3.0 <= inn["tau_1"] <= 7.0
assert 18.0 <= inn["n_1"] <= 268.0
assert 0.07 <= inn["w_D_uttak"] <= 0.10
assert 119.0 <= inn["w_N_uttak"] <= 168.0
# the table of 17.3
assert inn.bortfall[inndata.BORTFALL_KILDE] == (0.119, 0.21)
assert inn.bortfall[inndata.BORTFALL_EGNE_LAV] == pytest.approx((0.188, 0.376))
assert inn.bortfall[inndata.BORTFALL_EGNE_HOY] == pytest.approx((0.32, 0.64))
assert inn.bortfall_i(inndata.BORTFALL_KILDE, 2040) == 0.21
# the table of 17.4, g CO2 per kWh converted to tonnes per MWh
assert set(inn.u_alt) == {"hoved", "lav", "hoy_nedre", "hoy_ovre", "null"}
assert inn.u_alt_i("hoved", 2024) == pytest.approx(0.43)
assert inn.u_alt_i("hoved", 2045) == pytest.approx((0.2012 + 0.1312) / 2)
assert inn.u_alt_i("hoved", 2100) == pytest.approx(0.1312)
assert inn.u_alt_i("lav", 2100) == pytest.approx(0.09)
assert (inn.u_alt_i("hoy_nedre", 2050), inn.u_alt_i("hoy_ovre", 2050)) == pytest.approx(
(0.41, 0.626)
)
assert inn.u_alt_i("null", 2050) == 0.0
assert inn.kjoletaarn == {"forbruk": (2.2, 2.5, 3.2), "uttak": (3.0, 4.2, 9.8)}
def test_heltall_avviser_tall_som_ikke_er_hele(forste_trekning: inndata.Inndata) -> None:
with pytest.raises(ValueError, match="should be a whole number"):
forste_trekning.heltall("rho_N")