694 lines
29 KiB
Python
694 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_raden_for_standardvilkaar_sier_at_den_kan_trekke_i_favor_av_A() -> None:
|
|
"""Clarification 125: line 10 follows the frozen list, and the row says what follows."""
|
|
assert {navn for navn, rad in RADER.items() if rad.merknad} == {"10"}
|
|
assert "i favør av A" in RADER["10"].merknad
|
|
|
|
|
|
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
|