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

386
data/trekninger.json Normal file
View file

@ -0,0 +1,386 @@
{
"beskrivelse": "Trekningene av de frosne parameterne i modell/parametere.json. Én rad per trekning, én kolonne per størrelse som trekkes, i parameterfilas enheter.",
"tabell": "trekninger.npy",
"sha256_tabell": "6eabe71ad4ba55327276803f49bf0ca7c14bd5d29244edd0baadd76edc94595c",
"sha256_parametere": "45828355036bb7fc57974bcb4d886ce13dd67a441b4c548836cc184ac3b3f6cc",
"antall_trekninger": 10000,
"froe": 20261111,
"generator": "PCG64 (numpy.random.Generator)",
"numpy": "2.5.4",
"scipy": "1.18.1",
"korrelasjoner": [
{
"a": "o_xi",
"b": "tau_N",
"rangkorrelasjon": 0.5
},
{
"a": "rho_N",
"b": "rho_D",
"rangkorrelasjon": 0.5
},
{
"a": "KF",
"b": "o_f_stor",
"rangkorrelasjon": -0.5
},
{
"a": "PUE",
"b": "PUE_v",
"rangkorrelasjon": 0.5
}
],
"heltall": [
"n_0"
],
"kolonner": [
{
"navn": "c_N_ref",
"enhet": "kr/kW"
},
{
"navn": "w_xi",
"enhet": "–"
},
{
"navn": "u_xi",
"enhet": "–"
},
{
"navn": "o_xi",
"enhet": "–"
},
{
"navn": "nu",
"enhet": "–"
},
{
"navn": "ell",
"enhet": "–"
},
{
"navn": "n_0",
"enhet": "antall"
},
{
"navn": "tau_F",
"enhet": "år"
},
{
"navn": "tau_N",
"enhet": "år"
},
{
"navn": "KF",
"enhet": "–"
},
{
"navn": "o_p",
"enhet": "–"
},
{
"navn": "o_f_stor",
"enhet": "–"
},
{
"navn": "o_f_liten",
"enhet": "–"
},
{
"navn": "beta_F",
"enhet": "–"
},
{
"navn": "chi",
"enhet": "–"
},
{
"navn": "A_krav",
"enhet": "–"
},
{
"navn": "L_N",
"enhet": "år"
},
{
"navn": "f_N",
"enhet": "kr/kW per år"
},
{
"navn": "nu_f",
"enhet": "–"
},
{
"navn": "v_N",
"enhet": "kr/MWh"
},
{
"navn": "u_N",
"enhet": "kr/MWh"
},
{
"navn": "u_N_liten",
"enhet": "kr/MWh"
},
{
"navn": "d_N",
"enhet": "kr/MWh"
},
{
"navn": "D_avv",
"enhet": "mill. kr/MW"
},
{
"navn": "phi_U",
"enhet": "per reaktorår"
},
{
"navn": "K_U",
"enhet": "mrd. kr"
},
{
"navn": "andel_myndighet",
"enhet": "–"
},
{
"navn": "c_aarsverk",
"enhet": "mill. kr"
},
{
"navn": "n_reaktor",
"enhet": "MW per år"
},
{
"navn": "delta_L",
"enhet": "–"
},
{
"navn": "c_buf",
"enhet": "kr/kW"
},
{
"navn": "s_g",
"enhet": "–"
},
{
"navn": "c_gen",
"enhet": "kr/kW"
},
{
"navn": "D_linje",
"enhet": "km"
},
{
"navn": "c_H0",
"enhet": "mill. kr/MW IT"
},
{
"navn": "gamma_H",
"enhet": "per år"
},
{
"navn": "c_bygg",
"enhet": "mill. kr/MW IT"
},
{
"navn": "d_bygg",
"enhet": "–"
},
{
"navn": "L_H",
"enhet": "år"
},
{
"navn": "L_B",
"enhet": "år"
},
{
"navn": "tau_D",
"enhet": "år"
},
{
"navn": "PUE",
"enhet": "–"
},
{
"navn": "PUE_v",
"enhet": "–"
},
{
"navn": "lambda",
"enhet": "–"
},
{
"navn": "d_o_D",
"enhet": "mill. kr/MW IT per år"
},
{
"navn": "h_knapp",
"enhet": "timer per år"
},
{
"navn": "p_v",
"enhet": "kr/MWh"
},
{
"navn": "y_obs",
"enhet": "mill. kr/MW IT per år"
},
{
"navn": "pi_neg",
"enhet": "–"
},
{
"navn": "tau_pi",
"enhet": "år"
},
{
"navn": "sigma",
"enhet": "–"
},
{
"navn": "theta",
"enhet": "mill. tokens/s per MW"
},
{
"navn": "S0",
"enhet": "TWh"
},
{
"navn": "b_ut",
"enhet": "–"
},
{
"navn": "s_tort",
"enhet": "–"
},
{
"navn": "w_tort_vann",
"enhet": "–"
},
{
"navn": "psi_N",
"enhet": "–"
},
{
"navn": "kappa_vind",
"enhet": "–"
},
{
"navn": "c_fast",
"enhet": "kr/MW per år"
},
{
"navn": "c_res",
"enhet": "kr/MW per år"
},
{
"navn": "I_nett",
"enhet": "mill. kr/MW"
},
{
"navn": "tau_nett",
"enhet": "år"
},
{
"navn": "n_tap",
"enhet": "–"
},
{
"navn": "t_nett",
"enhet": "kr/kW per år"
},
{
"navn": "delta_V",
"enhet": "–"
},
{
"navn": "vind.investering",
"enhet": "kr/kW"
},
{
"navn": "vann.investering",
"enhet": "kr/kW"
},
{
"navn": "vann.drift",
"enhet": "kr/MWh"
},
{
"navn": "havvind.investering",
"enhet": "kr/kW"
},
{
"navn": "E_vann_rest",
"enhet": "TWh"
},
{
"navn": "E_vind_rest",
"enhet": "TWh"
},
{
"navn": "g_fornybar",
"enhet": "TWh per år"
},
{
"navn": "rho_N",
"enhet": "andel per år, reelt før skatt"
},
{
"navn": "rho_D",
"enhet": "andel per år, reelt før skatt"
},
{
"navn": "r_stat",
"enhet": "andel per år, reelt"
},
{
"navn": "s_B_NO",
"enhet": "–"
},
{
"navn": "u_kjerne",
"enhet": "g CO2e/kWh"
},
{
"navn": "u_vind",
"enhet": "g CO2e/kWh"
},
{
"navn": "u_havvind",
"enhet": "g CO2e/kWh"
},
{
"navn": "u_vann",
"enhet": "g CO2e/kWh"
},
{
"navn": "u_H",
"enhet": "tonn CO2e per MW IT"
},
{
"navn": "u_B",
"enhet": "tonn CO2e per MW IT"
},
{
"navn": "eta_N",
"enhet": "tonn uran per TWh"
},
{
"navn": "phi_X",
"enhet": "per år"
},
{
"navn": "D_X",
"enhet": "år"
},
{
"navn": "s_brikker",
"enhet": "–"
},
{
"navn": "eps_e",
"enhet": "–"
}
]
}

BIN
data/trekninger.npy Normal file

Binary file not shown.

59
pyproject.toml Normal file
View file

@ -0,0 +1,59 @@
# Tool configuration only. The pinned versions live in requirements.txt (runtime)
# and requirements-dev.txt (tests and checks); the code is run from src/ without
# being installed.
[tool.pytest.ini_options]
pythonpath = ["src"]
testpaths = ["tests"]
addopts = "-ra --strict-markers"
markers = [
"fasit: reproduces a published number with the source's own assumptions",
]
[tool.mypy]
strict = true
mypy_path = "src"
files = ["src", "tests"]
python_version = "3.11"
[tool.ruff]
line-length = 100
target-version = "py311"
src = ["src", "tests"]
# Text files (sources, specification, pre-registration) are never touched by the formatter.
extend-exclude = ["*.md"]
[tool.ruff.lint]
select = ["ALL"]
ignore = [
# Formatter conflicts (ruff's own recommendation).
"COM812",
"ISC001",
# Docstring style: Google convention is selected below; these two contradict it.
"D203",
"D213",
# Argument and variable names follow the symbols of the specification
# (P_u, KF, PUE, L_N, D_avv ...), so that every function can be read against
# its equation. Lower-casing them would break that link.
"N802",
"N803",
"N806",
# One function per equation: an equation with twelve symbols has twelve arguments.
"PLR0913",
# The licence is stated once, in LICENSE; files carry no copyright header.
"CPY001",
]
# The parameter file writes "no unit" and ranges with an en dash; the code must match it.
allowed-confusables = ["–"]
[tool.ruff.lint.pydocstyle]
convention = "google"
[tool.ruff.lint.per-file-ignores]
"tests/**" = [
"S101", # assert is what a test is
"PLR2004", # published numbers are compared as literals, with the source next to them
"INP001", # tests are not a package
"D103", # the name of a test says what it tests
"PLR0917", # helpers that mirror a source's table take its columns in order
]

5
requirements-dev.txt Normal file
View file

@ -0,0 +1,5 @@
-r requirements.txt
pytest==9.2.0
ruff==0.17.4
mypy==2.4.1
scipy-stubs==1.18.1.1

