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>
288 lines
11 KiB
Python
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()
|