tokenfabrikker/tests/test_utbygging.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

307 lines
12 KiB
Python

"""The build-out (chapter 4): whole calendar years, the limits of S22, vintages and export stops.
Made-up round numbers only.
"""
from __future__ import annotations
import math
import pytest
from tokenfabrikker import ligninger as lg
from tokenfabrikker import utbygging as ub
# ------------------------------------------------- whole years (clarification 21)
@pytest.mark.parametrize(
("tidspunkt", "aar"),
[(2047.0, 2047), (2047.0000000000005, 2047), (2047.3, 2048), (2046.999, 2047)],
)
def test_forste_driftsaar_rundes_opp(tidspunkt: float, aar: int) -> None:
assert lg.forste_driftsaar(tidspunkt=tidspunkt) == aar
@pytest.mark.parametrize(
("varighet", "hele"), [(14.4, 14), (14.5, 15), (14.6, 15), (0.2, 1), (60.0, 60), (1.49, 1)]
)
def test_levetid_rundes_til_naermeste_hele_aar(varighet: float, hele: int) -> None:
assert lg.avrundet_varighet(varighet=varighet) == hele
def test_avrundet_varighet_avviser_null() -> None:
with pytest.raises(ValueError, match="must be positive"):
lg.avrundet_varighet(varighet=0.0)
def test_byggeaar_hele_aar_faar_like_andeler() -> None:
assert lg.byggeaar_andeler(tau=4.0) == (0.25, 0.25, 0.25, 0.25)
def test_byggeaar_brokdelen_ligger_tidligst() -> None:
andeler = lg.byggeaar_andeler(tau=2.5)
assert andeler == pytest.approx((0.4, 0.4, 0.2))
assert math.fsum(andeler) == pytest.approx(1.0)
def test_byggetid_under_ett_aar_betales_aaret_for_oppstart() -> None:
assert lg.byggeaar_andeler(tau=0.4) == pytest.approx((1.0,))
assert lg.byggeaar_andeler(tau=1.0) == (1.0,)
def test_diskonteringsfaktor() -> None:
assert lg.diskonteringsfaktor(rho=0.1, t=2029, T_0=2027) == pytest.approx(1 / 1.21)
assert lg.diskonteringsfaktor(rho=0.1, t=2027, T_0=2027) == 1.0
# ------------------------------------------------------------- S33, S22, S39, S41
def test_s33_byggetiden_forsinker_forste_kraft() -> None:
felles = {"T_0": 2027.0, "tau_reg_min": 5.0}
assert lg.s33_tidligste_tidspunkt_kjernekraft(**felles, tau_F=20.0, tau_N=9.5) == 2047.0
assert lg.s33_tidligste_tidspunkt_kjernekraft(**felles, tau_F=15.0, tau_N=17.1) == 2049.1
assert lg.s33_tidligste_tidspunkt_nett(T_0=2027.0, tau_nett=7.5) == 2034.5
def test_s22_de_tre_leddene() -> None:
assert lg.s22_grense_reaktor(n_reaktor=1500.0, P_IT=1000.0, P_G_N=1500.0) == 1000.0
# 4.38 TWh per year, all of it counted in a dry year, covers 500 MW at full load
assert lg.s22_grense_fornybar(g_fornybar=4.38e6, w_tort=1.0, lam=1.0, PUE=1.0) == pytest.approx(
500.0
)
assert lg.s22_grense_brikker(s_brikker=0.04, G_server=25_000.0, utskifting=400.0) == 600.0
assert lg.s22_reaktoreffekt_B(lam=0.7, PUE=1.2, P_IT=1000.0, KF=0.84) == pytest.approx(1000.0)
def test_s39_enheter_i_B_rundes_opp_for_programmet() -> None:
per_enhet = 8760.0 * 0.8 * 1000.0
assert lg.s39_enheter_B(E_D_sum=2.0 * per_enhet, KF=0.8, P_ref=1000.0) == 2
assert lg.s39_enheter_B(E_D_sum=2.01 * per_enhet, KF=0.8, P_ref=1000.0) == 3
assert lg.s39_enheter_B(E_D_sum=0.0, KF=0.8, P_ref=1000.0) == 0
def test_s39_portefoljen_fylles_i_fast_rekkefolge() -> None:
felles = {"w_tort_vann": 0.8, "E_vann_rest": 2e6, "E_vind_rest": 3e6}
bare_vann = lg.s39_portefolje_C(E_torr=0.8e6, **felles)
assert (bare_vann.vann, bare_vann.vind, bare_vann.havvind) == pytest.approx((1e6, 0.0, 0.0))
alle = lg.s39_portefolje_C(E_torr=7e6, **felles)
# hydropower gives 1.6 TWh in a dry year, wind 3, and offshore wind the remaining 2.4
assert (alle.vann, alle.vind, alle.havvind) == pytest.approx((2e6, 3e6, 2.4e6))
assert alle.torraar(w_tort_vann=0.8) == pytest.approx(7e6)
assert alle.sum == pytest.approx(7.4e6)
@pytest.mark.parametrize("E_normal", [0.5e6, 2e6, 4e6, 9e6])
def test_s39_takt_og_portefolje_er_hverandres_inverse(E_normal: float) -> None:
felles = {"w_tort_vann": 0.8, "E_vann_rest": 2e6, "E_vind_rest": 3e6}
torr = lg.s39_torraarsenergi_av_takt(E_normal=E_normal, **felles)
assert lg.s39_portefolje_C(E_torr=torr, **felles).sum == pytest.approx(E_normal)
def test_s41_fordeles_paa_aarene_til_forste_anlegg() -> None:
per_aar = lg.s41_programkostnad(
andel_myndighet=0.2, aarsverk_prog=1000.0, c_aarsverk=1e6, t_1=2037, T_0=2027
)
assert per_aar == pytest.approx(20e6)
with pytest.raises(ValueError, match="after the decision year"):
lg.s41_programkostnad(
andel_myndighet=0.2, aarsverk_prog=1000.0, c_aarsverk=1e6, t_1=2027, T_0=2027
)
# ---------------------------------------------------------------- the export rule
def test_eksportstopp_varer_avrundet_antall_aar() -> None:
u = (0.9, 0.05, 0.9, 0.9, 0.9, 0.9)
assert ub.eksportstopp(u=u, phi_X=0.1, D_X=2.4) == (False, True, True, False, False, False)
assert ub.eksportstopp(u=u, phi_X=0.1, D_X=2.5) == (False, True, True, True, False, False)
def test_eksportstopp_ny_regel_forlenger_stoppen() -> None:
u = (0.05, 0.9, 0.05, 0.9, 0.9, 0.9)
assert ub.eksportstopp(u=u, phi_X=0.1, D_X=3.0) == (True, True, True, True, True, False)
def test_ingen_eksportregel_naar_sannsynligheten_er_null() -> None:
assert ub.eksportstopp(u=(0.0, 0.5, 0.99), phi_X=0.0, D_X=4.0) == (False, False, False)
def test_eksportstopp_stopper_ved_sluttaaret() -> None:
assert ub.eksportstopp(u=(0.9, 0.9, 0.0), phi_X=0.1, D_X=4.0) == (False, False, True)
# ------------------------------------------------------------------ the schedule
def _plan(**endringer: object) -> ub.Plan:
argumenter: dict[str, object] = {
"N_anlegg": 3,
"T_0": 2027,
"T_s": 2040,
"t_min": 2030,
"P_IT": 1000.0,
"L_H": 3,
"L_N": 20,
"brikker_per_aar": 500.0,
"kraftrom": ub.kraftrom_ubegrenset,
"stopp": (False,) * 13,
}
argumenter.update(endringer)
return ub.utbyggingsplan(**argumenter) # type: ignore[arg-type]
def test_brikker_telles_fra_forste_mulige_aar_og_utskifting_gaar_foran() -> None:
"""Hand-computed: 500 MW of chips a year, facilities of 1 000 MW, vintages of three years.
Deliveries count from the first possible operating year, 2030 (clarification 25). Stock
after deliveries: 2030 500, 2031 1 000 (facility 1 starts, 0 left), 2032 500, 2033 1 000
(facility 2 starts), 2034 500 (facility 1's vintage has expired and waits), 2035 1 000
(facility 1's vintage is replaced before facility 3 can start), 2036 500 (facility 2
waits), 2037 1 000 (facility 2 replaced), 2038 500 (facility 1 waits), 2039 1 000
(facility 1 replaced), 2040 500 (facility 2 waits). Facility 3 never gets chips.
"""
plan = _plan()
assert [a.start for a in plan.anlegg] == [2031, 2033]
assert plan.anlegg[0].aarganger == (2031, 2035, 2039)
assert plan.anlegg[1].aarganger == (2033, 2037)
assert not plan.gjennomforbar
assert plan.t_1 == 2031
def test_brikker_spart_opp_fra_beslutningsaaret_er_en_bryter() -> None:
"""The reading the text had before clarification 25 was decided: a stock from 2028.
Stock after deliveries: 2028 500, 2029 1 000, 2030 1 500 (facility 1 starts, 500 left),
2031 1 000 (facility 2 starts, 0 left), 2032 500, 2033 1 000 (facility 1's vintage is
replaced before facility 3 can start), 2034 500 (facility 2 waits), 2035 1 000 (facility
2 replaced), 2036 500, 2037 1 000 (facility 1 replaced), 2038 500, 2039 1 000 (facility
2 replaced), 2040 500. Facility 3 never gets chips.
"""
plan = _plan(forste_brikkeaar=2028)
assert [a.start for a in plan.anlegg] == [2030, 2031]
assert plan.anlegg[0].aarganger == (2030, 2033, 2037)
assert plan.anlegg[1].aarganger == (2031, 2035, 2039)
assert not plan.gjennomforbar
def test_utlevd_aargang_staar_uten_inntekt_til_den_byttes() -> None:
plan = _plan()
assert plan.aargang(0, 2033) == 2031
assert plan.aargang(0, 2034) is None # expired, no chips in stock
assert plan.aargang(0, 2035) == 2035
assert plan.aargang(1, 2036) is None
assert plan.aargang(0, 2030) is None # not in operation yet
assert plan.i_drift(0, 2034) # the facility is still operated
def test_den_som_har_ventet_lengst_faar_brikker_forst() -> None:
"""Chips for one facility a year from 2030, vintages of two years, a stop in 2033.
Facility 1 starts in 2030 and is replaced in 2032; facility 2 starts in 2031. Its vintage
expires in 2033, during the stop, so it waits. In 2034 facility 1 expires too, and there
are chips for one: facility 2, which expired first. Facility 1 follows in 2035. After
that each is replaced the year it expires.
"""
stopp = [False] * 13
stopp[2033 - 2028] = True
plan = _plan(
N_anlegg=2,
L_H=2,
brikker_per_aar=1000.0,
t_min=2030,
stopp=tuple(stopp),
forste_brikkeaar=2030,
)
assert plan.anlegg[0].aarganger == (2030, 2032, 2035, 2037, 2039)
assert plan.anlegg[1].aarganger == (2031, 2034, 2036, 2038, 2040)
assert plan.antall_med_last(2033) == 1
assert plan.antall_med_last(2034) == 1
assert plan.antall_i_drift(2034) == 2
assert not plan.har_last(0, 2034)
assert plan.har_last(1, 2034)
def test_reaktortakten_begrenser_antall_anlegg() -> None:
"""1 000 MW of reactors a year and 2 500 MW per facility: room for k after 2.5 k years."""
plan = _plan(
brikker_per_aar=5000.0,
L_H=20,
kraftrom=ub.kraftrom_reaktor(n_reaktor=1000.0, P_G_N=2500.0, T_0=2027),
)
assert [a.start for a in plan.anlegg] == [2030, 2032, 2035]
assert plan.gjennomforbar
def test_flere_anlegg_kan_starte_samme_aar() -> None:
plan = _plan(brikker_per_aar=5000.0, L_H=20, t_min=2035)
assert [a.start for a in plan.anlegg] == [2035, 2035, 2035]
assert plan.antall_i_drift(2034) == 0
assert plan.antall_i_drift(2035) == 3
def test_fornybar_takt_regnes_i_toerraarsenergi() -> None:
"""2 TWh a year: hydropower first (2 TWh potential, 0.8 in a dry year), then wind.
Dry-year energy after x years is 1.6 + 2 (x - 1) TWh for x >= 1. One facility needs
5 TWh: room for one after 2.7 years (first whole year 2030), for two after 5.2 (2033).
"""
rom = ub.kraftrom_fornybar(
g_fornybar=2e6, w_tort_vann=0.8, E_vann_rest=2e6, E_vind_rest=1e6, E_D=5e6, T_0=2027
)
assert rom(2028) == pytest.approx(1.6 / 5)
assert rom(2030) == pytest.approx(5.6 / 5)
plan = _plan(N_anlegg=2, brikker_per_aar=5000.0, L_H=20, t_min=2028, kraftrom=rom)
assert [a.start for a in plan.anlegg] == [2030, 2033]
def test_eksportstopp_gir_verken_leveranser_nye_anlegg_eller_nye_aarganger() -> None:
"""Chips for two facilities a year, but a stop in 2030-2031 and in 2033.
Facility 1 starts in 2032 instead of 2030; nothing is delivered during the stop, so the
stock in 2032 is what 2028, 2029 and 2032 gave. Its vintage expires in 2033, inside the
second stop, and is replaced in 2034.
"""
stopp = [False] * 13
for aar in (2030, 2031, 2033):
stopp[aar - 2028] = True
plan = _plan(N_anlegg=1, L_H=1, brikker_per_aar=2000.0, stopp=tuple(stopp))
assert plan.anlegg[0].start == 2032
assert plan.anlegg[0].aarganger[:3] == (2032, 2034, 2035)
assert plan.aargang(0, 2033) is None
def test_anlegget_drives_L_N_aar_og_fornyes_ikke_etter_det() -> None:
plan = _plan(N_anlegg=1, L_N=4, L_H=3, brikker_per_aar=5000.0)
anlegg = plan.anlegg[0]
assert (anlegg.start, anlegg.siste_driftsaar) == (2030, 2033)
assert anlegg.aarganger == (2030, 2033)
assert plan.i_drift(0, 2033)
assert not plan.i_drift(0, 2034)
assert plan.aargang(0, 2034) is None
def test_plan_uten_anlegg_har_ikke_noe_forste_aar() -> None:
plan = _plan(brikker_per_aar=10.0)
assert plan.anlegg == ()
with pytest.raises(ValueError, match="no facility"):
_ = plan.t_1
def test_feil_antall_aar_i_eksportstrommen_avvises() -> None:
with pytest.raises(ValueError, match="one export flag per year"):
_plan(stopp=(False,) * 5)
def test_losningenes_egenskaper() -> None:
assert not ub.Losning.A.paa_nett
assert all(a.paa_nett for a in ub.Losning if a is not ub.Losning.A)
assert [a for a in ub.Losning if a.kjernekraft] == [
ub.Losning.A,
ub.Losning.B,
ub.Losning.B_MERKET,
ub.Losning.T_K,
]
assert [a for a in ub.Losning if a.trinnvis] == [ub.Losning.T_F, ub.Losning.T_K]