One pure function per equation for chapters 1 to 3 of the specification (S1-S21, S36, S43-S47), a strict reader for the frozen parameter file with checksum, validation and unit conversion, and the 10 000 Monte Carlo draws of the 87 drawn quantities, stored in data/ and reproducible bit for bit. Tests: unit tests and edge cases per equation, the reader, the draws, and known answers from Argonne, NOU 2026: 4, Epoch and NVE with the sources' own assumptions. Five comparisons miss the 5 % tolerance and are kept as strict expected failures with the measured deviation. No result for the hypothesis is computed. ruff ALL and mypy strict pass. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
570 lines
21 KiB
Python
570 lines
21 KiB
Python
"""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)
|