2
requirements.txt Normal file
View file

@ -0,0 +1,2 @@
numpy==2.5.4
scipy==1.18.1

View file

@ -0,0 +1 @@
"""tokenfabrikker: the model in modell/spesifikasjon.md, one function per equation."""

View file

@ -0,0 +1,103 @@
"""Inverse distribution functions for the distribution types of the parameter file.
Every draw is made by putting a uniform number into the inverse distribution
function (chapter 11 of the specification), also for truncated distributions:
nothing is drawn again. The functions work in the file's own units.
"""
from __future__ import annotations
from typing import TYPE_CHECKING
import numpy as np
from scipy import special
if TYPE_CHECKING:
import numpy.typing as npt
from tokenfabrikker.parametere import Fordeling
Tabell = npt.NDArray[np.float64]
def pert_parametere(*, lav: float, modus: float, hoy: float, form: float) -> tuple[float, float]:
"""Shape parameters (a, b) of the beta distribution behind a beta-PERT."""
spenn = hoy - lav
return 1.0 + form * (modus - lav) / spenn, 1.0 + form * (hoy - modus) / spenn
def invers_jevn(u: Tabell, *, lav: float, hoy: float) -> Tabell:
"""Uniform between ``lav`` and ``hoy``."""
return lav + u * (hoy - lav)
def invers_jevn_heltall(u: Tabell, *, lav: float, hoy: float) -> Tabell:
"""Whole numbers lav, lav + 1, ..., hoy with equal probability."""
antall = round(hoy - lav) + 1
trinn = np.minimum(np.floor(u * antall), antall - 1)
return np.asarray(lav + trinn, dtype=np.float64)
def invers_logjevn(u: Tabell, *, lav: float, hoy: float) -> Tabell:
"""Uniform in the logarithm between ``lav`` and ``hoy``."""
return np.asarray(np.exp(np.log(lav) + u * (np.log(hoy) - np.log(lav))), dtype=np.float64)
def invers_pert(u: Tabell, *, lav: float, modus: float, hoy: float, form: float) -> Tabell:
"""Beta-PERT with the given low, mode, high and shape parameter."""
a, b = pert_parametere(lav=lav, modus=modus, hoy=hoy, form=form)
andel = np.asarray(special.betaincinv(a, b, u), dtype=np.float64)
return np.asarray(lav + (hoy - lav) * andel, dtype=np.float64)
def invers_lognormal(
u: Tabell,
*,
median: float,
sigma: float,
minste: float,
maks: float,
) -> Tabell:
"""Lognormal with median and sigma, truncated to [minste, maks]."""
nedre = special.ndtr((np.log(minste) - np.log(median)) / sigma) if minste > 0 else 0.0
ovre = special.ndtr((np.log(maks) - np.log(median)) / sigma)
z = special.ndtri(nedre + u * (ovre - nedre))
return np.asarray(np.clip(median * np.exp(sigma * z), minste, maks), dtype=np.float64)
def invers_diskret(u: Tabell, *, verdier: tuple[float, ...], vekter: tuple[float, ...]) -> Tabell:
"""Values with weights: the first value whose cumulative weight reaches ``u``."""
kumulativ = np.cumsum(np.asarray(vekter, dtype=np.float64))
kumulativ[-1] = 1.0
indeks = np.minimum(np.searchsorted(kumulativ, u, side="left"), len(verdier) - 1)
return np.asarray(verdier, dtype=np.float64)[indeks]
def invers(fordeling: Fordeling, u: Tabell, *, heltall: bool = False) -> Tabell:
"""Put uniform numbers ``u`` into the inverse distribution function of ``fordeling``.
``heltall=True`` turns a uniform range into equally likely whole numbers
(the parameter file marks such a quantity in its note, not in its type).
"""
tall = fordeling.tall
if fordeling.type == "jevn":
if heltall:
return invers_jevn_heltall(u, lav=tall["lav"], hoy=tall["hoy"])
return invers_jevn(u, lav=tall["lav"], hoy=tall["hoy"])
if heltall:
msg = "whole-number draws are only defined for the uniform type"
raise ValueError(msg)
if fordeling.type == "logjevn":
return invers_logjevn(u, lav=tall["lav"], hoy=tall["hoy"])
if fordeling.type == "pert":
return invers_pert(
u, lav=tall["lav"], modus=tall["modus"], hoy=tall["hoy"], form=tall["form"]
)
if fordeling.type == "lognormal":
return invers_lognormal(
u, median=tall["median"], sigma=tall["sigma"], minste=tall["min"], maks=tall["maks"]
)
if fordeling.type == "diskret":
return invers_diskret(u, verdier=fordeling.verdier, vekter=fordeling.vekter)
msg = f"nothing is drawn for distribution type {fordeling.type!r}"
raise ValueError(msg)

View file

