"""Unit tests and edge cases for the equations, with made-up round numbers. Nothing here uses the frozen parameters. """ from __future__ import annotations import math from typing import Any import numpy as np import pytest from scipy import integrate, stats from tokenfabrikker import ligninger as lg # ------------------------------------------------------------------- S1 and SFF def test_s1_kjent_verdi() -> None: assert lg.s1_crf(rho=0.06, L=40) == pytest.approx(0.0664615, abs=5e-8) def test_s1_rente_null() -> None: assert lg.s1_crf(rho=0.0, L=25) == 1 / 25 assert lg.s1_crf(rho=1e-12, L=25) == pytest.approx(1 / 25, rel=1e-9) def test_s1_er_annuiteten_som_betaler_tilbake_ett_belop() -> None: rho, levetid = 0.07, 12 naaverdi = sum(lg.s1_crf(rho=rho, L=levetid) / (1 + rho) ** t for t in range(1, levetid + 1)) assert naaverdi == pytest.approx(1.0) def test_s1_levetid_som_ikke_er_heltall() -> None: assert lg.s1_crf(rho=0.05, L=10) > lg.s1_crf(rho=0.05, L=10.5) > lg.s1_crf(rho=0.05, L=11) @pytest.mark.parametrize(("rho", "levetid"), [(0.05, 0.0), (0.05, -3.0), (-1.0, 10.0)]) def test_s1_avviser_ugyldige_verdier(rho: float, levetid: float) -> None: with pytest.raises(ValueError, match="must be"): lg.s1_crf(rho=rho, L=levetid) def test_sff_og_crf_skiller_seg_med_renten() -> None: assert lg.s1_crf(rho=0.06, L=40) - lg.sff(rho=0.06, L=40) == pytest.approx(0.06) assert lg.sff(rho=0.0, L=40) == 1 / 40 def test_sff_avsetningen_vokser_til_belopet() -> None: rho, levetid = 0.04, 30 saldo = sum(lg.sff(rho=rho, L=levetid) * (1 + rho) ** (levetid - t) for t in range(1, 31)) assert saldo == pytest.approx(1.0) # ------------------------------------------------------------------ S2, S3, S46 def test_s2_referansen_er_norges_forste_enhet() -> None: c = lg.s2_investering_per_mw(c_N_ref=1e8, P_u=1000, P_ref=1000, nu=0.8, ell=0.1, n_0=5, n=1) assert c == pytest.approx(1e8) def test_s2_en_dobling_gir_laeringsraten() -> None: felles: dict[str, Any] = {"c_N_ref": 1e8, "P_u": 1000.0, "P_ref": 1000.0, "nu": 0.8, "ell": 0.1} forste = lg.s2_investering_per_mw(**felles, n_0=3, n=1) doblet = lg.s2_investering_per_mw(**felles, n_0=3, n=5) # (3 + 5) / (3 + 1) = 2 assert doblet / forste == pytest.approx(0.9) def test_s2_negativ_laering_gjor_senere_enheter_dyrere() -> None: felles: dict[str, Any] = { "c_N_ref": 1e8, "P_u": 1000.0, "P_ref": 1000.0, "nu": 1.0, "ell": -0.07, } assert lg.s2_investering_per_mw(**felles, n_0=1, n=3) / 1e8 == pytest.approx(1.07) def test_s2_smaa_enheter_koster_mer_per_mw() -> None: felles: dict[str, Any] = {"c_N_ref": 1e8, "P_ref": 1000.0, "ell": 0.0, "n_0": 0, "n": 1} assert lg.s2_investering_per_mw(**felles, P_u=100, nu=0.84) == pytest.approx(1e8 * 10**0.16) assert lg.s2_investering_per_mw(**felles, P_u=100, nu=1.0) == pytest.approx(1e8) def test_s2_avviser_enhet_null_og_laering_en() -> None: felles: dict[str, Any] = {"c_N_ref": 1e8, "P_u": 1000.0, "P_ref": 1000.0, "nu": 1.0, "n_0": 0} with pytest.raises(ValueError, match="starts at 1"): lg.s2_investering_per_mw(**felles, ell=0.1, n=0) with pytest.raises(ValueError, match="below 1"): lg.s2_investering_per_mw(**felles, ell=1.0, n=1) def test_s3_faktoren_er_integralet_av_jevn_utbetaling() -> None: rho, tau = 0.07, 9.5 integral, _ = integrate.quad(lambda s: (1 + rho) ** s / tau, 0, tau) assert lg.s3_byggetidsfaktor(rho=rho, tau=tau) == pytest.approx(integral) def test_s3_grensetilfeller() -> None: assert lg.s3_byggetidsfaktor(rho=0.0, tau=10) == 1.0 assert lg.s3_byggetidsfaktor(rho=0.07, tau=0.0) == 1.0 assert lg.s3_byggetidsfaktor(rho=0.07, tau=1e-9) == pytest.approx(1.0) with pytest.raises(ValueError, match="negative"): lg.s3_byggetidsfaktor(rho=0.07, tau=-1.0) def test_s3_investering() -> None: faktor = lg.s3_byggetidsfaktor(rho=0.06, tau=10) verdi = lg.s3_investering_med_renter(xi_N=1.5, c_N=1e8, P_u=1000, rho=0.06, tau_N=10) assert verdi == pytest.approx(1.5 * 1e11 * faktor) def test_s46_lesningen_trekkes() -> None: assert lg.s46_overskridelsesfaktor(u_xi=0.2, w_xi=0.5, o_xi=0.6) == 1.6 assert lg.s46_overskridelsesfaktor(u_xi=0.7, w_xi=0.5, o_xi=0.6) == 1.0 assert lg.s46_overskridelsesfaktor(u_xi=0.5, w_xi=0.5, o_xi=0.6) == 1.0 assert lg.s46_overskridelsesfaktor(u_xi=0.0, w_xi=0.0, o_xi=0.6) == 1.0 # ------------------------------------------------------------------- S4, S5, S6 def test_s4_kapasitetsfaktoren_avkortes() -> None: assert lg.s4_kapasitetsfaktor(KF=0.95, o_p=0.05, o_f=0.02) == pytest.approx(0.95 * 0.98) assert lg.s4_kapasitetsfaktor(KF=0.80, o_p=0.05, o_f=0.02) == 0.80 def test_s4_energi_og_smaa_enheter() -> None: assert lg.s4_energi_kjernekraft(KF=0.9, N_u=2, P_u=1000) == pytest.approx(15_768_000) assert lg.s4_kapasitetsfaktor_smaa_enheter(KF=0.9, o_f_A=0.05, o_f=0.02) == pytest.approx( 0.9 * 0.95 / 0.98 ) def test_s5_regnet_for_haand() -> None: # One 1 000 MW unit: 1e11 kr with interest, 7 %, 40 years, 8 000 hours. crf, sff = lg.s1_crf(rho=0.07, L=40), lg.sff(rho=0.07, L=40) ventet = (1e11 * crf + 1.8e6 * 1000 + 8e6 * 1000 * sff) / 8e6 + 50 + 70 + 60 + 2 verdi = lg.s5_lcoe_kjernekraft( I_N=[1e11], rho=0.07, L_N=40, f_N_enhet=1.8e6, D_avv=8e6, P_u=1000, E_N=8e6, v_N=50, u_N=70, d_N=60, q_N=2, ) assert verdi == pytest.approx(ventet) def test_s5_fast_drift_skalerer_med_enhetsstorrelse() -> None: assert lg.s5_fast_drift(f_N=2e6, P_u=1000, P_ref=1000, nu_f=-0.28) == pytest.approx(2e6) assert lg.s5_fast_drift(f_N=2e6, P_u=100, P_ref=1000, nu_f=-0.28) == pytest.approx( 2e6 * 10**0.28 ) assert lg.s5_fast_drift(f_N=2e6, P_u=100, P_ref=1000, nu_f=0.0) == 2e6 def test_s6_bare_det_forsikringen_ikke_dekker() -> None: felles: dict[str, Any] = {"N_u": 2, "phi_U": 1e-5, "P_u": 1000.0, "P_ref": 1000.0, "E": 1.6e7} assert lg.s6_ulykkeskostnad(**felles, K_U=3e12, D_fors=8e9) == pytest.approx( 2 * 1e-5 * (3e12 - 8e9) / 1.6e7 ) assert lg.s6_ulykkeskostnad(**felles, K_U=5e9, D_fors=8e9) == 0.0 def test_s6_skalering_med_enhetsstorrelse() -> None: felles: dict[str, Any] = { "N_u": 25, "phi_U": 1e-5, "P_ref": 1000.0, "E": 8e6, "K_U": 3e12, "D_fors": 8e9, } liten = lg.s6_ulykkeskostnad(**felles, P_u=50) assert liten == pytest.approx(25 * 1e-5 * (3e12 * 0.05 - 8e9) / 8e6) uskalert = lg.s6_ulykkeskostnad(**felles, P_u=50, skaler_med_enhet=False) assert uskalert == pytest.approx(25 * 1e-5 * (3e12 - 8e9) / 8e6) assert lg.s6_ulykkeskostnad_per_hendelse(K_U=3e12, P_u=1600, P_ref=1000) == 3e12 # ------------------------------------------------------------- S7, S8, S44, S36 SETT = (5.0, 10.0, 20.0, 50.0, 100.0, 200.0, 300.0, 400.0, 500.0, 1000.0) def test_s7_storste_enhet_under_grensen() -> None: # limit = 0.1 * 0.8 * 1.2 * 1000 = 96 MW -> 50 MW units; full load 1 200 MW -> 24 units assert lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.1, lam=0.8, PUE=1.2, P_IT=1000) == (50.0, 24) def test_s7_grensen_treffer_en_storrelse_noyaktig() -> None: # limit = 0.1 * 1.0 * 1.0 * 1000 = 100 MW exactly: 100 MW is allowed (P <= limit) assert lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.1, lam=1.0, PUE=1.0, P_IT=1000) == (100.0, 10) def test_s7_ingen_storrelse_er_liten_nok() -> None: # limit = 0.05 * 0.5 * 1.1 * 100 = 2.75 MW: the smallest size is used assert lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.05, lam=0.5, PUE=1.1, P_IT=100) == (5.0, 22) def test_s7_runder_antall_enheter_opp() -> None: _, m = lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.1, lam=0.9, PUE=1.21, P_IT=1000) assert m == math.ceil(1210 / 100) with pytest.raises(ValueError, match="empty"): lg.s7_enhetsstorrelse(P_sett=(), chi=0.1, lam=0.9, PUE=1.2, P_IT=1000) @pytest.mark.parametrize(("m", "r", "o_p"), [(24, 3, 0.05), (10, 0, 0.08), (242, 9, 0.044)]) def test_s8_planlagt_stans_er_minste_tall_som_oppfyller_ulikheten( m: int, r: int, o_p: float ) -> None: n_p = lg.s8_planlagt_ute(m=m, r=r, o_p=o_p) assert n_p >= (m + r + n_p) * o_p assert n_p - 1 < (m + r + n_p - 1) * o_p assert n_p == math.ceil((m + r) * o_p / (1 - o_p) - 1e-12) def test_s8_planlagt_stans_grensetilfeller() -> None: assert lg.s8_planlagt_ute(m=24, r=3, o_p=0.0) == 0 # 7 >= (93 + 7) * 0.07 holds exactly, but 100 * 0.07 is 7.000000000000001 in floating point assert lg.s8_planlagt_ute(m=90, r=3, o_p=0.07) == 7 # 0.01 * 0.7 * 1.0 * 1000 is 6.999999999999999 in floating point; the limit is 7 MW assert ( lg.s7_enhetsstorrelse(P_sett=(5.0, 7.0, 10.0), chi=0.01, lam=0.7, PUE=1.0, P_IT=1000)[0] == 7.0 ) with pytest.raises(ValueError, match="planned outage"): lg.s8_planlagt_ute(m=24, r=3, o_p=1.0) def test_s8_tilgjengelighet_mot_scipy() -> None: m, r, o = 24, 3, 0.04 ventet = stats.binom.sf(m - 1, m + r, 1 - o) assert lg.s8_tilgjengelighet(m=m, r=r, o_merket=o) == pytest.approx(ventet, rel=1e-12) assert lg.s8_tilgjengelighet(m=m, r=0, o_merket=o) == pytest.approx((1 - o) ** m) assert lg.s8_tilgjengelighet(m=m, r=2, o_merket=0.0) == 1.0 @pytest.mark.parametrize("krav", [0.99, 0.995, 0.99995]) def test_s8_reserven_er_den_minste_som_naar_kravet(krav: float) -> None: m, o = 24, 0.04 r = lg.s8_reserveenheter(m=m, o_merket=o, A_krav=krav) assert lg.s8_tilgjengelighet(m=m, r=r, o_merket=o) >= krav assert r == 0 or lg.s8_tilgjengelighet(m=m, r=r - 1, o_merket=o) < krav def test_s8_reserven_grensetilfeller() -> None: assert lg.s8_reserveenheter(m=24, o_merket=0.0, A_krav=0.99995) == 0 with pytest.raises(ValueError, match="reaches availability"): lg.s8_reserveenheter(m=24, o_merket=1.0, A_krav=0.99, r_maks=50) assert lg.s8_uavhengig_utfallsrate(beta_F=0.1, o_f_A=0.05) == pytest.approx(0.045) assert lg.s8_antall_enheter(m=24, r=3, n_p=2) == 29 def test_s8_mange_smaa_enheter_gir_ikke_overflyt() -> None: verdi = lg.s8_tilgjengelighet(m=1200, r=60, o_merket=0.04) assert verdi == pytest.approx(stats.binom.sf(1199, 1260, 0.96), rel=1e-9) def test_s44_uten_reserve_og_uten_felles_utfall() -> None: assert lg.s44_inntektsfaktor(m=24, r=0, o_f_A=0.05, beta_F=0.0) == pytest.approx(0.95) def test_s44_mot_scipy_og_egenskaper() -> None: m, r, o_f, beta = 24, 3, 0.05, 0.2 o_merket = (1 - beta) * o_f x = np.arange(m + r + 1) forventet = float(np.sum(np.minimum(x, m) * stats.binom.pmf(x, m + r, 1 - o_merket))) gamma = lg.s44_inntektsfaktor(m=m, r=r, o_f_A=o_f, beta_F=beta) assert gamma == pytest.approx((1 - beta * o_f) * forventet / m, rel=1e-12) assert gamma <= 1 - beta * o_f assert gamma > lg.s44_inntektsfaktor(m=m, r=0, o_f_A=o_f, beta_F=beta) assert lg.s44_inntektsfaktor(m=m, r=r, o_f_A=0.0, beta_F=beta) == 1.0 def test_s44_alle_utfall_felles() -> None: assert lg.s44_inntektsfaktor(m=24, r=0, o_f_A=0.05, beta_F=1.0) == pytest.approx(0.95) def test_s36_buffer_og_ekstern_forsyning() -> None: assert lg.s36_buffer(delta_L=0.5, PUE=1.2, P_IT=1000) == pytest.approx(600) crf_nett, crf_buf = lg.s1_crf(rho=0.08, L=40), lg.s1_crf(rho=0.08, L=20) verdi = lg.s36_ekstern_forsyning( D_linje=50, c_linje=13e6, s_g=0.03, N_u=29, P_u=50, c_gen=1e7, rho_A=0.08, L_nett=40, L_buf=20, ) assert verdi == pytest.approx(2 * 50 * 13e6 * crf_nett + 0.03 * 29 * 50 * 1e7 * crf_buf) # ----------------------------------------------------------------- S9, S10, S11 def test_s10_energi() -> None: assert lg.s10_energi_datasenter(lam=0.7, PUE=1.2, P_IT=1000) == pytest.approx(7_358_400) def test_s9_er_s5_naar_alt_selges_og_ingenting_legges_til() -> None: enheter = [1e11, 0.9e11] felles: dict[str, Any] = { "L_N": 60.0, "f_N_enhet": 1.8e6, "D_avv": 8e6, "P_u": 1000.0, "d_N": 60.0, "q_N": 1.0, } s5 = lg.s5_lcoe_kjernekraft(I_N=enheter, rho=0.075, E_N=1.5e7, v_N=50, u_N=70, **felles) s9 = lg.s9_kraftkostnad_dedikert( I_N=enheter, rho_A=0.075, E_D=1.5e7, v_N=50, u_N_A=70, P_buf=0.0, c_buf=1e7, f_buf=4e5, L_buf=20, I_g_aar=0.0, **felles, ) assert s9 == pytest.approx(s5) def test_s9_buffer_og_ubrukt_kraft_gjor_det_dyrere() -> None: felles: dict[str, Any] = { "I_N": [5e9] * 29, "rho_A": 0.075, "L_N": 60.0, "f_N_enhet": 3e6, "D_avv": 8e6, "P_u": 50.0, "c_buf": 1e7, "f_buf": 4e5, "L_buf": 20.0, "v_N": 50.0, "u_N_A": 150.0, "d_N": 60.0, "q_N": 0.0, } uten = lg.s9_kraftkostnad_dedikert(P_buf=0, I_g_aar=0, E_D=7.4e6, **felles) med = lg.s9_kraftkostnad_dedikert(P_buf=600, I_g_aar=0, E_D=7.4e6, **felles) crf_buf = lg.s1_crf(rho=0.075, L=20) assert med - uten == pytest.approx(600 * (1e7 * crf_buf + 4e5) / 7.4e6) mindre_bruk = lg.s9_kraftkostnad_dedikert(P_buf=0, I_g_aar=0, E_D=3.7e6, **felles) assert mindre_bruk - 260 == pytest.approx(2 * (uten - 260)) def test_s11_referansekjoringen_har_ingen_kraftverk() -> None: verdi = lg.s11_kraftkostnad_nett( p_z=600, n_tap=0.05, portefolje=[], E_G=0.0, E_D=7e6, H_a=7e7, F_a=1.4e7 ) assert verdi == pytest.approx(1.05 * 600 + 8.4e7 / 7e6) def test_s11_kraftverk_som_akkurat_dekker_kostnaden_endrer_ingenting() -> None: ledd = lg.Portefoljeledd(x=1.0, LCOE=630.0, psi=1.05, regelen_binder=False) med = lg.s11_kraftkostnad_nett( p_z=600, n_tap=0.0, portefolje=[ledd], E_G=8e6, E_D=7e6, H_a=0.0, F_a=0.0 ) assert med == pytest.approx(600) def test_s11_portefolje_med_to_teknologier() -> None: """Hydro earns more than it costs, so S45 binds and its term is zero; wind stands as it is.""" vann = lg.Portefoljeledd(x=0.25, LCOE=500.0, psi=1.26, regelen_binder=True) vind = lg.Portefoljeledd(x=0.75, LCOE=450.0, psi=0.88, regelen_binder=False) assert vann.nettoledd(600) == 0.0 assert vind.nettoledd(600) == pytest.approx(450 - 0.88 * 600) verdi = lg.s11_kraftkostnad_nett( p_z=600, n_tap=0.1, portefolje=[vann, vind], E_G=8e6, E_D=7e6, H_a=7e7, F_a=0.0 ) assert verdi == pytest.approx(660 + 0.75 * (450 - 0.88 * 600) * 8 / 7 + 10) def test_s11_uten_tilleggsregelen_krediteres_overskuddet() -> None: """The sensitivity without S45: a profitable plant lowers the data centre's power cost.""" vann = lg.Portefoljeledd(x=1.0, LCOE=500.0, psi=1.26, regelen_binder=False) verdi = lg.s11_kraftkostnad_nett( p_z=600, n_tap=0.0, portefolje=[vann], E_G=7e6, E_D=7e6, H_a=0.0, F_a=0.0 ) assert verdi == pytest.approx(600 + 500 - 1.26 * 600) def test_s11_nettkostnad() -> None: crf = lg.s1_crf(rho=0.065, L=40) verdi = lg.s11_nettkostnad( I_nett=5e6, delta_V=0.4, PUE=1.2, P_IT=1000, P_G_N=1000, rho_N=0.065, L_nett=40 ) assert verdi == pytest.approx(5e6 * (0.6 * 1200 + 1000) * crf) def test_lcoe_fornybar() -> None: crf = lg.s1_crf(rho=0.06, L=30) faktor = lg.s3_byggetidsfaktor(rho=0.06, tau=2) felles: dict[str, Any] = { "investering": 1.4e7, "fullasttimer": 3400.0, "levetid": 30.0, "byggetid": 2.0, } per_mwh = lg.lcoe_fornybar( **felles, drift_per_mwh=120, drift_per_mw=0, rho=0.06, renter_i_investeringen=False ) assert per_mwh == pytest.approx(1.4e7 * faktor * crf / 3400 + 120) per_mw = lg.lcoe_fornybar( **felles, drift_per_mwh=0, drift_per_mw=9e5, rho=0.06, renter_i_investeringen=True ) assert per_mw == pytest.approx((1.4e7 * crf + 9e5) / 3400) # ------------------------------------------------------------------- S13 to S21 def test_s13_prisendringen_stopper_i_2035() -> None: assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2025) == 3e8 assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2030) == pytest.approx(3e8 * 0.95**5) assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2035) == pytest.approx(3e8 * 0.95**10) assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2080) == pytest.approx(3e8 * 0.95**10) def test_s14_snittlast() -> None: assert lg.s14_snittlast(lam_0=0.2, mu_u=0.8) == pytest.approx(0.84) def test_s15_regnet_for_haand() -> None: verdi = lg.s15_lcoc( c_bygg=1.2e8, d_bygg=0.1, c_H=2.7e8, rho_D=0.075, L_B=14, L_H=5, o_D=1.7e6, d_o_D=0.7e6, lam=0.7, PUE=1.14, c_a=600, ) ventet = ( 1.2e8 * 1.1 * lg.s1_crf(rho=0.075, L=14) + 2.7e8 * lg.s1_crf(rho=0.075, L=5) + 2.4e6 + 8760 * 0.7 * 1.14 * 600 ) assert verdi == pytest.approx(ventet) def test_s19_er_en_identitet() -> None: """M_a = mu Gamma y - LCOC_a equals the four terms of S19 for arbitrary inputs.""" rng = np.random.default_rng(1) for _ in range(200): c_bygg, c_H = rng.uniform(1e8, 2e8), rng.uniform(2e8, 4e8) rho_D, L_B, L_H = rng.uniform(0.03, 0.12), rng.uniform(7, 40), float(rng.integers(3, 8)) lam, PUE, PUE_v = rng.uniform(0.5, 0.9), rng.uniform(1.05, 1.2), rng.uniform(1.09, 1.2) o_D, o_D_v, d_o_D = rng.uniform(1e6, 2e6), rng.uniform(2e6, 4e6), rng.uniform(0, 1.4e6) d_bygg, c_a, p_v = rng.uniform(0, 0.15), rng.uniform(200, 1500), rng.uniform(600, 1200) pi_g, mu, gamma = rng.uniform(-0.45, 2.0), rng.uniform(0.8, 1.0), rng.uniform(0.9, 1.0) felles: dict[str, Any] = { "c_bygg": c_bygg, "c_H": c_H, "rho_D": rho_D, "L_B": L_B, "L_H": L_H, "lam": lam, } lcoc_v = lg.s15_lcoc(**felles, d_bygg=0, o_D=o_D_v, d_o_D=0, PUE=PUE_v, c_a=p_v) lcoc = lg.s15_lcoc(**felles, d_bygg=d_bygg, o_D=o_D, d_o_D=d_o_D, PUE=PUE, c_a=c_a) y = lg.s18_pris(LCOC_v=lcoc_v, pi_g=pi_g) margin = lg.s19_margin( lam=lam, PUE_v=PUE_v, p_v=p_v, PUE=PUE, c_a=c_a, pi_g=pi_g, LCOC_v=lcoc_v, o_D_v=o_D_v, o_D=o_D, d_o_D=d_o_D, d_bygg=d_bygg, c_bygg=c_bygg, rho_D=rho_D, L_B=L_B, mu=mu, Gamma=gamma, ) assert margin.sum == pytest.approx(mu * gamma * y - lcoc, rel=1e-9, abs=1e-3) def test_s16_s17_s18() -> None: assert lg.s16_inntekt(mu=0.95, Gamma=0.98, y=1e8, P_IT=1000) == pytest.approx(9.31e10) assert lg.s17_kontraktspris_fra_spot(y_spot=[1e8] * 5, rho_D=0.075) == pytest.approx(1e8) fallende = lg.s17_kontraktspris_fra_spot(y_spot=[1e8, 8e7, 6e7], rho_D=0.075) assert 6e7 < fallende < 1e8 assert lg.s18_pris(LCOC_v=8e7, pi_g=0.25) == pytest.approx(1e8) def test_s43_paaslaget_blir_ikke_negativt() -> None: assert lg.s43_knapphetspaaslag(y_obs=1.6e8, LCOC_v_2025=8e7) == pytest.approx(1.0) assert lg.s43_knapphetspaaslag(y_obs=7e7, LCOC_v_2025=8e7) == 0.0 def test_s20_s21_kontrollen_i_kapittel_3_3() -> None: """9 mill. USD per MW and year, theta 4.03 and mu_u 0.8 give 0.089 USD per million tokens.""" assert lg.s21_kostnad_per_token(LCOC=9e6, theta=4.03, mu_u=0.8) == pytest.approx( 0.089, abs=5e-4 ) inntekt = lg.s20_tokeninntekt(sigma=1.0, p_tok=0.0885, theta=4.03, mu_u=0.8, P_IT=1.0) assert inntekt == pytest.approx(9e6, rel=0.005) # --------------------------------------------------------------------- S45, S47 def test_s45_ingen_kreditt_for_overskudd() -> None: assert lg.s45_tilleggsfaktor(naaverdi_kostnader=80, naaverdi_salgsinntekter=100) == 0.8 assert lg.s45_tilleggsfaktor(naaverdi_kostnader=120, naaverdi_salgsinntekter=100) == 1.0 assert lg.s45_tilleggsfaktor(naaverdi_kostnader=120, naaverdi_salgsinntekter=0) == 1.0 def test_s47_ingen_kostnad_naar_effekten_ikke_mangler() -> None: felles: dict[str, Any] = { "c_fast": 1.4e6, "c_res": 1.2e6, "h_knapp": 100.0, "mu": 1.0, "y": 1e8, "PUE": 1.14, } assert lg.s47_effektkostnad(Delta_R=50, Delta_R_utfall=10, **felles) == 0.0 def test_s47_velger_det_billigste_tiltaket() -> None: felles: dict[str, Any] = {"c_fast": 1.4e6, "c_res": 1.2e6, "mu": 1.0, "y": 1e8, "PUE": 1.14} fast = 1.4e6 * 100 + 1.2e6 * (1100 - 100) per_time = 1e8 / (8760 * 1.14) faa_timer = lg.s47_effektkostnad(Delta_R=-100, Delta_R_utfall=-1100, h_knapp=10, **felles) assert faa_timer == pytest.approx(10 * per_time * 1100) mange_timer = lg.s47_effektkostnad(Delta_R=-100, Delta_R_utfall=-1100, h_knapp=200, **felles) assert mange_timer == pytest.approx(fast) def test_s47_bare_reserve_naar_effekten_holder_uten_utfall() -> None: verdi = lg.s47_effektkostnad( Delta_R=200, Delta_R_utfall=-800, c_fast=1.4e6, c_res=1.2e6, h_knapp=8760, mu=1, y=1e9, PUE=1, ) assert verdi == pytest.approx(1.2e6 * 800)