"""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()