@ -0,0 +1,674 @@
"""The levelised-cost block of the model specification, one function per equation.
Every function is named after the equation number in ``modell/spesifikasjon.md``
(``s1_...`` is equation S1) and takes the symbols of that equation as keyword
arguments. Nothing here reads the parameter file or draws random numbers.
Units (chapter 0 of the specification): money in 2025 kroner, power in MW,
energy in MWh, power prices in kr/MWh, compute capacity in MW IT, time in years.
The parameter file states costs in other units (kr/kW, mill. kr ...);
``tokenfabrikker.parametere`` converts them before they reach these functions.
This file covers chapters 1 to 3 (power plant, data centre, revenue) and the
two rules (S45, S47) that the levelised cost depends on. The cash flow, the
build-out and the power system (S12, S22 to S42) are not implemented here.
"""
from __future__ import annotations
import math
from dataclasses import dataclass
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from collections.abc import Sequence
TIMER_PER_AAR = 8760.0
"""Hours per year used throughout the specification."""
SEKUNDER_PER_AAR_MILLIONER = 31.536
"""Seconds per year divided by one million (S20, S21)."""
GRENSE_LITEN_ENHET_MW = 300.0
"""Units below this size use the outage rate and fuel cost for small units (chapter 1.2)."""
AVRUNDINGSTOLERANSE = 1e-12
"""Relative slack when a number is compared with a whole number or a limit (S7, S8)."""
BASISAAR_IT_PRIS = 2025
"""Year the IT hardware price c_H0 refers to (S13)."""
SISTE_AAR_IT_PRISENDRING = 2035
"""The real price change of IT hardware stops after this year (S13)."""
# --------------------------------------------------------------------------- S1
def s1_crf(*, rho: float, L: float) -> float:
"""S1: capital recovery factor, per year. CRF(0, L) = 1/L.
``rho`` is a real rate per year, ``L`` a lifetime in years (need not be whole).
"""
if L <= 0:
msg = f"lifetime must be positive, got {L}"
raise ValueError(msg)
if rho <= -1:
msg = f"rate must be above -1, got {rho}"
raise ValueError(msg)
if rho == 0:
return 1.0 / L
return rho / -math.expm1(-L * math.log1p(rho))
def sff(*, rho: float, L: float) -> float:
"""Sinking fund factor defined under S5: rho / ((1 + rho)^L - 1), per year. SFF(0, L) = 1/L.
Turns a payment at the end of the lifetime into an equal yearly provision.
"""
if L <= 0:
msg = f"lifetime must be positive, got {L}"
raise ValueError(msg)
if rho <= -1:
msg = f"rate must be above -1, got {rho}"
raise ValueError(msg)
if rho == 0:
return 1.0 / L
return rho / math.expm1(L * math.log1p(rho))
# ------------------------------------------------------------------ S2, S3, S46
def s2_laeringseksponent(*, ell: float) -> float:
"""S2: b = -log2(1 - ell). ``ell`` is the learning rate per doubling and may be negative."""
if ell >= 1:
msg = f"learning rate must be below 1, got {ell}"
raise ValueError(msg)
return -math.log2(1.0 - ell)
def s2_investering_per_mw(
*,
c_N_ref: float,
P_u: float,
P_ref: float,
nu: float,
ell: float,
n_0: float,
n: int,
) -> float:
"""S2: overnight investment per MW for unit number ``n`` of the Norwegian series, kr/MW.
``c_N_ref`` in kr/MW (the file's kr/kW times 1000) for a unit of ``P_ref`` MW
that is Norway's first (n = 1). ``n_0`` is the number of units of the design
built in the world before it.
"""
if n < 1:
msg = f"unit number starts at 1, got {n}"
raise ValueError(msg)
b = s2_laeringseksponent(ell=ell)
skala = math.pow(P_u / P_ref, nu - 1.0)
laering = math.pow((n_0 + n) / (n_0 + 1.0), -b)
return c_N_ref * skala * laering
def s3_byggetidsfaktor(*, rho: float, tau: float) -> float:
"""S3: interest during construction as a factor on the overnight cost.
Even payment over a construction time of ``tau`` years, compounded
continuously within the period: ((1 + rho)^tau - 1) / (tau ln(1 + rho)).
The factor is 1 when the rate or the construction time is zero.
"""
if tau < 0:
msg = f"construction time cannot be negative, got {tau}"
raise ValueError(msg)
x = tau * math.log1p(rho)
if x == 0:
return 1.0
return math.expm1(x) / x
def s3_investering_med_renter(
*,
xi_N: float,
c_N: float,
P_u: float,
rho: float,
tau_N: float,
) -> float:
"""S3: levelised-form investment for one unit, with interest during construction, kr.
``c_N`` in kr/MW from S2, ``P_u`` in MW, ``xi_N`` the overrun factor from S46.
The rate is rho_N on the grid and rho_A in solution A.
"""
return xi_N * c_N * P_u * s3_byggetidsfaktor(rho=rho, tau=tau_N)
def s46_overskridelsesfaktor(*, u_xi: float, w_xi: float, o_xi: float) -> float:
"""S46: xi_N = 1 + o_xi when u_xi < w_xi (the budget reading), otherwise 1."""
return 1.0 + o_xi if u_xi < w_xi else 1.0
# ------------------------------------------------------------------- S4, S5, S6
def s4_kapasitetsfaktor(*, KF: float, o_p: float, o_f: float) -> float:
"""S4 (text): the drawn capacity factor, capped at (1 - o_p)(1 - o_f)."""
return min(KF, (1.0 - o_p) * (1.0 - o_f))
def s4_kapasitetsfaktor_smaa_enheter(*, KF: float, o_f_A: float, o_f: float) -> float:
"""S4 (text): capacity factor for small units on the grid (B'), KF (1 - o_f^A)/(1 - o_f)."""
return KF * (1.0 - o_f_A) / (1.0 - o_f)
def s4_energi_kjernekraft(*, KF: float, N_u: int, P_u: float) -> float:
"""S4: yearly production of a plant with ``N_u`` units of ``P_u`` MW, MWh per year."""
return TIMER_PER_AAR * KF * N_u * P_u
def s5_fast_drift(*, f_N: float, P_u: float, P_ref: float, nu_f: float) -> float:
"""S5: fixed operation per MW for a unit of ``P_u`` MW, f_N (P_u/P_ref)^nu_f, kr/MW per year.
``f_N`` in kr/MW per year (the file's kr/kW per year times 1000).
"""
return f_N * math.pow(P_u / P_ref, nu_f)
def s6_ulykkeskostnad_per_hendelse(*, K_U: float, P_u: float, P_ref: float) -> float:
"""S6: K_U(P_u) = K_U min(1, P_u/P_ref), kr per event. ``K_U`` in kr (the file's mrd. kr)."""
return K_U * min(1.0, P_u / P_ref)
def s6_ulykkeskostnad(
*,
N_u: int,
phi_U: float,
K_U: float,
D_fors: float,
P_u: float,
P_ref: float,
E: float,
skaler_med_enhet: bool = True,
) -> float:
"""S6: expected accident cost not covered by insurance, kr/MWh.
``N_u`` counts every reactor in the plant, reserve units included. ``phi_U``
is per reactor-year, ``K_U`` and ``D_fors`` in kr, ``E`` in MWh per year
(E_N on the grid, E_D in solution A). ``skaler_med_enhet=False`` is the
sensitivity without scaling of K_U by unit size.
"""
k = s6_ulykkeskostnad_per_hendelse(K_U=K_U, P_u=P_u, P_ref=P_ref) if skaler_med_enhet else K_U
return N_u * phi_U * (k - min(k, D_fors)) / E
def s5_lcoe_kjernekraft(
*,
I_N: Sequence[float],
rho: float,
L_N: float,
f_N_enhet: float,
D_avv: float,
P_u: float,
E_N: float,
v_N: float,
u_N: float,
d_N: float,
q_N: float,
) -> float:
"""S5: cost per MWh for a grid-connected plant with identical units, kr/MWh.
``I_N`` holds S3 for each unit of the plant (kr); its length is the number
of units. ``f_N_enhet`` is S5's f_N(P_u) in kr/MW per year, ``D_avv`` in
kr/MW, ``E_N`` in MWh per year (S4); ``v_N``, ``u_N``, ``d_N`` and ``q_N``
in kr/MWh.
"""
crf = s1_crf(rho=rho, L=L_N)
avsetning = D_avv * P_u * sff(rho=rho, L=L_N)
aarlig = sum(i_n * crf + f_N_enhet * P_u + avsetning for i_n in I_N)
return aarlig / E_N + v_N + u_N + d_N + q_N
# ------------------------------------------------------------- S7, S8, S44, S36
def _tak(x: float) -> int:
"""Round up, without letting a rounding error in the last digit add a whole unit."""
return math.ceil(x * (1.0 - AVRUNDINGSTOLERANSE))
def s7_enhetsstorrelse(
*,
P_sett: Sequence[float],
chi: float,
lam: float,
PUE: float,
P_IT: float,
) -> tuple[float, int]:
"""S7: unit size and number of units that must run in solution A.
Returns ``(P_u, m)``: the largest size in ``P_sett`` not above
chi * lam * PUE * P_IT (the smallest size if none is small enough), and
m = ceil(PUE * P_IT / P_u).
"""
if not P_sett:
msg = "the set of unit sizes is empty"
raise ValueError(msg)
grense = chi * lam * PUE * P_IT * (1.0 + AVRUNDINGSTOLERANSE)
kandidater = [p for p in P_sett if p <= grense]
P_u = max(kandidater) if kandidater else min(P_sett)
return P_u, _tak(PUE * P_IT / P_u)
def s8_planlagt_ute(*, m: int, r: int, o_p: float) -> int:
"""S8: n_p, the smallest whole x (zero allowed) with x >= (m + r + x) o_p.
The comparison allows for rounding in the last digit: 100 * 0.07 is
7.000000000000001 in floating point, and seven units are enough.
"""
if not 0 <= o_p < 1:
msg = f"planned outage share must be in [0, 1), got {o_p}"
raise ValueError(msg)
x = 0
while x < (m + r + x) * o_p * (1.0 - AVRUNDINGSTOLERANSE):
x += 1
return x
def _log_binomisk(n: int, x: int, p: float) -> float:
"""Log of the binomial probability of ``x`` successes in ``n`` trials (0 < p < 1)."""
return (
math.lgamma(n + 1)
- math.lgamma(x + 1)
- math.lgamma(n - x + 1)
+ x * math.log(p)
+ (n - x) * math.log1p(-p)
)
def _binomisk(n: int, x: int, p: float) -> float:
"""Binomial probability of ``x`` successes in ``n`` trials with success probability ``p``."""
if p <= 0:
return 1.0 if x == 0 else 0.0
if p >= 1:
return 1.0 if x == n else 0.0
return math.exp(_log_binomisk(n, x, p))
def s8_uavhengig_utfallsrate(*, beta_F: float, o_f_A: float) -> float:
"""S8: o' = (1 - beta_F) o_f^A, the part of forced outage that hits units one by one."""
return (1.0 - beta_F) * o_f_A
def s8_tilgjengelighet(*, m: int, r: int, o_merket: float) -> float:
"""S8: A_uavh(m, r), the probability that at least ``m`` of ``m + r`` units run."""
n = m + r
return math.fsum(_binomisk(n, x, 1.0 - o_merket) for x in range(m, n + 1))
def s8_reserveenheter(*, m: int, o_merket: float, A_krav: float, r_maks: int = 10_000) -> int:
"""S8: r, the smallest number of reserve units with A_uavh(m, r) >= A_krav.
The specification computes r with the mode values of o_f^A and beta_F
(design values); the caller passes ``o_merket`` built from them.
"""
for r in range(r_maks + 1):
if s8_tilgjengelighet(m=m, r=r, o_merket=o_merket) >= A_krav:
return r
msg = f"no r up to {r_maks} reaches availability {A_krav}"
raise ValueError(msg)
def s8_antall_enheter(*, m: int, r: int, n_p: int) -> int:
"""S8: N_u = m + r + n_p, all units in the plant."""
return m + r + n_p
def s44_inntektsfaktor(*, m: int, r: int, o_f_A: float, beta_F: float) -> float:
"""S44: revenue factor Gamma = (1 - beta_F o_f^A) E[min(X, m)] / m.
X is the number of units running, binomial with m + r trials and success
probability 1 - o'. Uses the drawn values of o_f^A and beta_F.
"""
o_merket = s8_uavhengig_utfallsrate(beta_F=beta_F, o_f_A=o_f_A)
n = m + r
forventet = math.fsum(min(x, m) * _binomisk(n, x, 1.0 - o_merket) for x in range(n + 1))
return (1.0 - beta_F * o_f_A) * forventet / m
def s36_buffer(*, delta_L: float, PUE: float, P_IT: float) -> float:
"""S36: P_buf = delta_L * PUE * P_IT, the buffer that covers the largest load step, MW."""
return delta_L * PUE * P_IT
def s36_ekstern_forsyning(
*,
D_linje: float,
c_linje: float,
s_g: float,
N_u: int,
P_u: float,
c_gen: float,
rho_A: float,
L_nett: float,
L_buf: float,
) -> float:
"""S36: yearly cost of external supply to the plant itself (two lines and gensets), kr/year.
``D_linje`` in km, ``c_linje`` in kr/km, ``c_gen`` in kr/MW (the file's kr/kW times 1000).
"""
linjer = 2.0 * D_linje * c_linje * s1_crf(rho=rho_A, L=L_nett)
aggregater = s_g * N_u * P_u * c_gen * s1_crf(rho=rho_A, L=L_buf)
return linjer + aggregater
# ----------------------------------------------------------------- S9, S10, S11
def s10_energi_datasenter(*, lam: float, PUE: float, P_IT: float) -> float:
"""S10: E_D = 8760 * lam * PUE * P_IT, yearly energy to the data centre, MWh per year."""
return TIMER_PER_AAR * lam * PUE * P_IT
def s9_kraftkostnad_dedikert(
*,
I_N: Sequence[float],
rho_A: float,
L_N: float,
f_N_enhet: float,
D_avv: float,
P_u: float,
P_buf: float,
c_buf: float,
f_buf: float,
L_buf: float,
I_g_aar: float,
E_D: float,
v_N: float,
u_N_A: float,
d_N: float,
q_N: float,
) -> float:
"""S9: cost per MWh delivered to the data centre in solution A, kr/MWh.
``I_N`` holds S3 (with rho_A) for each of the plant's N_u units; unit
numbers run across the plants of the programme (S2). ``c_buf`` in
kr/MW, ``f_buf`` in kr/MW per year, ``I_g_aar`` from S36 in kr/year,
``E_D`` from S10. Power that is not used cannot be sold, so everything is
divided by E_D.
"""
crf = s1_crf(rho=rho_A, L=L_N)
avsetning = D_avv * P_u * sff(rho=rho_A, L=L_N)
verk = sum(i_n * crf + f_N_enhet * P_u + avsetning for i_n in I_N)
buffer = P_buf * (c_buf * s1_crf(rho=rho_A, L=L_buf) + f_buf)
return (verk + buffer + I_g_aar) / E_D + v_N + u_N_A + d_N + q_N
@dataclass(frozen=True)
class Portefoljeledd:
"""One technology i in the power portfolio of a grid solution (S11).
Attributes:
x: share of the portfolio's normal-year production E_G (the shares sum to 1).
LCOE: levelised cost of the technology, kr/MWh.
psi: value factor, achieved price over average price.
regelen_binder: True when the additionality rule S45 binds (varsigma below 1).
"""
x: float
LCOE: float
psi: float
regelen_binder: bool
def nettoledd(self, p_z: float) -> float:
"""The technology's net cost per MWh produced, kr/MWh.
Zero when S45 binds: a plant that pays its way without the data centre
neither adds nor takes (specification, chapter 16, clarification 11).
Otherwise LCOE - psi * p_z.
"""
return 0.0 if self.regelen_binder else self.LCOE - self.psi * p_z
def s11_nettkostnad(
*,
I_nett: float,
delta_V: float,
PUE: float,
P_IT: float,
P_G_N: float,
rho_N: float,
L_nett: float,
) -> float:
"""S11: H_a, yearly cost of new grid capacity for one facility, kr/year.
``I_nett`` in kr/MW. ``P_G_N`` is the nuclear capacity that needs a
connection (B and B'), zero in C and R.
"""
return I_nett * ((1.0 - delta_V) * PUE * P_IT + P_G_N) * s1_crf(rho=rho_N, L=L_nett)
def s11_kraftkostnad_nett(
*,
p_z: float,
n_tap: float,
portefolje: Sequence[Portefoljeledd],
E_G: float,
E_D: float,
H_a: float,
F_a: float,
) -> float:
"""S11: cost per MWh to the data centre in a grid solution (B, B', C, R), kr/MWh.
``p_z`` is the power price after the price effect, ``E_G`` the portfolio's
production in a normal year and ``E_D`` the data centre's use (MWh per year);
in B both are sums over the programme.
``H_a`` and ``F_a`` are the facility's yearly costs of grid and capacity
(kr/year). In R the portfolio is empty.
"""
kraftverk = sum(ledd.x * ledd.nettoledd(p_z) for ledd in portefolje)
return (1.0 + n_tap) * p_z + kraftverk * E_G / E_D + (H_a + F_a) / E_D
def lcoe_fornybar(
*,
investering: float,
drift_per_mwh: float,
drift_per_mw: float,
fullasttimer: float,
levetid: float,
byggetid: float,
rho: float,
renter_i_investeringen: bool,
) -> float:
"""Chapter 1.4: LCOE_i for renewable power from NVE's inputs, kr/MWh.
The specification gives no equation number; the form is S3 and S5 without
the nuclear terms. ``investering`` in kr/MW, ``drift_per_mwh`` in kr/MWh,
``drift_per_mw`` in kr/MW per year (one of the two is zero in the
parameter file). ``renter_i_investeringen=True`` means the source's
investment figure already holds interest during construction, so S3 is
not applied on top.
"""
faktor = 1.0 if renter_i_investeringen else s3_byggetidsfaktor(rho=rho, tau=byggetid)
kapital = investering * faktor * s1_crf(rho=rho, L=levetid)
return (kapital + drift_per_mw) / fullasttimer + drift_per_mwh
# ------------------------------------------------------------------- S13 to S21
def s13_it_kostnad(*, c_H0: float, gamma_H: float, t_v: int) -> float:
"""S13: c_H(t_v) = c_H0 (1 + gamma_H)^(min(t_v, 2035) - 2025), kr per MW IT."""
return c_H0 * (1.0 + gamma_H) ** (min(t_v, SISTE_AAR_IT_PRISENDRING) - BASISAAR_IT_PRIS)
def s14_snittlast(*, lam_0: float, mu_u: float) -> float:
"""S14: lam = lam_0 + (1 - lam_0) mu_u. Used only in the token control (chapter 3.3)."""
return lam_0 + (1.0 - lam_0) * mu_u
def s15_lcoc(
*,
c_bygg: float,
d_bygg: float,
c_H: float,
rho_D: float,
L_B: float,
L_H: float,
o_D: float,
d_o_D: float,
lam: float,
PUE: float,
c_a: float,
) -> float:
"""S15: yearly cost of compute per MW IT, kr per MW IT per year.
``c_bygg`` and ``c_H`` in kr per MW IT, ``o_D`` and ``d_o_D`` in kr per MW
IT per year, ``c_a`` in kr/MWh. For the competitor (S18) the caller passes
its power price, PUE and operating cost, with ``d_bygg`` and ``d_o_D`` zero.
"""
bygg = c_bygg * (1.0 + d_bygg) * s1_crf(rho=rho_D, L=L_B)
maskinvare = c_H * s1_crf(rho=rho_D, L=L_H)
kraft = TIMER_PER_AAR * lam * PUE * c_a
return bygg + maskinvare + o_D + d_o_D + kraft
def s16_inntekt(*, mu: float, Gamma: float, y: float, P_IT: float) -> float:
"""S16: yearly revenue of one vintage, mu * Gamma * y * P_IT, kr/year."""
return mu * Gamma * y * P_IT
def s17_kontraktspris_fra_spot(*, y_spot: Sequence[float], rho_D: float) -> float:
"""S17: fixed yearly price equivalent to a spot path over the equipment's life.
``y_spot[x]`` is the spot price in year t_v + x; the length is L_H.
Not used in the report.
"""
L_H = len(y_spot)
naaverdi = sum(y / (1.0 + rho_D) ** (x + 1) for x, y in enumerate(y_spot))
return s1_crf(rho=rho_D, L=L_H) * naaverdi
def s18_pris(*, LCOC_v: float, pi_g: float) -> float:
"""S18: price of compute, y = LCOC^v (1 + pi_g), kr per MW IT per year."""
return LCOC_v * (1.0 + pi_g)
def s43_knapphetspaaslag(*, y_obs: float, LCOC_v_2025: float) -> float:
"""S43: pi_0 = y_obs / LCOC^v(2025) - 1, set to zero when negative."""
return max(0.0, y_obs / LCOC_v_2025 - 1.0)
@dataclass(frozen=True)
class Margin:
"""S19: Norway's margin per MW IT and year, split into its four terms (kr).
Attributes:
kraftfortrinn: 8760 lam (PUE^v p^v - PUE c_a).
knapphet: pi_g LCOC^v.
drift_bygg_skatt: o_D^v - o_D - d_o_D - d_bygg c_bygg CRF(rho_D, L_B).
usolgt: (1 - mu Gamma) y, entered with a minus sign in the sum.
"""
kraftfortrinn: float
knapphet: float
drift_bygg_skatt: float
usolgt: float
@property
def sum(self) -> float:
"""The margin M_a."""
return self.kraftfortrinn + self.knapphet + self.drift_bygg_skatt - self.usolgt
def s19_margin(
*,
lam: float,
PUE_v: float,
p_v: float,
PUE: float,
c_a: float,
pi_g: float,
LCOC_v: float,
o_D_v: float,
o_D: float,
d_o_D: float,
d_bygg: float,
c_bygg: float,
rho_D: float,
L_B: float,
mu: float,
Gamma: float,
) -> Margin:
"""S19: the right-hand side of the accounting identity M_a = mu Gamma y - LCOC_a."""
y = s18_pris(LCOC_v=LCOC_v, pi_g=pi_g)
return Margin(
kraftfortrinn=TIMER_PER_AAR * lam * (PUE_v * p_v - PUE * c_a),
knapphet=pi_g * LCOC_v,
drift_bygg_skatt=o_D_v - o_D - d_o_D - d_bygg * c_bygg * s1_crf(rho=rho_D, L=L_B),
usolgt=(1.0 - mu * Gamma) * y,
)
def s20_tokeninntekt(
*,
sigma: float,
p_tok: float,
theta: float,
mu_u: float,
P_IT: float,
) -> float:
"""S20: yearly revenue from selling tokens (control only), kr/year.
``p_tok`` in kr per million tokens, ``theta`` in million tokens per second per MW.
"""
return sigma * p_tok * theta * mu_u * P_IT * SEKUNDER_PER_AAR_MILLIONER * 1e6
def s21_kostnad_per_token(*, LCOC: float, theta: float, mu_u: float) -> float:
"""S21: cost per million tokens (control only), kr per million tokens."""
return LCOC / (theta * mu_u * SEKUNDER_PER_AAR_MILLIONER * 1e6)
# --------------------------------------------------------------------- S45, S47
def s45_tilleggsfaktor(*, naaverdi_kostnader: float, naaverdi_salgsinntekter: float) -> float:
"""S45: varsigma_i = min(1, present value of costs / present value of sales revenue).
Both present values are taken with rho_N over all facilities of the
solution, per technology. With no revenue the factor is 1. With a residual
value in the plant's cash flow the factor is found by iteration in the
cash-flow part; this function is the closed form without it.
"""
if naaverdi_salgsinntekter <= 0:
return 1.0
return min(1.0, naaverdi_kostnader / naaverdi_salgsinntekter)
def s47_effektkostnad(
*,
Delta_R: float,
Delta_R_utfall: float,
c_fast: float,
c_res: float,
h_knapp: float,
mu: float,
y: float,
PUE: float,
) -> float:
"""S47: F_a, yearly cost of the capacity a grid solution lacks, kr/year, whole programme.
``Delta_R`` and ``Delta_R_utfall`` (S24, the latter with the largest new
unit out) in MW; ``c_fast`` and ``c_res`` in kr/MW per year; ``h_knapp``
in hours per year; ``y`` in kr per MW IT per year, the average over the
vintages in operation that year. The cheaper of new firm capacity plus
reserve, and disconnection in the scarce hours.
"""
R_minus = max(0.0, -Delta_R)
R_utfall_minus = max(0.0, -Delta_R_utfall)
fast_effekt = c_fast * R_minus + c_res * (R_utfall_minus - R_minus)
utkobling = h_knapp * mu * y / (TIMER_PER_AAR * PUE) * R_utfall_minus
return min(fast_effekt, utkobling)

