"""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 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