tokenfabrikker/tests/oppdiktet/lag_grunnlag.py
Kjell Tore Guttormsen 7dd3edc68a
feat(verktoy): the tools of chapter 12 and the data files of the main run, on made-up numbers (clarifications 126 to 133)
grunnlag.py holds what a run needs besides the model code, from a made-up
basis file or from the freeze (which stops until the EEA assessment is
written down). datafiler.py writes the six files in a fixed format without
rounding and compares two folders. verktoy.py is the command line:
hovedkjoring, kontroll, scenario, folsomhet, terskel, sammenlign,
arbeidskopi. tests/oppdiktet holds a made-up basis of 200 draws and the files
written from it; they are reproduced byte for byte with 1 and 8 processes and
in a new process. Nothing is computed on the frozen parameters.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-13 21:55:03 +01:00

288 lines
11 KiB
Python

"""Write the made-up basis file ``grunnlag.json`` (chapter 16, clarifications 127 and 129).
Every number is invented: the made-up set of ``tests/conftest.py``, with a
few quantities varied per draw by a seeded generator, and with made-up values
for what only the sensitivity rows and the three marked scenarios read. The
file is marked «oppdiktet»; nothing computed from it says anything about the
hypothesis. The stored reference in ``fasit/`` is the main run written from it.
Run from the root of the repository:
PYTHONPATH=src .venv/bin/python tests/oppdiktet/lag_grunnlag.py [antall]
The reference in ``fasit/`` is the main run of this file on the ladder 1, 2, 5, and is
checked against a run made anew (clarification 129):
PYTHONPATH=src .venv/bin/python -m tokenfabrikker.verktoy hovedkjoring \
--grunnlag tests/oppdiktet/grunnlag.json --ut tests/oppdiktet/fasit --stige 1,2,5 \
--prosesser 8
PYTHONPATH=src .venv/bin/python -m tokenfabrikker.verktoy kontroll \
--grunnlag tests/oppdiktet/grunnlag.json --fasit tests/oppdiktet/fasit --prosesser 8
A set the build-out rejects (nuclear power before the new grid, a step that
is not a whole number of modules) would stop the run (clarification 96); such
sets are drawn again, so the file holds only sets the build-out accepts.
"""
from __future__ import annotations
import dataclasses
import json
import random
import sys
from pathlib import Path
from typing import TYPE_CHECKING, Final, cast
HER: Final = Path(__file__).resolve().parent
sys.path.insert(0, str(HER.parent))
from conftest import GRUNNVERDIER, lag_inndata # noqa: E402
from tokenfabrikker import folsomheter as fs # noqa: E402
from tokenfabrikker import inndata as ind # noqa: E402
from tokenfabrikker import kontantstrom as ks # noqa: E402
from tokenfabrikker import ligninger as lg # noqa: E402
from tokenfabrikker.utbygging import Losning # noqa: E402
if TYPE_CHECKING:
from collections.abc import Callable, Iterator, Mapping
from tokenfabrikker.inndata import Inndata
FIL: Final = HER / "grunnlag.json"
FROE: Final = 20261113
ANTALL: Final = 200
STIGE: Final = (1, 2, 5)
"""The ladder of the made-up reference; every set must be accepted on every step of it."""
FAKTORER: Final[Mapping[str, float]] = {
"c_N_ref": 1e3,
"y_obs": 1e6,
"c_H0": 1e6,
"c_bygg": 1e6,
"D_avv": 1e6,
"S0": 1e6,
"K_U": 1e9,
"SNKS_snitt": 1e9,
}
"""The made-up file's units: kr/kW, mill. kr, TWh and mrd. kr, as the parameter file has them."""
TILLEGG: Final[Mapping[str, float]] = {"tau_pi": 2.5, "P_dim0": 1450.0, "eps_e": 0.0}
"""What only the sensitivity rows read (lines 13, 21 and 28), in the equations' units."""
ENDRET: Final[Mapping[str, float]] = {"SNKS_snitt": 40e9, "T_slutt": 2060}
"""Values of the made-up set changed so that M6 can reach the 25 % step on made-up numbers."""
MODELLVALG: Final = ("T0", "T_slutt", "P_IT", "P_m", "P_ref", "L_buf")
def _rund(x: float, steg: float) -> float:
return round(round(x / steg) * steg, 10)
TRUKNE: Final[Mapping[str, tuple[str, Callable[[random.Random], float]]]] = {
# name: (status, drawn value in the made-up file's unit)
"c_N_ref": ("kilde", lambda r: _rund(r.uniform(40_000.0, 140_000.0), 100.0)),
"w_xi": ("åpen forutsetning", lambda r: _rund(r.uniform(0.2, 0.8), 0.01)),
"u_xi": ("modellvalg", lambda r: _rund(r.random(), 0.01)),
"tau_N": ("kilde", lambda r: _rund(r.uniform(3.0, 8.0), 0.1)),
"n_reaktor": ("åpen forutsetning", lambda r: _rund(r.uniform(40.0, 2000.0), 10.0)),
"c_H0": ("kilde", lambda r: _rund(r.uniform(150.0, 250.0), 1.0)),
"PUE": ("kilde", lambda r: _rund(r.uniform(1.1, 1.4), 0.01)),
"PUE_v": ("kilde", lambda r: _rund(r.uniform(1.1, 1.5), 0.01)),
"p_v": ("kilde", lambda r: _rund(r.uniform(2200.0, 4200.0), 10.0)),
"y_obs": ("kilde", lambda r: _rund(r.uniform(101.0, 229.0), 1.0)),
"rho_N": ("kilde", lambda r: _rund(r.uniform(0.04, 0.08), 0.001)),
"rho_D": ("åpen forutsetning", lambda r: _rund(r.uniform(0.0, 0.04), 0.001)),
"phi_X": ("åpen forutsetning", lambda r: _rund(r.uniform(0.0, 0.1), 0.001)),
"n_1": ("åpen forutsetning", lambda r: _rund(r.uniform(100.0, 300.0), 1.0)),
"tau_pi": ("kilde", lambda r: _rund(r.uniform(2.0, 2.8), 0.01)),
"eps_e": ("åpen forutsetning", lambda r: _rund(r.uniform(-0.05, 0.1), 0.001)),
}
"""The drawn quantities; rho_D is drawn as rho_N plus a margin, so the two are correlated."""
Y_OBS_MAKS: Final = 229.0
"""The upper end of the made-up contract prices, in mill. kr per MW IT and year."""
BORTFALL: Final[Mapping[str, list[float]]] = {
ind.BORTFALL_KILDE: [0.12, 0.21],
ind.BORTFALL_EGNE_LAV: [0.19, 0.38],
ind.BORTFALL_EGNE_HOY: [0.32, 0.64],
}
GAMMA_TRINN: Final[Mapping[str, float]] = dict(
zip(lg.GAMMA_TRINN, (1.0, 0.9, 0.7, 0.0), strict=True)
)
M5: Final[Mapping[str, str]] = {
"A": "holder under betingelser",
"B": "holder under betingelser",
"B'": "holder under betingelser",
"C": "holder",
"R": "holder",
"T-F": "holder",
"T-K": "holder under betingelser",
}
EOS: Final[Mapping[str, str]] = {
"direkte": "består",
"heleid_selskap": "består",
"majoritet_boers": "usikker",
"petroleumsmodell": "består",
}
KARBONBANER: Final[Mapping[str, Mapping[str, float]]] = {
"lav": {"2026": 500.0, "2100": 500.0},
"hoy": {"2026": 3000.0, "2100": 4000.0},
}
def grunnverdier() -> dict[str, float]:
"""Every scalar in the equations' units: the made-up set, changed and extended."""
return {**GRUNNVERDIER, **ENDRET, **TILLEGG}
def trekk(rng: random.Random) -> dict[str, float]:
"""One draw, in the made-up file's units."""
verdier = {navn: trekker(rng) for navn, (_, trekker) in TRUKNE.items()}
verdier["rho_D"] = _rund(verdier["rho_N"] + verdier["rho_D"], 0.001)
return verdier
def som_inndata(verdier: Mapping[str, float], u_eksport: tuple[float, ...]) -> Inndata:
"""The set of one draw, as the basis file will give it."""
mal = lag_inndata()
v = grunnverdier()
for navn, x in verdier.items():
v[navn] = x * FAKTORER.get(navn, 1.0)
return dataclasses.replace(
mal,
v=v,
u_eksport=u_eksport,
bortfall={n: (d[0], d[1]) for n, d in BORTFALL.items()},
Gamma_trinn=GAMMA_TRINN,
)
def varianter(
inn: Inndata, losning: Losning
) -> Iterator[tuple[Inndata, Losning, dict[str, object], dict[str, object]]]:
"""The set, and the set as each sensitivity row that touches the build-out changes it."""
yield inn, losning, {}, {}
for rad in fs.RADER.values():
if not rad.er_kjoring or losning not in rad.gjelder:
continue
x, a = inn.med(rad.verdier) if rad.verdier else inn, losning
dim, plan = dict(rad.brytere.dim), dict(rad.brytere.plan)
if rad.saerskilt is fs.Saerskilt.BESLUTNINGSAAR:
x = fs.med_beslutningsaar(x, fs.BESLUTNINGSAAR)
elif rad.saerskilt is fs.Saerskilt.C_I_MODULER:
a, plan = Losning.T_F, {"uten_forste_trinn": True}
elif rad.saerskilt is fs.Saerskilt.RHO_A:
dim = {"rho_A": x["rho_N"]}
elif rad.saerskilt is fs.Saerskilt.HALV_TAU_N:
x = x.med({"tau_N": x["tau_N"] / 2.0})
yield x, a, dim, plan
def godtatt(inn: Inndata) -> bool:
"""True when the build-out accepts the set on every step, also as the rows change it."""
try:
for losning in Losning:
for x, a, dim, plan in varianter(inn, losning):
d = ks.dimensjoner(x, a, **dim) # type: ignore[arg-type]
for n in STIGE:
ks.lag_plan(x, a, d, N_anlegg=n, **plan) # type: ignore[arg-type]
except ValueError:
return False
return True
def lag(antall: int = ANTALL, froe: int = FROE) -> dict[str, object]:
"""The content of the basis file."""
rng = random.Random(froe) # noqa: S311 - made-up numbers, not a secret
v = grunnverdier()
antall_aar = round(v["T_slutt"] - v["T0"])
trekninger: list[dict[str, object]] = []
while len(trekninger) < antall:
verdier = trekk(rng)
u_eksport = tuple(_rund(rng.random(), 0.0001) for _ in range(antall_aar))
if not godtatt(som_inndata(verdier, u_eksport)):
continue
trekninger.append({"verdier": list(verdier.values()), "u_eksport": list(u_eksport)})
mal = lag_inndata()
storrelser = [
{
"navn": navn,
"faktor": FAKTORER.get(navn, 1.0),
"status": TRUKNE[navn][0]
if navn in TRUKNE
else ("modellvalg" if navn in MODELLVALG else "kilde"),
"verdi": None if navn in TRUKNE else verdi / FAKTORER.get(navn, 1.0),
}
for navn, verdi in v.items()
]
# the values of a draw stand in the order of the quantities in the file
rekkefolge = [list(TRUKNE).index(navn) for navn in v if navn in TRUKNE]
for t in trekninger:
rad = cast("list[float]", t["verdier"])
t["verdier"] = [rad[i] for i in rekkefolge]
return {
"merke": "oppdiktet",
"storrelser": storrelser,
"tabeller": {
"design": dict(mal.design),
"P_u_sett": list(mal.P_u_sett),
"psi": dict(mal.psi),
"kappa": dict(mal.kappa),
"linjer": {n: {"alpha": p.alpha, "b": p.b} for n, p in mal.linjer.items()},
"karbonpris": {str(t): p for t, p in mal.karbonpris.items()},
"eierformer": {
n: {
"s": f.s,
"theta": f.theta,
"tau_g": f.tau_g,
"h": f.h,
"r_d": f.r_d,
"r_q": f.r_q,
"zeta": f.zeta,
"skatt": f.skatt,
}
for n, f in mal.eierformer.items()
},
"areal": dict(mal.areal),
"petroleum_median": 30e9,
"bortfall": dict(BORTFALL),
"u_alt": {n: {str(t): x for t, x in b.items()} for n, b in mal.u_alt.items()},
"kjoletaarn": {n: list(x) for n, x in mal.kjoletaarn.items()},
"Gamma_trinn": dict(GAMMA_TRINN),
},
"trekninger": trekninger,
"M5": dict(M5),
"eos": dict(EOS),
"karbonbaner": {n: dict(b) for n, b in KARBONBANER.items()},
"y_obs_maks": Y_OBS_MAKS,
}
def tekst(data: Mapping[str, object]) -> str:
"""The file's text: indent one, one quantity and one draw per line, UTF-8 as is, LF."""
deler = []
for navn, verdi in data.items():
if navn in {"storrelser", "trekninger"}:
rader = ",\n".join(
" " + json.dumps(r, ensure_ascii=False, allow_nan=False)
for r in verdi # type: ignore[attr-defined]
)
kropp = "[\n" + rader + "\n ]"
else:
kropp = json.dumps(verdi, ensure_ascii=False, indent=1, allow_nan=False)
kropp = kropp.replace("\n", "\n ")
deler.append(f" {json.dumps(navn)}: {kropp}")
return "{\n" + ",\n".join(deler) + "\n}\n"
def main() -> None:
"""Write the file; the number of draws may be given on the command line."""
antall = int(sys.argv[1]) if len(sys.argv) > 1 else ANTALL
FIL.write_bytes(tekst(lag(antall)).encode("utf-8"))
sys.stdout.write(f"{antall} oppdiktede trekninger skrevet til {FIL.name}\n")
if __name__ == "__main__":
main()