feat(kode): add the levelised equations, the parameter reader and the draws
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>
This commit is contained in:
parent
736f636691
commit
a63f66c416
14 changed files with 3656 additions and 0 deletions
456
tests/test_fasit.py
Normal file
456
tests/test_fasit.py
Normal file
|
|
@ -0,0 +1,456 @@
|
|||
"""Known answers: the model's own functions, fed with a source's assumptions, against its result.
|
||||
|
||||
None of these tests uses the frozen parameters, and none computes a result for
|
||||
the hypothesis. Each one takes the inputs a published calculation states, runs
|
||||
them through the same functions the model uses, and compares with the number
|
||||
the source reports. The tolerance is 5 %, the one the specification sets for
|
||||
the Argonne test (chapter 1.3).
|
||||
|
||||
A comparison that misses the tolerance is kept as an expected failure with the
|
||||
measured deviation and the cause where it is known. No parameter and no
|
||||
equation is tuned to make a test pass.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import ligninger as lg
|
||||
|
||||
pytestmark = pytest.mark.fasit
|
||||
|
||||
TOLERANSE = 0.05
|
||||
|
||||
|
||||
def _avvik(beregnet: float, fasit: float) -> float:
|
||||
return beregnet / fasit - 1.0
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- Argonne
|
||||
# Stauff et al. (ANL/NSE-25/47, 2025), table 6-1 (curves) and table 6-3 (results);
|
||||
# source entry K12-001. Method: Hanna et al. (Energies 17, 5073, 2024). 2022 USD, 6 %, 40 years.
|
||||
#
|
||||
# What the two sources state, and how it is mapped onto the model's functions:
|
||||
# - overnight cost 18 562 P^-0.16 USD/kW: S2 with c_N_ref at 1 000 MW and nu = 0.84
|
||||
# - learning rate 0.145 P^-0.083, "renormalized to start from the 2nd unit" (Hanna): S2 with
|
||||
# n_0 = 1, so that the first unit on the site costs the between-of-a-kind figure
|
||||
# - construction time 16 P^0.25 months, interest during construction at 6 %: S3
|
||||
# - capacity factor from refuelling only, four weeks every 2 years (5 P^-0.17 years below
|
||||
# 200 MW) (Hanna, section 3)
|
||||
# - number of units without grid: 1 + demand / unit size (ANL p. 51)
|
||||
# - O&M with fuel 181 P^-0.28 USD/MWh, times 0.53/N + 0.47 with N units on the site
|
||||
# The equations of the article are images that could not be read, and the link to its code
|
||||
# was not recoverable, so two points are this project's reading: n_0 = 1, and whether the
|
||||
# O&M of a unit follows its capacity or the energy delivered (both are tested below).
|
||||
|
||||
ARGONNE_MED_NETT = ( # demand MWe, unit MWe, units, USD/MWh (option 1)
|
||||
(50, 50, 1, 147),
|
||||
(100, 50, 2, 129),
|
||||
(500, 500, 1, 97),
|
||||
(1000, 1000, 1, 87),
|
||||
(2000, 1000, 2, 79),
|
||||
(6000, 1000, 6, 72),
|
||||
)
|
||||
ARGONNE_UTEN_NETT = ( # option 4
|
||||
(50, 5, 11, 174),
|
||||
(100, 10, 11, 153),
|
||||
(500, 50, 11, 116),
|
||||
(1000, 50, 21, 103),
|
||||
(2000, 100, 21, 92),
|
||||
(6000, 400, 16, 77),
|
||||
)
|
||||
ARGONNE_RENTE = 0.06
|
||||
ARGONNE_AAR = 40.0
|
||||
GRENSE_BRENSELSBYTTE_MW = 200.0
|
||||
UKER_STANS = 4.0
|
||||
UKER_PER_AAR = 365.25 / 7.0
|
||||
|
||||
|
||||
def _argonne_kapasitetsfaktor(P: float) -> float:
|
||||
intervall: float = 2.0 if P >= GRENSE_BRENSELSBYTTE_MW else 5.0 * P**-0.17
|
||||
return 1.0 - UKER_STANS / UKER_PER_AAR / intervall
|
||||
|
||||
|
||||
def _argonne_drift(P: float, N: int) -> float:
|
||||
return float(181.0 * P**-0.28 * (0.53 / N + 0.47))
|
||||
|
||||
|
||||
def _argonne_enheter(P: float, N: int, n_0: int) -> list[float]:
|
||||
c_ref = 18562.0 * 1000.0**-0.16 * 1e3 # USD per MW at 1 000 MW
|
||||
return [
|
||||
lg.s3_investering_med_renter(
|
||||
xi_N=1.0,
|
||||
c_N=lg.s2_investering_per_mw(
|
||||
c_N_ref=c_ref,
|
||||
P_u=P,
|
||||
P_ref=1000.0,
|
||||
nu=0.84,
|
||||
ell=0.145 * P**-0.083,
|
||||
n_0=n_0,
|
||||
n=n,
|
||||
),
|
||||
P_u=P,
|
||||
rho=ARGONNE_RENTE,
|
||||
tau_N=16.0 * P**0.25 / 12.0,
|
||||
)
|
||||
for n in range(1, N + 1)
|
||||
]
|
||||
|
||||
|
||||
def argonne_med_nett(P: float, N: int, *, n_0: int = 1) -> float:
|
||||
"""Option 1 (through the grid): S5 with the study's curves, USD/MWh."""
|
||||
kf = _argonne_kapasitetsfaktor(P)
|
||||
return lg.s5_lcoe_kjernekraft(
|
||||
I_N=_argonne_enheter(P, N, n_0),
|
||||
rho=ARGONNE_RENTE,
|
||||
L_N=ARGONNE_AAR,
|
||||
f_N_enhet=0.0,
|
||||
D_avv=0.0,
|
||||
P_u=P,
|
||||
E_N=lg.s4_energi_kjernekraft(KF=kf, N_u=N, P_u=P),
|
||||
v_N=_argonne_drift(P, N),
|
||||
u_N=0.0,
|
||||
d_N=0.0,
|
||||
q_N=0.0,
|
||||
)
|
||||
|
||||
|
||||
def argonne_uten_nett(last: float, P: float, N: int, *, n_0: int = 1, drift_fast: bool) -> float:
|
||||
"""Option 4 (no grid): S9 without buffer and external supply, USD/MWh delivered.
|
||||
|
||||
``drift_fast=True`` charges the O&M of every unit as a fixed yearly cost at
|
||||
the unit's own capacity factor; ``False`` charges it per MWh delivered.
|
||||
"""
|
||||
kf = _argonne_kapasitetsfaktor(P)
|
||||
drift = _argonne_drift(P, N)
|
||||
return lg.s9_kraftkostnad_dedikert(
|
||||
I_N=_argonne_enheter(P, N, n_0),
|
||||
rho_A=ARGONNE_RENTE,
|
||||
L_N=ARGONNE_AAR,
|
||||
f_N_enhet=drift * lg.TIMER_PER_AAR * kf if drift_fast else 0.0,
|
||||
D_avv=0.0,
|
||||
P_u=P,
|
||||
P_buf=0.0,
|
||||
c_buf=0.0,
|
||||
f_buf=0.0,
|
||||
L_buf=20.0,
|
||||
I_g_aar=0.0,
|
||||
E_D=lg.s10_energi_datasenter(lam=1.0, PUE=1.0, P_IT=last),
|
||||
v_N=0.0 if drift_fast else drift,
|
||||
u_N_A=0.0,
|
||||
d_N=0.0,
|
||||
q_N=0.0,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("last", "P", "N", "fasit"), ARGONNE_MED_NETT)
|
||||
def test_argonne_med_nett(last: int, P: int, N: int, fasit: int) -> None:
|
||||
"""Table 6-3, option 1: all six rows within 5 % (87 USD/MWh at 1 000 MWe is hit to 0.1 %)."""
|
||||
assert last == N * P
|
||||
assert abs(_avvik(argonne_med_nett(P, N), fasit)) <= TOLERANSE
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("last", "P", "N", "fasit"), ARGONNE_UTEN_NETT)
|
||||
def test_argonne_uten_nett_drift_etter_kapasitet(last: int, P: int, N: int, fasit: int) -> None:
|
||||
"""Table 6-3, option 4, with O&M following installed capacity: all six rows within 5 %."""
|
||||
assert 1 + last // P == N
|
||||
assert abs(_avvik(argonne_uten_nett(last, P, N, drift_fast=True), fasit)) <= TOLERANSE
|
||||
|
||||
|
||||
_FOR_LAVT = "O&M charged per MWh delivered gives a result more than 5 % below the study"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("last", "P", "N", "fasit"),
|
||||
[
|
||||
pytest.param(50, 5, 11, 174, marks=pytest.mark.xfail(strict=True, reason=_FOR_LAVT)),
|
||||
pytest.param(100, 10, 11, 153, marks=pytest.mark.xfail(strict=True, reason=_FOR_LAVT)),
|
||||
pytest.param(500, 50, 11, 116, marks=pytest.mark.xfail(strict=True, reason=_FOR_LAVT)),
|
||||
(1000, 50, 21, 103),
|
||||
(2000, 100, 21, 92),
|
||||
(6000, 400, 16, 77),
|
||||
],
|
||||
)
|
||||
def test_argonne_uten_nett_drift_etter_energi(last: int, P: int, N: int, fasit: int) -> None:
|
||||
"""Table 6-3, option 4, with O&M per MWh delivered: three of six rows miss by 6 to 7 %."""
|
||||
assert abs(_avvik(argonne_uten_nett(last, P, N, drift_fast=False), fasit)) <= TOLERANSE
|
||||
|
||||
|
||||
def test_argonne_uten_laering_fra_andre_enhet_feiler() -> None:
|
||||
"""With n_0 = 0 (learning from the first unit) the 103 USD/MWh row is missed by about 10 %."""
|
||||
lavt = argonne_uten_nett(1000, 50, 21, n_0=0, drift_fast=False)
|
||||
assert _avvik(lavt, 103) < -TOLERANSE
|
||||
|
||||
|
||||
def test_argonne_nett_er_billigere_enn_uten_nett() -> None:
|
||||
"""The study's headline: 87 with grid against 103 without, for 1 000 MWe."""
|
||||
med = argonne_med_nett(1000, 1)
|
||||
uten = argonne_uten_nett(1000, 50, 21, drift_fast=True)
|
||||
assert uten / med == pytest.approx(103 / 87, rel=TOLERANSE)
|
||||
|
||||
|
||||
# ------------------------------------------------------------- NOU 2026: 4, appendix 4
|
||||
# The Nuclear Power Committee's own spreadsheet (digital appendix 4, sheets "Forutsetninger"
|
||||
# and "Kontantstrøm"; source entries K16-011, K16-012, K16-013, K03-021). 1 400 MW, start 2040,
|
||||
# investment spread evenly over 14 years, 80 years of operation, 7 600 full-load hours, 5 %.
|
||||
# The NOU text reports the power price needed for a positive present value: 132 øre/kWh ("Lav")
|
||||
# and 219 øre/kWh ("Høy"). Revenue per MWh in the sheet is price x value factor 1.05, plus 5 %
|
||||
# for heat and 1 % for system services on top of that, plus 10 kr/MWh for guarantees of origin.
|
||||
|
||||
NOU_EFFEKT = 1400.0
|
||||
NOU_TIMER = 7600.0
|
||||
NOU_RENTE = 0.05
|
||||
NOU_BYGGEAAR = 14
|
||||
NOU_DRIFTSAAR = 80
|
||||
NOU_VERDIFAKTOR = 1.05
|
||||
NOU_TILLEGG = 0.05 + 0.01
|
||||
NOU_OPPRINNELSE = 10.0 # kr/MWh
|
||||
NOU_SCENARIOER = { # kr/kW, kr/kW per year, kr/MWh (variable, fuel, waste and decommissioning)
|
||||
"Lav": (109_000.0, 1610.0, 115.0, 60.0, 70.0),
|
||||
"Høy": (177_000.0, 2515.0, 187.0, 100.0, 200.0),
|
||||
}
|
||||
|
||||
|
||||
def nou_balansepris_modell(scenario: str) -> float:
|
||||
"""Break-even power price from the model's S3 and S5, øre/kWh."""
|
||||
investering, fast, variabel, brensel, avfall = NOU_SCENARIOER[scenario]
|
||||
enhet = lg.s3_investering_med_renter(
|
||||
xi_N=1.0, c_N=investering * 1e3, P_u=NOU_EFFEKT, rho=NOU_RENTE, tau_N=NOU_BYGGEAAR
|
||||
)
|
||||
lcoe = lg.s5_lcoe_kjernekraft(
|
||||
I_N=[enhet],
|
||||
rho=NOU_RENTE,
|
||||
L_N=NOU_DRIFTSAAR,
|
||||
f_N_enhet=fast * 1e3,
|
||||
D_avv=0.0,
|
||||
P_u=NOU_EFFEKT,
|
||||
E_N=NOU_TIMER * NOU_EFFEKT,
|
||||
v_N=variabel,
|
||||
u_N=brensel,
|
||||
d_N=avfall,
|
||||
q_N=0.0,
|
||||
)
|
||||
return (lcoe - NOU_OPPRINNELSE) / (NOU_VERDIFAKTOR * (1.0 + NOU_TILLEGG)) / 10.0
|
||||
|
||||
|
||||
def nou_regneark_naaverdi(scenario: str, kraftpris: float) -> float:
|
||||
"""The spreadsheet's own present value (cell Kontantstrøm!B32), mill. kr.
|
||||
|
||||
Written out here from the sheet's formulas, independently of the model:
|
||||
yearly amounts from 2026, discounted with Excel's NPV (first year one period).
|
||||
``kraftpris`` in øre/kWh.
|
||||
"""
|
||||
investering, fast, variabel, brensel, avfall = NOU_SCENARIOER[scenario]
|
||||
gwh = NOU_TIMER * NOU_EFFEKT / 1e3
|
||||
salg = kraftpris * NOU_VERDIFAKTOR * gwh / 100.0
|
||||
inntekt = salg * (1.0 + NOU_TILLEGG) + gwh * NOU_OPPRINNELSE / 1e3
|
||||
drift = variabel + fast * 1e3 / NOU_TIMER
|
||||
kostnad = gwh * (brensel + avfall + drift) / 1e3
|
||||
strom = [-investering * NOU_EFFEKT / 1e3 / NOU_BYGGEAAR] * NOU_BYGGEAAR
|
||||
strom += [inntekt - kostnad] * NOU_DRIFTSAAR
|
||||
return sum(belop / (1.0 + NOU_RENTE) ** (aar + 1) for aar, belop in enumerate(strom))
|
||||
|
||||
|
||||
def nou_regneark_balansepris(scenario: str) -> float:
|
||||
"""The price at which the spreadsheet's present value is zero, øre/kWh."""
|
||||
ved_null = nou_regneark_naaverdi(scenario, 0.0)
|
||||
ved_hundre = nou_regneark_naaverdi(scenario, 100.0)
|
||||
return -ved_null / (ved_hundre - ved_null) * 100.0
|
||||
|
||||
|
||||
def test_nou_regnearket_er_gjengitt_riktig() -> None:
|
||||
"""The replica gives the sheet's own number: -84 626.139 mill. kr at 60 øre/kWh ("Lav")."""
|
||||
assert nou_regneark_naaverdi("Lav", 60.0) == pytest.approx(-84626.139055439344, rel=1e-12)
|
||||
|
||||
|
||||
def test_nou_regnearket_gir_132_men_222() -> None:
|
||||
"""The sheet gives 132.2 for "Lav", as the NOU says, but 222.1 for "Høy", not 219.
|
||||
|
||||
The NOU text (p. 381-382) says 219. With all three choices on "Høy" the
|
||||
sheet's formulas give 222.1; the difference of 1.4 % is not explained.
|
||||
"""
|
||||
assert nou_regneark_balansepris("Lav") == pytest.approx(132.2, abs=0.05)
|
||||
assert nou_regneark_balansepris("Høy") == pytest.approx(222.1, abs=0.05)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("scenario", "fasit"), [("Lav", 132.0), ("Høy", 219.0)])
|
||||
def test_nou_balansepris(scenario: str, fasit: float) -> None:
|
||||
"""S3 and S5 with the committee's assumptions: 134.5 and 225.8 against 132 and 219.
|
||||
|
||||
The model is 1.7 % above the sheet because S3 counts interest from the
|
||||
middle of each construction year and the sheet from the end of it.
|
||||
"""
|
||||
assert abs(_avvik(nou_balansepris_modell(scenario), fasit)) <= TOLERANSE
|
||||
assert nou_balansepris_modell(scenario) == pytest.approx(
|
||||
nou_regneark_balansepris(scenario), rel=0.02
|
||||
)
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------- Epoch
|
||||
# Epoch AI (14 May 2026), "Servers account for 60% of the total cost of ownership of a
|
||||
# one-gigawatt AI data center"; source entries K08-K03 and K01-043. USD million per GW IT.
|
||||
# Capital: servers 21 188, network 4 925 (5 years); facility 11 433, land 172, utility works
|
||||
# 164 (14 years). Operation without power: taxes 143, maintenance 120, labour 40, water 6.
|
||||
# Power: 8.34 cents/kWh, PUE 1.14, utilisation 71 %. Total 8 514 per year.
|
||||
# The page does not state the discount rate. It says land is annualised as the opportunity
|
||||
# cost of capital at the same rate, and reports 13 per year on 172: 7.56 %. That is used here.
|
||||
|
||||
|
||||
def test_epoch_aarskostnad() -> None:
|
||||
"""S15 with Epoch's inputs gives 8.76 against 8.51 bn USD per GW and year (+2.8 %).
|
||||
|
||||
The difference lies in the capital recovery factor for servers: Epoch
|
||||
reports 0.24, S1 gives 0.248 at 7.56 % and five years.
|
||||
"""
|
||||
lcoc = lg.s15_lcoc(
|
||||
c_bygg=(11433.0 + 172.0 + 164.0) * 1e3,
|
||||
d_bygg=0.0,
|
||||
c_H=(21188.0 + 4925.0) * 1e3,
|
||||
rho_D=13.0 / 172.0,
|
||||
L_B=14.0,
|
||||
L_H=5.0,
|
||||
o_D=(143.0 + 120.0 + 40.0 + 6.0) * 1e3,
|
||||
d_o_D=0.0,
|
||||
lam=0.71,
|
||||
PUE=1.14,
|
||||
c_a=83.4,
|
||||
)
|
||||
assert abs(_avvik(lcoc, 8514.0 * 1e3)) <= TOLERANSE
|
||||
assert lcoc / 1e6 == pytest.approx(8.756, abs=0.001)
|
||||
|
||||
|
||||
def test_epoch_kraftandel() -> None:
|
||||
"""Power is about 7 % of the yearly cost, as the specification says under S19."""
|
||||
kraft = lg.TIMER_PER_AAR * 0.71 * 1.14 * 83.4
|
||||
assert kraft / 8514e3 == pytest.approx(0.07, abs=0.005)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------- NVE
|
||||
# NVE's LCOE spreadsheet 2026 (source entries K11-002, K11-003, K11-004, K11-006): 6 %, 2025
|
||||
# kroner. NVE counts interest during construction from the start of each year, S3 from the
|
||||
# middle of it; that alone puts S3 about 3 % of the capital cost lower. NVE also lets
|
||||
# production fall every year (0.42 % for wind, 0.1 % for nuclear), which the model does not.
|
||||
# For hydro NVE's investment figure already includes interest during construction.
|
||||
|
||||
NVE_RENTE = 0.06
|
||||
|
||||
|
||||
def _nve_fornybar(
|
||||
investering: float,
|
||||
drift_mwh: float,
|
||||
drift_kw: float,
|
||||
timer: float,
|
||||
levetid: float,
|
||||
byggetid: float,
|
||||
*,
|
||||
renter_med: bool,
|
||||
) -> float:
|
||||
"""LCOE in øre/kWh from the model's function, with NVE's inputs."""
|
||||
return (
|
||||
lg.lcoe_fornybar(
|
||||
investering=investering * 1e3,
|
||||
drift_per_mwh=drift_mwh,
|
||||
drift_per_mw=drift_kw * 1e3,
|
||||
fullasttimer=timer,
|
||||
levetid=levetid,
|
||||
byggetid=byggetid,
|
||||
rho=NVE_RENTE,
|
||||
renter_i_investeringen=renter_med,
|
||||
)
|
||||
/ 10.0
|
||||
)
|
||||
|
||||
|
||||
def _nve_kjernekraft() -> float:
|
||||
enhet = lg.s3_investering_med_renter(
|
||||
xi_N=1.0, c_N=126874.7 * 1e3, P_u=1600.0, rho=NVE_RENTE, tau_N=10.0
|
||||
)
|
||||
return (
|
||||
lg.s5_lcoe_kjernekraft(
|
||||
I_N=[enhet],
|
||||
rho=NVE_RENTE,
|
||||
L_N=40.0,
|
||||
f_N_enhet=1846.23 * 1e3,
|
||||
D_avv=0.0,
|
||||
P_u=1600.0,
|
||||
E_N=7884.0 * 1600.0,
|
||||
v_N=51.753252816351818,
|
||||
u_N=75.0,
|
||||
d_N=60.0,
|
||||
q_N=0.0,
|
||||
)
|
||||
/ 10.0
|
||||
)
|
||||
|
||||
|
||||
def test_nve_kjernekraft() -> None:
|
||||
"""S3 and S5 with NVE's inputs: 187.3 against 193.9 øre/kWh (-3.4 %)."""
|
||||
assert abs(_avvik(_nve_kjernekraft(), 193.94)) <= TOLERANSE
|
||||
|
||||
|
||||
def test_nve_vannkraft_uten_renter_paa_nytt() -> None:
|
||||
"""Hydro: 48.94 against 48.94 øre/kWh when S3 is not applied on top of NVE's figure."""
|
||||
verdi = _nve_fornybar(18749.0, 70.0, 0.0, 2971.0, 40.0, 3.0, renter_med=True)
|
||||
assert verdi == pytest.approx(48.94, abs=0.01)
|
||||
|
||||
|
||||
def test_nve_vannkraft_med_s3_teller_rentene_to_ganger() -> None:
|
||||
"""Hydro with S3 on top of NVE's figure gives 52.8 øre/kWh, 7.9 % above NVE.
|
||||
|
||||
NVE's sheet says interest during construction is included in the investment
|
||||
figure for hydro ("Inkludert i modulkostnader"). The parameter file holds
|
||||
that figure together with a construction time of three years.
|
||||
"""
|
||||
verdi = _nve_fornybar(18749.0, 70.0, 0.0, 2971.0, 40.0, 3.0, renter_med=False)
|
||||
assert _avvik(verdi, 48.94) == pytest.approx(0.079, abs=0.002)
|
||||
|
||||
|
||||
@pytest.mark.xfail(
|
||||
strict=True,
|
||||
reason="43.9 against 46.9 øre/kWh (-6.3 %): interest from mid-year, and no yearly loss",
|
||||
)
|
||||
def test_nve_vindkraft() -> None:
|
||||
"""Wind on land with NVE's inputs."""
|
||||
verdi = _nve_fornybar(13915.0, 120.0, 0.0, 3357.0, 30.0, 2.0, renter_med=False)
|
||||
assert abs(_avvik(verdi, 46.91)) <= TOLERANSE
|
||||
|
||||
|
||||
@pytest.mark.xfail(
|
||||
strict=True,
|
||||
reason="114.0 against 120.6 øre/kWh (-5.5 %): interest from mid-year; the rest not found",
|
||||
)
|
||||
def test_nve_havvind() -> None:
|
||||
"""Bottom-fixed offshore wind with NVE's inputs (investment with grid and contingency)."""
|
||||
verdi = _nve_fornybar(52800.0, 0.0, 900.0, 4467.0, 30.0, 3.0, renter_med=False)
|
||||
assert abs(_avvik(verdi, 120.61)) <= TOLERANSE
|
||||
|
||||
|
||||
def _nve_metode(
|
||||
investering: float,
|
||||
byggetid: int,
|
||||
levetid: int,
|
||||
timer: float,
|
||||
tap: float,
|
||||
drift_ore: float,
|
||||
fast: float,
|
||||
) -> float:
|
||||
"""NVE's own convention, written out independently of the model, øre/kWh.
|
||||
|
||||
Interest from the start of each construction year, production falling by
|
||||
``tap`` per year, operation cost on the first year's production.
|
||||
"""
|
||||
renter = sum((1.0 + NVE_RENTE) ** k for k in range(1, byggetid + 1)) / byggetid
|
||||
aar = range(1, levetid + 1)
|
||||
energi = sum(timer * (1.0 - tap) ** (t - 1) / (1.0 + NVE_RENTE) ** t for t in aar)
|
||||
drift = sum((drift_ore * timer / 100.0 + fast) / (1.0 + NVE_RENTE) ** t for t in aar)
|
||||
return (investering * renter + drift) / energi * 100.0
|
||||
|
||||
|
||||
def test_nve_avviket_er_forklart_for_vind_og_kjernekraft() -> None:
|
||||
"""With NVE's two conventions the same inputs give NVE's numbers within 0.2 %."""
|
||||
vind = _nve_metode(13915.0, 2, 30, 3357.0, 0.0042, 12.0, 0.0)
|
||||
kjernekraft = _nve_metode(
|
||||
126874.7, 10, 40, 7884.0, 0.001, 7.5 + 6.0 + 5.1753252816351818, 1846.23
|
||||
)
|
||||
assert vind == pytest.approx(46.913, rel=0.002)
|
||||
assert kjernekraft == pytest.approx(193.945, rel=0.002)
|
||||
570
tests/test_ligninger.py
Normal file
570
tests/test_ligninger.py
Normal file
|
|
@ -0,0 +1,570 @@
|
|||
"""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)
|
||||
276
tests/test_parametere.py
Normal file
276
tests/test_parametere.py
Normal file
|
|
@ -0,0 +1,276 @@
|
|||
"""The parameter file is the frozen one, is read strictly, and is converted to the right units."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
import re
|
||||
from collections import Counter
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import parametere as pm
|
||||
|
||||
ROT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def raa() -> dict[str, Any]:
|
||||
data: dict[str, Any] = json.loads(pm.STANDARDSTI.read_text(encoding="utf-8"))
|
||||
return data
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def sett() -> pm.Parametersett:
|
||||
return pm.les_parametere()
|
||||
|
||||
|
||||
def _endret(raa: dict[str, Any], parameter_id: str) -> tuple[dict[str, Any], dict[str, Any]]:
|
||||
"""A deep copy of the file and the entry with this id inside the copy."""
|
||||
kopi = copy.deepcopy(raa)
|
||||
post = next(p for p in kopi["parametere"] if p["id"] == parameter_id)
|
||||
return kopi, post
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- the freeze
|
||||
|
||||
|
||||
def test_sjekksummen_er_den_i_forhaandsregistreringen() -> None:
|
||||
tekst = (ROT / "FORHANDSREGISTRERING.md").read_text(encoding="utf-8")
|
||||
funnet = re.search(r"SHA-256: `([0-9a-f]{64})`", tekst)
|
||||
assert funnet is not None
|
||||
assert funnet.group(1) == pm.FROSSEN_SHA256
|
||||
assert pm.sjekksum() == pm.FROSSEN_SHA256
|
||||
|
||||
|
||||
def test_en_endret_fil_avvises(tmp_path: Path) -> None:
|
||||
kopi = tmp_path / "parametere.json"
|
||||
kopi.write_bytes(pm.STANDARDSTI.read_bytes().replace(b'"verdi": 2027', b'"verdi": 2030'))
|
||||
with pytest.raises(pm.ParameterError, match="not the frozen parameter file"):
|
||||
pm.les_parametere(kopi)
|
||||
assert pm.les_parametere(kopi, krev_frossen=False).fast("T0") == 2030
|
||||
|
||||
|
||||
def test_antall_og_status_som_i_forhaandsregistreringen(sett: pm.Parametersett) -> None:
|
||||
"""124 parameters: 80 with source, 1 derived, 35 open assumptions, 8 choices of set-up."""
|
||||
assert len(sett.parametere) == 124
|
||||
assert Counter(p.status for p in sett.parametere) == {
|
||||
"kilde": 80,
|
||||
"avledet": 1,
|
||||
"åpen forutsetning": 35,
|
||||
"modellvalg": 8,
|
||||
}
|
||||
|
||||
|
||||
def test_tabellen_i_spesifikasjonen_har_de_samme_parameterne(sett: pm.Parametersett) -> None:
|
||||
tekst = (ROT / "modell" / "spesifikasjon.md").read_text(encoding="utf-8")
|
||||
tabell = tekst.split("<!-- PARAMETERTABELL START -->")[1].split("<!-- PARAMETERTABELL SLUTT")[0]
|
||||
ider = re.findall(r"^\| `([^`]+)` \|", tabell, flags=re.MULTILINE)
|
||||
assert ider == [p.id for p in sett.parametere]
|
||||
|
||||
|
||||
# ------------------------------------------------------------ strict validation
|
||||
|
||||
|
||||
def test_ukjent_felt_overst_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["kommentar"] = "x"
|
||||
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['kommentar'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_ukjent_felt_i_parameter_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post["verdi"] = 140000
|
||||
with pytest.raises(pm.ParameterError, match=r"c_N_ref.*unknown field"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_ukjent_felt_i_fordeling_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post["fordeling"]["modus"] = 140000
|
||||
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['modus'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_manglende_felt_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "tau_N")
|
||||
del post["fordeling"]["modus"]
|
||||
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['modus'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
kopi, post = _endret(raa, "tau_N")
|
||||
del post["merknad"]
|
||||
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['merknad'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("felt", "verdi", "melding"),
|
||||
[
|
||||
("enhet", "kr/kWh", "unknown unit"),
|
||||
("status", "antatt", "unknown status"),
|
||||
("poster", ["K3-20"], "malformed source entries"),
|
||||
("poster", [], "requires at least one source entry"),
|
||||
],
|
||||
)
|
||||
def test_ukjent_enhet_status_og_post_er_feil(
|
||||
raa: dict[str, Any], felt: str, verdi: object, melding: str
|
||||
) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post[felt] = verdi
|
||||
with pytest.raises(pm.ParameterError, match=melding):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_ukjent_fordelingstype_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post["fordeling"]["type"] = "normal"
|
||||
with pytest.raises(pm.ParameterError, match="unknown distribution type 'normal'"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("parameter_id", "felt", "verdi", "melding"),
|
||||
[
|
||||
("tau_N", "modus", 20.0, "does not hold"),
|
||||
("c_N_ref", "lav", 171500, "range is empty"),
|
||||
("tau_N", "form", 6, "PERT shape"),
|
||||
("phi_U", "lav", 0.0, "must be positive"),
|
||||
("o_xi", "sigma", -1.0, "must be positive"),
|
||||
("o_xi", "avkorting", "trekk på nytt", "truncation must be"),
|
||||
("L_H", "vekter", [0.2, 0.2, 0.2, 0.2, 0.3], "weights sum to"),
|
||||
("L_H", "vekter", [0.5, 0.5], "same, non-zero length"),
|
||||
("c_N_ref", "lav", "109000", "expected a number"),
|
||||
("c_N_ref", "lav", True, "expected a number"),
|
||||
],
|
||||
)
|
||||
def test_ugyldig_fordeling_er_feil(
|
||||
raa: dict[str, Any], parameter_id: str, felt: str, verdi: object, melding: str
|
||||
) -> None:
|
||||
kopi, post = _endret(raa, parameter_id)
|
||||
post["fordeling"][felt] = verdi
|
||||
with pytest.raises(pm.ParameterError, match=melding):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_duplikater_er_feil(raa: dict[str, Any], tmp_path: Path) -> None:
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["parametere"].append(copy.deepcopy(kopi["parametere"][5]))
|
||||
with pytest.raises(pm.ParameterError, match="duplicate parameter id"):
|
||||
pm.tolk_parametere(kopi)
|
||||
fil = tmp_path / "p.json"
|
||||
fil.write_text('{"versjon": "1", "versjon": "2"}', encoding="utf-8")
|
||||
with pytest.raises(pm.ParameterError, match="duplicate key 'versjon'"):
|
||||
pm.les_parametere(fil, krev_frossen=False)
|
||||
|
||||
|
||||
def test_ugyldig_json_og_feil_antall_trekninger(raa: dict[str, Any], tmp_path: Path) -> None:
|
||||
fil = tmp_path / "p.json"
|
||||
fil.write_text("{", encoding="utf-8")
|
||||
with pytest.raises(pm.ParameterError, match="not valid JSON"):
|
||||
pm.les_parametere(fil, krev_frossen=False)
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["monte_carlo"]["antall_trekninger"] = 5000
|
||||
with pytest.raises(pm.ParameterError, match="N_trekk differs"):
|
||||
pm.tolk_parametere(kopi)
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["monte_carlo"]["metode"] = "LHS"
|
||||
with pytest.raises(pm.ParameterError, match="monte_carlo: unknown field"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_sammensatt_parameter_maa_ha_alle_feltene(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "vind")
|
||||
post["fordeling"]["degradering"] = {"type": "fast", "verdi": 0.0042}
|
||||
with pytest.raises(pm.ParameterError, match="a composite must have the fields"):
|
||||
pm.tolk_parametere(kopi)
|
||||
kopi, post = _endret(raa, "pris_balanse")
|
||||
post["enhet"] = "TWh; øre/kWh (2025-kroner)"
|
||||
with pytest.raises(pm.ParameterError, match="expected a table with unit"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
# -------------------------------------------------------------- unit conversion
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("navn", "enhet", "faktor"),
|
||||
[
|
||||
("c_N_ref", "kr/kW", 1e3),
|
||||
("f_N", "kr/kW per år", 1e3),
|
||||
("v_N", "kr/MWh", 1.0),
|
||||
("D_avv", "mill. kr/MW", 1e6),
|
||||
("K_U", "mrd. kr", 1e9),
|
||||
("D_fors", "mill. kr", 1e6),
|
||||
("c_H0", "mill. kr/MW IT", 1e6),
|
||||
("o_D", "mill. kr/MW IT per år", 1e6),
|
||||
("c_linje", "mill. kr/km", 1e6),
|
||||
("c_fast", "kr/MW per år", 1.0),
|
||||
("S0", "TWh", 1e6),
|
||||
("g_fornybar", "TWh per år", 1e6),
|
||||
("G_server", "GW per år", 1e3),
|
||||
("u_kjerne", "g CO2e/kWh", 1e-3),
|
||||
("eta_N", "tonn uran per TWh", 1e-6),
|
||||
("vind.investering", "kr/kW", 1e3),
|
||||
("vind.drift", "kr/MWh", 1.0),
|
||||
("havvind.drift", "kr/kW per år", 1e3),
|
||||
("vann.fullasttimer", "t/år", 1.0),
|
||||
],
|
||||
)
|
||||
def test_enhetsfaktorer(sett: pm.Parametersett, navn: str, enhet: str, faktor: float) -> None:
|
||||
storrelse = sett.storrelse(navn)
|
||||
assert (storrelse.enhet, storrelse.faktor) == (enhet, faktor)
|
||||
|
||||
|
||||
def test_faste_verdier_i_ligningenes_enheter(sett: pm.Parametersett) -> None:
|
||||
assert sett.fast("P_ref") == 1000.0
|
||||
assert sett.fast("c_linje") == pytest.approx(13.4e6)
|
||||
assert sett.fast("D_fors") == pytest.approx(8.202e9)
|
||||
assert sett.fast("o_D_v") == pytest.approx(3.21e6)
|
||||
assert sett.fast("G_server") == 25_000.0
|
||||
assert sett.fast("havvind.drift") == 900_000.0
|
||||
assert sett.fast("vind.levetid") == 30.0
|
||||
assert sett.fast("SNKS_snitt") == pytest.approx(536.3e9)
|
||||
with pytest.raises(pm.ParameterError, match="not a fixed scalar"):
|
||||
sett.fast("c_N_ref")
|
||||
with pytest.raises(KeyError):
|
||||
sett.storrelse("finnes_ikke")
|
||||
|
||||
|
||||
def test_lister_og_tabeller(sett: pm.Parametersett) -> None:
|
||||
assert sett.liste("stige") == (1.0, 5.0, 10.0, 20.0, 40.0)
|
||||
assert sett.liste("P_u_sett")[0] == 5.0
|
||||
assert sett.liste("P_u_sett")[-1] == 1000.0
|
||||
assert sett.karbonpris()["sentral"][2030] == 2377.0
|
||||
assert sett.karbonpris()["lav"][2100] == 8547.0
|
||||
petroleum = sett.petroleumsinntekt()
|
||||
assert petroleum[2022] == pytest.approx(1285.223e9)
|
||||
assert sum(petroleum.values()) / 10 == pytest.approx(482.4e9, rel=1e-3)
|
||||
with pytest.raises(pm.ParameterError, match="not a table"):
|
||||
sett.tabell("c_N_ref")
|
||||
|
||||
|
||||
def test_prisene_regnes_om_til_2025_kroner_per_mwh(sett: pm.Parametersett) -> None:
|
||||
scenarioer = sett.pris_balanse()
|
||||
assert len(scenarioer) == 12
|
||||
svakest = scenarioer[-1]
|
||||
assert svakest.navn.startswith("N11")
|
||||
assert svakest.balanse == pytest.approx(-3.6e6)
|
||||
assert svakest.pris["NO1"] == pytest.approx(76.8 * 10 * 137.7 / 129.6)
|
||||
assert set(svakest.pris) == {"NO1", "NO2", "NO3", "NO4", "NO5", "Norge"}
|
||||
|
||||
|
||||
def test_alle_storrelser_og_rekkefolgen(sett: pm.Parametersett) -> None:
|
||||
"""136 scalar quantities with the composites split; 87 of them are drawn, in file order."""
|
||||
assert len(sett.storrelser()) == 136
|
||||
stokastiske = [s.navn for s in sett.stokastiske()]
|
||||
assert len(stokastiske) == 87
|
||||
assert stokastiske[:4] == ["c_N_ref", "w_xi", "u_xi", "o_xi"]
|
||||
assert stokastiske[-1] == "eps_e"
|
||||
plass = stokastiske.index("vann.investering")
|
||||
assert stokastiske[plass : plass + 2] == ["vann.investering", "vann.drift"]
|
||||
assert sett.monte_carlo.froe == 20261111
|
||||
assert sett.monte_carlo.antall_trekninger == 10_000
|
||||
assert len(sett.foelsomheter) == 29
|
||||
262
tests/test_trekninger.py
Normal file
262
tests/test_trekninger.py
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
"""The draws follow the frozen set-up, hit the frozen distributions and can be reproduced.
|
||||
|
||||
These tests look at the drawn parameter values only. No model result is computed.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
import pytest
|
||||
from scipy import stats
|
||||
|
||||
from tokenfabrikker import fordelinger, trekninger
|
||||
from tokenfabrikker import parametere as pm
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
Tabell = npt.NDArray[np.float64]
|
||||
|
||||
ANTALL_STANDARDFEIL = 4.0
|
||||
"""Every statistical check allows four standard errors of the sampling error."""
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def sett() -> pm.Parametersett:
|
||||
return pm.les_parametere()
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def trukket(sett: pm.Parametersett) -> trekninger.Trekninger:
|
||||
return trekninger.trekk(sett)
|
||||
|
||||
|
||||
def _kvantil(sett: pm.Parametersett, navn: str, q: float) -> float:
|
||||
"""The theoretical quantile of a drawn quantity, from its inverse distribution function."""
|
||||
fordeling = sett.storrelse(navn).fordeling
|
||||
return float(
|
||||
fordelinger.invers(fordeling, np.array([q]), heltall=navn in trekninger.HELTALL)[0]
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- reproducibility
|
||||
|
||||
|
||||
def test_oppsettet_folger_parameterfila(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
assert trukket.tabell.shape == (10_000, 87)
|
||||
assert trukket.kolonner == tuple(s.navn for s in sett.stokastiske())
|
||||
assert trukket.tabell.dtype == np.float64
|
||||
assert np.isfinite(trukket.tabell).all()
|
||||
|
||||
|
||||
def test_samme_fro_gir_samme_trekninger(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
assert np.array_equal(trekninger.trekk(sett).tabell, trukket.tabell)
|
||||
|
||||
|
||||
def test_den_lagrede_fila_kan_gjenskapes(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
"""``data/trekninger.npy`` is what the generator gives, bit for bit or within tolerance."""
|
||||
lagret = trekninger.les()
|
||||
assert lagret.kolonner == trukket.kolonner
|
||||
assert lagret.enheter == trukket.enheter
|
||||
dom, avvik = trekninger.kontroller(sett)
|
||||
assert dom in {"identisk", "innenfor toleranse"}, avvik
|
||||
beskrivelse = json.loads(
|
||||
(trekninger.DATAMAPPE / trekninger.BESKRIVELSESFIL).read_text(encoding="utf-8")
|
||||
)
|
||||
assert beskrivelse["sha256_parametere"] == pm.FROSSEN_SHA256
|
||||
assert beskrivelse["antall_trekninger"] == sett.monte_carlo.antall_trekninger
|
||||
assert beskrivelse["froe"] == sett.monte_carlo.froe
|
||||
|
||||
|
||||
def test_skriv_og_les(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger, tmp_path: Path
|
||||
) -> None:
|
||||
sha256 = trekninger.skriv(trukket, sett, tmp_path)
|
||||
lest = trekninger.les(tmp_path)
|
||||
assert np.array_equal(lest.tabell, trukket.tabell)
|
||||
assert trekninger.kontroller(sett, tmp_path) == ("identisk", 0.0)
|
||||
assert trekninger.skriv(trukket, sett, tmp_path) == sha256
|
||||
tabellfil = tmp_path / trekninger.TABELLFIL
|
||||
raa = bytearray(tabellfil.read_bytes())
|
||||
raa[-1] ^= 1
|
||||
tabellfil.write_bytes(bytes(raa))
|
||||
with pytest.raises(pm.ParameterError, match="does not match the checksum"):
|
||||
trekninger.les(tmp_path)
|
||||
|
||||
|
||||
def test_kommandolinjen(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
assert trekninger.main(["lag", "--mappe", str(tmp_path)]) == 0
|
||||
assert "10000 trekninger av 87 størrelser" in capsys.readouterr().out
|
||||
assert trekninger.main(["kontroll", "--mappe", str(tmp_path)]) == 0
|
||||
assert capsys.readouterr().out.startswith("identisk")
|
||||
|
||||
|
||||
# ------------------------------------------------------------ the distributions
|
||||
|
||||
|
||||
def test_alle_trekninger_ligger_innenfor_spennet(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
for storrelse in sett.stokastiske():
|
||||
verdier = trukket.kolonne(storrelse.navn)
|
||||
fordeling = storrelse.fordeling
|
||||
if fordeling.type == "diskret":
|
||||
assert set(np.unique(verdier)) <= set(fordeling.verdier), storrelse.navn
|
||||
continue
|
||||
nedre = fordeling.tall["min" if fordeling.type == "lognormal" else "lav"]
|
||||
ovre = fordeling.tall["maks" if fordeling.type == "lognormal" else "hoy"]
|
||||
assert nedre <= float(np.min(verdier)), storrelse.navn
|
||||
assert float(np.max(verdier)) <= ovre, storrelse.navn
|
||||
|
||||
|
||||
@pytest.mark.parametrize("q", [0.05, 0.5, 0.95])
|
||||
def test_median_og_ytterpunkter_treffer(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger, q: float
|
||||
) -> None:
|
||||
"""The share of draws below the theoretical 5 %, 50 % and 95 % points is 5 %, 50 % and 95 %."""
|
||||
n = trukket.tabell.shape[0]
|
||||
slingring = ANTALL_STANDARDFEIL * np.sqrt(q * (1 - q) / n)
|
||||
for storrelse in sett.stokastiske():
|
||||
navn = storrelse.navn
|
||||
if storrelse.fordeling.type == "diskret" or navn in trekninger.HELTALL:
|
||||
continue
|
||||
if navn == "KF" and q > 0.5:
|
||||
continue # the cap at (1 - o_p)(1 - o_f) changes the upper tail
|
||||
andel = float(np.mean(trukket.kolonne(navn) <= _kvantil(sett, navn, q)))
|
||||
assert abs(andel - q) <= slingring, (navn, q, andel)
|
||||
|
||||
|
||||
def test_diskrete_fordelinger_treffer_vektene(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
n = trukket.tabell.shape[0]
|
||||
for navn in ("A_krav", "L_H"):
|
||||
fordeling = sett.storrelse(navn).fordeling
|
||||
for verdi, vekt in zip(fordeling.verdier, fordeling.vekter, strict=True):
|
||||
andel = float(np.mean(trukket.kolonne(navn) == verdi))
|
||||
assert abs(andel - vekt) <= ANTALL_STANDARDFEIL * np.sqrt(vekt * (1 - vekt) / n), navn
|
||||
|
||||
|
||||
def test_n_0_er_heltall_med_lik_sannsynlighet(trukket: trekninger.Trekninger) -> None:
|
||||
verdier = trukket.kolonne("n_0")
|
||||
assert np.array_equal(verdier, np.round(verdier))
|
||||
assert set(np.unique(verdier)) == set(range(1, 21))
|
||||
andeler = np.bincount(verdier.astype(int))[1:] / verdier.size
|
||||
assert np.max(np.abs(andeler - 0.05)) <= ANTALL_STANDARDFEIL * np.sqrt(
|
||||
0.05 * 0.95 / verdier.size
|
||||
)
|
||||
|
||||
|
||||
def test_overskridelsen_har_median_og_snitt_som_parameterfila_sier(
|
||||
trukket: trekninger.Trekninger,
|
||||
) -> None:
|
||||
"""o_xi: median 0.648, and mean about 1.12 after truncation at 12.8 (the file's note)."""
|
||||
o_xi = trukket.kolonne("o_xi")
|
||||
assert float(np.median(o_xi)) == pytest.approx(0.648, rel=0.05)
|
||||
assert float(np.mean(o_xi)) == pytest.approx(1.12, rel=0.05)
|
||||
assert float(np.max(o_xi)) <= 12.8
|
||||
|
||||
|
||||
def test_pert_har_riktig_snitt(sett: pm.Parametersett, trukket: trekninger.Trekninger) -> None:
|
||||
"""A beta-PERT with shape 4 has mean (low + 4 mode + high) / 6."""
|
||||
for navn in ("tau_N", "L_N", "rho_N", "c_H0", "S0"):
|
||||
tall = sett.storrelse(navn).fordeling.tall
|
||||
ventet = (tall["lav"] + 4 * tall["modus"] + tall["hoy"]) / 6
|
||||
verdier = trukket.kolonne(navn)
|
||||
slingring = ANTALL_STANDARDFEIL * float(np.std(verdier)) / np.sqrt(verdier.size)
|
||||
assert abs(float(np.mean(verdier)) - ventet) <= slingring, navn
|
||||
|
||||
|
||||
def test_kapasitetsfaktoren_er_avkortet(trukket: trekninger.Trekninger) -> None:
|
||||
tak = (1 - trukket.kolonne("o_p")) * (1 - trukket.kolonne("o_f_stor"))
|
||||
assert np.all(trukket.kolonne("KF") <= tak)
|
||||
assert 0 < float(np.mean(trukket.kolonne("KF") == tak)) < 0.05
|
||||
|
||||
|
||||
# --------------------------------------------------------------- correlations
|
||||
|
||||
|
||||
def _rangkorrelasjon(a: Tabell, b: Tabell) -> float:
|
||||
return float(stats.spearmanr(a, b).statistic)
|
||||
|
||||
|
||||
def test_rangkorrelasjonene_treffer(sett: pm.Parametersett, trukket: trekninger.Trekninger) -> None:
|
||||
n = trukket.tabell.shape[0]
|
||||
for a, b, parameter in trekninger.KORRELASJONER:
|
||||
ventet = sett.fast(parameter)
|
||||
funnet = _rangkorrelasjon(trukket.kolonne(a), trukket.kolonne(b))
|
||||
assert abs(funnet - ventet) <= ANTALL_STANDARDFEIL / np.sqrt(n), (a, b, funnet)
|
||||
|
||||
|
||||
def test_normalkorrelasjonen_gir_rangkorrelasjonen() -> None:
|
||||
assert trekninger.normalkorrelasjon(0.5) == pytest.approx(0.5176, abs=1e-4)
|
||||
assert trekninger.normalkorrelasjon(0.0) == 0.0
|
||||
assert trekninger.normalkorrelasjon(1.0) == pytest.approx(1.0)
|
||||
assert trekninger.normalkorrelasjon(-0.5) == -trekninger.normalkorrelasjon(0.5)
|
||||
|
||||
|
||||
def test_alle_andre_par_er_ukorrelerte(trukket: trekninger.Trekninger) -> None:
|
||||
"""No pair outside the four in chapter 11 has a rank correlation above 0.05."""
|
||||
korrelasjon = np.asarray(stats.spearmanr(trukket.tabell).statistic)
|
||||
np.fill_diagonal(korrelasjon, 0.0)
|
||||
for a, b, _ in trekninger.KORRELASJONER:
|
||||
i, j = trukket.kolonner.index(a), trukket.kolonner.index(b)
|
||||
korrelasjon[i, j] = korrelasjon[j, i] = 0.0
|
||||
assert float(np.max(np.abs(korrelasjon))) < 0.05
|
||||
|
||||
|
||||
# --------------------------------------------------- inverse distribution functions
|
||||
|
||||
|
||||
def test_inverse_fordelingsfunksjoner() -> None:
|
||||
u = np.array([0.0, 0.25, 0.5, 1.0])
|
||||
assert fordelinger.invers_jevn(u, lav=2.0, hoy=6.0).tolist() == [2.0, 3.0, 4.0, 6.0]
|
||||
assert fordelinger.invers_jevn_heltall(u, lav=1.0, hoy=4.0).tolist() == [1.0, 2.0, 3.0, 4.0]
|
||||
assert fordelinger.invers_logjevn(u, lav=1e-8, hoy=1e-4)[2] == pytest.approx(1e-6)
|
||||
diskret = fordelinger.invers_diskret(
|
||||
np.array([0.0, 0.3, 0.31, 0.99, 1.0]), verdier=(3.0, 5.0, 7.0), vekter=(0.3, 0.4, 0.3)
|
||||
)
|
||||
assert diskret.tolist() == [3.0, 3.0, 5.0, 7.0, 7.0]
|
||||
|
||||
|
||||
def test_pert_er_betafordelingen() -> None:
|
||||
a, b = fordelinger.pert_parametere(lav=6.0, modus=9.5, hoy=17.1, form=4.0)
|
||||
assert (a, b) == pytest.approx((1 + 4 * 3.5 / 11.1, 1 + 4 * 7.6 / 11.1))
|
||||
u = np.linspace(0.01, 0.99, 9)
|
||||
ventet = 6.0 + 11.1 * stats.beta.ppf(u, a, b)
|
||||
assert fordelinger.invers_pert(u, lav=6.0, modus=9.5, hoy=17.1, form=4.0) == pytest.approx(
|
||||
ventet
|
||||
)
|
||||
kant = fordelinger.invers_pert(np.array([0.0, 1.0]), lav=5.0, modus=5.0, hoy=9.0, form=4.0)
|
||||
assert kant.tolist() == [5.0, 9.0]
|
||||
|
||||
|
||||
def test_avkortet_lognormal() -> None:
|
||||
u = np.array([0.0, 0.5, 1.0])
|
||||
uavkortet = fordelinger.invers_lognormal(u[1:2], median=0.648, sigma=1.09, minste=0.0, maks=1e9)
|
||||
assert uavkortet[0] == pytest.approx(0.648)
|
||||
avkortet = fordelinger.invers_lognormal(u, median=0.648, sigma=1.09, minste=0.0, maks=12.8)
|
||||
assert avkortet[0] == 0.0
|
||||
assert avkortet[2] == pytest.approx(12.8)
|
||||
assert avkortet[1] < 0.648 + 0.01
|
||||
andel_under_maks = stats.norm.cdf(np.log(12.8 / 0.648) / 1.09)
|
||||
assert avkortet[1] == pytest.approx(
|
||||
0.648 * np.exp(1.09 * stats.norm.ppf(0.5 * andel_under_maks))
|
||||
)
|
||||
|
||||
|
||||
def test_fast_verdi_trekkes_ikke(sett: pm.Parametersett) -> None:
|
||||
with pytest.raises(ValueError, match="nothing is drawn"):
|
||||
fordelinger.invers(sett.storrelse("P_ref").fordeling, np.array([0.5]))
|
||||
with pytest.raises(ValueError, match="only defined for the uniform type"):
|
||||
fordelinger.invers(sett.storrelse("tau_N").fordeling, np.array([0.5]), heltall=True)
|
||||
Loading…
Add table
Add a link
Reference in a new issue