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:
Kjell Tore Guttormsen 2026-11-12 10:08:47 +01:00
commit a63f66c416
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
14 changed files with 3656 additions and 0 deletions

456
tests/test_fasit.py Normal file
View 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
View 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
View 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
View 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)