"""The addition to the direction (chapter 17): solution T in modules, and S48 to S54. Made-up round numbers only. The hand-computed build-outs follow chapter 17.1 line by line. """ from __future__ import annotations import math from typing import TYPE_CHECKING import pytest from tokenfabrikker import inndata as idt from tokenfabrikker import kontantstrom as ks from tokenfabrikker import ligninger as lg from tokenfabrikker import utbygging as ub from tokenfabrikker.utbygging import Kraft, Losning if TYPE_CHECKING: from collections.abc import Callable from conftest import LagInndata # ------------------------------------------------------------------- S48 and S49 @pytest.mark.parametrize( ("tau_1", "tau_nett", "tau_D", "tidspunkt"), [ (3.0, 10.0, 2.5, 2030.5), # the module itself takes longest: one year plus tau_D (5.0, 10.0, 2.5, 2032.0), # the connection within the grid that exists takes longest (5.0, 4.0, 1.0, 2031.0), # new grid comes before the first-stage connection would ], ) def test_s48_tidligste_tidspunkt( tau_1: float, tau_nett: float, tau_D: float, tidspunkt: float ) -> None: assert lg.s48_tidligste_tidspunkt_trinnvis( T_0=2027.0, tau_1=tau_1, tau_nett=tau_nett, tau_D=tau_D ) == pytest.approx(tidspunkt) def test_s48_saldoen_tar_med_rest_men_aldri_mer_enn_en_modul_trenger() -> None: felles = {"n_1": 100.0, "PUE": 1.2, "P_m": 100.0} assert lg.s48_nettsaldo(saldo_forrige=0.0, brukt_forrige=0.0, **felles) == 100.0 assert lg.s48_nettsaldo(saldo_forrige=200.0, brukt_forrige=120.0, **felles) == 180.0 # 300 would be carried on, but the balance stops at n_1 + PUE P_m = 220 assert lg.s48_nettsaldo(saldo_forrige=200.0, brukt_forrige=0.0, **felles) == 220.0 def test_s49_krever_en_hel_enhet_for_det_som_gjenstaar() -> None: felles = {"lam": 0.75, "PUE": 1.2, "P_m": 100.0, "P_ref": 1000.0} # seven modules left draw 630 MW on average, less than one unit gives (800 MW) assert not lg.s49_kjernekraft_bygges(J=10, J_F=3, KF=0.8, **felles) assert lg.s49_kjernekraft_bygges(J=20, J_F=3, KF=0.8, **felles) assert lg.s49_kjernekraft_bygges(J=13, J_F=3, KF=0.9, **felles) # exactly one unit assert not lg.s49_kjernekraft_bygges(J=10, J_F=10, KF=0.8, **felles) with pytest.raises(ValueError, match="J_F must lie"): lg.s49_kjernekraft_bygges(J=10, J_F=11, KF=0.8, **felles) # ------------------------------------------------------ the build-out in modules def _trinnvis(**endringer: object) -> ub.Trinnvisplan: argumenter: dict[str, object] = { "J": 4, "T_0": 2027, "T_s": 2045, "t_forste": 2030, "t_nett": 2034, "P_m": 100.0, "PUE": 1.2, "n_1": 100.0, "L_H": 20, "L_N": 20, "brikker_per_aar": 1000.0, "kraftrom": ub.kraftrom_ubegrenset, "forste_aar_kraft": lambda _j: 2028, "stopp": (False,) * 18, } argumenter.update(endringer) return ub.utbyggingsplan_trinnvis(**argumenter) # type: ignore[arg-type] def _start(plan: ub.Plan) -> list[int]: return [modul.start for modul in plan.anlegg] def test_forste_trinn_folger_nettsaldoen() -> None: """Hand-computed: 100 MW of draw a year, a module draws 120, the balance stops at 220. 2030: 100, no module. 2031: 200, module 1 (80 left). 2032: 180, module 2 (60 left). 2033: 160, module 3. 2034: new grid can be in place, no limit, module 4. """ plan = _trinnvis() assert _start(plan) == [2031, 2032, 2033, 2034] assert [plan.i_forste_trinn(k) for k in range(4)] == [True, True, True, False] assert plan.gjennomforbar assert (plan.t_N, plan.J_F, plan.kjernekraft_bygges) == (None, None, False) def test_saldoen_samles_ikke_opp_mens_krafta_holder_igjen() -> None: """No power before 2033. The balance is 100, 200, then 220 and 220: one module, not three.""" plan = _trinnvis(kraftrom=lambda t: math.inf if t >= 2033 else 0.0) assert _start(plan) == [2033, 2034, 2034, 2034] def test_flere_moduler_kan_starte_samme_aar() -> None: """250 MW a year: 2030 has room for two modules (240), 2031 has 10 + 250 = 260, two more.""" assert _start(_trinnvis(n_1=250.0)) == [2030, 2030, 2031, 2031] def test_saldoen_vokser_ogsaa_i_et_aar_med_eksportstopp() -> None: """Stop in 2031: balance 100, 200 (nothing starts), 220 (module 1), 200 (module 2).""" stopp = tuple(t == 2031 for t in range(2028, 2046)) assert _start(_trinnvis(stopp=stopp)) == [2032, 2033, 2034, 2034] def test_ingen_modul_starter_for_kraftverkene_kan_betales() -> None: plan = _trinnvis(n_1=1000.0, forste_aar_kraft=lambda j: 2030 if j == 1 else 2032) assert _start(plan) == [2030, 2032, 2032, 2032] def test_brikkene_telles_fra_forste_mulige_aar_for_modulene() -> None: """100 MW of chips a year from 2030 and no other limit: one module a year.""" plan = _trinnvis(n_1=1000.0, brikker_per_aar=100.0) assert _start(plan) == [2030, 2031, 2032, 2033] def test_uten_forste_trinn_starter_modulene_naar_nytt_nett_kan_komme() -> None: assert _start(_trinnvis(t_forste=2034)) == [2034, 2034, 2034, 2034] def _fase(t_N: int, *, per_aar: float = math.inf, bygges: bool = True) -> ub.Kjernekraftfase: return ub.Kjernekraftfase( t_N=t_N, rom=lambda t: per_aar * (t - t_N + 1), bygges=lambda _J_F: bygges ) def test_tk_bygger_kjernekraftmoduler_i_reaktorenes_takt() -> None: """Power for two renewable modules only; from 2035 the reactors have room for two a year.""" plan = _trinnvis( J=6, n_1=1000.0, t_nett=2031, kraftrom=lambda _t: 2.0, kjernekraft=_fase(2035, per_aar=2.0) ) assert _start(plan) == [2030, 2030, 2035, 2035, 2036, 2036] assert (plan.t_N, plan.J_F, plan.kjernekraft_bygges) == (2035, 2, True) assert [plan.er_kjernekraftmodul(k) for k in range(6)] == [False, False, True, True, True, True] uten_kjernekraft = _trinnvis(J=6, n_1=1000.0, t_nett=2031, kraftrom=lambda _t: 2.0) assert _start(uten_kjernekraft) == [2030, 2030] assert not uten_kjernekraft.gjennomforbar def test_tk_kjernekraftmodulene_bruker_bare_brikker_levert_fra_t_N() -> None: """Hand-computed: 100 MW of chips a year, vintages of three years, one renewable module. 2030: module 1 (stock 0). 2031 and 2032: the stock grows to 200. 2033 = t_N: the 200 become the old stock; module 1's vintage is replaced from it (100 left) and the year's delivery starts module 2. Had the old stock been open to nuclear modules, modules 2 and 3 would both have started in 2033. 2034: module 3. 2035: module 4. 2036: modules 1 and 2 expired the same year; module 1 takes the last of the old stock, module 2 the delivery. 2037: module 3. 2038: module 4. 2039: module 1 takes the delivery (no old stock left), module 2 waits. 2040: module 2 before module 3, which waits. """ plan = _trinnvis( T_s=2040, stopp=(False,) * 13, t_nett=2030, L_H=3, brikker_per_aar=100.0, kraftrom=lambda _t: 1.0, kjernekraft=_fase(2033), ) assert [m.aarganger for m in plan.anlegg] == [ (2030, 2033, 2036, 2039), (2033, 2036, 2040), (2034, 2037), (2035, 2038), ] assert plan.J_F == 1 def test_tk_en_utskifting_som_maa_vente_holder_ikke_de_neste_i_koen_tilbake() -> None: """Hand-computed: the old stock is 400 at t_N = 2035, deliveries 100 a year, vintages 3 years. Module 1 (renewable) starts in 2034, modules 2 to 4 (nuclear) in 2035, 2036 and 2037. Replacements: 2037 module 1 (old stock 300), 2038 module 2, 2039 module 3, 2040 module 1 (old stock 200) and module 4. Export stop in 2041 and 2042. In 2043 four vintages wait, in this order: module 2, 3, 1, 4. Module 2 takes the delivery. Module 3 has no chips it may use and waits. Module 1, behind it in the queue, is replaced from the old stock. Module 4 waits. 2044: module 3. """ plan = _trinnvis( T_s=2044, stopp=tuple(t in {2041, 2042} for t in range(2028, 2045)), t_nett=2030, L_H=3, brikker_per_aar=100.0, kraftrom=lambda t: 1.0 if t >= 2034 else 0.0, kjernekraft=_fase(2035), ) assert [m.aarganger for m in plan.anlegg] == [ (2034, 2037, 2040, 2043), (2035, 2038, 2043), (2036, 2039, 2044), (2037, 2040), ] def test_tk_er_tf_naar_s49_ikke_er_oppfylt() -> None: felles: dict[str, object] = {"J": 6, "L_H": 3, "brikker_per_aar": 100.0} tf = _trinnvis(**felles) tk = _trinnvis(**felles, kjernekraft=_fase(2036, bygges=False)) assert tk.anlegg == tf.anlegg assert (tk.J_F, tk.kjernekraft_bygges) == (4, False) assert not any(tk.er_kjernekraftmodul(k) for k in range(len(tk.anlegg))) def test_kjernekraft_for_nytt_nett_har_ingen_regel() -> None: with pytest.raises(ValueError, match="no rule for that"): _trinnvis(kjernekraft=_fase(2033)) def test_trinnvis_krever_ett_stoppflagg_per_aar() -> None: with pytest.raises(ValueError, match="one export flag per year"): _trinnvis(stopp=(False,) * 3) # --------------------------------------------------------- the timeline, S50 def test_s50_summerer_per_krafttype() -> None: felles: dict[str, object] = { "P": [100.0, 100.0, 1000.0], "har_aargang": [True, False, True], "kraft": ["ny", "ny", "kjerne"], } assert lg.s50_regnekraft_i_drift(**felles, x="ny") == 100.0 # type: ignore[arg-type] assert lg.s50_regnekraft_i_drift(**felles, x="kjerne") == 1000.0 # type: ignore[arg-type] assert lg.s50_regnekraft_i_drift(**felles, x="annet") == 0.0 # type: ignore[arg-type] with pytest.raises(ValueError, match="one size, one flag and one type"): lg.s50_regnekraft_i_drift(P=[1.0], har_aargang=[], kraft=[], x="ny") def test_tidslinjen_skiller_fornybar_kraft_og_kjernekraft_i_tk() -> None: plan = _trinnvis( J=6, n_1=1000.0, t_nett=2031, kraftrom=lambda _t: 2.0, kjernekraft=_fase(2035, per_aar=2.0) ) linje = ub.tidslinje(Losning.T_K, plan, P_IT=1000.0) aar = range(2028, 2046) fornybar = dict(zip(aar, linje[Kraft.NY_FORNYBAR], strict=True)) kjernekraft = dict(zip(aar, linje[Kraft.KJERNEKRAFT_PAA_NETTET], strict=True)) assert (fornybar[2029], fornybar[2030], fornybar[2045]) == (0.0, 200.0, 200.0) assert (kjernekraft[2034], kjernekraft[2035], kjernekraft[2036]) == (0.0, 200.0, 400.0) assert not any(linje[Kraft.EGET_KJERNEKRAFTVERK]) assert not any(linje[Kraft.KJOP_FRA_NETTET]) def test_tidslinjen_teller_ikke_en_modul_uten_brikker() -> None: """One module, vintages of three years, and no chips after the first: 100 MW in 2030 to 2032.""" plan = _trinnvis( J=1, n_1=1000.0, L_H=3, stopp=tuple(t > 2030 for t in range(2028, 2046)), t_nett=2030 ) linje = ub.tidslinje(Losning.T_F, plan, P_IT=1000.0)[Kraft.NY_FORNYBAR] assert linje == (0.0, 0.0, 100.0, 100.0, 100.0) + (0.0,) * 13 @pytest.mark.parametrize( ("losning", "kraft"), [ (Losning.A, Kraft.EGET_KJERNEKRAFTVERK), (Losning.B, Kraft.KJERNEKRAFT_PAA_NETTET), (Losning.B_MERKET, Kraft.KJERNEKRAFT_PAA_NETTET), (Losning.C, Kraft.NY_FORNYBAR), (Losning.R, Kraft.KJOP_FRA_NETTET), ], ) def test_tidslinjen_for_losningene_med_hele_anlegg(losning: Losning, kraft: Kraft) -> None: plan = ub.utbyggingsplan( N_anlegg=2, T_0=2027, T_s=2032, t_min=2030, P_IT=1000.0, L_H=5, L_N=20, brikker_per_aar=1000.0, kraftrom=ub.kraftrom_ubegrenset, stopp=(False,) * 5, ) linje = ub.tidslinje(losning, plan, P_IT=1000.0) assert linje[kraft] == (0.0, 0.0, 1000.0, 2000.0, 2000.0) assert all(not any(verdier) for x, verdier in linje.items() if x is not kraft) def test_krafttype_i_t_krever_en_trinnvisplan(oppdiktet: LagInndata) -> None: inn = oppdiktet() plan = ks.lag_plan(inn, Losning.C, ks.dimensjoner(inn, Losning.C), N_anlegg=1) with pytest.raises(TypeError, match="utbyggingsplan_trinnvis"): ub.krafttype(Losning.T_F, plan, 0) # ------------------------------------------- the plan from a set of values def _lag(inn: idt.Inndata, losning: Losning, N_anlegg: int, **brytere: bool) -> ub.Trinnvisplan: plan = ks.lag_plan(inn, losning, ks.dimensjoner(inn, losning), N_anlegg=N_anlegg, **brytere) assert isinstance(plan, ub.Trinnvisplan) return plan def test_dimensjoneringen_i_t_er_per_modul(oppdiktet: LagInndata) -> None: inn = oppdiktet() tf, tk = ks.dimensjoner(inn, Losning.T_F), ks.dimensjoner(inn, Losning.T_K) assert tf.E_D == pytest.approx(8760 * 0.75 * 1.2 * 100.0) assert (tf.P_u, tf.P_G_N) == (0.0, 0.0) assert tk.P_u == 1000.0 assert tk.P_G_N == pytest.approx(0.75 * 1.2 * 100.0 / 0.8) assert ks.antall_moduler(inn, 3) == 30 with pytest.raises(ValueError, match="whole number of modules"): ks.antall_moduler(oppdiktet(P_m=300.0), 1) def test_tf_fra_det_oppdiktede_tallsettet(oppdiktet: LagInndata) -> None: """Hand-computed: new grid in 2033, first module in 2030 (S48: one year plus tau_D = 2). 150 MW of draw a year, a module draws 120: 2030 one module (30 left), 2031 180, one module, 2032 210, one module. From 2033 no limit: chips and power have room for the seven that remain. """ plan = _lag(oppdiktet(tau_nett=6.0), Losning.T_F, 1) assert (plan.t_forste, plan.t_nett, plan.P_m, plan.N_anlegg) == (2030, 2033, 100.0, 10) assert _start(plan) == [2030, 2031, 2032] + [2033] * 7 uten = _lag(oppdiktet(tau_nett=6.0), Losning.T_F, 1, uten_forste_trinn=True) assert _start(uten) == [2033] * 10 def test_forste_aar_kraft_folger_byggetidene_i_portefoljen(oppdiktet: LagInndata) -> None: """Modules 1 and 2 get hydropower (paid the year before start), 3 to 5 wind (two years). Module 6 is the first that needs offshore wind, with three years of construction. """ inn = oppdiktet() forste = ks.forste_aar_kraft(inn, ks.dimensjoner(inn, Losning.T_F)) assert [forste(j) for j in (1, 2, 3, 5, 6)] == [2029, 2029, 2030, 2030, 2031] def test_tk_fra_det_oppdiktede_tallsettet(oppdiktet: LagInndata) -> None: """Hand-computed, with renewable power for three modules before nuclear power in 2035. 0.5 TWh a year of new renewable power has room for 1 module in 2030, 2 in 2031 and 3 in 2033. S49 for two facilities: 17 modules left draw 1 530 MW on average, more than the 800 MW one unit gives, so nuclear power is built. 1 000 MW of chips a year from 2035: ten modules in 2035 and seven in 2036; the replacements in the renewable modules take from the old stock. For one facility 7 modules are left, 630 MW: no nuclear power. """ inn = oppdiktet(tau_nett=6.0, g_fornybar=0.5e6) plan = _lag(inn, Losning.T_K, 2) assert (plan.t_N, plan.J_F, plan.kjernekraft_bygges) == (2035, 3, True) assert _start(plan) == [2030, 2031, 2033] + [2035] * 10 + [2036] * 7 assert plan.anlegg[0].aarganger[:2] == (2030, 2035) assert plan.gjennomforbar ett_anlegg = _lag(inn, Losning.T_K, 1) assert (ett_anlegg.J_F, ett_anlegg.kjernekraft_bygges) == (3, False) assert ett_anlegg.anlegg == _lag(inn, Losning.T_F, 1).anlegg uten_vilkaaret = _lag(inn, Losning.T_K, 1, uten_s49=True) assert uten_vilkaaret.kjernekraft_bygges assert _start(uten_vilkaaret) == [2030, 2031, 2033] + [2035] * 7 def test_bryterne_for_t_gjelder_bare_t(oppdiktet: LagInndata) -> None: inn = oppdiktet() dim = ks.dimensjoner(inn, Losning.C) with pytest.raises(ValueError, match="only apply to solution T"): ks.lag_plan(inn, Losning.C, dim, N_anlegg=1, uten_s49=True) with pytest.raises(ValueError, match="not defined for T"): ks.lag_plan( inn, Losning.T_F, ks.dimensjoner(inn, Losning.T_F), N_anlegg=1, brikker_fra_T0=True ) # ----------------------------------------- AI use on the users' own machines, S51 and S52 @pytest.mark.parametrize( ("t_v", "d"), [(2020, 0.0), (2025, 0.0), (2028, 0.06), (2030, 0.1), (2033, 0.16), (2035, 0.2), (2060, 0.2)], ) def test_bortfallet_er_lineaert_mellom_tre_punkter_og_fast_etterpaa(t_v: int, d: float) -> None: assert lg.s51_bortfall(t_v=t_v, d_30=0.1, d_35=0.2) == pytest.approx(d) def test_bortfallet_er_en_andel() -> None: with pytest.raises(ValueError, match="d_35 is a share"): lg.s51_bortfall(t_v=2030, d_30=0.1, d_35=1.2) def test_s51_uten_bortfall_er_hovedforlopet() -> None: assert lg.s51_etterspoerselsfaktor(eps_d=1.0, d=0.0) == 1.0 assert lg.s51_etterspoerselsfaktor(eps_d=2.0, d=0.0) == 1.0 def test_s51_faktoren() -> None: assert lg.s51_etterspoerselsfaktor(eps_d=1.0, d=0.21) == pytest.approx(0.79) assert lg.s51_etterspoerselsfaktor(eps_d=0.5, d=0.64) == pytest.approx(0.68) assert lg.s51_etterspoerselsfaktor(eps_d=2.0, d=0.64) == 0.0 # never below zero with pytest.raises(ValueError, match="share between 0 and 1"): lg.s51_etterspoerselsfaktor(eps_d=1.0, d=1.5) with pytest.raises(ValueError, match="cannot be negative"): lg.s51_etterspoerselsfaktor(eps_d=-1.0, d=0.5) def test_bortfallet_i_scenarioet_med_egne_maskiner() -> None: assert lg.s51_bortfall_egne_maskiner(s_flytt=0.8, s_trening=0.5) == pytest.approx(0.4) assert lg.s51_bortfall_egne_maskiner(s_flytt=0.8, s_trening=1.0) == 0.0 def test_s52_terskelen_er_pristerskelen_uttrykt_som_bortfall() -> None: assert lg.s52_bortfallsterskel(k_a=0.7, eps_d=1.0) == pytest.approx(0.3) assert lg.s52_bortfallsterskel(k_a=0.7, eps_d=2.0) == pytest.approx(0.15) assert lg.s52_bortfallsterskel(k_a=0.3, eps_d=0.5) == 1.0 # never above one assert lg.s52_bortfallsterskel(k_a=1.0, eps_d=1.0) == 0.0 # tolerates no loss assert lg.s52_bortfallsterskel(k_a=1.4, eps_d=1.0) == 0.0 assert lg.s52_bortfallsterskel(k_a=None, eps_d=1.0) is None with pytest.raises(ValueError, match="must be positive"): lg.s52_bortfallsterskel(k_a=0.7, eps_d=0.0) @pytest.mark.parametrize("eps_d", [0.5, 1.0, 2.0]) def test_s52_gir_samme_faktor_som_pristerskelen(eps_d: float) -> None: """A loss of d* for every vintage is the same as multiplying the price by k_a (17.3).""" k_a = 0.6 d = lg.s52_bortfallsterskel(k_a=k_a, eps_d=eps_d) assert d is not None assert lg.s51_etterspoerselsfaktor(eps_d=eps_d, d=d) == pytest.approx(k_a) # ------------------------------------------- emissions with deduction and water def test_s53_unngaatte_utslipp_for_ett_anlegg() -> None: """1 000 MW IT at load 0.7 and PUE 1.14 uses 6 990 480 MWh; at 0.34 tonnes per MWh.""" felles = {"u_alt": 0.34, "Gamma": 1.0, "lam": 0.7, "PUE_v": 1.14, "P": 1000.0} assert lg.s53_unngaatt_utslipp(mu=1.0, mu_d=1.0, **felles) == pytest.approx(2_376_763.2) # only compute that is sold and delivered replaces compute elsewhere assert lg.s53_unngaatt_utslipp(mu=0.9, mu_d=0.5, **felles) == pytest.approx(0.45 * 2_376_763.2) assert lg.s53_unngaatt_utslipp(mu=1.0, mu_d=1.0, **{**felles, "u_alt": 0.0}) == 0.0 def test_s53_med_fradrag_kan_bli_negativt() -> None: assert lg.s53_utslipp_med_fradrag(U_liv=100.0, U_unngaatt=30.0) == 70.0 assert lg.s53_utslipp_med_fradrag(U_liv=100.0, U_unngaatt=250.0) == -150.0 def test_s54_kjolevann() -> None: E_IT = lg.s54_it_energi(lam=0.7, P=1000.0) assert E_IT == pytest.approx(6_132_000.0) E_N = 8760 * 0.84 * 1000.0 assert lg.s54_kjolevann(w_D=0.085, w_N=145.0, E_IT=E_IT, E_N=E_N) == pytest.approx( 521_220.0 + 1_066_968_000.0 ) # consumption of fresh water with sea-water cooling: only the data centre's assert lg.s54_kjolevann(w_D=0.085, w_N=0.0, E_IT=E_IT, E_N=E_N) == pytest.approx(521_220.0) # ------------------------------------------------------------------ the paths def test_lineaer_bane() -> None: bane = {2030: 10.0, 2040: 30.0, 2050: 0.0} verdier = [lg.lineaer_bane(punkter=bane, t=t) for t in (2020, 2030, 2035, 2040, 2045, 2060)] assert verdier == pytest.approx([10.0, 10.0, 20.0, 30.0, 15.0, 0.0]) assert lg.lineaer_bane(punkter={2024: 0.5}, t=2090) == 0.5 with pytest.raises(ValueError, match="at least one point"): lg.lineaer_bane(punkter={}, t=2030) def test_banene_i_det_oppdiktede_tallsettet(oppdiktet: LagInndata) -> None: inn = oppdiktet() assert inn.u_alt_i("hoved", 2030) == pytest.approx(0.3) assert inn.u_alt_i("hoved", 2090) == pytest.approx(0.1) assert inn.u_alt_i("fast", 2090) == 0.5 assert inn.bortfall_i("hoyt", 2032) == pytest.approx(0.3 + 0.4 * 0.3) assert inn.karbonpris_i(2050) == 1000.0 def test_tabellene_for_bortfall_tolkes_som_i_17_3() -> None: """The table of 17.3, built from tables in the layout of the parameter file.""" bortfall = idt.tolk_bortfall( d_kilde={"2030": 0.119, "2035": 0.21}, s_flytt={"2030": 0.4, "2035": 0.8}, s_trening={"hoy": 0.53, "lav": 0.2}, ) assert bortfall[idt.BORTFALL_KILDE] == (0.119, 0.21) assert bortfall[idt.BORTFALL_EGNE_LAV] == pytest.approx((0.188, 0.376)) assert bortfall[idt.BORTFALL_EGNE_HOY] == pytest.approx((0.32, 0.64)) def test_tabellen_for_u_alt_regnes_om_til_tonn_per_mwh() -> None: baner = idt.tolk_u_alt( { "hoved": {"2024": 400, "2030": 300}, "lav": {"2025": 200, "2030": 100}, "hoy": {"lav": 410, "hoy": 626}, "null": 0, } ) assert baner["hoved"] == pytest.approx({2024: 0.4, 2030: 0.3}) assert baner["lav"] == pytest.approx({2025: 0.2, 2030: 0.1}) assert baner["hoy_nedre"] == pytest.approx({2024: 0.41}) assert baner["hoy_ovre"] == pytest.approx({2024: 0.626}) assert baner["null"] == {2024: 0.0} def test_tabellen_for_kjoletaarn() -> None: taarn = idt.tolk_kjoletaarn({"forbruk": [2.2, 2.5, 3.2], "uttak": [3.0, 4.2, 9.8]}) assert taarn == {"forbruk": (2.2, 2.5, 3.2), "uttak": (3.0, 4.2, 9.8)} def _alle(funksjon: Callable[[int], bool], antall: int) -> list[bool]: return [funksjon(k) for k in range(antall)] def test_modulene_i_forste_trinn_er_de_som_startet_for_nytt_nett(oppdiktet: LagInndata) -> None: plan = _lag(oppdiktet(tau_nett=6.0), Losning.T_F, 1) assert _alle(plan.i_forste_trinn, 10) == [True] * 3 + [False] * 7