"""The verdicts (chapter 11 and the pre-registration), tested on invented outcomes. No array here comes from the model run on the frozen parameters: the outcomes per draw are made up, and the two conditions that are read from the power system are computed on the made-up set in ``conftest.py``. Nothing here says anything about the hypothesis. """ from __future__ import annotations import math from typing import TYPE_CHECKING import pytest from tokenfabrikker import dommer from tokenfabrikker import kontantstrom as ks from tokenfabrikker import ligninger as lg from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag, Trinnvalg from tokenfabrikker.kontantstrom import Knapphet from tokenfabrikker.utbygging import Losning if TYPE_CHECKING: from conftest import LagInndata from tokenfabrikker.inndata import Inndata E_D = 8760.0 * 0.75 * 1.2 * 1000.0 """Yearly energy to one made-up data centre: 7 884 000 MWh.""" _UENDRET = Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False) _EFFEKT_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=False) _ENERGI_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=True) def _utfall(*deler: tuple[float | None, int]) -> list[float | None]: """Invented outcomes: each value repeated the given number of draws.""" return [verdi for verdi, antall in deler for _ in range(antall)] def _regn(inn: Inndata, losning: Losning, *, N_anlegg: int = 1) -> ks.Programresultat: dim = ks.dimensjoner(inn, losning) plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg) return ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING, dim=dim) # ------------------------------------------------------------------- shares def test_s37_andel() -> None: assert lg.s37_andel([True, False, True, True]) == 0.75 with pytest.raises(ValueError, match="at least one draw"): lg.s37_andel([]) def test_trekning_uten_verdi_teller_i_nevneren() -> None: utfall = _utfall((1.0, 6), (-1.0, 2), (None, 2)) assert dommer.andel_positiv(utfall) == 0.6 assert dommer.andel(utfall, 0.0, minst=True) == 0.6 assert dommer.andel(utfall, 0.0, minst=False) == 0.2 assert dommer.median(utfall) == 1.0 assert dommer.median(_utfall((1.0, 4), (None, 6))) == -math.inf # -------------------------------------------------------------- M1, M2 @pytest.mark.parametrize( ("positive", "negative", "uten", "dom"), [ (80, 20, 0, Dom.HOLDER), (79, 21, 0, Dom.BETINGELSER), (20, 80, 0, Dom.BETINGELSER), (19, 81, 0, Dom.HOLDER_IKKE), (80, 0, 20, Dom.HOLDER), (79, 0, 21, Dom.BETINGELSER), (19, 0, 81, Dom.HOLDER_IKKE), ], ) def test_dom_m1(positive: int, negative: int, uten: int, dom: Dom) -> None: """Positive in at least 80 % of all draws holds; in under 20 % it does not.""" assert dommer.dom_m1(_utfall((5.0, positive), (-5.0, negative), (None, uten))) is dom def test_dom_m2_teller_null_som_oppfylt() -> None: """S42 is an inequality with >=: a sum of exactly zero meets it.""" assert dommer.dom_m2(_utfall((0.0, 80), (-1.0, 20))) is Dom.HOLDER assert dommer.dom_m2(_utfall((0.0, 50), (-1.0, 50))) is Dom.BETINGELSER assert dommer.dom_m2(_utfall((1.0, 10), (-1.0, 50), (None, 40))) is Dom.HOLDER_IKKE def test_m7_hvem_som_er_best_blant_a_b_og_c() -> None: """Clarification 137 a, one rule for each: the highest value among those that can be built. Ten draws. 0-4: A highest. 5-7: B highest (A lower, C equal to A in 5-7). 8-9: A cannot be built, B is negative and C cannot be built either: B is best alone. The two versions of solution T are left out here; ``test_trinnvis_dommer.py`` has all five. """ A = _utfall((10.0, 5), (1.0, 3), (None, 2)) B = _utfall((5.0, 5), (2.0, 3), (-9.0, 2)) C = _utfall((None, 5), (1.0, 3), (None, 2)) beste = dommer.beste_per_trekning({Losning.A: A, Losning.B: B, Losning.C: C}) assert beste == [(Losning.A,)] * 5 + [(Losning.B,)] * 5 # equal values share the place, in the order A, B, C; none built leaves none assert dommer.beste_per_trekning({Losning.A: [1.0], Losning.B: [1.0], Losning.C: [0.0]}) == [ (Losning.A, Losning.B) ] assert dommer.beste_per_trekning({Losning.C: [3.0], Losning.B: [2.0], Losning.A: [3.0]}) == [ (Losning.A, Losning.C) ] assert dommer.beste_per_trekning({Losning.A: [None], Losning.B: [None], Losning.C: [None]}) == [ () ] # C can be best as A can, and a solution that cannot be built is never among the best assert dommer.beste_per_trekning({Losning.A: [None], Losning.B: [-1.0], Losning.C: [0.0]}) == [ (Losning.C,) ] # ------------------------------------------------------------------ M3 and M4 def test_m3_verste_prisvirkning_i_R(oppdiktet: LagInndata) -> None: """One facility in R takes 3.942 TWh from the balance: 39.42 kr/MWh on a price of 600. In the dry year the effect is 1.2 times larger; the price level 1.5 is in both numerator and denominator. The made-up lines are the same in all areas. """ inn = oppdiktet() res = _regn(inn, Losning.R) normal = 10e-6 * 0.5 * E_D / 600.0 assert dommer.m3_verste_prisvirkning(inn, res) == pytest.approx(1.2 * normal) assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.A)) == 0.0 # B produces more than the data centres use: the price falls assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.B)) < 0 def test_dom_m3() -> None: assert dommer.dom_m3(_utfall((0.05, 80), (0.2, 20))) is Dom.HOLDER assert dommer.dom_m3(_utfall((0.051, 80), (0.2, 20))) is Dom.BETINGELSER assert dommer.dom_m3(_utfall((0.16, 80), (0.0, 20))) is Dom.HOLDER_IKKE assert dommer.dom_m3(_utfall((0.15, 80), (0.0, 20))) is Dom.BETINGELSER # a draw without a value meets neither condition assert dommer.dom_m3(_utfall((0.16, 79), (None, 21))) is Dom.BETINGELSER assert dommer.dom_m3(_utfall((0.0, 79), (None, 21))) is Dom.BETINGELSER def test_m4_forsyning_i_de_fem_losningene(oppdiktet: LagInndata) -> None: """A changes nothing. R only takes power. B and one facility in C add more than they take. With three facilities C has used up hydropower and wind on land; offshore wind counts nothing in the scarcest hour, so capacity is missing, but energy is not. """ inn = oppdiktet() assert dommer.m4_forsyning(inn, _regn(inn, Losning.A)) == _UENDRET assert dommer.m4_forsyning(inn, _regn(inn, Losning.R)) == _ENERGI_MANGLER assert dommer.m4_forsyning(inn, _regn(inn, Losning.B)) == _UENDRET assert dommer.m4_forsyning(inn, _regn(inn, Losning.C)) == _UENDRET tre = _regn(inn, Losning.C, N_anlegg=3) assert dommer.m4_forsyning(inn, tre) == _EFFEKT_MANGLER def test_m4_C_dekker_akkurat_forbruket_i_toerraaret(oppdiktet: LagInndata) -> None: """With nothing displaced in the grid queue, C's dry-year balance is zero, not weaker.""" inn = oppdiktet(delta_V=0.0, kappa_vind=1.0) res = _regn(inn, Losning.C) assert max(abs(rad.Delta_Q_tort) for rad in res.kraftaar) < 1.0 assert not dommer.m4_forsyning(inn, res).svakere_ogsaa_med_tiltak def test_dom_m4() -> None: ok, effekt, energi = _UENDRET, _EFFEKT_MANGLER, _ENERGI_MANGLER assert dommer.dom_m4([ok] * 8 + [energi] * 2) is Dom.HOLDER assert dommer.dom_m4([ok] * 7 + [effekt] * 3) is Dom.BETINGELSER assert dommer.dom_m4([effekt] * 10) is Dom.BETINGELSER assert dommer.dom_m4([energi] * 8 + [ok] * 2) is Dom.HOLDER_IKKE assert dommer.dom_m4([energi] * 7 + [None] * 3) is Dom.BETINGELSER # -------------------------------------------------------- M6 and the ladder def test_dom_m6() -> None: assert dommer.dom_m6(_utfall((0.25, 80), (0.0, 20))) is Dom.HOLDER assert dommer.dom_m6(_utfall((0.24, 80), (0.0, 20))) is Dom.BETINGELSER assert dommer.dom_m6(_utfall((0.049, 80), (0.3, 20))) is Dom.HOLDER_IKKE assert dommer.dom_m6(_utfall((0.05, 80), (0.3, 20))) is Dom.BETINGELSER # a path that cannot be built does not reach 5 % assert dommer.dom_m6(_utfall((0.3, 20), (None, 80))) is Dom.HOLDER_IKKE def _stige(**andel_per_trinn: tuple[float, int]) -> dict[int, dict[Losning, list[float | None]]]: """A made-up ladder: for A, M6 is the given value in the given number of 10 draws. B can be built in the same draws and contributes nothing; R reaches 90 % everywhere. """ stige = {} for navn, (verdi, antall) in andel_per_trinn.items(): trinn = int(navn.removeprefix("n")) stige[trinn] = { Losning.A: _utfall((verdi, antall), (None, 10 - antall)), Losning.B: _utfall((0.0, antall), (None, 10 - antall)), Losning.R: _utfall((0.9, 10)), } return stige def test_dommene_leses_paa_det_laveste_trinnet_som_gir_25_prosent() -> None: stige = _stige(n1=(0.03, 10), n5=(0.1, 10), n10=(0.3, 8), n20=(0.5, 10)) assert dommer.trinn_for_dommene(stige) == Trinnvalg(10, Grunnlag.TRINN_25) def test_trinnet_med_ett_anlegg_kan_ikke_vaere_25_prosent_trinnet() -> None: """Clarification 104: step 1 reaches 25 % and so does step 10; step 5 only reaches 5 %.""" stige = _stige(n1=(0.3, 10), n5=(0.1, 10), n10=(0.3, 8)) assert dommer.trinn_for_dommene(stige) == Trinnvalg(10, Grunnlag.TRINN_25) def test_naar_bare_ett_anlegg_naar_25_prosent_leses_dommene_paa_5_prosent_trinnet() -> None: """Clarification 104: there is no 25 % step, and step 1 is the lowest that reaches 5 %.""" stige = _stige(n1=(0.3, 10), n5=(0.1, 10), n10=(0.2, 10)) assert dommer.trinn_for_dommene(stige) == Trinnvalg(1, Grunnlag.TRINN_5) # the single facility reaches 25 % in too few draws to be the 5 % step: the next step is stige = _stige(n1=(0.3, 7), n5=(0.1, 10)) assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.TRINN_5) # a ladder with the single facility only assert dommer.trinn_for_dommene(_stige(n1=(0.3, 10))) == Trinnvalg(1, Grunnlag.TRINN_5) def test_regelen_for_trinnet_er_monoton_i_trinnet_med_ett_anlegg() -> None: """Clarification 104: a weaker single facility no longer gives another step (103 g).""" sterk = _stige(n1=(0.3, 10), n5=(0.3, 10)) svak = _stige(n1=(0.03, 10), n5=(0.3, 10)) assert dommer.trinn_for_dommene(sterk) == Trinnvalg(5, Grunnlag.TRINN_25) assert dommer.trinn_for_dommene(svak) == Trinnvalg(5, Grunnlag.TRINN_25) def test_ellers_paa_trinnet_som_gir_5_prosent() -> None: """25 % is reached in only 7 of 10 draws on the top step; 5 % in 8 of 10 from step 5.""" stige = _stige(n1=(0.03, 10), n5=(0.1, 8), n10=(0.3, 7)) assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.TRINN_5) def test_ellers_paa_hoyeste_trinn_som_lar_seg_bygge() -> None: """No step reaches 5 %. Step 10 can be built in 7 of 10 draws, step 5 in 9.""" stige = _stige(n1=(0.01, 10), n5=(0.03, 9), n10=(0.04, 7)) assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.HOYESTE) def test_referansekjoringen_kan_ikke_gi_trinnet() -> None: """R reaches 90 % on every step here, but only A, B, C, T-F and T-K decide the step.""" stige = _stige(n1=(0.0, 10), n5=(0.0, 10)) assert dommer.trinn_for_dommene(stige).grunnlag is Grunnlag.HOYESTE def test_ingen_trinn_lar_seg_bygge() -> None: stige = { 1: { Losning.A: _utfall((None, 10)), Losning.B: _utfall((0.1, 7), (None, 3)), } } assert dommer.trinn_for_dommene(stige) == Trinnvalg(None, Grunnlag.INGEN) # ---------------------------------------------------------------- overall verdicts def _dommer(**endringer: Dom) -> dict[str, Dom]: alle = dict.fromkeys(dommer.MAAL_DEL_I, Dom.HOLDER) alle.update(endringer) return alle def test_del_I_holder_naar_en_losning_holder_paa_alle_maal() -> None: per_losning = { Losning.A: _dommer(M1=Dom.HOLDER_IKKE), Losning.B: _dommer(), Losning.C: _dommer(M3=Dom.BETINGELSER), } median = {Losning.A: -1.0, Losning.B: 5.0, Losning.C: 5.0} paa_25 = Trinnvalg(10, Grunnlag.TRINN_25) assert dommer.del_I(per_losning, median, paa_25) is Dom.HOLDER # on the 5 % step, or with a single facility, it can at most hold under conditions assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_5)) is Dom.BETINGELSER assert dommer.del_I(per_losning, median, Trinnvalg(1, Grunnlag.TRINN_25)) is Dom.BETINGELSER def test_del_I_holder_ikke_naar_hver_losning_er_felt() -> None: """A fails M1, B has a negative median, C fails M4. M6 alone cannot fell a solution.""" per_losning = { Losning.A: _dommer(M1=Dom.HOLDER_IKKE), Losning.B: _dommer(M1=Dom.BETINGELSER), Losning.C: _dommer(M4=Dom.HOLDER_IKKE), } median = {Losning.A: -1.0, Losning.B: -0.5, Losning.C: 5.0} valg = Trinnvalg(10, Grunnlag.TRINN_25) assert dommer.del_I(per_losning, median, valg) is Dom.HOLDER_IKKE per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE) assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER # C has none of M1 to M5 under conditions: what is missing is the scale, and no # threshold is needed (clarifications 103 g and 109) assert dommer.del_I(per_losning, median, valg, har_terskel={}) is Dom.BETINGELSER # without conditions that can be named within the range of the sources it does not hold per_losning[Losning.C] = _dommer(M2=Dom.BETINGELSER, M6=Dom.HOLDER_IKKE) assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER assert dommer.del_I(per_losning, median, valg, har_terskel={}) is Dom.HOLDER_IKKE uten = {Losning.C: {"M1": True, "M2": False}} assert dommer.del_I(per_losning, median, valg, har_terskel=uten) is Dom.HOLDER_IKKE med = {Losning.C: {"M2": True}} assert dommer.del_I(per_losning, median, valg, har_terskel=med) is Dom.BETINGELSER # a threshold for a solution that is felled does not help feil = {Losning.A: {"M2": True}, Losning.B: {"M1": True}} assert dommer.del_I(per_losning, median, valg, har_terskel=feil) is Dom.HOLDER_IKKE per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE) # the pre-registration says a negative median; a median of exactly zero does not fell median[Losning.B] = 0.0 per_losning[Losning.C] = _dommer(M4=Dom.HOLDER_IKKE) assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER assert dommer.del_I(per_losning, median, Trinnvalg(None, Grunnlag.INGEN)) is Dom.HOLDER_IKKE def test_del_I_ser_ikke_paa_referansekjoringen() -> None: """The reference run R holds on everything here; it cannot give «holder».""" per_losning = { Losning.A: _dommer(M2=Dom.HOLDER_IKKE), Losning.R: _dommer(), } median = {Losning.A: 1.0, Losning.R: 9.0} assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_25)) is Dom.HOLDER_IKKE def test_hvor_mye_av_dommen_som_skyldes_baner_som_ikke_lar_seg_bygge() -> None: """Clarification 69: 2 of 8 draws cannot be built; 3 of the 6 others meet the condition.""" oppfylt = [True, None, False, True, None, False, True, False] assert dommer.ved_siden_av_dommen(oppfylt) == pytest.approx((0.25, 0.5)) assert dommer.ved_siden_av_dommen([None, None]) == (1.0, None) assert dommer.ved_siden_av_dommen([True, True]) == (0.0, 1.0) def test_betingelsene_kan_navngis_naar_hvert_maal_har_en_terskel_som_teller() -> None: """Clarifications 93 and 109: every one of M1 to M5 under conditions; M5 by definition.""" d = _dommer(M1=Dom.BETINGELSER, M3=Dom.BETINGELSER, M5=Dom.BETINGELSER, M6=Dom.BETINGELSER) assert dommer.maal_under_betingelser(d) == ("M1", "M3", "M5") assert dommer.kan_navngis(d, {"M1": True, "M3": True}) assert not dommer.kan_navngis(d, {"M1": True, "M3": False}) assert not dommer.kan_navngis(d, {"M1": True}) # M5 alone is named by definition, and M6 needs no threshold assert dommer.kan_navngis(_dommer(M5=Dom.BETINGELSER), {}) assert dommer.kan_navngis(_dommer(M6=Dom.BETINGELSER), {}) assert dommer.kan_navngis(_dommer(), {}) def test_felt_er_ett_av_M1_til_M5_som_ikke_holder_eller_negativ_median() -> None: assert dommer.er_felt(_dommer(M5=Dom.HOLDER_IKKE), 1.0) assert dommer.er_felt(_dommer(), -1.0) assert not dommer.er_felt(_dommer(M6=Dom.HOLDER_IKKE), 0.0)