View file

@ -0,0 +1,637 @@
"""Reads the frozen parameter file ``modell/parametere.json``.
Three jobs:
1. Check that the file is the frozen one (SHA-256 recorded in
``FORHANDSREGISTRERING.md``).
2. Validate the structure. Unknown fields, unknown units, unknown distribution
types and inconsistent ranges are errors, never warnings.
3. Give every scalar quantity a factor from the unit in the file to the units
the equations use (kroner, MW, MWh, kr/MWh, years; chapter 0 of the
specification).
The file is never written by this module.
"""
from __future__ import annotations
import hashlib
import itertools
import json
import math
import re
from dataclasses import dataclass
from pathlib import Path
from typing import TYPE_CHECKING, Final, cast
if TYPE_CHECKING:
from collections.abc import Mapping
FROSSEN_SHA256: Final = "45828355036bb7fc57974bcb4d886ce13dd67a441b4c548836cc184ac3b3f6cc"
"""Checksum of the frozen file (commit 01b27fa), as recorded in the pre-registration."""
STANDARDSTI: Final = Path(__file__).resolve().parents[2] / "modell" / "parametere.json"
_TOPPFELT: Final = frozenset(
{
"versjon",
"beskrivelse",
"prisaar",
"valuta",
"omregning",
"monte_carlo",
"foelsomheter",
"fordelingstyper",
"status",
"parametere",
}
)
_PARAMETERFELT: Final = frozenset(
{
"id",
"symbol",
"navn",
"enhet",
"fordeling",
"poster",
"status",
"ligninger",
"kildeverdi",
"merknad",
}
)
_MONTE_CARLO_FELT: Final = frozenset(
{
"antall_trekninger",
"froe",
"generator",
"pert_form",
"rekkefolge",
"korrelasjon",
"avkorting",
"aarlige_hendelser",
"felles_trekninger",
"referansefil",
}
)
_FORDELINGSFELT: Final[dict[str, frozenset[str]]] = {
"fast": frozenset({"type", "verdi"}),
"jevn": frozenset({"type", "lav", "hoy"}),
"logjevn": frozenset({"type", "lav", "hoy"}),
"pert": frozenset({"type", "lav", "modus", "hoy", "form"}),
"lognormal": frozenset({"type", "median", "sigma", "min", "maks", "avkorting"}),
"diskret": frozenset({"type", "verdier", "vekter"}),
}
_AVKORTING: Final = "invers fordelingsfunksjon"
ENHETSFAKTOR: Final[dict[str, float]] = {
# money per capacity, energy and time -> kr, MW, MWh, years
"kr/kW": 1e3,
"kr/kW per år": 1e3,
"kr/MW per år": 1.0,
"kr/MWh": 1.0,
"mill. kr": 1e6,
"mrd. kr": 1e9,
"mill. kr/MW": 1e6,
"mill. kr/MW IT": 1e6,
"mill. kr/MW IT per år": 1e6,
"mill. kr/km": 1e6,
"kr per tonn": 1.0,
"kr per kr": 1.0,
# energy and power
"TWh": 1e6,
"TWh per år": 1e6,
"GW per år": 1e3,
"MW per år": 1.0,
"MW": 1.0,
"MW IT": 1.0,
# emissions and waste -> tonnes per MWh, tonnes per MW IT
"g CO2e/kWh": 1e-3,
"tonn CO2e per MW IT": 1.0,
"tonn uran per TWh": 1e-6,
# time, counts, shares and rates
"år": 1.0,
"kalenderår": 1.0,
"timer per år": 1.0,
"t/år": 1.0,
"antall": 1.0,
"anlegg": 1.0,
"årsverk": 1.0,
"km": 1.0,
"per år": 1.0,
"per reaktorår": 1.0,
"andel per år": 1.0,
"andel per år, reelt": 1.0,
"andel per år, reelt før skatt": 1.0,
"mill. tokens/s per MW": 1.0,
"–": 1.0,
}
"""Factor from each unit used in the file to the unit the equations use."""
_TABELLENHET: Final[dict[str, str]] = {
"pris_balanse": "TWh; øre/kWh (2023-kroner)",
"alpha": "km² per TWh per år; tomt i km² per MW IT",
"eierformer": "–; –; –; –; andel per år; andel per år; –",
}
"""Tables whose unit string is not a single unit; each has its own accessor."""
_SAMMENSATT_FELT: Final = ("investering", "drift", "fullasttimer", "levetid", "byggetid")
_POST: Final = re.compile(r"^K\d{2}-(\d{3}|K\d{2}|Ka\d{2})$")
_PRISOMRAADER: Final = ("NO1", "NO2", "NO3", "NO4", "NO5", "Norge")
_ORE_PER_KWH_TIL_KR_PER_MWH: Final = 10.0
_PRISAAR_NVE: Final = "2023"
_KARBONBANER: Final = ("lav", "sentral", "hoy")
_VEKTTOLERANSE: Final = 1e-9
class ParameterError(ValueError):
"""The parameter file is not the frozen one, or does not have the expected form."""
# ------------------------------------------------------------------ data model
@dataclass(frozen=True)
class Fordeling:
"""One distribution as the file states it, in the file's unit.
Attributes:
type: fast, jevn, logjevn, pert, lognormal or diskret.
tall: the numeric fields of the type (lav, hoy, modus, form, median,
sigma, min, maks); for a scalar ``fast`` the key is ``verdi``.
verdier: the values of a ``diskret`` distribution.
vekter: their weights, summing to one.
tabell: the value of a ``fast`` entry that is a list or a table.
"""
type: str
tall: Mapping[str, float]
verdier: tuple[float, ...] = ()
vekter: tuple[float, ...] = ()
tabell: object = None
@property
def er_fast(self) -> bool:
"""True when nothing is drawn for this quantity."""
return self.type == "fast"
@dataclass(frozen=True)
class Storrelse:
"""One scalar quantity: a parameter, or one field of a composite parameter.
Attributes:
navn: the parameter id, or ``id.field`` for a composite (``vind.investering``).
enhet: the unit in the file.
faktor: multiply a value in ``enhet`` by this to get the equations' unit.
fordeling: the distribution, in the file's unit.
"""
navn: str
enhet: str
faktor: float
fordeling: Fordeling
@dataclass(frozen=True)
class Parameter:
"""One entry of the file's ``parametere`` list."""
id: str
symbol: str
navn: str
enhet: str
status: str
poster: tuple[str, ...]
ligninger: str
kildeverdi: str
merknad: str
storrelser: tuple[Storrelse, ...]
@dataclass(frozen=True)
class MonteCarlo:
"""The file's set-up for the draws."""
antall_trekninger: int
froe: int
generator: str
pert_form: float
rekkefolge: str
korrelasjon: str
avkorting: str
aarlige_hendelser: str
felles_trekninger: str
referansefil: str
@dataclass(frozen=True)
class Prisscenario:
"""One of NVE's twelve scenarios for 2035 (S38), in the equations' units.
Attributes:
navn: the scenario name in the file.
balanse: Norway's power balance in a normal year, MWh.
pris: price per area and for Norway, kr/MWh in 2025 kroner.
"""
navn: str
balanse: float
pris: Mapping[str, float]
@dataclass(frozen=True)
class Parametersett:
"""The whole file, validated."""
versjon: str
prisaar: int
valuta: str
omregning: Mapping[str, object]
monte_carlo: MonteCarlo
foelsomheter: tuple[str, ...]
parametere: tuple[Parameter, ...]
def parameter(self, parameter_id: str) -> Parameter:
"""The entry with this id."""
for p in self.parametere:
if p.id == parameter_id:
return p
msg = f"no parameter with id {parameter_id!r}"
raise KeyError(msg)
def storrelser(self) -> tuple[Storrelse, ...]:
"""Every scalar quantity, in the order of the file (composites field by field)."""
return tuple(s for p in self.parametere for s in p.storrelser)
def storrelse(self, navn: str) -> Storrelse:
"""The scalar quantity with this name (``id`` or ``id.field``)."""
for s in self.storrelser():
if s.navn == navn:
return s
msg = f"no scalar quantity named {navn!r}"
raise KeyError(msg)
def stokastiske(self) -> tuple[Storrelse, ...]:
"""The quantities that are drawn, in the order they are drawn."""
return tuple(s for s in self.storrelser() if not s.fordeling.er_fast)
def fast(self, navn: str) -> float:
"""A fixed scalar value, converted to the equations' unit."""
s = self.storrelse(navn)
if not s.fordeling.er_fast or "verdi" not in s.fordeling.tall:
msg = f"{navn!r} is not a fixed scalar"
raise ParameterError(msg)
return s.fordeling.tall["verdi"] * s.faktor
def tabell(self, parameter_id: str) -> object:
"""The raw value of a fixed table or list, in the file's unit."""
fordeling = self.parameter(parameter_id).storrelser[0].fordeling
if fordeling.tabell is None:
msg = f"{parameter_id!r} is not a table"
raise ParameterError(msg)
return fordeling.tabell
def liste(self, parameter_id: str) -> tuple[float, ...]:
"""A fixed list of numbers (``stige``, ``P_u_sett``), converted to the equations' unit."""
s = self.parameter(parameter_id).storrelser[0]
verdier = _tall_liste(s.fordeling.tabell, f"{parameter_id}.fordeling.verdi")
return tuple(v * s.faktor for v in verdier)
def pris_balanse(self) -> tuple[Prisscenario, ...]:
"""NVE's twelve scenarios (S38): balance in MWh, prices in kr/MWh in 2025 kroner."""
kpi = _ordbok(self.omregning["kpi_norge_2015_100"], "omregning.kpi_norge_2015_100")
prisjustering = _tall(kpi[str(self.prisaar)], "kpi") / _tall(kpi[_PRISAAR_NVE], "kpi")
rader = _liste(self.tabell("pris_balanse"), "pris_balanse")
scenarioer = []
for i, rad in enumerate(rader):
felt = _liste(rad, f"pris_balanse[{i}]")
if len(felt) != len(_PRISOMRAADER) + 2:
msg = f"pris_balanse[{i}] should have {len(_PRISOMRAADER) + 2} columns"
raise ParameterError(msg)
priser = {
omraade: _tall(felt[2 + j], f"pris_balanse[{i}]")
* _ORE_PER_KWH_TIL_KR_PER_MWH
* prisjustering
for j, omraade in enumerate(_PRISOMRAADER)
}
scenarioer.append(
Prisscenario(
navn=_tekst(felt[0], f"pris_balanse[{i}]"),
balanse=_tall(felt[1], f"pris_balanse[{i}]") * ENHETSFAKTOR["TWh"],
pris=priser,
)
)
return tuple(scenarioer)
def karbonpris(self) -> dict[str, dict[int, float]]:
"""The three carbon price paths (lav, sentral, hoy): year -> kr per tonne."""
tabell = _ordbok(self.tabell("p_CO2"), "p_CO2")
baner: dict[str, dict[int, float]] = {bane: {} for bane in _KARBONBANER}
for aar, verdier in tabell.items():
tre = _tall_liste(verdier, f"p_CO2[{aar}]")
if len(tre) != len(_KARBONBANER):
msg = f"p_CO2[{aar}] should have {len(_KARBONBANER)} values"
raise ParameterError(msg)
for bane, verdi in zip(_KARBONBANER, tre, strict=True):
baner[bane][int(aar)] = verdi
return baner
def petroleumsinntekt(self) -> dict[int, float]:
"""The state's net cash flow from petroleum per year, kr in current prices (SNKS)."""
s = self.parameter("SNKS").storrelser[0]
tabell = _ordbok(s.fordeling.tabell, "SNKS")
return {int(aar): _tall(v, f"SNKS[{aar}]") * s.faktor for aar, v in tabell.items()}
# ------------------------------------------------------------------ JSON helpers
def _ordbok(verdi: object, hvor: str) -> dict[str, object]:
if not isinstance(verdi, dict):
msg = f"{hvor}: expected an object"
raise ParameterError(msg)
return cast("dict[str, object]", verdi)
def _liste(verdi: object, hvor: str) -> list[object]:
if not isinstance(verdi, list):
msg = f"{hvor}: expected a list"
raise ParameterError(msg)
return cast("list[object]", verdi)
def _tekst(verdi: object, hvor: str) -> str:
if not isinstance(verdi, str):
msg = f"{hvor}: expected text"
raise ParameterError(msg)
return verdi
def _tall(verdi: object, hvor: str) -> float:
if isinstance(verdi, bool) or not isinstance(verdi, int | float):
msg = f"{hvor}: expected a number"
raise ParameterError(msg)
tall = float(verdi)
if not math.isfinite(tall):
msg = f"{hvor}: expected a finite number"
raise ParameterError(msg)
return tall
def _heltall(verdi: object, hvor: str) -> int:
if isinstance(verdi, bool) or not isinstance(verdi, int):
msg = f"{hvor}: expected a whole number"
raise ParameterError(msg)
return verdi
def _tall_liste(verdi: object, hvor: str) -> tuple[float, ...]:
return tuple(_tall(v, hvor) for v in _liste(verdi, hvor))
def _krev_felt(funnet: Mapping[str, object], ventet: frozenset[str], hvor: str) -> None:
ukjente = sorted(set(funnet) - ventet)
mangler = sorted(ventet - set(funnet))
if ukjente:
msg = f"{hvor}: unknown field(s) {ukjente}"
raise ParameterError(msg)
if mangler:
msg = f"{hvor}: missing field(s) {mangler}"
raise ParameterError(msg)
def _uten_duplikater(par: list[tuple[str, object]]) -> dict[str, object]:
ordbok: dict[str, object] = {}
for nokkel, verdi in par:
if nokkel in ordbok:
msg = f"duplicate key {nokkel!r}"
raise ParameterError(msg)
ordbok[nokkel] = verdi
return ordbok
# ------------------------------------------------------------------- validation
def _enhetsfaktor(enhet: str, hvor: str) -> float:
if enhet not in ENHETSFAKTOR:
msg = f"{hvor}: unknown unit {enhet!r}"
raise ParameterError(msg)
return ENHETSFAKTOR[enhet]
def _krev_stigende(tall: Mapping[str, float], rekkefolge: tuple[str, ...], hvor: str) -> None:
verdier = [tall[n] for n in rekkefolge]
if any(a > b for a, b in itertools.pairwise(verdier)) or verdier[0] >= verdier[-1]:
msg = f"{hvor}: {' <= '.join(rekkefolge)} does not hold, or the range is empty"
raise ParameterError(msg)
def _tolk_diskret(raa: dict[str, object], hvor: str) -> Fordeling:
verdier = _tall_liste(raa["verdier"], hvor)
vekter = _tall_liste(raa["vekter"], hvor)
if not verdier or len(verdier) != len(vekter) or any(v < 0 for v in vekter):
msg = f"{hvor}: values and non-negative weights must have the same, non-zero length"
raise ParameterError(msg)
if abs(math.fsum(vekter) - 1.0) > _VEKTTOLERANSE:
msg = f"{hvor}: weights sum to {math.fsum(vekter)}, not 1"
raise ParameterError(msg)
return Fordeling(type="diskret", tall={}, verdier=verdier, vekter=vekter)
def _tolk_skalar_fordeling(raa: dict[str, object], hvor: str, pert_form: float) -> Fordeling:
"""Validate a distribution that is not ``fast`` and not ``sammensatt``."""
type_ = _tekst(raa["type"], hvor)
_krev_felt(raa, _FORDELINGSFELT[type_], hvor)
if type_ == "diskret":
return _tolk_diskret(raa, hvor)
if type_ == "lognormal" and raa["avkorting"] != _AVKORTING:
msg = f"{hvor}: truncation must be {_AVKORTING!r}"
raise ParameterError(msg)
tall = {n: _tall(v, f"{hvor}.{n}") for n, v in raa.items() if n not in {"type", "avkorting"}}
if type_ == "jevn":
_krev_stigende(tall, ("lav", "hoy"), hvor)
elif type_ == "logjevn":
_krev_stigende(tall, ("lav", "hoy"), hvor)
if tall["lav"] <= 0:
msg = f"{hvor}: a log-uniform range must be positive"
raise ParameterError(msg)
elif type_ == "pert":
_krev_stigende(tall, ("lav", "modus", "hoy"), hvor)
if tall["form"] != pert_form:
msg = f"{hvor}: PERT shape {tall['form']} differs from monte_carlo.pert_form"
raise ParameterError(msg)
else: # lognormal
_krev_stigende(tall, ("min", "maks"), hvor)
if tall["median"] <= 0 or tall["sigma"] <= 0 or tall["min"] < 0:
msg = f"{hvor}: median and sigma must be positive and min non-negative"
raise ParameterError(msg)
return Fordeling(type=type_, tall=tall)
def _tolk_fordeling(raa: object, hvor: str, typer: frozenset[str], pert_form: float) -> Fordeling:
"""Validate one distribution that is not ``sammensatt``."""
felt = _ordbok(raa, hvor)
if "type" not in felt:
msg = f"{hvor}: missing field(s) ['type']"
raise ParameterError(msg)
type_ = _tekst(felt["type"], hvor)
if type_ not in typer or type_ not in _FORDELINGSFELT:
msg = f"{hvor}: unknown distribution type {type_!r}"
raise ParameterError(msg)
if type_ != "fast":
return _tolk_skalar_fordeling(felt, hvor, pert_form)
_krev_felt(felt, _FORDELINGSFELT["fast"], hvor)
verdi = felt["verdi"]
if isinstance(verdi, list | dict):
return Fordeling(type="fast", tall={}, tabell=verdi)
return Fordeling(type="fast", tall={"verdi": _tall(verdi, hvor)})
def _tolk_storrelser(
parameter_id: str,
enhet: str,
raa: object,
typer: frozenset[str],
pert_form: float,
) -> tuple[Storrelse, ...]:
hvor = f"{parameter_id}.fordeling"
felt = _ordbok(raa, hvor)
if felt.get("type") != "sammensatt":
fordeling = _tolk_fordeling(felt, hvor, typer, pert_form)
if parameter_id in _TABELLENHET:
if enhet != _TABELLENHET[parameter_id] or fordeling.tabell is None:
msg = f"{parameter_id}: expected a table with unit {_TABELLENHET[parameter_id]!r}"
raise ParameterError(msg)
return (Storrelse(parameter_id, enhet, 1.0, fordeling),)
return (Storrelse(parameter_id, enhet, _enhetsfaktor(enhet, parameter_id), fordeling),)
if "sammensatt" not in typer:
msg = f"{hvor}: unknown distribution type 'sammensatt'"
raise ParameterError(msg)
navn = tuple(n for n in felt if n != "type")
enheter = tuple(enhet.split("; "))
if navn != _SAMMENSATT_FELT or len(enheter) != len(navn):
msg = (
f"{hvor}: a composite must have the fields {list(_SAMMENSATT_FELT)} with one unit each"
)
raise ParameterError(msg)
return tuple(
Storrelse(
f"{parameter_id}.{n}",
e,
_enhetsfaktor(e, f"{parameter_id}.{n}"),
_tolk_fordeling(felt[n], f"{hvor}.{n}", typer - {"sammensatt"}, pert_form),
)
for n, e in zip(navn, enheter, strict=True)
)
def _tolk_parameter(
raa: object,
nummer: int,
statuser: frozenset[str],
typer: frozenset[str],
pert_form: float,
) -> Parameter:
felt = _ordbok(raa, f"parametere[{nummer}]")
hvor = f"parametere[{nummer}] ({felt.get('id', '?')})"
_krev_felt(felt, _PARAMETERFELT, hvor)
parameter_id = _tekst(felt["id"], hvor)
status = _tekst(felt["status"], hvor)
if status not in statuser:
msg = f"{hvor}: unknown status {status!r}"
raise ParameterError(msg)
poster = tuple(_tekst(p, hvor) for p in _liste(felt["poster"], hvor))
feil_poster = [p for p in poster if not _POST.match(p)]
if feil_poster:
msg = f"{hvor}: malformed source entries {feil_poster}"
raise ParameterError(msg)
if status in {"kilde", "avledet"} and not poster:
msg = f"{hvor}: status {status!r} requires at least one source entry"
raise ParameterError(msg)
enhet = _tekst(felt["enhet"], hvor)
return Parameter(
id=parameter_id,
symbol=_tekst(felt["symbol"], hvor),
navn=_tekst(felt["navn"], hvor),
enhet=enhet,
status=status,
poster=poster,
ligninger=_tekst(felt["ligninger"], hvor),
kildeverdi=_tekst(felt["kildeverdi"], hvor),
merknad=_tekst(felt["merknad"], hvor),
storrelser=_tolk_storrelser(parameter_id, enhet, felt["fordeling"], typer, pert_form),
)
def _tolk_monte_carlo(raa: object) -> MonteCarlo:
felt = _ordbok(raa, "monte_carlo")
_krev_felt(felt, _MONTE_CARLO_FELT, "monte_carlo")
return MonteCarlo(
antall_trekninger=_heltall(felt["antall_trekninger"], "monte_carlo.antall_trekninger"),
froe=_heltall(felt["froe"], "monte_carlo.froe"),
generator=_tekst(felt["generator"], "monte_carlo.generator"),
pert_form=_tall(felt["pert_form"], "monte_carlo.pert_form"),
rekkefolge=_tekst(felt["rekkefolge"], "monte_carlo.rekkefolge"),
korrelasjon=_tekst(felt["korrelasjon"], "monte_carlo.korrelasjon"),
avkorting=_tekst(felt["avkorting"], "monte_carlo.avkorting"),
aarlige_hendelser=_tekst(felt["aarlige_hendelser"], "monte_carlo.aarlige_hendelser"),
felles_trekninger=_tekst(felt["felles_trekninger"], "monte_carlo.felles_trekninger"),
referansefil=_tekst(felt["referansefil"], "monte_carlo.referansefil"),
)
def tolk_parametere(data: object) -> Parametersett:
"""Validate parsed JSON and return the parameter set. Raises ``ParameterError``."""
topp = _ordbok(data, "file")
_krev_felt(topp, _TOPPFELT, "file")
monte_carlo = _tolk_monte_carlo(topp["monte_carlo"])
statuser = frozenset(_ordbok(topp["status"], "status"))
typer = frozenset(_ordbok(topp["fordelingstyper"], "fordelingstyper"))
parametere = tuple(
_tolk_parameter(raa, i, statuser, typer, monte_carlo.pert_form)
for i, raa in enumerate(_liste(topp["parametere"], "parametere"))
)
ider = [p.id for p in parametere]
duplikater = sorted({i for i in ider if ider.count(i) > 1})
if duplikater:
msg = f"duplicate parameter id(s) {duplikater}"
raise ParameterError(msg)
sett = Parametersett(
versjon=_tekst(topp["versjon"], "versjon"),
prisaar=_heltall(topp["prisaar"], "prisaar"),
valuta=_tekst(topp["valuta"], "valuta"),
omregning=_ordbok(topp["omregning"], "omregning"),
monte_carlo=monte_carlo,
foelsomheter=tuple(_tekst(f, "foelsomheter") for f in _liste(topp["foelsomheter"], "f")),
parametere=parametere,
)
if sett.fast("N_trekk") != monte_carlo.antall_trekninger:
msg = "N_trekk differs from monte_carlo.antall_trekninger"
raise ParameterError(msg)
return sett
def sjekksum(sti: Path = STANDARDSTI) -> str:
"""SHA-256 of the file's bytes, as ``shasum -a 256`` prints it."""
return hashlib.sha256(sti.read_bytes()).hexdigest()
def les_parametere(sti: Path = STANDARDSTI, *, krev_frossen: bool = True) -> Parametersett:
"""Read and validate the parameter file.
With ``krev_frossen=True`` (the default) a file whose checksum differs from
the frozen one is refused. A deviation from the freeze needs a new entry in
the pre-registration and a new checksum here.
"""
raa = sti.read_bytes()
if krev_frossen and hashlib.sha256(raa).hexdigest() != FROSSEN_SHA256:
msg = f"{sti} is not the frozen parameter file (SHA-256 differs from the pre-registration)"
raise ParameterError(msg)
try:
data = json.loads(raa.decode("utf-8"), object_pairs_hook=_uten_duplikater)
except json.JSONDecodeError as feil:
msg = f"{sti} is not valid JSON: {feil}"
raise ParameterError(msg) from feil
return tolk_parametere(data)

