feat(kode): add the levelised equations, the parameter reader and the draws
One pure function per equation for chapters 1 to 3 of the specification (S1-S21, S36, S43-S47), a strict reader for the frozen parameter file with checksum, validation and unit conversion, and the 10 000 Monte Carlo draws of the 87 drawn quantities, stored in data/ and reproducible bit for bit. Tests: unit tests and edge cases per equation, the reader, the draws, and known answers from Argonne, NOU 2026: 4, Epoch and NVE with the sources' own assumptions. Five comparisons miss the 5 % tolerance and are kept as strict expected failures with the measured deviation. No result for the hypothesis is computed. ruff ALL and mypy strict pass. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
parent
736f636691
commit
a63f66c416
14 changed files with 3656 additions and 0 deletions
386
data/trekninger.json
Normal file
386
data/trekninger.json
Normal 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
BIN
data/trekninger.npy
Normal file
Binary file not shown.
59
pyproject.toml
Normal file
59
pyproject.toml
Normal 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
5
requirements-dev.txt
Normal 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
2
requirements.txt
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
numpy==2.5.4
|
||||
scipy==1.18.1
|
||||
1
src/tokenfabrikker/__init__.py
Normal file
1
src/tokenfabrikker/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
"""tokenfabrikker: the model in modell/spesifikasjon.md, one function per equation."""
|
||||
103
src/tokenfabrikker/fordelinger.py
Normal file
103
src/tokenfabrikker/fordelinger.py
Normal 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)
|
||||
674
src/tokenfabrikker/ligninger.py
Normal file
674
src/tokenfabrikker/ligninger.py
Normal 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)
|
||||
637
src/tokenfabrikker/parametere.py
Normal file
637
src/tokenfabrikker/parametere.py
Normal 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)
|
||||
225
src/tokenfabrikker/trekninger.py
Normal file
225
src/tokenfabrikker/trekninger.py
Normal 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
456
tests/test_fasit.py
Normal file
|
|
@ -0,0 +1,456 @@
|
|||
"""Known answers: the model's own functions, fed with a source's assumptions, against its result.
|
||||
|
||||
None of these tests uses the frozen parameters, and none computes a result for
|
||||
the hypothesis. Each one takes the inputs a published calculation states, runs
|
||||
them through the same functions the model uses, and compares with the number
|
||||
the source reports. The tolerance is 5 %, the one the specification sets for
|
||||
the Argonne test (chapter 1.3).
|
||||
|
||||
A comparison that misses the tolerance is kept as an expected failure with the
|
||||
measured deviation and the cause where it is known. No parameter and no
|
||||
equation is tuned to make a test pass.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import ligninger as lg
|
||||
|
||||
pytestmark = pytest.mark.fasit
|
||||
|
||||
TOLERANSE = 0.05
|
||||
|
||||
|
||||
def _avvik(beregnet: float, fasit: float) -> float:
|
||||
return beregnet / fasit - 1.0
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- Argonne
|
||||
# Stauff et al. (ANL/NSE-25/47, 2025), table 6-1 (curves) and table 6-3 (results);
|
||||
# source entry K12-001. Method: Hanna et al. (Energies 17, 5073, 2024). 2022 USD, 6 %, 40 years.
|
||||
#
|
||||
# What the two sources state, and how it is mapped onto the model's functions:
|
||||
# - overnight cost 18 562 P^-0.16 USD/kW: S2 with c_N_ref at 1 000 MW and nu = 0.84
|
||||
# - learning rate 0.145 P^-0.083, "renormalized to start from the 2nd unit" (Hanna): S2 with
|
||||
# n_0 = 1, so that the first unit on the site costs the between-of-a-kind figure
|
||||
# - construction time 16 P^0.25 months, interest during construction at 6 %: S3
|
||||
# - capacity factor from refuelling only, four weeks every 2 years (5 P^-0.17 years below
|
||||
# 200 MW) (Hanna, section 3)
|
||||
# - number of units without grid: 1 + demand / unit size (ANL p. 51)
|
||||
# - O&M with fuel 181 P^-0.28 USD/MWh, times 0.53/N + 0.47 with N units on the site
|
||||
# The equations of the article are images that could not be read, and the link to its code
|
||||
# was not recoverable, so two points are this project's reading: n_0 = 1, and whether the
|
||||
# O&M of a unit follows its capacity or the energy delivered (both are tested below).
|
||||
|
||||
ARGONNE_MED_NETT = ( # demand MWe, unit MWe, units, USD/MWh (option 1)
|
||||
(50, 50, 1, 147),
|
||||
(100, 50, 2, 129),
|
||||
(500, 500, 1, 97),
|
||||
(1000, 1000, 1, 87),
|
||||
(2000, 1000, 2, 79),
|
||||
(6000, 1000, 6, 72),
|
||||
)
|
||||
ARGONNE_UTEN_NETT = ( # option 4
|
||||
(50, 5, 11, 174),
|
||||
(100, 10, 11, 153),
|
||||
(500, 50, 11, 116),
|
||||
(1000, 50, 21, 103),
|
||||
(2000, 100, 21, 92),
|
||||
(6000, 400, 16, 77),
|
||||
)
|
||||
ARGONNE_RENTE = 0.06
|
||||
ARGONNE_AAR = 40.0
|
||||
GRENSE_BRENSELSBYTTE_MW = 200.0
|
||||
UKER_STANS = 4.0
|
||||
UKER_PER_AAR = 365.25 / 7.0
|
||||
|
||||
|
||||
def _argonne_kapasitetsfaktor(P: float) -> float:
|
||||
intervall: float = 2.0 if P >= GRENSE_BRENSELSBYTTE_MW else 5.0 * P**-0.17
|
||||
return 1.0 - UKER_STANS / UKER_PER_AAR / intervall
|
||||
|
||||
|
||||
def _argonne_drift(P: float, N: int) -> float:
|
||||
return float(181.0 * P**-0.28 * (0.53 / N + 0.47))
|
||||
|
||||
|
||||
def _argonne_enheter(P: float, N: int, n_0: int) -> list[float]:
|
||||
c_ref = 18562.0 * 1000.0**-0.16 * 1e3 # USD per MW at 1 000 MW
|
||||
return [
|
||||
lg.s3_investering_med_renter(
|
||||
xi_N=1.0,
|
||||
c_N=lg.s2_investering_per_mw(
|
||||
c_N_ref=c_ref,
|
||||
P_u=P,
|
||||
P_ref=1000.0,
|
||||
nu=0.84,
|
||||
ell=0.145 * P**-0.083,
|
||||
n_0=n_0,
|
||||
n=n,
|
||||
),
|
||||
P_u=P,
|
||||
rho=ARGONNE_RENTE,
|
||||
tau_N=16.0 * P**0.25 / 12.0,
|
||||
)
|
||||
for n in range(1, N + 1)
|
||||
]
|
||||
|
||||
|
||||
def argonne_med_nett(P: float, N: int, *, n_0: int = 1) -> float:
|
||||
"""Option 1 (through the grid): S5 with the study's curves, USD/MWh."""
|
||||
kf = _argonne_kapasitetsfaktor(P)
|
||||
return lg.s5_lcoe_kjernekraft(
|
||||
I_N=_argonne_enheter(P, N, n_0),
|
||||
rho=ARGONNE_RENTE,
|
||||
L_N=ARGONNE_AAR,
|
||||
f_N_enhet=0.0,
|
||||
D_avv=0.0,
|
||||
P_u=P,
|
||||
E_N=lg.s4_energi_kjernekraft(KF=kf, N_u=N, P_u=P),
|
||||
v_N=_argonne_drift(P, N),
|
||||
u_N=0.0,
|
||||
d_N=0.0,
|
||||
q_N=0.0,
|
||||
)
|
||||
|
||||
|
||||
def argonne_uten_nett(last: float, P: float, N: int, *, n_0: int = 1, drift_fast: bool) -> float:
|
||||
"""Option 4 (no grid): S9 without buffer and external supply, USD/MWh delivered.
|
||||
|
||||
``drift_fast=True`` charges the O&M of every unit as a fixed yearly cost at
|
||||
the unit's own capacity factor; ``False`` charges it per MWh delivered.
|
||||
"""
|
||||
kf = _argonne_kapasitetsfaktor(P)
|
||||
drift = _argonne_drift(P, N)
|
||||
return lg.s9_kraftkostnad_dedikert(
|
||||
I_N=_argonne_enheter(P, N, n_0),
|
||||
rho_A=ARGONNE_RENTE,
|
||||
L_N=ARGONNE_AAR,
|
||||
f_N_enhet=drift * lg.TIMER_PER_AAR * kf if drift_fast else 0.0,
|
||||
D_avv=0.0,
|
||||
P_u=P,
|
||||
P_buf=0.0,
|
||||
c_buf=0.0,
|
||||
f_buf=0.0,
|
||||
L_buf=20.0,
|
||||
I_g_aar=0.0,
|
||||
E_D=lg.s10_energi_datasenter(lam=1.0, PUE=1.0, P_IT=last),
|
||||
v_N=0.0 if drift_fast else drift,
|
||||
u_N_A=0.0,
|
||||
d_N=0.0,
|
||||
q_N=0.0,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("last", "P", "N", "fasit"), ARGONNE_MED_NETT)
|
||||
def test_argonne_med_nett(last: int, P: int, N: int, fasit: int) -> None:
|
||||
"""Table 6-3, option 1: all six rows within 5 % (87 USD/MWh at 1 000 MWe is hit to 0.1 %)."""
|
||||
assert last == N * P
|
||||
assert abs(_avvik(argonne_med_nett(P, N), fasit)) <= TOLERANSE
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("last", "P", "N", "fasit"), ARGONNE_UTEN_NETT)
|
||||
def test_argonne_uten_nett_drift_etter_kapasitet(last: int, P: int, N: int, fasit: int) -> None:
|
||||
"""Table 6-3, option 4, with O&M following installed capacity: all six rows within 5 %."""
|
||||
assert 1 + last // P == N
|
||||
assert abs(_avvik(argonne_uten_nett(last, P, N, drift_fast=True), fasit)) <= TOLERANSE
|
||||
|
||||
|
||||
_FOR_LAVT = "O&M charged per MWh delivered gives a result more than 5 % below the study"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("last", "P", "N", "fasit"),
|
||||
[
|
||||
pytest.param(50, 5, 11, 174, marks=pytest.mark.xfail(strict=True, reason=_FOR_LAVT)),
|
||||
pytest.param(100, 10, 11, 153, marks=pytest.mark.xfail(strict=True, reason=_FOR_LAVT)),
|
||||
pytest.param(500, 50, 11, 116, marks=pytest.mark.xfail(strict=True, reason=_FOR_LAVT)),
|
||||
(1000, 50, 21, 103),
|
||||
(2000, 100, 21, 92),
|
||||
(6000, 400, 16, 77),
|
||||
],
|
||||
)
|
||||
def test_argonne_uten_nett_drift_etter_energi(last: int, P: int, N: int, fasit: int) -> None:
|
||||
"""Table 6-3, option 4, with O&M per MWh delivered: three of six rows miss by 6 to 7 %."""
|
||||
assert abs(_avvik(argonne_uten_nett(last, P, N, drift_fast=False), fasit)) <= TOLERANSE
|
||||
|
||||
|
||||
def test_argonne_uten_laering_fra_andre_enhet_feiler() -> None:
|
||||
"""With n_0 = 0 (learning from the first unit) the 103 USD/MWh row is missed by about 10 %."""
|
||||
lavt = argonne_uten_nett(1000, 50, 21, n_0=0, drift_fast=False)
|
||||
assert _avvik(lavt, 103) < -TOLERANSE
|
||||
|
||||
|
||||
def test_argonne_nett_er_billigere_enn_uten_nett() -> None:
|
||||
"""The study's headline: 87 with grid against 103 without, for 1 000 MWe."""
|
||||
med = argonne_med_nett(1000, 1)
|
||||
uten = argonne_uten_nett(1000, 50, 21, drift_fast=True)
|
||||
assert uten / med == pytest.approx(103 / 87, rel=TOLERANSE)
|
||||
|
||||
|
||||
# ------------------------------------------------------------- NOU 2026: 4, appendix 4
|
||||
# The Nuclear Power Committee's own spreadsheet (digital appendix 4, sheets "Forutsetninger"
|
||||
# and "Kontantstrøm"; source entries K16-011, K16-012, K16-013, K03-021). 1 400 MW, start 2040,
|
||||
# investment spread evenly over 14 years, 80 years of operation, 7 600 full-load hours, 5 %.
|
||||
# The NOU text reports the power price needed for a positive present value: 132 øre/kWh ("Lav")
|
||||
# and 219 øre/kWh ("Høy"). Revenue per MWh in the sheet is price x value factor 1.05, plus 5 %
|
||||
# for heat and 1 % for system services on top of that, plus 10 kr/MWh for guarantees of origin.
|
||||
|
||||
NOU_EFFEKT = 1400.0
|
||||
NOU_TIMER = 7600.0
|
||||
NOU_RENTE = 0.05
|
||||
NOU_BYGGEAAR = 14
|
||||
NOU_DRIFTSAAR = 80
|
||||
NOU_VERDIFAKTOR = 1.05
|
||||
NOU_TILLEGG = 0.05 + 0.01
|
||||
NOU_OPPRINNELSE = 10.0 # kr/MWh
|
||||
NOU_SCENARIOER = { # kr/kW, kr/kW per year, kr/MWh (variable, fuel, waste and decommissioning)
|
||||
"Lav": (109_000.0, 1610.0, 115.0, 60.0, 70.0),
|
||||
"Høy": (177_000.0, 2515.0, 187.0, 100.0, 200.0),
|
||||
}
|
||||
|
||||
|
||||
def nou_balansepris_modell(scenario: str) -> float:
|
||||
"""Break-even power price from the model's S3 and S5, øre/kWh."""
|
||||
investering, fast, variabel, brensel, avfall = NOU_SCENARIOER[scenario]
|
||||
enhet = lg.s3_investering_med_renter(
|
||||
xi_N=1.0, c_N=investering * 1e3, P_u=NOU_EFFEKT, rho=NOU_RENTE, tau_N=NOU_BYGGEAAR
|
||||
)
|
||||
lcoe = lg.s5_lcoe_kjernekraft(
|
||||
I_N=[enhet],
|
||||
rho=NOU_RENTE,
|
||||
L_N=NOU_DRIFTSAAR,
|
||||
f_N_enhet=fast * 1e3,
|
||||
D_avv=0.0,
|
||||
P_u=NOU_EFFEKT,
|
||||
E_N=NOU_TIMER * NOU_EFFEKT,
|
||||
v_N=variabel,
|
||||
u_N=brensel,
|
||||
d_N=avfall,
|
||||
q_N=0.0,
|
||||
)
|
||||
return (lcoe - NOU_OPPRINNELSE) / (NOU_VERDIFAKTOR * (1.0 + NOU_TILLEGG)) / 10.0
|
||||
|
||||
|
||||
def nou_regneark_naaverdi(scenario: str, kraftpris: float) -> float:
|
||||
"""The spreadsheet's own present value (cell Kontantstrøm!B32), mill. kr.
|
||||
|
||||
Written out here from the sheet's formulas, independently of the model:
|
||||
yearly amounts from 2026, discounted with Excel's NPV (first year one period).
|
||||
``kraftpris`` in øre/kWh.
|
||||
"""
|
||||
investering, fast, variabel, brensel, avfall = NOU_SCENARIOER[scenario]
|
||||
gwh = NOU_TIMER * NOU_EFFEKT / 1e3
|
||||
salg = kraftpris * NOU_VERDIFAKTOR * gwh / 100.0
|
||||
inntekt = salg * (1.0 + NOU_TILLEGG) + gwh * NOU_OPPRINNELSE / 1e3
|
||||
drift = variabel + fast * 1e3 / NOU_TIMER
|
||||
kostnad = gwh * (brensel + avfall + drift) / 1e3
|
||||
strom = [-investering * NOU_EFFEKT / 1e3 / NOU_BYGGEAAR] * NOU_BYGGEAAR
|
||||
strom += [inntekt - kostnad] * NOU_DRIFTSAAR
|
||||
return sum(belop / (1.0 + NOU_RENTE) ** (aar + 1) for aar, belop in enumerate(strom))
|
||||
|
||||
|
||||
def nou_regneark_balansepris(scenario: str) -> float:
|
||||
"""The price at which the spreadsheet's present value is zero, øre/kWh."""
|
||||
ved_null = nou_regneark_naaverdi(scenario, 0.0)
|
||||
ved_hundre = nou_regneark_naaverdi(scenario, 100.0)
|
||||
return -ved_null / (ved_hundre - ved_null) * 100.0
|
||||
|
||||
|
||||
def test_nou_regnearket_er_gjengitt_riktig() -> None:
|
||||
"""The replica gives the sheet's own number: -84 626.139 mill. kr at 60 øre/kWh ("Lav")."""
|
||||
assert nou_regneark_naaverdi("Lav", 60.0) == pytest.approx(-84626.139055439344, rel=1e-12)
|
||||
|
||||
|
||||
def test_nou_regnearket_gir_132_men_222() -> None:
|
||||
"""The sheet gives 132.2 for "Lav", as the NOU says, but 222.1 for "Høy", not 219.
|
||||
|
||||
The NOU text (p. 381-382) says 219. With all three choices on "Høy" the
|
||||
sheet's formulas give 222.1; the difference of 1.4 % is not explained.
|
||||
"""
|
||||
assert nou_regneark_balansepris("Lav") == pytest.approx(132.2, abs=0.05)
|
||||
assert nou_regneark_balansepris("Høy") == pytest.approx(222.1, abs=0.05)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("scenario", "fasit"), [("Lav", 132.0), ("Høy", 219.0)])
|
||||
def test_nou_balansepris(scenario: str, fasit: float) -> None:
|
||||
"""S3 and S5 with the committee's assumptions: 134.5 and 225.8 against 132 and 219.
|
||||
|
||||
The model is 1.7 % above the sheet because S3 counts interest from the
|
||||
middle of each construction year and the sheet from the end of it.
|
||||
"""
|
||||
assert abs(_avvik(nou_balansepris_modell(scenario), fasit)) <= TOLERANSE
|
||||
assert nou_balansepris_modell(scenario) == pytest.approx(
|
||||
nou_regneark_balansepris(scenario), rel=0.02
|
||||
)
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------- Epoch
|
||||
# Epoch AI (14 May 2026), "Servers account for 60% of the total cost of ownership of a
|
||||
# one-gigawatt AI data center"; source entries K08-K03 and K01-043. USD million per GW IT.
|
||||
# Capital: servers 21 188, network 4 925 (5 years); facility 11 433, land 172, utility works
|
||||
# 164 (14 years). Operation without power: taxes 143, maintenance 120, labour 40, water 6.
|
||||
# Power: 8.34 cents/kWh, PUE 1.14, utilisation 71 %. Total 8 514 per year.
|
||||
# The page does not state the discount rate. It says land is annualised as the opportunity
|
||||
# cost of capital at the same rate, and reports 13 per year on 172: 7.56 %. That is used here.
|
||||
|
||||
|
||||
def test_epoch_aarskostnad() -> None:
|
||||
"""S15 with Epoch's inputs gives 8.76 against 8.51 bn USD per GW and year (+2.8 %).
|
||||
|
||||
The difference lies in the capital recovery factor for servers: Epoch
|
||||
reports 0.24, S1 gives 0.248 at 7.56 % and five years.
|
||||
"""
|
||||
lcoc = lg.s15_lcoc(
|
||||
c_bygg=(11433.0 + 172.0 + 164.0) * 1e3,
|
||||
d_bygg=0.0,
|
||||
c_H=(21188.0 + 4925.0) * 1e3,
|
||||
rho_D=13.0 / 172.0,
|
||||
L_B=14.0,
|
||||
L_H=5.0,
|
||||
o_D=(143.0 + 120.0 + 40.0 + 6.0) * 1e3,
|
||||
d_o_D=0.0,
|
||||
lam=0.71,
|
||||
PUE=1.14,
|
||||
c_a=83.4,
|
||||
)
|
||||
assert abs(_avvik(lcoc, 8514.0 * 1e3)) <= TOLERANSE
|
||||
assert lcoc / 1e6 == pytest.approx(8.756, abs=0.001)
|
||||
|
||||
|
||||
def test_epoch_kraftandel() -> None:
|
||||
"""Power is about 7 % of the yearly cost, as the specification says under S19."""
|
||||
kraft = lg.TIMER_PER_AAR * 0.71 * 1.14 * 83.4
|
||||
assert kraft / 8514e3 == pytest.approx(0.07, abs=0.005)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------- NVE
|
||||
# NVE's LCOE spreadsheet 2026 (source entries K11-002, K11-003, K11-004, K11-006): 6 %, 2025
|
||||
# kroner. NVE counts interest during construction from the start of each year, S3 from the
|
||||
# middle of it; that alone puts S3 about 3 % of the capital cost lower. NVE also lets
|
||||
# production fall every year (0.42 % for wind, 0.1 % for nuclear), which the model does not.
|
||||
# For hydro NVE's investment figure already includes interest during construction.
|
||||
|
||||
NVE_RENTE = 0.06
|
||||
|
||||
|
||||
def _nve_fornybar(
|
||||
investering: float,
|
||||
drift_mwh: float,
|
||||
drift_kw: float,
|
||||
timer: float,
|
||||
levetid: float,
|
||||
byggetid: float,
|
||||
*,
|
||||
renter_med: bool,
|
||||
) -> float:
|
||||
"""LCOE in øre/kWh from the model's function, with NVE's inputs."""
|
||||
return (
|
||||
lg.lcoe_fornybar(
|
||||
investering=investering * 1e3,
|
||||
drift_per_mwh=drift_mwh,
|
||||
drift_per_mw=drift_kw * 1e3,
|
||||
fullasttimer=timer,
|
||||
levetid=levetid,
|
||||
byggetid=byggetid,
|
||||
rho=NVE_RENTE,
|
||||
renter_i_investeringen=renter_med,
|
||||
)
|
||||
/ 10.0
|
||||
)
|
||||
|
||||
|
||||
def _nve_kjernekraft() -> float:
|
||||
enhet = lg.s3_investering_med_renter(
|
||||
xi_N=1.0, c_N=126874.7 * 1e3, P_u=1600.0, rho=NVE_RENTE, tau_N=10.0
|
||||
)
|
||||
return (
|
||||
lg.s5_lcoe_kjernekraft(
|
||||
I_N=[enhet],
|
||||
rho=NVE_RENTE,
|
||||
L_N=40.0,
|
||||
f_N_enhet=1846.23 * 1e3,
|
||||
D_avv=0.0,
|
||||
P_u=1600.0,
|
||||
E_N=7884.0 * 1600.0,
|
||||
v_N=51.753252816351818,
|
||||
u_N=75.0,
|
||||
d_N=60.0,
|
||||
q_N=0.0,
|
||||
)
|
||||
/ 10.0
|
||||
)
|
||||
|
||||
|
||||
def test_nve_kjernekraft() -> None:
|
||||
"""S3 and S5 with NVE's inputs: 187.3 against 193.9 øre/kWh (-3.4 %)."""
|
||||
assert abs(_avvik(_nve_kjernekraft(), 193.94)) <= TOLERANSE
|
||||
|
||||
|
||||
def test_nve_vannkraft_uten_renter_paa_nytt() -> None:
|
||||
"""Hydro: 48.94 against 48.94 øre/kWh when S3 is not applied on top of NVE's figure."""
|
||||
verdi = _nve_fornybar(18749.0, 70.0, 0.0, 2971.0, 40.0, 3.0, renter_med=True)
|
||||
assert verdi == pytest.approx(48.94, abs=0.01)
|
||||
|
||||
|
||||
def test_nve_vannkraft_med_s3_teller_rentene_to_ganger() -> None:
|
||||
"""Hydro with S3 on top of NVE's figure gives 52.8 øre/kWh, 7.9 % above NVE.
|
||||
|
||||
NVE's sheet says interest during construction is included in the investment
|
||||
figure for hydro ("Inkludert i modulkostnader"). The parameter file holds
|
||||
that figure together with a construction time of three years.
|
||||
"""
|
||||
verdi = _nve_fornybar(18749.0, 70.0, 0.0, 2971.0, 40.0, 3.0, renter_med=False)
|
||||
assert _avvik(verdi, 48.94) == pytest.approx(0.079, abs=0.002)
|
||||
|
||||
|
||||
@pytest.mark.xfail(
|
||||
strict=True,
|
||||
reason="43.9 against 46.9 øre/kWh (-6.3 %): interest from mid-year, and no yearly loss",
|
||||
)
|
||||
def test_nve_vindkraft() -> None:
|
||||
"""Wind on land with NVE's inputs."""
|
||||
verdi = _nve_fornybar(13915.0, 120.0, 0.0, 3357.0, 30.0, 2.0, renter_med=False)
|
||||
assert abs(_avvik(verdi, 46.91)) <= TOLERANSE
|
||||
|
||||
|
||||
@pytest.mark.xfail(
|
||||
strict=True,
|
||||
reason="114.0 against 120.6 øre/kWh (-5.5 %): interest from mid-year; the rest not found",
|
||||
)
|
||||
def test_nve_havvind() -> None:
|
||||
"""Bottom-fixed offshore wind with NVE's inputs (investment with grid and contingency)."""
|
||||
verdi = _nve_fornybar(52800.0, 0.0, 900.0, 4467.0, 30.0, 3.0, renter_med=False)
|
||||
assert abs(_avvik(verdi, 120.61)) <= TOLERANSE
|
||||
|
||||
|
||||
def _nve_metode(
|
||||
investering: float,
|
||||
byggetid: int,
|
||||
levetid: int,
|
||||
timer: float,
|
||||
tap: float,
|
||||
drift_ore: float,
|
||||
fast: float,
|
||||
) -> float:
|
||||
"""NVE's own convention, written out independently of the model, øre/kWh.
|
||||
|
||||
Interest from the start of each construction year, production falling by
|
||||
``tap`` per year, operation cost on the first year's production.
|
||||
"""
|
||||
renter = sum((1.0 + NVE_RENTE) ** k for k in range(1, byggetid + 1)) / byggetid
|
||||
aar = range(1, levetid + 1)
|
||||
energi = sum(timer * (1.0 - tap) ** (t - 1) / (1.0 + NVE_RENTE) ** t for t in aar)
|
||||
drift = sum((drift_ore * timer / 100.0 + fast) / (1.0 + NVE_RENTE) ** t for t in aar)
|
||||
return (investering * renter + drift) / energi * 100.0
|
||||
|
||||
|
||||
def test_nve_avviket_er_forklart_for_vind_og_kjernekraft() -> None:
|
||||
"""With NVE's two conventions the same inputs give NVE's numbers within 0.2 %."""
|
||||
vind = _nve_metode(13915.0, 2, 30, 3357.0, 0.0042, 12.0, 0.0)
|
||||
kjernekraft = _nve_metode(
|
||||
126874.7, 10, 40, 7884.0, 0.001, 7.5 + 6.0 + 5.1753252816351818, 1846.23
|
||||
)
|
||||
assert vind == pytest.approx(46.913, rel=0.002)
|
||||
assert kjernekraft == pytest.approx(193.945, rel=0.002)
|
||||
570
tests/test_ligninger.py
Normal file
570
tests/test_ligninger.py
Normal file
|
|
@ -0,0 +1,570 @@
|
|||
"""Unit tests and edge cases for the equations, with made-up round numbers.
|
||||
|
||||
Nothing here uses the frozen parameters.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
from typing import Any
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
from scipy import integrate, stats
|
||||
|
||||
from tokenfabrikker import ligninger as lg
|
||||
|
||||
# ------------------------------------------------------------------- S1 and SFF
|
||||
|
||||
|
||||
def test_s1_kjent_verdi() -> None:
|
||||
assert lg.s1_crf(rho=0.06, L=40) == pytest.approx(0.0664615, abs=5e-8)
|
||||
|
||||
|
||||
def test_s1_rente_null() -> None:
|
||||
assert lg.s1_crf(rho=0.0, L=25) == 1 / 25
|
||||
assert lg.s1_crf(rho=1e-12, L=25) == pytest.approx(1 / 25, rel=1e-9)
|
||||
|
||||
|
||||
def test_s1_er_annuiteten_som_betaler_tilbake_ett_belop() -> None:
|
||||
rho, levetid = 0.07, 12
|
||||
naaverdi = sum(lg.s1_crf(rho=rho, L=levetid) / (1 + rho) ** t for t in range(1, levetid + 1))
|
||||
assert naaverdi == pytest.approx(1.0)
|
||||
|
||||
|
||||
def test_s1_levetid_som_ikke_er_heltall() -> None:
|
||||
assert lg.s1_crf(rho=0.05, L=10) > lg.s1_crf(rho=0.05, L=10.5) > lg.s1_crf(rho=0.05, L=11)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("rho", "levetid"), [(0.05, 0.0), (0.05, -3.0), (-1.0, 10.0)])
|
||||
def test_s1_avviser_ugyldige_verdier(rho: float, levetid: float) -> None:
|
||||
with pytest.raises(ValueError, match="must be"):
|
||||
lg.s1_crf(rho=rho, L=levetid)
|
||||
|
||||
|
||||
def test_sff_og_crf_skiller_seg_med_renten() -> None:
|
||||
assert lg.s1_crf(rho=0.06, L=40) - lg.sff(rho=0.06, L=40) == pytest.approx(0.06)
|
||||
assert lg.sff(rho=0.0, L=40) == 1 / 40
|
||||
|
||||
|
||||
def test_sff_avsetningen_vokser_til_belopet() -> None:
|
||||
rho, levetid = 0.04, 30
|
||||
saldo = sum(lg.sff(rho=rho, L=levetid) * (1 + rho) ** (levetid - t) for t in range(1, 31))
|
||||
assert saldo == pytest.approx(1.0)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ S2, S3, S46
|
||||
|
||||
|
||||
def test_s2_referansen_er_norges_forste_enhet() -> None:
|
||||
c = lg.s2_investering_per_mw(c_N_ref=1e8, P_u=1000, P_ref=1000, nu=0.8, ell=0.1, n_0=5, n=1)
|
||||
assert c == pytest.approx(1e8)
|
||||
|
||||
|
||||
def test_s2_en_dobling_gir_laeringsraten() -> None:
|
||||
felles: dict[str, Any] = {"c_N_ref": 1e8, "P_u": 1000.0, "P_ref": 1000.0, "nu": 0.8, "ell": 0.1}
|
||||
forste = lg.s2_investering_per_mw(**felles, n_0=3, n=1)
|
||||
doblet = lg.s2_investering_per_mw(**felles, n_0=3, n=5) # (3 + 5) / (3 + 1) = 2
|
||||
assert doblet / forste == pytest.approx(0.9)
|
||||
|
||||
|
||||
def test_s2_negativ_laering_gjor_senere_enheter_dyrere() -> None:
|
||||
felles: dict[str, Any] = {
|
||||
"c_N_ref": 1e8,
|
||||
"P_u": 1000.0,
|
||||
"P_ref": 1000.0,
|
||||
"nu": 1.0,
|
||||
"ell": -0.07,
|
||||
}
|
||||
assert lg.s2_investering_per_mw(**felles, n_0=1, n=3) / 1e8 == pytest.approx(1.07)
|
||||
|
||||
|
||||
def test_s2_smaa_enheter_koster_mer_per_mw() -> None:
|
||||
felles: dict[str, Any] = {"c_N_ref": 1e8, "P_ref": 1000.0, "ell": 0.0, "n_0": 0, "n": 1}
|
||||
assert lg.s2_investering_per_mw(**felles, P_u=100, nu=0.84) == pytest.approx(1e8 * 10**0.16)
|
||||
assert lg.s2_investering_per_mw(**felles, P_u=100, nu=1.0) == pytest.approx(1e8)
|
||||
|
||||
|
||||
def test_s2_avviser_enhet_null_og_laering_en() -> None:
|
||||
felles: dict[str, Any] = {"c_N_ref": 1e8, "P_u": 1000.0, "P_ref": 1000.0, "nu": 1.0, "n_0": 0}
|
||||
with pytest.raises(ValueError, match="starts at 1"):
|
||||
lg.s2_investering_per_mw(**felles, ell=0.1, n=0)
|
||||
with pytest.raises(ValueError, match="below 1"):
|
||||
lg.s2_investering_per_mw(**felles, ell=1.0, n=1)
|
||||
|
||||
|
||||
def test_s3_faktoren_er_integralet_av_jevn_utbetaling() -> None:
|
||||
rho, tau = 0.07, 9.5
|
||||
integral, _ = integrate.quad(lambda s: (1 + rho) ** s / tau, 0, tau)
|
||||
assert lg.s3_byggetidsfaktor(rho=rho, tau=tau) == pytest.approx(integral)
|
||||
|
||||
|
||||
def test_s3_grensetilfeller() -> None:
|
||||
assert lg.s3_byggetidsfaktor(rho=0.0, tau=10) == 1.0
|
||||
assert lg.s3_byggetidsfaktor(rho=0.07, tau=0.0) == 1.0
|
||||
assert lg.s3_byggetidsfaktor(rho=0.07, tau=1e-9) == pytest.approx(1.0)
|
||||
with pytest.raises(ValueError, match="negative"):
|
||||
lg.s3_byggetidsfaktor(rho=0.07, tau=-1.0)
|
||||
|
||||
|
||||
def test_s3_investering() -> None:
|
||||
faktor = lg.s3_byggetidsfaktor(rho=0.06, tau=10)
|
||||
verdi = lg.s3_investering_med_renter(xi_N=1.5, c_N=1e8, P_u=1000, rho=0.06, tau_N=10)
|
||||
assert verdi == pytest.approx(1.5 * 1e11 * faktor)
|
||||
|
||||
|
||||
def test_s46_lesningen_trekkes() -> None:
|
||||
assert lg.s46_overskridelsesfaktor(u_xi=0.2, w_xi=0.5, o_xi=0.6) == 1.6
|
||||
assert lg.s46_overskridelsesfaktor(u_xi=0.7, w_xi=0.5, o_xi=0.6) == 1.0
|
||||
assert lg.s46_overskridelsesfaktor(u_xi=0.5, w_xi=0.5, o_xi=0.6) == 1.0
|
||||
assert lg.s46_overskridelsesfaktor(u_xi=0.0, w_xi=0.0, o_xi=0.6) == 1.0
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- S4, S5, S6
|
||||
|
||||
|
||||
def test_s4_kapasitetsfaktoren_avkortes() -> None:
|
||||
assert lg.s4_kapasitetsfaktor(KF=0.95, o_p=0.05, o_f=0.02) == pytest.approx(0.95 * 0.98)
|
||||
assert lg.s4_kapasitetsfaktor(KF=0.80, o_p=0.05, o_f=0.02) == 0.80
|
||||
|
||||
|
||||
def test_s4_energi_og_smaa_enheter() -> None:
|
||||
assert lg.s4_energi_kjernekraft(KF=0.9, N_u=2, P_u=1000) == pytest.approx(15_768_000)
|
||||
assert lg.s4_kapasitetsfaktor_smaa_enheter(KF=0.9, o_f_A=0.05, o_f=0.02) == pytest.approx(
|
||||
0.9 * 0.95 / 0.98
|
||||
)
|
||||
|
||||
|
||||
def test_s5_regnet_for_haand() -> None:
|
||||
# One 1 000 MW unit: 1e11 kr with interest, 7 %, 40 years, 8 000 hours.
|
||||
crf, sff = lg.s1_crf(rho=0.07, L=40), lg.sff(rho=0.07, L=40)
|
||||
ventet = (1e11 * crf + 1.8e6 * 1000 + 8e6 * 1000 * sff) / 8e6 + 50 + 70 + 60 + 2
|
||||
verdi = lg.s5_lcoe_kjernekraft(
|
||||
I_N=[1e11],
|
||||
rho=0.07,
|
||||
L_N=40,
|
||||
f_N_enhet=1.8e6,
|
||||
D_avv=8e6,
|
||||
P_u=1000,
|
||||
E_N=8e6,
|
||||
v_N=50,
|
||||
u_N=70,
|
||||
d_N=60,
|
||||
q_N=2,
|
||||
)
|
||||
assert verdi == pytest.approx(ventet)
|
||||
|
||||
|
||||
def test_s5_fast_drift_skalerer_med_enhetsstorrelse() -> None:
|
||||
assert lg.s5_fast_drift(f_N=2e6, P_u=1000, P_ref=1000, nu_f=-0.28) == pytest.approx(2e6)
|
||||
assert lg.s5_fast_drift(f_N=2e6, P_u=100, P_ref=1000, nu_f=-0.28) == pytest.approx(
|
||||
2e6 * 10**0.28
|
||||
)
|
||||
assert lg.s5_fast_drift(f_N=2e6, P_u=100, P_ref=1000, nu_f=0.0) == 2e6
|
||||
|
||||
|
||||
def test_s6_bare_det_forsikringen_ikke_dekker() -> None:
|
||||
felles: dict[str, Any] = {"N_u": 2, "phi_U": 1e-5, "P_u": 1000.0, "P_ref": 1000.0, "E": 1.6e7}
|
||||
assert lg.s6_ulykkeskostnad(**felles, K_U=3e12, D_fors=8e9) == pytest.approx(
|
||||
2 * 1e-5 * (3e12 - 8e9) / 1.6e7
|
||||
)
|
||||
assert lg.s6_ulykkeskostnad(**felles, K_U=5e9, D_fors=8e9) == 0.0
|
||||
|
||||
|
||||
def test_s6_skalering_med_enhetsstorrelse() -> None:
|
||||
felles: dict[str, Any] = {
|
||||
"N_u": 25,
|
||||
"phi_U": 1e-5,
|
||||
"P_ref": 1000.0,
|
||||
"E": 8e6,
|
||||
"K_U": 3e12,
|
||||
"D_fors": 8e9,
|
||||
}
|
||||
liten = lg.s6_ulykkeskostnad(**felles, P_u=50)
|
||||
assert liten == pytest.approx(25 * 1e-5 * (3e12 * 0.05 - 8e9) / 8e6)
|
||||
uskalert = lg.s6_ulykkeskostnad(**felles, P_u=50, skaler_med_enhet=False)
|
||||
assert uskalert == pytest.approx(25 * 1e-5 * (3e12 - 8e9) / 8e6)
|
||||
assert lg.s6_ulykkeskostnad_per_hendelse(K_U=3e12, P_u=1600, P_ref=1000) == 3e12
|
||||
|
||||
|
||||
# ------------------------------------------------------------- S7, S8, S44, S36
|
||||
|
||||
SETT = (5.0, 10.0, 20.0, 50.0, 100.0, 200.0, 300.0, 400.0, 500.0, 1000.0)
|
||||
|
||||
|
||||
def test_s7_storste_enhet_under_grensen() -> None:
|
||||
# limit = 0.1 * 0.8 * 1.2 * 1000 = 96 MW -> 50 MW units; full load 1 200 MW -> 24 units
|
||||
assert lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.1, lam=0.8, PUE=1.2, P_IT=1000) == (50.0, 24)
|
||||
|
||||
|
||||
def test_s7_grensen_treffer_en_storrelse_noyaktig() -> None:
|
||||
# limit = 0.1 * 1.0 * 1.0 * 1000 = 100 MW exactly: 100 MW is allowed (P <= limit)
|
||||
assert lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.1, lam=1.0, PUE=1.0, P_IT=1000) == (100.0, 10)
|
||||
|
||||
|
||||
def test_s7_ingen_storrelse_er_liten_nok() -> None:
|
||||
# limit = 0.05 * 0.5 * 1.1 * 100 = 2.75 MW: the smallest size is used
|
||||
assert lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.05, lam=0.5, PUE=1.1, P_IT=100) == (5.0, 22)
|
||||
|
||||
|
||||
def test_s7_runder_antall_enheter_opp() -> None:
|
||||
_, m = lg.s7_enhetsstorrelse(P_sett=SETT, chi=0.1, lam=0.9, PUE=1.21, P_IT=1000)
|
||||
assert m == math.ceil(1210 / 100)
|
||||
with pytest.raises(ValueError, match="empty"):
|
||||
lg.s7_enhetsstorrelse(P_sett=(), chi=0.1, lam=0.9, PUE=1.2, P_IT=1000)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("m", "r", "o_p"), [(24, 3, 0.05), (10, 0, 0.08), (242, 9, 0.044)])
|
||||
def test_s8_planlagt_stans_er_minste_tall_som_oppfyller_ulikheten(
|
||||
m: int, r: int, o_p: float
|
||||
) -> None:
|
||||
n_p = lg.s8_planlagt_ute(m=m, r=r, o_p=o_p)
|
||||
assert n_p >= (m + r + n_p) * o_p
|
||||
assert n_p - 1 < (m + r + n_p - 1) * o_p
|
||||
assert n_p == math.ceil((m + r) * o_p / (1 - o_p) - 1e-12)
|
||||
|
||||
|
||||
def test_s8_planlagt_stans_grensetilfeller() -> None:
|
||||
assert lg.s8_planlagt_ute(m=24, r=3, o_p=0.0) == 0
|
||||
# 7 >= (93 + 7) * 0.07 holds exactly, but 100 * 0.07 is 7.000000000000001 in floating point
|
||||
assert lg.s8_planlagt_ute(m=90, r=3, o_p=0.07) == 7
|
||||
# 0.01 * 0.7 * 1.0 * 1000 is 6.999999999999999 in floating point; the limit is 7 MW
|
||||
assert (
|
||||
lg.s7_enhetsstorrelse(P_sett=(5.0, 7.0, 10.0), chi=0.01, lam=0.7, PUE=1.0, P_IT=1000)[0]
|
||||
== 7.0
|
||||
)
|
||||
with pytest.raises(ValueError, match="planned outage"):
|
||||
lg.s8_planlagt_ute(m=24, r=3, o_p=1.0)
|
||||
|
||||
|
||||
def test_s8_tilgjengelighet_mot_scipy() -> None:
|
||||
m, r, o = 24, 3, 0.04
|
||||
ventet = stats.binom.sf(m - 1, m + r, 1 - o)
|
||||
assert lg.s8_tilgjengelighet(m=m, r=r, o_merket=o) == pytest.approx(ventet, rel=1e-12)
|
||||
assert lg.s8_tilgjengelighet(m=m, r=0, o_merket=o) == pytest.approx((1 - o) ** m)
|
||||
assert lg.s8_tilgjengelighet(m=m, r=2, o_merket=0.0) == 1.0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("krav", [0.99, 0.995, 0.99995])
|
||||
def test_s8_reserven_er_den_minste_som_naar_kravet(krav: float) -> None:
|
||||
m, o = 24, 0.04
|
||||
r = lg.s8_reserveenheter(m=m, o_merket=o, A_krav=krav)
|
||||
assert lg.s8_tilgjengelighet(m=m, r=r, o_merket=o) >= krav
|
||||
assert r == 0 or lg.s8_tilgjengelighet(m=m, r=r - 1, o_merket=o) < krav
|
||||
|
||||
|
||||
def test_s8_reserven_grensetilfeller() -> None:
|
||||
assert lg.s8_reserveenheter(m=24, o_merket=0.0, A_krav=0.99995) == 0
|
||||
with pytest.raises(ValueError, match="reaches availability"):
|
||||
lg.s8_reserveenheter(m=24, o_merket=1.0, A_krav=0.99, r_maks=50)
|
||||
assert lg.s8_uavhengig_utfallsrate(beta_F=0.1, o_f_A=0.05) == pytest.approx(0.045)
|
||||
assert lg.s8_antall_enheter(m=24, r=3, n_p=2) == 29
|
||||
|
||||
|
||||
def test_s8_mange_smaa_enheter_gir_ikke_overflyt() -> None:
|
||||
verdi = lg.s8_tilgjengelighet(m=1200, r=60, o_merket=0.04)
|
||||
assert verdi == pytest.approx(stats.binom.sf(1199, 1260, 0.96), rel=1e-9)
|
||||
|
||||
|
||||
def test_s44_uten_reserve_og_uten_felles_utfall() -> None:
|
||||
assert lg.s44_inntektsfaktor(m=24, r=0, o_f_A=0.05, beta_F=0.0) == pytest.approx(0.95)
|
||||
|
||||
|
||||
def test_s44_mot_scipy_og_egenskaper() -> None:
|
||||
m, r, o_f, beta = 24, 3, 0.05, 0.2
|
||||
o_merket = (1 - beta) * o_f
|
||||
x = np.arange(m + r + 1)
|
||||
forventet = float(np.sum(np.minimum(x, m) * stats.binom.pmf(x, m + r, 1 - o_merket)))
|
||||
gamma = lg.s44_inntektsfaktor(m=m, r=r, o_f_A=o_f, beta_F=beta)
|
||||
assert gamma == pytest.approx((1 - beta * o_f) * forventet / m, rel=1e-12)
|
||||
assert gamma <= 1 - beta * o_f
|
||||
assert gamma > lg.s44_inntektsfaktor(m=m, r=0, o_f_A=o_f, beta_F=beta)
|
||||
assert lg.s44_inntektsfaktor(m=m, r=r, o_f_A=0.0, beta_F=beta) == 1.0
|
||||
|
||||
|
||||
def test_s44_alle_utfall_felles() -> None:
|
||||
assert lg.s44_inntektsfaktor(m=24, r=0, o_f_A=0.05, beta_F=1.0) == pytest.approx(0.95)
|
||||
|
||||
|
||||
def test_s36_buffer_og_ekstern_forsyning() -> None:
|
||||
assert lg.s36_buffer(delta_L=0.5, PUE=1.2, P_IT=1000) == pytest.approx(600)
|
||||
crf_nett, crf_buf = lg.s1_crf(rho=0.08, L=40), lg.s1_crf(rho=0.08, L=20)
|
||||
verdi = lg.s36_ekstern_forsyning(
|
||||
D_linje=50,
|
||||
c_linje=13e6,
|
||||
s_g=0.03,
|
||||
N_u=29,
|
||||
P_u=50,
|
||||
c_gen=1e7,
|
||||
rho_A=0.08,
|
||||
L_nett=40,
|
||||
L_buf=20,
|
||||
)
|
||||
assert verdi == pytest.approx(2 * 50 * 13e6 * crf_nett + 0.03 * 29 * 50 * 1e7 * crf_buf)
|
||||
|
||||
|
||||
# ----------------------------------------------------------------- S9, S10, S11
|
||||
|
||||
|
||||
def test_s10_energi() -> None:
|
||||
assert lg.s10_energi_datasenter(lam=0.7, PUE=1.2, P_IT=1000) == pytest.approx(7_358_400)
|
||||
|
||||
|
||||
def test_s9_er_s5_naar_alt_selges_og_ingenting_legges_til() -> None:
|
||||
enheter = [1e11, 0.9e11]
|
||||
felles: dict[str, Any] = {
|
||||
"L_N": 60.0,
|
||||
"f_N_enhet": 1.8e6,
|
||||
"D_avv": 8e6,
|
||||
"P_u": 1000.0,
|
||||
"d_N": 60.0,
|
||||
"q_N": 1.0,
|
||||
}
|
||||
s5 = lg.s5_lcoe_kjernekraft(I_N=enheter, rho=0.075, E_N=1.5e7, v_N=50, u_N=70, **felles)
|
||||
s9 = lg.s9_kraftkostnad_dedikert(
|
||||
I_N=enheter,
|
||||
rho_A=0.075,
|
||||
E_D=1.5e7,
|
||||
v_N=50,
|
||||
u_N_A=70,
|
||||
P_buf=0.0,
|
||||
c_buf=1e7,
|
||||
f_buf=4e5,
|
||||
L_buf=20,
|
||||
I_g_aar=0.0,
|
||||
**felles,
|
||||
)
|
||||
assert s9 == pytest.approx(s5)
|
||||
|
||||
|
||||
def test_s9_buffer_og_ubrukt_kraft_gjor_det_dyrere() -> None:
|
||||
felles: dict[str, Any] = {
|
||||
"I_N": [5e9] * 29,
|
||||
"rho_A": 0.075,
|
||||
"L_N": 60.0,
|
||||
"f_N_enhet": 3e6,
|
||||
"D_avv": 8e6,
|
||||
"P_u": 50.0,
|
||||
"c_buf": 1e7,
|
||||
"f_buf": 4e5,
|
||||
"L_buf": 20.0,
|
||||
"v_N": 50.0,
|
||||
"u_N_A": 150.0,
|
||||
"d_N": 60.0,
|
||||
"q_N": 0.0,
|
||||
}
|
||||
uten = lg.s9_kraftkostnad_dedikert(P_buf=0, I_g_aar=0, E_D=7.4e6, **felles)
|
||||
med = lg.s9_kraftkostnad_dedikert(P_buf=600, I_g_aar=0, E_D=7.4e6, **felles)
|
||||
crf_buf = lg.s1_crf(rho=0.075, L=20)
|
||||
assert med - uten == pytest.approx(600 * (1e7 * crf_buf + 4e5) / 7.4e6)
|
||||
mindre_bruk = lg.s9_kraftkostnad_dedikert(P_buf=0, I_g_aar=0, E_D=3.7e6, **felles)
|
||||
assert mindre_bruk - 260 == pytest.approx(2 * (uten - 260))
|
||||
|
||||
|
||||
def test_s11_referansekjoringen_har_ingen_kraftverk() -> None:
|
||||
verdi = lg.s11_kraftkostnad_nett(
|
||||
p_z=600, n_tap=0.05, portefolje=[], E_G=0.0, E_D=7e6, H_a=7e7, F_a=1.4e7
|
||||
)
|
||||
assert verdi == pytest.approx(1.05 * 600 + 8.4e7 / 7e6)
|
||||
|
||||
|
||||
def test_s11_kraftverk_som_akkurat_dekker_kostnaden_endrer_ingenting() -> None:
|
||||
ledd = lg.Portefoljeledd(x=1.0, LCOE=630.0, psi=1.05, regelen_binder=False)
|
||||
med = lg.s11_kraftkostnad_nett(
|
||||
p_z=600, n_tap=0.0, portefolje=[ledd], E_G=8e6, E_D=7e6, H_a=0.0, F_a=0.0
|
||||
)
|
||||
assert med == pytest.approx(600)
|
||||
|
||||
|
||||
def test_s11_portefolje_med_to_teknologier() -> None:
|
||||
"""Hydro earns more than it costs, so S45 binds and its term is zero; wind stands as it is."""
|
||||
vann = lg.Portefoljeledd(x=0.25, LCOE=500.0, psi=1.26, regelen_binder=True)
|
||||
vind = lg.Portefoljeledd(x=0.75, LCOE=450.0, psi=0.88, regelen_binder=False)
|
||||
assert vann.nettoledd(600) == 0.0
|
||||
assert vind.nettoledd(600) == pytest.approx(450 - 0.88 * 600)
|
||||
verdi = lg.s11_kraftkostnad_nett(
|
||||
p_z=600, n_tap=0.1, portefolje=[vann, vind], E_G=8e6, E_D=7e6, H_a=7e7, F_a=0.0
|
||||
)
|
||||
assert verdi == pytest.approx(660 + 0.75 * (450 - 0.88 * 600) * 8 / 7 + 10)
|
||||
|
||||
|
||||
def test_s11_uten_tilleggsregelen_krediteres_overskuddet() -> None:
|
||||
"""The sensitivity without S45: a profitable plant lowers the data centre's power cost."""
|
||||
vann = lg.Portefoljeledd(x=1.0, LCOE=500.0, psi=1.26, regelen_binder=False)
|
||||
verdi = lg.s11_kraftkostnad_nett(
|
||||
p_z=600, n_tap=0.0, portefolje=[vann], E_G=7e6, E_D=7e6, H_a=0.0, F_a=0.0
|
||||
)
|
||||
assert verdi == pytest.approx(600 + 500 - 1.26 * 600)
|
||||
|
||||
|
||||
def test_s11_nettkostnad() -> None:
|
||||
crf = lg.s1_crf(rho=0.065, L=40)
|
||||
verdi = lg.s11_nettkostnad(
|
||||
I_nett=5e6, delta_V=0.4, PUE=1.2, P_IT=1000, P_G_N=1000, rho_N=0.065, L_nett=40
|
||||
)
|
||||
assert verdi == pytest.approx(5e6 * (0.6 * 1200 + 1000) * crf)
|
||||
|
||||
|
||||
def test_lcoe_fornybar() -> None:
|
||||
crf = lg.s1_crf(rho=0.06, L=30)
|
||||
faktor = lg.s3_byggetidsfaktor(rho=0.06, tau=2)
|
||||
felles: dict[str, Any] = {
|
||||
"investering": 1.4e7,
|
||||
"fullasttimer": 3400.0,
|
||||
"levetid": 30.0,
|
||||
"byggetid": 2.0,
|
||||
}
|
||||
per_mwh = lg.lcoe_fornybar(
|
||||
**felles, drift_per_mwh=120, drift_per_mw=0, rho=0.06, renter_i_investeringen=False
|
||||
)
|
||||
assert per_mwh == pytest.approx(1.4e7 * faktor * crf / 3400 + 120)
|
||||
per_mw = lg.lcoe_fornybar(
|
||||
**felles, drift_per_mwh=0, drift_per_mw=9e5, rho=0.06, renter_i_investeringen=True
|
||||
)
|
||||
assert per_mw == pytest.approx((1.4e7 * crf + 9e5) / 3400)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- S13 to S21
|
||||
|
||||
|
||||
def test_s13_prisendringen_stopper_i_2035() -> None:
|
||||
assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2025) == 3e8
|
||||
assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2030) == pytest.approx(3e8 * 0.95**5)
|
||||
assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2035) == pytest.approx(3e8 * 0.95**10)
|
||||
assert lg.s13_it_kostnad(c_H0=3e8, gamma_H=-0.05, t_v=2080) == pytest.approx(3e8 * 0.95**10)
|
||||
|
||||
|
||||
def test_s14_snittlast() -> None:
|
||||
assert lg.s14_snittlast(lam_0=0.2, mu_u=0.8) == pytest.approx(0.84)
|
||||
|
||||
|
||||
def test_s15_regnet_for_haand() -> None:
|
||||
verdi = lg.s15_lcoc(
|
||||
c_bygg=1.2e8,
|
||||
d_bygg=0.1,
|
||||
c_H=2.7e8,
|
||||
rho_D=0.075,
|
||||
L_B=14,
|
||||
L_H=5,
|
||||
o_D=1.7e6,
|
||||
d_o_D=0.7e6,
|
||||
lam=0.7,
|
||||
PUE=1.14,
|
||||
c_a=600,
|
||||
)
|
||||
ventet = (
|
||||
1.2e8 * 1.1 * lg.s1_crf(rho=0.075, L=14)
|
||||
+ 2.7e8 * lg.s1_crf(rho=0.075, L=5)
|
||||
+ 2.4e6
|
||||
+ 8760 * 0.7 * 1.14 * 600
|
||||
)
|
||||
assert verdi == pytest.approx(ventet)
|
||||
|
||||
|
||||
def test_s19_er_en_identitet() -> None:
|
||||
"""M_a = mu Gamma y - LCOC_a equals the four terms of S19 for arbitrary inputs."""
|
||||
rng = np.random.default_rng(1)
|
||||
for _ in range(200):
|
||||
c_bygg, c_H = rng.uniform(1e8, 2e8), rng.uniform(2e8, 4e8)
|
||||
rho_D, L_B, L_H = rng.uniform(0.03, 0.12), rng.uniform(7, 40), float(rng.integers(3, 8))
|
||||
lam, PUE, PUE_v = rng.uniform(0.5, 0.9), rng.uniform(1.05, 1.2), rng.uniform(1.09, 1.2)
|
||||
o_D, o_D_v, d_o_D = rng.uniform(1e6, 2e6), rng.uniform(2e6, 4e6), rng.uniform(0, 1.4e6)
|
||||
d_bygg, c_a, p_v = rng.uniform(0, 0.15), rng.uniform(200, 1500), rng.uniform(600, 1200)
|
||||
pi_g, mu, gamma = rng.uniform(-0.45, 2.0), rng.uniform(0.8, 1.0), rng.uniform(0.9, 1.0)
|
||||
felles: dict[str, Any] = {
|
||||
"c_bygg": c_bygg,
|
||||
"c_H": c_H,
|
||||
"rho_D": rho_D,
|
||||
"L_B": L_B,
|
||||
"L_H": L_H,
|
||||
"lam": lam,
|
||||
}
|
||||
lcoc_v = lg.s15_lcoc(**felles, d_bygg=0, o_D=o_D_v, d_o_D=0, PUE=PUE_v, c_a=p_v)
|
||||
lcoc = lg.s15_lcoc(**felles, d_bygg=d_bygg, o_D=o_D, d_o_D=d_o_D, PUE=PUE, c_a=c_a)
|
||||
y = lg.s18_pris(LCOC_v=lcoc_v, pi_g=pi_g)
|
||||
margin = lg.s19_margin(
|
||||
lam=lam,
|
||||
PUE_v=PUE_v,
|
||||
p_v=p_v,
|
||||
PUE=PUE,
|
||||
c_a=c_a,
|
||||
pi_g=pi_g,
|
||||
LCOC_v=lcoc_v,
|
||||
o_D_v=o_D_v,
|
||||
o_D=o_D,
|
||||
d_o_D=d_o_D,
|
||||
d_bygg=d_bygg,
|
||||
c_bygg=c_bygg,
|
||||
rho_D=rho_D,
|
||||
L_B=L_B,
|
||||
mu=mu,
|
||||
Gamma=gamma,
|
||||
)
|
||||
assert margin.sum == pytest.approx(mu * gamma * y - lcoc, rel=1e-9, abs=1e-3)
|
||||
|
||||
|
||||
def test_s16_s17_s18() -> None:
|
||||
assert lg.s16_inntekt(mu=0.95, Gamma=0.98, y=1e8, P_IT=1000) == pytest.approx(9.31e10)
|
||||
assert lg.s17_kontraktspris_fra_spot(y_spot=[1e8] * 5, rho_D=0.075) == pytest.approx(1e8)
|
||||
fallende = lg.s17_kontraktspris_fra_spot(y_spot=[1e8, 8e7, 6e7], rho_D=0.075)
|
||||
assert 6e7 < fallende < 1e8
|
||||
assert lg.s18_pris(LCOC_v=8e7, pi_g=0.25) == pytest.approx(1e8)
|
||||
|
||||
|
||||
def test_s43_paaslaget_blir_ikke_negativt() -> None:
|
||||
assert lg.s43_knapphetspaaslag(y_obs=1.6e8, LCOC_v_2025=8e7) == pytest.approx(1.0)
|
||||
assert lg.s43_knapphetspaaslag(y_obs=7e7, LCOC_v_2025=8e7) == 0.0
|
||||
|
||||
|
||||
def test_s20_s21_kontrollen_i_kapittel_3_3() -> None:
|
||||
"""9 mill. USD per MW and year, theta 4.03 and mu_u 0.8 give 0.089 USD per million tokens."""
|
||||
assert lg.s21_kostnad_per_token(LCOC=9e6, theta=4.03, mu_u=0.8) == pytest.approx(
|
||||
0.089, abs=5e-4
|
||||
)
|
||||
inntekt = lg.s20_tokeninntekt(sigma=1.0, p_tok=0.0885, theta=4.03, mu_u=0.8, P_IT=1.0)
|
||||
assert inntekt == pytest.approx(9e6, rel=0.005)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------- S45, S47
|
||||
|
||||
|
||||
def test_s45_ingen_kreditt_for_overskudd() -> None:
|
||||
assert lg.s45_tilleggsfaktor(naaverdi_kostnader=80, naaverdi_salgsinntekter=100) == 0.8
|
||||
assert lg.s45_tilleggsfaktor(naaverdi_kostnader=120, naaverdi_salgsinntekter=100) == 1.0
|
||||
assert lg.s45_tilleggsfaktor(naaverdi_kostnader=120, naaverdi_salgsinntekter=0) == 1.0
|
||||
|
||||
|
||||
def test_s47_ingen_kostnad_naar_effekten_ikke_mangler() -> None:
|
||||
felles: dict[str, Any] = {
|
||||
"c_fast": 1.4e6,
|
||||
"c_res": 1.2e6,
|
||||
"h_knapp": 100.0,
|
||||
"mu": 1.0,
|
||||
"y": 1e8,
|
||||
"PUE": 1.14,
|
||||
}
|
||||
assert lg.s47_effektkostnad(Delta_R=50, Delta_R_utfall=10, **felles) == 0.0
|
||||
|
||||
|
||||
def test_s47_velger_det_billigste_tiltaket() -> None:
|
||||
felles: dict[str, Any] = {"c_fast": 1.4e6, "c_res": 1.2e6, "mu": 1.0, "y": 1e8, "PUE": 1.14}
|
||||
fast = 1.4e6 * 100 + 1.2e6 * (1100 - 100)
|
||||
per_time = 1e8 / (8760 * 1.14)
|
||||
faa_timer = lg.s47_effektkostnad(Delta_R=-100, Delta_R_utfall=-1100, h_knapp=10, **felles)
|
||||
assert faa_timer == pytest.approx(10 * per_time * 1100)
|
||||
mange_timer = lg.s47_effektkostnad(Delta_R=-100, Delta_R_utfall=-1100, h_knapp=200, **felles)
|
||||
assert mange_timer == pytest.approx(fast)
|
||||
|
||||
|
||||
def test_s47_bare_reserve_naar_effekten_holder_uten_utfall() -> None:
|
||||
verdi = lg.s47_effektkostnad(
|
||||
Delta_R=200,
|
||||
Delta_R_utfall=-800,
|
||||
c_fast=1.4e6,
|
||||
c_res=1.2e6,
|
||||
h_knapp=8760,
|
||||
mu=1,
|
||||
y=1e9,
|
||||
PUE=1,
|
||||
)
|
||||
assert verdi == pytest.approx(1.2e6 * 800)
|
||||
276
tests/test_parametere.py
Normal file
276
tests/test_parametere.py
Normal file
|
|
@ -0,0 +1,276 @@
|
|||
"""The parameter file is the frozen one, is read strictly, and is converted to the right units."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
import re
|
||||
from collections import Counter
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import parametere as pm
|
||||
|
||||
ROT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def raa() -> dict[str, Any]:
|
||||
data: dict[str, Any] = json.loads(pm.STANDARDSTI.read_text(encoding="utf-8"))
|
||||
return data
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def sett() -> pm.Parametersett:
|
||||
return pm.les_parametere()
|
||||
|
||||
|
||||
def _endret(raa: dict[str, Any], parameter_id: str) -> tuple[dict[str, Any], dict[str, Any]]:
|
||||
"""A deep copy of the file and the entry with this id inside the copy."""
|
||||
kopi = copy.deepcopy(raa)
|
||||
post = next(p for p in kopi["parametere"] if p["id"] == parameter_id)
|
||||
return kopi, post
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- the freeze
|
||||
|
||||
|
||||
def test_sjekksummen_er_den_i_forhaandsregistreringen() -> None:
|
||||
tekst = (ROT / "FORHANDSREGISTRERING.md").read_text(encoding="utf-8")
|
||||
funnet = re.search(r"SHA-256: `([0-9a-f]{64})`", tekst)
|
||||
assert funnet is not None
|
||||
assert funnet.group(1) == pm.FROSSEN_SHA256
|
||||
assert pm.sjekksum() == pm.FROSSEN_SHA256
|
||||
|
||||
|
||||
def test_en_endret_fil_avvises(tmp_path: Path) -> None:
|
||||
kopi = tmp_path / "parametere.json"
|
||||
kopi.write_bytes(pm.STANDARDSTI.read_bytes().replace(b'"verdi": 2027', b'"verdi": 2030'))
|
||||
with pytest.raises(pm.ParameterError, match="not the frozen parameter file"):
|
||||
pm.les_parametere(kopi)
|
||||
assert pm.les_parametere(kopi, krev_frossen=False).fast("T0") == 2030
|
||||
|
||||
|
||||
def test_antall_og_status_som_i_forhaandsregistreringen(sett: pm.Parametersett) -> None:
|
||||
"""124 parameters: 80 with source, 1 derived, 35 open assumptions, 8 choices of set-up."""
|
||||
assert len(sett.parametere) == 124
|
||||
assert Counter(p.status for p in sett.parametere) == {
|
||||
"kilde": 80,
|
||||
"avledet": 1,
|
||||
"åpen forutsetning": 35,
|
||||
"modellvalg": 8,
|
||||
}
|
||||
|
||||
|
||||
def test_tabellen_i_spesifikasjonen_har_de_samme_parameterne(sett: pm.Parametersett) -> None:
|
||||
tekst = (ROT / "modell" / "spesifikasjon.md").read_text(encoding="utf-8")
|
||||
tabell = tekst.split("<!-- PARAMETERTABELL START -->")[1].split("<!-- PARAMETERTABELL SLUTT")[0]
|
||||
ider = re.findall(r"^\| `([^`]+)` \|", tabell, flags=re.MULTILINE)
|
||||
assert ider == [p.id for p in sett.parametere]
|
||||
|
||||
|
||||
# ------------------------------------------------------------ strict validation
|
||||
|
||||
|
||||
def test_ukjent_felt_overst_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["kommentar"] = "x"
|
||||
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['kommentar'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_ukjent_felt_i_parameter_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post["verdi"] = 140000
|
||||
with pytest.raises(pm.ParameterError, match=r"c_N_ref.*unknown field"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_ukjent_felt_i_fordeling_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post["fordeling"]["modus"] = 140000
|
||||
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['modus'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_manglende_felt_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "tau_N")
|
||||
del post["fordeling"]["modus"]
|
||||
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['modus'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
kopi, post = _endret(raa, "tau_N")
|
||||
del post["merknad"]
|
||||
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['merknad'\]"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("felt", "verdi", "melding"),
|
||||
[
|
||||
("enhet", "kr/kWh", "unknown unit"),
|
||||
("status", "antatt", "unknown status"),
|
||||
("poster", ["K3-20"], "malformed source entries"),
|
||||
("poster", [], "requires at least one source entry"),
|
||||
],
|
||||
)
|
||||
def test_ukjent_enhet_status_og_post_er_feil(
|
||||
raa: dict[str, Any], felt: str, verdi: object, melding: str
|
||||
) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post[felt] = verdi
|
||||
with pytest.raises(pm.ParameterError, match=melding):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_ukjent_fordelingstype_er_feil(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "c_N_ref")
|
||||
post["fordeling"]["type"] = "normal"
|
||||
with pytest.raises(pm.ParameterError, match="unknown distribution type 'normal'"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("parameter_id", "felt", "verdi", "melding"),
|
||||
[
|
||||
("tau_N", "modus", 20.0, "does not hold"),
|
||||
("c_N_ref", "lav", 171500, "range is empty"),
|
||||
("tau_N", "form", 6, "PERT shape"),
|
||||
("phi_U", "lav", 0.0, "must be positive"),
|
||||
("o_xi", "sigma", -1.0, "must be positive"),
|
||||
("o_xi", "avkorting", "trekk på nytt", "truncation must be"),
|
||||
("L_H", "vekter", [0.2, 0.2, 0.2, 0.2, 0.3], "weights sum to"),
|
||||
("L_H", "vekter", [0.5, 0.5], "same, non-zero length"),
|
||||
("c_N_ref", "lav", "109000", "expected a number"),
|
||||
("c_N_ref", "lav", True, "expected a number"),
|
||||
],
|
||||
)
|
||||
def test_ugyldig_fordeling_er_feil(
|
||||
raa: dict[str, Any], parameter_id: str, felt: str, verdi: object, melding: str
|
||||
) -> None:
|
||||
kopi, post = _endret(raa, parameter_id)
|
||||
post["fordeling"][felt] = verdi
|
||||
with pytest.raises(pm.ParameterError, match=melding):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_duplikater_er_feil(raa: dict[str, Any], tmp_path: Path) -> None:
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["parametere"].append(copy.deepcopy(kopi["parametere"][5]))
|
||||
with pytest.raises(pm.ParameterError, match="duplicate parameter id"):
|
||||
pm.tolk_parametere(kopi)
|
||||
fil = tmp_path / "p.json"
|
||||
fil.write_text('{"versjon": "1", "versjon": "2"}', encoding="utf-8")
|
||||
with pytest.raises(pm.ParameterError, match="duplicate key 'versjon'"):
|
||||
pm.les_parametere(fil, krev_frossen=False)
|
||||
|
||||
|
||||
def test_ugyldig_json_og_feil_antall_trekninger(raa: dict[str, Any], tmp_path: Path) -> None:
|
||||
fil = tmp_path / "p.json"
|
||||
fil.write_text("{", encoding="utf-8")
|
||||
with pytest.raises(pm.ParameterError, match="not valid JSON"):
|
||||
pm.les_parametere(fil, krev_frossen=False)
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["monte_carlo"]["antall_trekninger"] = 5000
|
||||
with pytest.raises(pm.ParameterError, match="N_trekk differs"):
|
||||
pm.tolk_parametere(kopi)
|
||||
kopi = copy.deepcopy(raa)
|
||||
kopi["monte_carlo"]["metode"] = "LHS"
|
||||
with pytest.raises(pm.ParameterError, match="monte_carlo: unknown field"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
def test_sammensatt_parameter_maa_ha_alle_feltene(raa: dict[str, Any]) -> None:
|
||||
kopi, post = _endret(raa, "vind")
|
||||
post["fordeling"]["degradering"] = {"type": "fast", "verdi": 0.0042}
|
||||
with pytest.raises(pm.ParameterError, match="a composite must have the fields"):
|
||||
pm.tolk_parametere(kopi)
|
||||
kopi, post = _endret(raa, "pris_balanse")
|
||||
post["enhet"] = "TWh; øre/kWh (2025-kroner)"
|
||||
with pytest.raises(pm.ParameterError, match="expected a table with unit"):
|
||||
pm.tolk_parametere(kopi)
|
||||
|
||||
|
||||
# -------------------------------------------------------------- unit conversion
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("navn", "enhet", "faktor"),
|
||||
[
|
||||
("c_N_ref", "kr/kW", 1e3),
|
||||
("f_N", "kr/kW per år", 1e3),
|
||||
("v_N", "kr/MWh", 1.0),
|
||||
("D_avv", "mill. kr/MW", 1e6),
|
||||
("K_U", "mrd. kr", 1e9),
|
||||
("D_fors", "mill. kr", 1e6),
|
||||
("c_H0", "mill. kr/MW IT", 1e6),
|
||||
("o_D", "mill. kr/MW IT per år", 1e6),
|
||||
("c_linje", "mill. kr/km", 1e6),
|
||||
("c_fast", "kr/MW per år", 1.0),
|
||||
("S0", "TWh", 1e6),
|
||||
("g_fornybar", "TWh per år", 1e6),
|
||||
("G_server", "GW per år", 1e3),
|
||||
("u_kjerne", "g CO2e/kWh", 1e-3),
|
||||
("eta_N", "tonn uran per TWh", 1e-6),
|
||||
("vind.investering", "kr/kW", 1e3),
|
||||
("vind.drift", "kr/MWh", 1.0),
|
||||
("havvind.drift", "kr/kW per år", 1e3),
|
||||
("vann.fullasttimer", "t/år", 1.0),
|
||||
],
|
||||
)
|
||||
def test_enhetsfaktorer(sett: pm.Parametersett, navn: str, enhet: str, faktor: float) -> None:
|
||||
storrelse = sett.storrelse(navn)
|
||||
assert (storrelse.enhet, storrelse.faktor) == (enhet, faktor)
|
||||
|
||||
|
||||
def test_faste_verdier_i_ligningenes_enheter(sett: pm.Parametersett) -> None:
|
||||
assert sett.fast("P_ref") == 1000.0
|
||||
assert sett.fast("c_linje") == pytest.approx(13.4e6)
|
||||
assert sett.fast("D_fors") == pytest.approx(8.202e9)
|
||||
assert sett.fast("o_D_v") == pytest.approx(3.21e6)
|
||||
assert sett.fast("G_server") == 25_000.0
|
||||
assert sett.fast("havvind.drift") == 900_000.0
|
||||
assert sett.fast("vind.levetid") == 30.0
|
||||
assert sett.fast("SNKS_snitt") == pytest.approx(536.3e9)
|
||||
with pytest.raises(pm.ParameterError, match="not a fixed scalar"):
|
||||
sett.fast("c_N_ref")
|
||||
with pytest.raises(KeyError):
|
||||
sett.storrelse("finnes_ikke")
|
||||
|
||||
|
||||
def test_lister_og_tabeller(sett: pm.Parametersett) -> None:
|
||||
assert sett.liste("stige") == (1.0, 5.0, 10.0, 20.0, 40.0)
|
||||
assert sett.liste("P_u_sett")[0] == 5.0
|
||||
assert sett.liste("P_u_sett")[-1] == 1000.0
|
||||
assert sett.karbonpris()["sentral"][2030] == 2377.0
|
||||
assert sett.karbonpris()["lav"][2100] == 8547.0
|
||||
petroleum = sett.petroleumsinntekt()
|
||||
assert petroleum[2022] == pytest.approx(1285.223e9)
|
||||
assert sum(petroleum.values()) / 10 == pytest.approx(482.4e9, rel=1e-3)
|
||||
with pytest.raises(pm.ParameterError, match="not a table"):
|
||||
sett.tabell("c_N_ref")
|
||||
|
||||
|
||||
def test_prisene_regnes_om_til_2025_kroner_per_mwh(sett: pm.Parametersett) -> None:
|
||||
scenarioer = sett.pris_balanse()
|
||||
assert len(scenarioer) == 12
|
||||
svakest = scenarioer[-1]
|
||||
assert svakest.navn.startswith("N11")
|
||||
assert svakest.balanse == pytest.approx(-3.6e6)
|
||||
assert svakest.pris["NO1"] == pytest.approx(76.8 * 10 * 137.7 / 129.6)
|
||||
assert set(svakest.pris) == {"NO1", "NO2", "NO3", "NO4", "NO5", "Norge"}
|
||||
|
||||
|
||||
def test_alle_storrelser_og_rekkefolgen(sett: pm.Parametersett) -> None:
|
||||
"""136 scalar quantities with the composites split; 87 of them are drawn, in file order."""
|
||||
assert len(sett.storrelser()) == 136
|
||||
stokastiske = [s.navn for s in sett.stokastiske()]
|
||||
assert len(stokastiske) == 87
|
||||
assert stokastiske[:4] == ["c_N_ref", "w_xi", "u_xi", "o_xi"]
|
||||
assert stokastiske[-1] == "eps_e"
|
||||
plass = stokastiske.index("vann.investering")
|
||||
assert stokastiske[plass : plass + 2] == ["vann.investering", "vann.drift"]
|
||||
assert sett.monte_carlo.froe == 20261111
|
||||
assert sett.monte_carlo.antall_trekninger == 10_000
|
||||
assert len(sett.foelsomheter) == 29
|
||||
262
tests/test_trekninger.py
Normal file
262
tests/test_trekninger.py
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
"""The draws follow the frozen set-up, hit the frozen distributions and can be reproduced.
|
||||
|
||||
These tests look at the drawn parameter values only. No model result is computed.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
import pytest
|
||||
from scipy import stats
|
||||
|
||||
from tokenfabrikker import fordelinger, trekninger
|
||||
from tokenfabrikker import parametere as pm
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
Tabell = npt.NDArray[np.float64]
|
||||
|
||||
ANTALL_STANDARDFEIL = 4.0
|
||||
"""Every statistical check allows four standard errors of the sampling error."""
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def sett() -> pm.Parametersett:
|
||||
return pm.les_parametere()
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def trukket(sett: pm.Parametersett) -> trekninger.Trekninger:
|
||||
return trekninger.trekk(sett)
|
||||
|
||||
|
||||
def _kvantil(sett: pm.Parametersett, navn: str, q: float) -> float:
|
||||
"""The theoretical quantile of a drawn quantity, from its inverse distribution function."""
|
||||
fordeling = sett.storrelse(navn).fordeling
|
||||
return float(
|
||||
fordelinger.invers(fordeling, np.array([q]), heltall=navn in trekninger.HELTALL)[0]
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- reproducibility
|
||||
|
||||
|
||||
def test_oppsettet_folger_parameterfila(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
assert trukket.tabell.shape == (10_000, 87)
|
||||
assert trukket.kolonner == tuple(s.navn for s in sett.stokastiske())
|
||||
assert trukket.tabell.dtype == np.float64
|
||||
assert np.isfinite(trukket.tabell).all()
|
||||
|
||||
|
||||
def test_samme_fro_gir_samme_trekninger(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
assert np.array_equal(trekninger.trekk(sett).tabell, trukket.tabell)
|
||||
|
||||
|
||||
def test_den_lagrede_fila_kan_gjenskapes(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
"""``data/trekninger.npy`` is what the generator gives, bit for bit or within tolerance."""
|
||||
lagret = trekninger.les()
|
||||
assert lagret.kolonner == trukket.kolonner
|
||||
assert lagret.enheter == trukket.enheter
|
||||
dom, avvik = trekninger.kontroller(sett)
|
||||
assert dom in {"identisk", "innenfor toleranse"}, avvik
|
||||
beskrivelse = json.loads(
|
||||
(trekninger.DATAMAPPE / trekninger.BESKRIVELSESFIL).read_text(encoding="utf-8")
|
||||
)
|
||||
assert beskrivelse["sha256_parametere"] == pm.FROSSEN_SHA256
|
||||
assert beskrivelse["antall_trekninger"] == sett.monte_carlo.antall_trekninger
|
||||
assert beskrivelse["froe"] == sett.monte_carlo.froe
|
||||
|
||||
|
||||
def test_skriv_og_les(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger, tmp_path: Path
|
||||
) -> None:
|
||||
sha256 = trekninger.skriv(trukket, sett, tmp_path)
|
||||
lest = trekninger.les(tmp_path)
|
||||
assert np.array_equal(lest.tabell, trukket.tabell)
|
||||
assert trekninger.kontroller(sett, tmp_path) == ("identisk", 0.0)
|
||||
assert trekninger.skriv(trukket, sett, tmp_path) == sha256
|
||||
tabellfil = tmp_path / trekninger.TABELLFIL
|
||||
raa = bytearray(tabellfil.read_bytes())
|
||||
raa[-1] ^= 1
|
||||
tabellfil.write_bytes(bytes(raa))
|
||||
with pytest.raises(pm.ParameterError, match="does not match the checksum"):
|
||||
trekninger.les(tmp_path)
|
||||
|
||||
|
||||
def test_kommandolinjen(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
assert trekninger.main(["lag", "--mappe", str(tmp_path)]) == 0
|
||||
assert "10000 trekninger av 87 størrelser" in capsys.readouterr().out
|
||||
assert trekninger.main(["kontroll", "--mappe", str(tmp_path)]) == 0
|
||||
assert capsys.readouterr().out.startswith("identisk")
|
||||
|
||||
|
||||
# ------------------------------------------------------------ the distributions
|
||||
|
||||
|
||||
def test_alle_trekninger_ligger_innenfor_spennet(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
for storrelse in sett.stokastiske():
|
||||
verdier = trukket.kolonne(storrelse.navn)
|
||||
fordeling = storrelse.fordeling
|
||||
if fordeling.type == "diskret":
|
||||
assert set(np.unique(verdier)) <= set(fordeling.verdier), storrelse.navn
|
||||
continue
|
||||
nedre = fordeling.tall["min" if fordeling.type == "lognormal" else "lav"]
|
||||
ovre = fordeling.tall["maks" if fordeling.type == "lognormal" else "hoy"]
|
||||
assert nedre <= float(np.min(verdier)), storrelse.navn
|
||||
assert float(np.max(verdier)) <= ovre, storrelse.navn
|
||||
|
||||
|
||||
@pytest.mark.parametrize("q", [0.05, 0.5, 0.95])
|
||||
def test_median_og_ytterpunkter_treffer(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger, q: float
|
||||
) -> None:
|
||||
"""The share of draws below the theoretical 5 %, 50 % and 95 % points is 5 %, 50 % and 95 %."""
|
||||
n = trukket.tabell.shape[0]
|
||||
slingring = ANTALL_STANDARDFEIL * np.sqrt(q * (1 - q) / n)
|
||||
for storrelse in sett.stokastiske():
|
||||
navn = storrelse.navn
|
||||
if storrelse.fordeling.type == "diskret" or navn in trekninger.HELTALL:
|
||||
continue
|
||||
if navn == "KF" and q > 0.5:
|
||||
continue # the cap at (1 - o_p)(1 - o_f) changes the upper tail
|
||||
andel = float(np.mean(trukket.kolonne(navn) <= _kvantil(sett, navn, q)))
|
||||
assert abs(andel - q) <= slingring, (navn, q, andel)
|
||||
|
||||
|
||||
def test_diskrete_fordelinger_treffer_vektene(
|
||||
sett: pm.Parametersett, trukket: trekninger.Trekninger
|
||||
) -> None:
|
||||
n = trukket.tabell.shape[0]
|
||||
for navn in ("A_krav", "L_H"):
|
||||
fordeling = sett.storrelse(navn).fordeling
|
||||
for verdi, vekt in zip(fordeling.verdier, fordeling.vekter, strict=True):
|
||||
andel = float(np.mean(trukket.kolonne(navn) == verdi))
|
||||
assert abs(andel - vekt) <= ANTALL_STANDARDFEIL * np.sqrt(vekt * (1 - vekt) / n), navn
|
||||
|
||||
|
||||
def test_n_0_er_heltall_med_lik_sannsynlighet(trukket: trekninger.Trekninger) -> None:
|
||||
verdier = trukket.kolonne("n_0")
|
||||
assert np.array_equal(verdier, np.round(verdier))
|
||||
assert set(np.unique(verdier)) == set(range(1, 21))
|
||||
andeler = np.bincount(verdier.astype(int))[1:] / verdier.size
|
||||
assert np.max(np.abs(andeler - 0.05)) <= ANTALL_STANDARDFEIL * np.sqrt(
|
||||
0.05 * 0.95 / verdier.size
|
||||
)
|
||||
|
||||
|
||||
def test_overskridelsen_har_median_og_snitt_som_parameterfila_sier(
|
||||
trukket: trekninger.Trekninger,
|
||||
) -> None:
|
||||
"""o_xi: median 0.648, and mean about 1.12 after truncation at 12.8 (the file's note)."""
|
||||
o_xi = trukket.kolonne("o_xi")
|
||||
assert float(np.median(o_xi)) == pytest.approx(0.648, rel=0.05)
|
||||
assert float(np.mean(o_xi)) == pytest.approx(1.12, rel=0.05)
|
||||
assert float(np.max(o_xi)) <= 12.8
|
||||
|
||||
|
||||
def test_pert_har_riktig_snitt(sett: pm.Parametersett, trukket: trekninger.Trekninger) -> None:
|
||||
"""A beta-PERT with shape 4 has mean (low + 4 mode + high) / 6."""
|
||||
for navn in ("tau_N", "L_N", "rho_N", "c_H0", "S0"):
|
||||
tall = sett.storrelse(navn).fordeling.tall
|
||||
ventet = (tall["lav"] + 4 * tall["modus"] + tall["hoy"]) / 6
|
||||
verdier = trukket.kolonne(navn)
|
||||
slingring = ANTALL_STANDARDFEIL * float(np.std(verdier)) / np.sqrt(verdier.size)
|
||||
assert abs(float(np.mean(verdier)) - ventet) <= slingring, navn
|
||||
|
||||
|
||||
def test_kapasitetsfaktoren_er_avkortet(trukket: trekninger.Trekninger) -> None:
|
||||
tak = (1 - trukket.kolonne("o_p")) * (1 - trukket.kolonne("o_f_stor"))
|
||||
assert np.all(trukket.kolonne("KF") <= tak)
|
||||
assert 0 < float(np.mean(trukket.kolonne("KF") == tak)) < 0.05
|
||||
|
||||
|
||||
# --------------------------------------------------------------- correlations
|
||||
|
||||
|
||||
def _rangkorrelasjon(a: Tabell, b: Tabell) -> float:
|
||||
return float(stats.spearmanr(a, b).statistic)
|
||||
|
||||
|
||||
def test_rangkorrelasjonene_treffer(sett: pm.Parametersett, trukket: trekninger.Trekninger) -> None:
|
||||
n = trukket.tabell.shape[0]
|
||||
for a, b, parameter in trekninger.KORRELASJONER:
|
||||
ventet = sett.fast(parameter)
|
||||
funnet = _rangkorrelasjon(trukket.kolonne(a), trukket.kolonne(b))
|
||||
assert abs(funnet - ventet) <= ANTALL_STANDARDFEIL / np.sqrt(n), (a, b, funnet)
|
||||
|
||||
|
||||
def test_normalkorrelasjonen_gir_rangkorrelasjonen() -> None:
|
||||
assert trekninger.normalkorrelasjon(0.5) == pytest.approx(0.5176, abs=1e-4)
|
||||
assert trekninger.normalkorrelasjon(0.0) == 0.0
|
||||
assert trekninger.normalkorrelasjon(1.0) == pytest.approx(1.0)
|
||||
assert trekninger.normalkorrelasjon(-0.5) == -trekninger.normalkorrelasjon(0.5)
|
||||
|
||||
|
||||
def test_alle_andre_par_er_ukorrelerte(trukket: trekninger.Trekninger) -> None:
|
||||
"""No pair outside the four in chapter 11 has a rank correlation above 0.05."""
|
||||
korrelasjon = np.asarray(stats.spearmanr(trukket.tabell).statistic)
|
||||
np.fill_diagonal(korrelasjon, 0.0)
|
||||
for a, b, _ in trekninger.KORRELASJONER:
|
||||
i, j = trukket.kolonner.index(a), trukket.kolonner.index(b)
|
||||
korrelasjon[i, j] = korrelasjon[j, i] = 0.0
|
||||
assert float(np.max(np.abs(korrelasjon))) < 0.05
|
||||
|
||||
|
||||
# --------------------------------------------------- inverse distribution functions
|
||||
|
||||
|
||||
def test_inverse_fordelingsfunksjoner() -> None:
|
||||
u = np.array([0.0, 0.25, 0.5, 1.0])
|
||||
assert fordelinger.invers_jevn(u, lav=2.0, hoy=6.0).tolist() == [2.0, 3.0, 4.0, 6.0]
|
||||
assert fordelinger.invers_jevn_heltall(u, lav=1.0, hoy=4.0).tolist() == [1.0, 2.0, 3.0, 4.0]
|
||||
assert fordelinger.invers_logjevn(u, lav=1e-8, hoy=1e-4)[2] == pytest.approx(1e-6)
|
||||
diskret = fordelinger.invers_diskret(
|
||||
np.array([0.0, 0.3, 0.31, 0.99, 1.0]), verdier=(3.0, 5.0, 7.0), vekter=(0.3, 0.4, 0.3)
|
||||
)
|
||||
assert diskret.tolist() == [3.0, 3.0, 5.0, 7.0, 7.0]
|
||||
|
||||
|
||||
def test_pert_er_betafordelingen() -> None:
|
||||
a, b = fordelinger.pert_parametere(lav=6.0, modus=9.5, hoy=17.1, form=4.0)
|
||||
assert (a, b) == pytest.approx((1 + 4 * 3.5 / 11.1, 1 + 4 * 7.6 / 11.1))
|
||||
u = np.linspace(0.01, 0.99, 9)
|
||||
ventet = 6.0 + 11.1 * stats.beta.ppf(u, a, b)
|
||||
assert fordelinger.invers_pert(u, lav=6.0, modus=9.5, hoy=17.1, form=4.0) == pytest.approx(
|
||||
ventet
|
||||
)
|
||||
kant = fordelinger.invers_pert(np.array([0.0, 1.0]), lav=5.0, modus=5.0, hoy=9.0, form=4.0)
|
||||
assert kant.tolist() == [5.0, 9.0]
|
||||
|
||||
|
||||
def test_avkortet_lognormal() -> None:
|
||||
u = np.array([0.0, 0.5, 1.0])
|
||||
uavkortet = fordelinger.invers_lognormal(u[1:2], median=0.648, sigma=1.09, minste=0.0, maks=1e9)
|
||||
assert uavkortet[0] == pytest.approx(0.648)
|
||||
avkortet = fordelinger.invers_lognormal(u, median=0.648, sigma=1.09, minste=0.0, maks=12.8)
|
||||
assert avkortet[0] == 0.0
|
||||
assert avkortet[2] == pytest.approx(12.8)
|
||||
assert avkortet[1] < 0.648 + 0.01
|
||||
andel_under_maks = stats.norm.cdf(np.log(12.8 / 0.648) / 1.09)
|
||||
assert avkortet[1] == pytest.approx(
|
||||
0.648 * np.exp(1.09 * stats.norm.ppf(0.5 * andel_under_maks))
|
||||
)
|
||||
|
||||
|
||||
def test_fast_verdi_trekkes_ikke(sett: pm.Parametersett) -> None:
|
||||
with pytest.raises(ValueError, match="nothing is drawn"):
|
||||
fordelinger.invers(sett.storrelse("P_ref").fordeling, np.array([0.5]))
|
||||
with pytest.raises(ValueError, match="only defined for the uniform type"):
|
||||
fordelinger.invers(sett.storrelse("tau_N").fordeling, np.array([0.5]), heltall=True)
|
||||
Loading…
Add table
Add a link
Reference in a new issue