tokenfabrikker/tests/test_folsomheter.py
Kjell Tore Guttormsen 45aaffcb69
feat(folsomheter): the sensitivity list through the run over the draws, with eleven new switches in the model code
42 rows from the 37 lines: each row is the main run with one change, run
on the main run's step for the solutions it applies to and put in the
fixed table next to the main run. New switches in dimensjoner and
regn_program for lines 4, 7, 8, 10, 12, 13, 16, 17, 18, 20 and 21, the
cost factor of line 28 in the ownership pass, and the state's cash flow
next to M6. With the switches off every figure is unchanged to the last
digit. Made-up draws only; nothing is computed.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-13 20:31:12 +01:00

688 lines
29 KiB
Python

"""The sensitivity list through the run (chapter 11; clarifications 112, 113, 116 to 123).
Made-up draws only: variants of the made-up set of ``conftest.py``, and invented outcomes per
draw for the table. Nothing here says anything about the hypothesis.
"""
from __future__ import annotations
import dataclasses
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import dommer, eierskap
from tokenfabrikker import folsomheter as fs
from tokenfabrikker import kjoring as kj
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag, Trinnvalg
from tokenfabrikker.folsomheter import RADER, Avlesning
from tokenfabrikker.kjoring import Bane, Brytere, Eierrad, Kjoring, Scenario, Utfall
from tokenfabrikker.kontantstrom import Diskontering, Knapphet, Paaslagsform, Skattekostnad
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
NORM = Scenario("normalisering", Knapphet.NORMALISERING)
VARER = Scenario("knapphet varer", Knapphet.VARER)
OVER = Scenario("overkapasitet", Knapphet.OVERKAPASITET)
LAVT = Scenario("lavt", Knapphet.NORMALISERING, "lavt")
HOYT = Scenario("hoyt", Knapphet.NORMALISERING, "hoyt")
SCENARIOER = (VARER, NORM, OVER, LAVT, HOYT)
"""The price scenarios and the two marked scenarios of the made-up set."""
EOS = {
"direkte": "består",
"heleid_selskap": "består",
"majoritet_boers": "usikker",
"petroleumsmodell": "består",
}
KARBONBANER = {"lav": {2026: 500.0, 2100: 500.0}, "hoy": {2026: 3000.0, 2100: 4000.0}}
"""Made-up low and high paths of the carbon price; the made-up set has 1 000 kr in every year."""
# ------------------------------------------------------------------ the list
def test_lista_har_42_rader_fra_37_linjer() -> None:
assert len(RADER) == 42
linjer = [rad.linje for rad in RADER.values()]
assert sorted(set(linjer)) == list(range(1, fs.ANTALL_LINJER + 1))
assert linjer == sorted(linjer)
assert sorted({n for n in linjer if linjer.count(n) == 2}) == [11, 17, 19, 31, 32]
assert [navn for navn, rad in RADER.items() if not rad.er_kjoring] == [
"24",
"25",
"28",
"29",
"30",
]
assert {navn: rad.eierrad for navn, rad in RADER.items() if rad.eierrad is not None} == {
"24": Eierrad.STATENS_RENTE,
"25": Eierrad.EGENKAPITALKRAV,
"28": Eierrad.EFFEKTIVITET,
"29": Eierrad.ZETA_LIK_EIERANDEL,
}
def test_radene_leses_av_der_avklaring_112_sier() -> None:
andre = {
navn: rad.avlesning for navn, rad in RADER.items() if rad.avlesning is not Avlesning.HOVED
}
assert andre == {
"12": Avlesning.VARER,
"13": Avlesning.VARER,
"24": Avlesning.EIERFORMER,
"25": Avlesning.EIERFORMER,
"28": Avlesning.EIERFORMER,
"29": Avlesning.EIERFORMER,
"31a": Avlesning.MERKET,
"31b": Avlesning.MERKET,
}
assert fs.scenarioer_for(RADER["14"], SCENARIOER) == (NORM,)
assert fs.scenarioer_for(RADER["12"], SCENARIOER) == (VARER,)
assert fs.scenarioer_for(RADER["31a"], SCENARIOER) == (LAVT, HOYT)
assert fs.scenarioer_for(RADER["24"], SCENARIOER) == ()
def test_hvilke_losninger_radene_gjelder() -> None:
"""Clarifications 117 to 122, row by row."""
A, B, Bm, C, R, TF, TK = (
Losning.A,
Losning.B,
Losning.B_MERKET,
Losning.C,
Losning.R,
Losning.T_F,
Losning.T_K,
)
alle = (A, B, Bm, C, R, TF, TK)
assert set(alle) == set(Losning)
ikke_alle = {
navn: set(rad.gjelder) for navn, rad in RADER.items() if set(rad.gjelder) != set(alle)
}
assert ikke_alle == {
"1": {A, B, Bm, TK},
"2": {A, B, Bm, TK},
"3": {A},
"4": {B, Bm, TK},
"5": {A, Bm},
"6": {A, B, Bm, TK},
"7": {A, Bm},
"8": {A, Bm},
"9": {A, Bm},
"10": {A},
"20": {A, Bm},
"21": {B, Bm, TK},
"22": {B, Bm, C, TF, TK},
"24": {A, B, C, TF, TK},
"25": {A, B, C, TF, TK},
"28": {A, B, C, TF, TK},
"29": {A, B, C, TF, TK},
"32a": {TF, TK},
"32b": {TF, TK},
"33": {TF, TK},
"34": {TF, TK},
"35": {C},
"36": {TK},
"37": {C, TF, TK},
}
# ------------------------------------------------------------------ one draw
@pytest.mark.parametrize(
("rad", "losning", "endring", "grunn"),
[
# the made-up set has u_xi = 0.9 and w_xi = 0.5: no overrun. With u_xi = 0.3 there is one.
("1", Losning.A, {"w_xi": 0.0}, {"u_xi": 0.3}),
("2", Losning.B, {"w_xi": 1.0}, {}),
("5", Losning.A, {"nu": 0.6}, {}),
("6", Losning.B, {"ell": -0.23}, {}),
("11a", Losning.C, {"mu_rel": 0.90}, {}),
("11b", Losning.R, {"mu_rel": 0.95}, {}),
("14", Losning.C, {"p_v": 1198.0}, {}),
("15", Losning.B, {"PUE_v": 1.45}, {}),
("17a", Losning.A, {"varphi": 0.0}, {}),
("27", Losning.C, {"P_IT": 300.0}, {}),
("27", Losning.T_F, {"P_IT": 300.0}, {}),
("27", Losning.A, {"P_IT": 300.0}, {}),
("32a", Losning.T_F, {"P_m": 50.0}, {}),
("32b", Losning.T_K, {"P_m": 200.0}, {}),
# the first stage of the made-up set takes 150 MW a year; the modules wait for grid
("33", Losning.T_F, {"n_1": 650.0}, {"tau_nett": 6.0}),
],
)
def test_en_rad_med_fast_verdi_er_hovedkjoringen_med_verdien_byttet(
oppdiktet: LagInndata,
rad: str,
losning: Losning,
endring: dict[str, float],
grunn: dict[str, float],
) -> None:
"""The value is set after the draw: every other quantity keeps its value."""
inn = oppdiktet().med(grunn)
med = fs.regn_bane(inn, losning, 2, (NORM, VARER), rad=RADER[rad])
assert med == kj.regn_bane(inn.med(endring), losning, 2, (NORM, VARER))
assert med != kj.regn_bane(inn, losning, 2, (NORM, VARER))
def test_bortfallets_utslag_virker_bare_i_de_merkede_scenarioene(oppdiktet: LagInndata) -> None:
"""Line 31: eps_d moves nothing on the main path."""
for navn, eps in (("31a", 0.5), ("31b", 2.0)):
med = fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM, LAVT), rad=RADER[navn])
hoved = kj.regn_bane(oppdiktet(), Losning.C, 2, (NORM, LAVT))
assert med == kj.regn_bane(oppdiktet(eps_d=eps), Losning.C, 2, (NORM, LAVT))
assert med.utfall[NORM.navn] == hoved.utfall[NORM.navn]
assert med.utfall[LAVT.navn] != hoved.utfall[LAVT.navn]
def test_rho_A_lik_rho_N_bruker_trekningens_rho_N(oppdiktet: LagInndata) -> None:
"""Line 3. The made-up set has rho_N = 0.06 and rho_D = 0.08."""
for rho_N in (0.06, 0.05):
inn = oppdiktet(rho_N=rho_N)
med = fs.regn_bane(inn, Losning.A, 2, (NORM,), rad=RADER["3"])
assert med == kj.regn_bane(
inn, Losning.A, 2, (NORM,), brytere=Brytere(dim={"rho_A": rho_N})
)
# a lower required return for the plant lowers the cost of power, and so helps M2; the
# plant's cash flow is costs only in A, so its present value falls
hoved = kj.regn_bane(inn, Losning.A, 2, (NORM,))
assert med.utfall[NORM.navn].S42 > hoved.utfall[NORM.navn].S42
assert med.utfall[NORM.navn].NNV < hoved.utfall[NORM.navn].NNV
def test_halv_byggetid_gjelder_enheter_under_300_MW(oppdiktet: LagInndata) -> None:
"""Line 9. The made-up set gives units of 50 MW in A; with chi = 0.5 they are 400 MW."""
for losning in (Losning.A, Losning.B_MERKET):
med = fs.regn_bane(oppdiktet(), losning, 2, (NORM,), rad=RADER["9"])
assert med == kj.regn_bane(oppdiktet(tau_N=2.0), losning, 2, (NORM,))
assert med != kj.regn_bane(oppdiktet(), losning, 2, (NORM,))
stor = oppdiktet(chi=0.5)
assert ks.dimensjoner(stor, Losning.A).P_u == 400.0
assert fs.regn_bane(stor, Losning.A, 2, (NORM,), rad=RADER["9"]) == kj.regn_bane(
stor, Losning.A, 2, (NORM,)
)
def test_karbonprisens_baner_gis_av_den_som_kjorer(oppdiktet: LagInndata) -> None:
"""Line 19: the run reads no file, so the two paths are passed in."""
inn = oppdiktet()
for navn, bane in (("19a", "lav"), ("19b", "hoy")):
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER[navn], karbonbaner=KARBONBANER)
byttet = dataclasses.replace(inn, karbonpris=KARBONBANER[bane])
assert med == kj.regn_bane(byttet, Losning.C, 2, (NORM,))
hoved = kj.regn_bane(inn, Losning.C, 2, (NORM,)).utfall[NORM.navn].NNV
lav = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["19a"], karbonbaner=KARBONBANER)
assert lav.utfall[NORM.navn].NNV > hoved > med.utfall[NORM.navn].NNV
with pytest.raises(ValueError, match="low and its high path"):
fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["19a"])
def test_beslutningsaar_2030_bruker_eksportradens_tall_for_samme_kalenderaar(
oppdiktet: LagInndata,
) -> None:
"""Line 26, clarification 113: the number stored for year t is used in year t.
The made-up set runs from 2027 to 2060, so the row has 33 numbers, for 2028 to 2060.
With a stop in 2034 only (the seventh number) the path built from 2030 meets it in
its fourth year, not in its seventh.
"""
u = tuple(0.0 if aar == 2034 else 0.9 for aar in range(2028, 2061))
inn = oppdiktet(u_eksport=u, phi_X=0.5)
senere = fs.med_beslutningsaar(inn, 2030)
assert (senere["T0"], len(senere.u_eksport)) == (2030.0, 30)
assert senere.u_eksport == u[3:]
assert senere.u_eksport.index(0.0) == 2034 - 2031
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["26"])
assert med == kj.regn_bane(
oppdiktet(u_eksport=u[3:], phi_X=0.5, T0=2030), Losning.C, 2, (NORM,)
)
assert med.forste_aar == 2031
assert med != kj.regn_bane(
oppdiktet(u_eksport=u[:30], phi_X=0.5, T0=2030), Losning.C, 2, (NORM,)
)
with pytest.raises(ValueError, match="later, not earlier"):
fs.med_beslutningsaar(inn, 2026)
def test_C_i_moduler_er_T_F_uten_forste_trinn_paa_plassen_til_C(oppdiktet: LagInndata) -> None:
"""Line 35, clarification 73."""
inn = oppdiktet()
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["35"])
assert med == kj.regn_bane(
inn, Losning.T_F, 2, (NORM,), brytere=Brytere(plan={"uten_forste_trinn": True})
)
assert med != kj.regn_bane(inn, Losning.C, 2, (NORM,))
def test_radene_som_er_brytere_gir_bryteren_til_modellkoden(oppdiktet: LagInndata) -> None:
"""Lines 22, 23, 34, 36 and 37 against the model code called directly."""
inn = oppdiktet(phi_X=0.5, u_eksport=(0.1,) * 4 + (0.9,) * 29)
def nnv(
losning: Losning, plan_valg: dict[str, object], program_valg: dict[str, object]
) -> float:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2, **plan_valg) # type: ignore[arg-type]
return ks.regn_program(
inn,
losning,
plan,
Knapphet.NORMALISERING,
dim=dim,
**program_valg, # type: ignore[arg-type]
).NNV
tilfeller: list[tuple[str, Losning, dict[str, object], dict[str, object]]] = [
("22", Losning.C, {}, {"tilleggsregel": False}),
("23", Losning.C, {"eksportregel": False}, {}),
("34", Losning.T_F, {}, {"full_fortrengning_i_forste_trinn": True}),
("36", Losning.T_K, {"uten_s49": True}, {}),
("37", Losning.C, {"ny_kraft_fra": 2031}, {}),
]
for navn, losning, plan_valg, program_valg in tilfeller:
med = fs.regn_bane(inn, losning, 2, (NORM,), rad=RADER[navn])
assert med.utfall[NORM.navn].NNV == nnv(losning, plan_valg, program_valg), navn
def test_radene_med_ny_modellkode_gir_bryteren_til_modellkoden(oppdiktet: LagInndata) -> None:
"""Lines 4, 7, 8, 10, 12, 13, 16, 17, 18, 20 and 21: the switch each row sets."""
assert {
navn: (dict(r.brytere.dim), dict(r.brytere.program))
for navn, r in RADER.items()
if r.linje in (4, 7, 8, 10, 12, 13, 16, 18, 20, 21) or navn == "17b"
} == {
"4": ({"paaslag_kjernekraft": 0.02}, {}),
"7": ({"minstelast": 0.20}, {}),
"8": ({"fritt_enhetsvalg": True}, {}),
"10": ({"gamma_trinn": True}, {}),
"12": ({}, {"paaslag": Paaslagsform.VARIG}),
"13": ({}, {"paaslag": Paaslagsform.AVTAKENDE}),
"16": ({}, {"diskontering": Diskontering.RUNDSKRIV}),
"17b": ({}, {"skattekostnad": Skattekostnad.ALL_KAPITAL}),
"18": ({}, {"skattekostnad": Skattekostnad.STATENS_RENTE}),
"20": ({"skaler_K_U": False}, {}),
"21": ({"bare_over_dimensjonerende_feil": True}, {}),
}
trinn = {"A>=A*": 1.0, "0.99<=A<A*": 0.9, "0.95<=A<0.99": 0.7, "A<0.95": 0.0}
grunn = oppdiktet()
# what only the rows read, with made-up values
v = {"tau_pi": 2.5, "P_dim0": 1450.0, **grunn.v}
inn = dataclasses.replace(grunn, v=v, Gamma_trinn=trinn)
tilfeller = [
("4", Losning.B, NORM),
("7", Losning.A, NORM),
("8", Losning.A, NORM),
("10", Losning.A, NORM),
("12", Losning.C, VARER),
("13", Losning.C, VARER),
("16", Losning.C, NORM),
("17b", Losning.C, NORM),
("18", Losning.A, NORM),
("20", Losning.A, NORM),
("21", Losning.B, NORM),
]
for navn, losning, scenario in tilfeller:
rad = RADER[navn]
med = fs.regn_bane(inn, losning, 2, (scenario,), rad=rad)
assert med == kj.regn_bane(inn, losning, 2, (scenario,), brytere=rad.brytere), navn
def test_en_rad_regnes_bare_for_losningene_den_gjelder(oppdiktet: LagInndata) -> None:
with pytest.raises(ValueError, match="row 3 is not computed for solution C"):
fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM,), rad=RADER["3"])
with pytest.raises(ValueError, match="row 30 is not computed"):
fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM,), rad=RADER["30"])
with pytest.raises(ValueError, match="row 24 is not computed"):
fs.regn_bane(oppdiktet(), Losning.A, 2, (NORM,), rad=RADER["24"])
# ------------------------------------------------------------- over the draws
def test_en_rad_kjores_paa_hovedkjoringens_trinn_for_losningene_den_gjelder(
oppdiktet: LagInndata,
) -> None:
trekninger = [oppdiktet(), oppdiktet(p_v=3000.0), oppdiktet(n_reaktor=100.0)]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.TRINN_5)
k = fs.kjor_rad(
trekninger, RADER["1"], valg, scenarioer=SCENARIOER, losninger=(Losning.A, Losning.C)
)
assert k is not None
assert (k.stige, k.scenarioer, k.losninger, k.antall) == ((2,), (NORM,), (Losning.A,), 3)
assert k.trekninger[1][Losning.A, 2] == kj.regn_bane(
oppdiktet(p_v=3000.0, w_xi=0.0), Losning.A, 2, (NORM,)
)
# the same figures on several processes
assert (
fs.kjor_rad(
trekninger,
RADER["1"],
valg,
scenarioer=SCENARIOER,
losninger=(Losning.A, Losning.C),
prosesser=2,
)
== k
)
# the rows that are read in other scenarios
varig = fs.kjor_rad(
trekninger[:1], RADER["31a"], valg, scenarioer=SCENARIOER, losninger=(Losning.C,)
)
assert varig is not None
assert varig.scenarioer == (LAVT, HOYT)
def test_en_rad_uten_egen_kjoring_gir_ingen(oppdiktet: LagInndata) -> None:
trekninger = [oppdiktet()]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.TRINN_5)
uten = Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN)
assert fs.kjor_rad(trekninger, RADER["1"], uten, scenarioer=SCENARIOER) is None
assert fs.kjor_rad(trekninger, RADER["30"], valg, scenarioer=SCENARIOER) is None
assert fs.kjor_rad(trekninger, RADER["24"], valg, scenarioer=SCENARIOER) is None
# none of the row's solutions, or none of its scenarios, in the run
assert (
fs.kjor_rad(trekninger, RADER["3"], valg, scenarioer=SCENARIOER, losninger=(Losning.C,))
is None
)
assert fs.kjor_rad(trekninger, RADER["12"], valg, scenarioer=(NORM,)) is None
with pytest.raises(ValueError, match="at least one draw"):
fs.kjor_rad([], RADER["1"], valg, scenarioer=SCENARIOER)
# ----------------------------------------- the table, on invented outcomes per draw
def _u(NNV: float = 1.0, *, M6: float | None = 0.3, M6_median: float | None = None) -> Utfall:
return Utfall(
NNV=NNV,
S42=1.0,
M3=0.0,
M4=Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False),
M6=M6,
M6_snitt=M6,
M6_median=M6 if M6_median is None else M6_median,
M6_2050=None,
M6_topp=0.0 if M6 is None else M6,
stabilt_aar=None if M6 is None else 2040,
toppaar=2040,
)
def _kjoring(
per_trekning: list[dict[Losning, Utfall | None]],
scenarioer: tuple[Scenario, ...] = (NORM,),
trinn: int = 5,
) -> Kjoring:
"""A run on one step put together from invented outcomes, the same in every scenario."""
def bane(u: Utfall | None) -> Bane:
linje: dict[Kraft, tuple[float, ...]] = {}
utfall = {} if u is None else {s.navn: u for s in scenarioer}
return Bane(byggbar=u is not None, forste_aar=2028, tidslinje=linje, utfall=utfall)
return Kjoring(
stige=(trinn,),
scenarioer=scenarioer,
losninger=tuple(per_trekning[0]),
trekninger=tuple({(a, trinn): bane(u) for a, u in t.items()} for t in per_trekning),
)
VALG = Trinnvalg(trinn=5, grunnlag=Grunnlag.TRINN_25)
M5 = dict.fromkeys(Losning, Dom.HOLDER)
def test_hovedkjoringen_i_tabellen_er_dommene_paa_trinnet() -> None:
"""The main run in the format of the table gives what ``sett_dommer`` gives on the step."""
hoved = _kjoring(
[
{Losning.A: _u(1.0 if j < 7 else -1.0), Losning.C: _u(0.5), Losning.R: _u(2.0)}
for j in range(10)
]
)
d = kj.sett_dommer(hoved, M5)
t = fs.hovedtabell(hoved, M5, d.valg, NORM)
norm = d.scenarioer[NORM.navn]
assert (t.rad, t.scenario, t.gjelder) == (fs.HOVEDKJORINGEN, NORM.navn, ())
assert t.losninger == norm.per_trinn[5]
assert (t.M7, t.del_I, t.del_II) == (norm.M7[5], norm.del_I, norm.del_II)
assert t.ved_siden_av[Losning.A] == kj.ved_siden_av_m6(hoved.utfall(NORM, Losning.A, 5))
with pytest.raises(ValueError, match="no table"):
fs.hovedtabell(hoved, M5, Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN), NORM)
def test_en_rad_i_tabellen_har_radens_utfall_der_den_gjelder_og_hovedkjoringens_ellers() -> None:
"""Row 3 applies to A. A is best in 7 of 10 draws in the main run and in 2 of 10 in the row."""
hoved = _kjoring(
[{Losning.A: _u(1.0 if j < 7 else -1.0), Losning.C: _u(0.5)} for j in range(10)]
)
radkjoring = _kjoring([{Losning.A: _u(1.0 if j < 2 else 0.1)} for j in range(10)])
(t,) = fs.tabell(hoved, RADER["3"], radkjoring, M5, VALG).values()
assert (t.rad, t.scenario, t.gjelder) == ("3", NORM.navn, (Losning.A,))
assert t.losninger[Losning.C] == fs.hovedtabell(hoved, M5, VALG, NORM).losninger[Losning.C]
a = t.losninger[Losning.A]
assert (a.maal["M1"].andel_holder, a.maal["M1"].dom, a.median_M1) == (1.0, Dom.HOLDER, 0.1)
assert t.M7 is not None
assert (t.M7.andel_holder, t.M7.dom) == (0.2, Dom.BETINGELSER)
assert (t.del_I, t.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
# the main run next to it: 7 of 10 positive, and A best in those 7
h = fs.hovedtabell(hoved, M5, VALG, NORM)
assert h.M7 is not None
assert (h.losninger[Losning.A].maal["M1"].andel_holder, h.M7.andel_holder) == (0.7, 0.7)
# without a run of the row every solution has the main run's figures
(uten,) = fs.tabell(hoved, RADER["3"], None, M5, VALG).values()
assert (uten.losninger, uten.M7, uten.del_I) == (h.losninger, h.M7, h.del_I)
def test_M6_mot_medianen_er_en_dom_og_ingen_kjoring() -> None:
"""Row 30: M6 is 30 % against the average and 10 % against the median in every draw."""
hoved = _kjoring(
[{Losning.A: _u(M6=0.3, M6_median=0.1), Losning.C: _u(M6=None)} for _ in range(10)]
)
(t,) = fs.tabell(hoved, RADER["30"], None, M5, VALG).values()
h = fs.hovedtabell(hoved, M5, VALG, NORM)
assert h.losninger[Losning.A].maal["M6"].dom is Dom.HOLDER
assert t.losninger[Losning.A].maal["M6"].dom is Dom.BETINGELSER
assert t.losninger[Losning.A].maal["M6"].andel_holder == 0.0
assert t.losninger[Losning.A].maal["M1"] == h.losninger[Losning.A].maal["M1"]
# a path without a year of stable operation has neither figure
assert t.losninger[Losning.C].maal["M6"] == h.losninger[Losning.C].maal["M6"]
assert (h.del_I, t.del_I) == (Dom.HOLDER, Dom.BETINGELSER)
assert t.gjelder == (Losning.A, Losning.C)
def test_C_i_moduler_staar_paa_plassen_til_C_og_endrer_ikke_M7_og_del_I() -> None:
"""Row 35: the path beats A in every draw, and is still not one of the five solutions."""
hoved = _kjoring([{Losning.A: _u(1.0), Losning.C: _u(0.5)} for _ in range(10)])
radkjoring = _kjoring([{Losning.C: _u(-2.0 if j < 9 else 3.0)} for j in range(10)])
(t,) = fs.tabell(hoved, RADER["35"], radkjoring, M5, VALG).values()
h = fs.hovedtabell(hoved, M5, VALG, NORM)
assert t.losninger[Losning.C].maal["M1"].andel_holder == 0.1
assert t.losninger[Losning.C].median_M1 == -2.0
assert (t.M7, t.del_I, t.del_II) == (h.M7, h.del_I, h.del_II)
assert h.M7 is not None
assert h.M7.andel_holder == 1.0
def test_tabellen_har_en_rad_per_scenario_raden_leses_av_i() -> None:
hoved = _kjoring([{Losning.C: _u(1.0)} for _ in range(4)], scenarioer=(NORM, VARER, LAVT, HOYT))
radkjoring = _kjoring([{Losning.C: _u(-1.0)} for _ in range(4)], scenarioer=(LAVT, HOYT))
t = fs.tabell(hoved, RADER["31a"], radkjoring, M5, VALG)
assert list(t) == [LAVT.navn, HOYT.navn]
assert all(rad.losninger[Losning.C].median_M1 == -1.0 for rad in t.values())
varig = fs.tabell(hoved, RADER["12"], None, M5, VALG)
assert list(varig) == [VARER.navn]
# the rows of the ownership forms have no table here, and nothing has one without a step
assert fs.tabell(hoved, RADER["24"], None, M5, VALG) == {}
assert fs.tabell(hoved, RADER["31a"], radkjoring, M5, Trinnvalg(None, Grunnlag.INGEN)) == {}
def test_tabellen_gjennom_modellen_paa_oppdiktede_trekninger(oppdiktet: LagInndata) -> None:
"""Row 14 through the model: the row's outcomes are the main run's with the value replaced."""
trekninger = [oppdiktet(), oppdiktet(c_H0=150e6), oppdiktet(n_reaktor=100.0)]
losninger = (Losning.A, Losning.C)
hoved = kj.kjor(trekninger, stige=(2,), scenarioer=(NORM,), losninger=losninger)
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
m5 = dict.fromkeys(losninger, Dom.HOLDER)
radkjoring = fs.kjor_rad(trekninger, RADER["14"], valg, scenarioer=(NORM,), losninger=losninger)
(t,) = fs.tabell(hoved, RADER["14"], radkjoring, m5, valg).values()
byttet = kj.kjor(
[x.med({"p_v": 1198.0}) for x in trekninger],
stige=(2,),
scenarioer=(NORM,),
losninger=losninger,
)
assert t.losninger == fs.hovedtabell(byttet, m5, valg, NORM).losninger
assert t.del_I == dommer.del_I(
{a: t.losninger[a].dommer for a in losninger},
{a: t.losninger[a].median_M1 for a in losninger},
valg,
)
# ------------------------------------------- the rows of the ownership forms
def _eiertrekninger(oppdiktet: LagInndata) -> list[Inndata]:
"""Three made-up draws with an overrun in A (u_xi below w_xi) and a made-up eps_e."""
return [
dataclasses.replace(x, v={**x.v, "eps_e": eps})
for x, eps in (
(oppdiktet(u_xi=0.3), 0.05),
(oppdiktet(u_xi=0.3, p_v=3000.0), -0.02),
(oppdiktet(u_xi=0.3, c_H0=150e6), 0.08),
)
]
def _eier(
inn: Inndata, losning: Losning = Losning.A
) -> tuple[ks.Programresultat, eierskap.Bedriftsstrom]:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
res = ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING, dim=dim)
return res, eierskap.bedriftsstrom(inn, res, tilleggsregel=True)
def test_eierformradene_gir_det_avklaring_122_sier(oppdiktet: LagInndata) -> None:
trekninger = _eiertrekninger(oppdiktet)
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
def tabell(rad: Eierrad) -> kj.Eierformtabell:
t = kj.eierformer_paa_trinnet(
trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,), rad=rad
)[Losning.A]
assert t is not None
return t
hoved = tabell(Eierrad.HOVED)
assert (
hoved
== kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,))[
Losning.A
]
)
former = list(EOS)
per_trekning = [_eier(x) for x in trekninger]
def lcoc(navn: str) -> list[float]:
return [
eierskap.lcoc_med_kapitalkostnad(x, res, eierskap.krav_for_skatt(x, x.eierformer[navn]))
for x, (res, _) in zip(trekninger, per_trekning, strict=True)
]
# line 24: the state's cash flow valued with the state's borrowing rate
med_24 = tabell(Eierrad.STATENS_RENTE)
for j, navn in enumerate(former):
utfall = [
eierskap.eierresultat(x, strom, x.eierformer[navn], rente=x["r_stat"])
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
]
assert med_24.kriterier[j] == eierskap.eierkriterier(navn, utfall, lcoc(navn))
assert med_24.kriterier != hoved.kriterier
# line 25: the settlement priced with the owners' required return on equity
med_25 = tabell(Eierrad.EGENKAPITALKRAV)
for j, navn in enumerate(former):
utfall = [
eierskap.eierresultat(x, strom, x.eierformer[navn])
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
]
assert med_25.kriterier[j] == eierskap.eierkriterier(
navn, utfall, lcoc(navn), egenkapitalkrav=True
)
# the two forms without private owners have no settlement and are unchanged
assert med_25.kriterier[:2] == hoved.kriterier[:2]
assert med_25.kriterier[2:] != hoved.kriterier[2:]
# line 28: the costs of direct ownership and the wholly owned company times 1 + eps_e
med_28 = tabell(Eierrad.EFFEKTIVITET)
assert med_28.kriterier[2:] == hoved.kriterier[2:]
for j, navn in enumerate(former[:2]):
utfall, kost = [], []
for x, (res, _) in zip(trekninger, per_trekning, strict=True):
faktor = 1.0 + x["eps_e"]
strom = eierskap.bedriftsstrom(x, res, tilleggsregel=True, kostnadsfaktor=faktor)
utfall.append(eierskap.eierresultat(x, strom, x.eierformer[navn]))
kost.append(
eierskap.lcoc_med_kapitalkostnad(
x, res, eierskap.krav_for_skatt(x, x.eierformer[navn]), kostnadsfaktor=faktor
)
)
assert med_28.kriterier[j] == eierskap.eierkriterier(navn, utfall, kost)
assert med_28.kriterier[j] != hoved.kriterier[j]
# line 29: zeta equal to the state's share; 1 already for the two forms the state owns alone
med_29 = tabell(Eierrad.ZETA_LIK_EIERANDEL)
assert med_29.kriterier[:2] == hoved.kriterier[:2]
for j, navn in enumerate(former[2:], start=2):
utfall = [
eierskap.eierresultat(
x, strom, dataclasses.replace(x.eierformer[navn], zeta=x.eierformer[navn].s)
)
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
]
assert med_29.kriterier[j] == eierskap.eierkriterier(navn, utfall, lcoc(navn))
assert med_29.kriterier[j] != hoved.kriterier[j]
def test_uten_eps_e_er_effektivitetsraden_hovedkjoringen(oppdiktet: LagInndata) -> None:
trekninger = [
dataclasses.replace(x, v={**x.v, "eps_e": 0.0}) for x in _eiertrekninger(oppdiktet)
]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
kall = {"scenario": NORM, "losninger": (Losning.C,)}
assert kj.eierformer_paa_trinnet(
trekninger,
valg,
EOS,
rad=Eierrad.EFFEKTIVITET,
**kall, # type: ignore[arg-type]
) == kj.eierformer_paa_trinnet(trekninger, valg, EOS, **kall) # type: ignore[arg-type]
def test_statens_kontantstrom_ved_siden_av_M6_over_trekningene(oppdiktet: LagInndata) -> None:
"""Clarification 123: S30 for the wholly owned company in the stable year, over M6's base."""
trekninger = [*_eiertrekninger(oppdiktet), oppdiktet(n_reaktor=40.0)]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
t = kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,))[
Losning.A
]
assert t is not None
# with 40 MW of reactors a year the second facility of A does not start by 2060
assert t.antall_byggbare == 3
tall = []
for x in trekninger[:3]:
res, strom = _eier(x)
heleid = eierskap.eierresultat(x, strom, x.eierformer["heleid_selskap"])
tall.append(eierskap.statens_kontantstrom_ved_m6(x, res, heleid))
assert all(v is not None for v in tall)
assert t.statens_kontantstrom == kj.sidetall(tall)
assert t.statens_kontantstrom is not None
assert t.statens_kontantstrom.antall == 3