View file

@ -0,0 +1,225 @@
"""The 10 000 Monte Carlo draws of the frozen parameters (chapter 11 of the specification).
The set-up comes from the parameter file: seed, generator, order, PERT shape,
correlations and truncation. The draws are stored next to the code, in the
units of the parameter file, so that every later computation and every reader
uses the same numbers:
- ``data/trekninger.npy``: float64 table, one row per draw, one column per drawn quantity.
- ``data/trekninger.json``: the column names and units, the set-up and the checksums.
How one draw is made:
1. Independent standard normal numbers, one per drawn quantity, in the order
of the parameter file (a composite parameter field by field). Fixed values
use no random number.
2. Four pairs are correlated with a Gaussian copula (2 x 2 Cholesky factor).
The coefficients in the file are rank correlations; the correlation of the
normal numbers is 2 sin(pi r / 6), which gives rank correlation r.
3. The normal numbers are turned into uniform numbers and put into the inverse
distribution function of each quantity.
4. KF is set to (1 - o_p)(1 - o_f) when the drawn value is higher.
Events that are drawn per year (the export rule) use their own stream and are
generated together with the build-out (S22), not here.
Run ``python -m tokenfabrikker.trekninger lag`` to write the files and
``python -m tokenfabrikker.trekninger kontroll`` to check that they can be
reproduced.
"""
from __future__ import annotations
import argparse
import hashlib
import json
import math
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import TYPE_CHECKING, Final
import numpy as np
import scipy
from scipy import special
from tokenfabrikker import fordelinger
from tokenfabrikker.parametere import (
FROSSEN_SHA256,
STANDARDSTI,
ParameterError,
Parametersett,
les_parametere,
)
if TYPE_CHECKING:
import numpy.typing as npt
DATAMAPPE: Final = Path(__file__).resolve().parents[2] / "data"
TABELLFIL: Final = "trekninger.npy"
BESKRIVELSESFIL: Final = "trekninger.json"
GENERATOR: Final = "PCG64 (numpy.random.Generator)"
"""The only generator this module implements; the parameter file must name it."""
KORRELASJONER: Final[tuple[tuple[str, str, str], ...]] = (
("o_xi", "tau_N", "korr_xi_tau"),
("rho_N", "rho_D", "korr_rho"),
("KF", "o_f_stor", "korr_KF_of"),
("PUE", "PUE_v", "korr_PUE"),
)
"""Correlated pairs (chapter 11) and the parameter that holds each rank correlation."""
HELTALL: Final = frozenset({"n_0"})
"""Uniform quantities that the parameter file's note says are whole numbers."""
TOLERANSE: Final = 1e-12
"""Relative deviation accepted as 'within tolerance' when the stored draws are checked."""
@dataclass(frozen=True)
class Trekninger:
"""The draws: ``tabell[i, j]`` is draw ``i`` of quantity ``kolonner[j]``, in ``enheter[j]``."""
kolonner: tuple[str, ...]
enheter: tuple[str, ...]
tabell: npt.NDArray[np.float64]
def kolonne(self, navn: str) -> npt.NDArray[np.float64]:
"""All draws of one quantity, in the unit of the parameter file."""
return self.tabell[:, self.kolonner.index(navn)]
def normalkorrelasjon(rangkorrelasjon: float) -> float:
"""Correlation of the normal numbers that gives this rank correlation: 2 sin(pi r / 6)."""
return 2.0 * math.sin(math.pi * rangkorrelasjon / 6.0)
def trekk(sett: Parametersett) -> Trekninger:
"""Make the draws exactly as the parameter file's ``monte_carlo`` block prescribes."""
oppsett = sett.monte_carlo
if oppsett.generator != GENERATOR:
msg = f"generator {oppsett.generator!r} is not implemented"
raise ParameterError(msg)
storrelser = sett.stokastiske()
kolonner = tuple(s.navn for s in storrelser)
rng = np.random.Generator(np.random.PCG64(oppsett.froe))
z = rng.standard_normal((oppsett.antall_trekninger, len(kolonner)))
for navn_a, navn_b, navn_korrelasjon in KORRELASJONER:
a, b = sorted((kolonner.index(navn_a), kolonner.index(navn_b)))
r = normalkorrelasjon(sett.fast(navn_korrelasjon))
z[:, b] = r * z[:, a] + math.sqrt(1.0 - r * r) * z[:, b]
u = np.asarray(special.ndtr(z), dtype=np.float64)
tabell = np.empty_like(z)
for j, storrelse in enumerate(storrelser):
tabell[:, j] = fordelinger.invers(
storrelse.fordeling, u[:, j], heltall=storrelse.navn in HELTALL
)
kf, o_p, o_f = (kolonner.index(n) for n in ("KF", "o_p", "o_f_stor"))
tabell[:, kf] = np.minimum(tabell[:, kf], (1.0 - tabell[:, o_p]) * (1.0 - tabell[:, o_f]))
return Trekninger(kolonner, tuple(s.enhet for s in storrelser), tabell)
def beskrivelse(trekninger: Trekninger, sett: Parametersett, sha256_tabell: str) -> str:
"""The text of ``trekninger.json`` for these draws."""
innhold = {
"beskrivelse": (
"Trekningene av de frosne parameterne i modell/parametere.json. Én rad per "
"trekning, én kolonne per størrelse som trekkes, i parameterfilas enheter."
),
"tabell": TABELLFIL,
"sha256_tabell": sha256_tabell,
"sha256_parametere": FROSSEN_SHA256,
"antall_trekninger": sett.monte_carlo.antall_trekninger,
"froe": sett.monte_carlo.froe,
"generator": sett.monte_carlo.generator,
"numpy": np.__version__,
"scipy": scipy.__version__,
"korrelasjoner": [
{"a": a, "b": b, "rangkorrelasjon": sett.fast(k)} for a, b, k in KORRELASJONER
],
"heltall": sorted(HELTALL),
"kolonner": [
{"navn": n, "enhet": e}
for n, e in zip(trekninger.kolonner, trekninger.enheter, strict=True)
],
}
return json.dumps(innhold, ensure_ascii=False, indent=2) + "\n"
def _tabellbytes(tabell: npt.NDArray[np.float64]) -> bytes:
"""The bytes ``numpy.save`` writes for the table (little-endian float64, C order)."""
import io # noqa: PLC0415 (only needed here)
buffer = io.BytesIO()
np.save(buffer, np.ascontiguousarray(tabell, dtype="<f8"), allow_pickle=False)
return buffer.getvalue()
def skriv(trekninger: Trekninger, sett: Parametersett, mappe: Path = DATAMAPPE) -> str:
"""Write both files and return the checksum of the table."""
mappe.mkdir(parents=True, exist_ok=True)
raa = _tabellbytes(trekninger.tabell)
sha256 = hashlib.sha256(raa).hexdigest()
(mappe / TABELLFIL).write_bytes(raa)
(mappe / BESKRIVELSESFIL).write_text(beskrivelse(trekninger, sett, sha256), encoding="utf-8")
return sha256
def les(mappe: Path = DATAMAPPE) -> Trekninger:
"""Read the stored draws. The table must match the checksum in the description file."""
innhold = json.loads((mappe / BESKRIVELSESFIL).read_text(encoding="utf-8"))
raa = (mappe / TABELLFIL).read_bytes()
if hashlib.sha256(raa).hexdigest() != innhold["sha256_tabell"]:
msg = f"{mappe / TABELLFIL} does not match the checksum in {BESKRIVELSESFIL}"
raise ParameterError(msg)
tabell = np.load(mappe / TABELLFIL, allow_pickle=False)
kolonner = tuple(k["navn"] for k in innhold["kolonner"])
enheter = tuple(k["enhet"] for k in innhold["kolonner"])
return Trekninger(kolonner, enheter, tabell)
def kontroller(sett: Parametersett, mappe: Path = DATAMAPPE) -> tuple[str, float]:
"""Make the draws again and compare with the stored table.
Returns the verdict and the largest relative deviation: ``identisk`` (bit
for bit), ``innenfor toleranse`` (differences below ``TOLERANSE``, which
another processor or library build can give) or ``endret``.
"""
lagret = les(mappe)
ny = trekk(sett)
if ny.kolonner != lagret.kolonner or ny.tabell.shape != lagret.tabell.shape:
return "endret", math.inf
if _tabellbytes(ny.tabell) == (mappe / TABELLFIL).read_bytes():
return "identisk", 0.0
nevner = np.maximum(np.abs(lagret.tabell), np.finfo(np.float64).tiny)
avvik = float(np.max(np.abs(ny.tabell - lagret.tabell) / nevner))
return ("innenfor toleranse" if avvik <= TOLERANSE else "endret"), avvik
def main(argumenter: list[str] | None = None) -> int:
"""Command line: ``lag`` writes the draws, ``kontroll`` checks that they can be reproduced."""
tolker = argparse.ArgumentParser(description=__doc__.splitlines()[0] if __doc__ else None)
tolker.add_argument("kommando", choices=("lag", "kontroll"))
tolker.add_argument("--parametere", type=Path, default=STANDARDSTI)
tolker.add_argument("--mappe", type=Path, default=DATAMAPPE)
valg = tolker.parse_args(argumenter)
sett = les_parametere(valg.parametere)
if valg.kommando == "lag":
trekninger = trekk(sett)
sha256 = skriv(trekninger, sett, valg.mappe)
rader, kolonner = trekninger.tabell.shape
sys.stdout.write(
f"{rader} trekninger av {kolonner} størrelser skrevet. SHA-256: {sha256}\n"
)
return 0
dom, avvik = kontroller(sett, valg.mappe)
sys.stdout.write(f"{dom} (største relative avvik {avvik:.3g})\n")
return 0 if dom != "endret" else 1
if __name__ == "__main__":
raise SystemExit(main())

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)