tokenfabrikker/rapport/resultater/folsomheter.py
Kjell Tore Guttormsen 4defd09580
docs(rapport): chapter 6, the results, generated from the eight result files, with ten figures
Every measured number in the prose and the tables is read from data/resultater/ by
rapport/lag_resultater.py (modules in rapport/resultater/) and carries file, path and raw
value in rapport/generert/tall.json. Chapter 8 says what is missing: the ranking of the
ownership forms under other weightings and limits is not computed, and the reproduction
is on one machine.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-14 19:41:41 +01:00

993 lines
39 KiB
Python

r"""The sensitivity list next to the main run (chapter 6, section «Følsomhetene»).
Reads ``folsomheter.json`` (the main run's row and the 42 rows of the fixed table, each in the
scenarios it is read in; the four rows of the ownership forms with their tables), and for the
«before» column of those four rows ``eierformer.json``. One derived figure about the timeline
reads ``tidslinje.json``. The short descriptions of the rows are written here; the values they
name are checked against the frozen list in ``modell/parametere.json`` (``foelsomheter``), read
as data, so that a description cannot name a value the list does not have.
Writes the tables (``folsomheter-*.tex``) and the figure data (``folsomheter-*.dat``) and returns
every number ``kap6-folsomheter.tex`` shows, under keys that start with ``folsomheter.``.
Standard library only. Nothing is computed beyond picking values out, except the ``avledet``
figures, each with its explanation: the counts of rows that change a verdict word, the largest
share of draws in which T-K runs on nuclear power, and the order of the rows in the figure.
"""
from __future__ import annotations
import json
import math
from decimal import Decimal
from typing import TYPE_CHECKING, Any
from resultater.felles import LOSNING, SCENARIO, Tall, avledet, fra_fil, hent, les, norsk
if TYPE_CHECKING:
from pathlib import Path
from resultater.felles import Steg
FIL = "folsomheter.json"
EIER = "eierformer.json"
TID = "tidslinje.json"
DOM = "dommer.json"
LOSNINGER = ("A", "B", "B'", "C", "R", "T-F", "T-K")
FEM = ("A", "B", "C", "T-F", "T-K")
MAAL = ("M1", "M2", "M3", "M4", "M5", "M6")
ANDELER = ("M2", "M3", "M4", "M6")
TELLER = "normalisering"
FORMER = ("direkte", "heleid_selskap", "majoritet_boers", "petroleumsmodell")
EIERRADER = ("24", "25", "28", "29")
FIGUR = ("A", "B", "C")
FIGUR_ANTALL = 8
FIGUR_UTENFOR = ("26", "27")
"""Rows left out of the figure: their present values are not comparable in size (113)."""
LOSNING_TEX = {"A": "A", "B": "B", "B'": "$B'$", "C": "C", "R": "R", "T-F": "T-F", "T-K": "T-K"}
SCENARIO_TEX = {
"knapphet varer": "«knapphet varer»",
"normalisering": "«normalisering»",
"overkapasitet": "«overkapasitet»",
"kildenes lave forlop": "«kildenes lave forløp»",
"80 % paa egne maskiner, lav": r"«80~\% på egne maskiner», lav",
"80 % paa egne maskiner, hoy": r"«80~\% på egne maskiner», høy",
}
AVLESNING_TEX = {
"normalisering på hovedforløpet": "«normalisering»",
"knapphet varer": "«knapphet varer»",
"de merkede scenarioene": "de tre merkede scenarioene",
"tabellene for eierformene": "tabellene for eierformene",
}
FORM_TEX = {
"direkte": "Direkte",
"heleid_selskap": "Heleid",
"majoritet_boers": "Majoritet",
"petroleumsmodell": "Petroleumsmodellen",
}
FORM_NOKKEL = {
"direkte": "direkte",
"heleid_selskap": "heleid",
"majoritet_boers": "majoritet",
"petroleumsmodell": "petroleum",
}
# The rows as the reader sees them: a short description in the words of the specification
# (clarifications 117 to 122 and the frozen list), the substrings of the frozen line that the
# description's values come from (checked against modell/parametere.json), and a note from the
# specification where the row needs one beyond the note in the file.
RADTEKST: dict[str, tuple[str, tuple[str, ...], str]] = {
"1": (r"Kostnadsspennet for kjernekraft er sluttkostnader ($w_\xi = 0$)", ("w_xi = 0",), ""),
"2": (r"Kostnadsspennet for kjernekraft er et budsjett ($w_\xi = 1$)", ("w_xi = 1",), ""),
"3": (
r"Avkastningskravet for kraftverket i A lik kravet for kraft ($\rho_A = \rho_N$)",
("rho_A = rho_N",),
"",
),
"4": (
"Avkastningskravet for kjernekraftverk på nettet 2 prosentpoeng høyere",
("2 prosentpoeng",),
"A er uendret.",
),
"5": (r"Skalaeksponenten for investering $\nu = 0{,}6$", ("nu = 0,6",), ""),
"6": (r"Læringsraten $\ell = -0{,}23$", ("ell = \u22120,23",), ""),
"7": (r"Minstelasten i S7 lik 20~\% av merkeeffekten", ("20 %", "S7"), ""),
"8": ("Fritt valg av enhetsstørrelse i S7, med buffer", ("fritt valg", "S7"), ""),
"9": (r"Halv byggetid for enheter under 300~MW", ("halv byggetid", "300 MW"), ""),
"10": (
"Inntektsfaktor etter standardvilkår i stedet for S44",
("standardvilkår", "S44"),
"",
),
"11a": (r"Norges andel solgt kapasitet $\mu_{\text{rel}} = 0{,}90$", ("mu_rel = 0,90",), ""),
"11b": (r"Norges andel solgt kapasitet $\mu_{\text{rel}} = 0{,}95$", ("0,95",), ""),
"12": ("Varig knapphet: dagens påslag for alle årganger", ("varig knapphet",), ""),
"13": ("Avtakende knapphet: påslaget avtar med tiden", ("avtakende knapphet",), ""),
"14": (
r"Konkurrentens kraftpris lik EU-snittet for de største kundene, 1\,198~kr/MWh",
("1 198 kr/MWh", "EU-snittet"),
"",
),
"15": ("PUE hos konkurrenten 1,45", ("PUE hos konkurrenten 1,45",), ""),
"16": (
r"Rundskrivets rente: 4~\%, så 3~\% og 2~\%, for alle kontantstrømmene i netto nåverdi",
("rundskrivets rente", "4 %", "3 %", "2 %"),
"Avvik fra rundskrivet. Endrer bare netto nåverdi (M1 og M7).",
),
"17a": ("Skattekostnaden lik null", ("skattekostnaden 0",), ""),
"17b": (
"Skattekostnaden 0,20 på all innskutt kapital",
("0,20 på all innskutt kapital",),
"",
),
"18": ("Subsidieelementet regnet med statens lånerente", ("statens lånerente",), ""),
"19a": ("Karbonprisens lave bane i stedet for den sentrale", ("karbonpris lav",), ""),
"19b": ("Karbonprisens høye bane i stedet for den sentrale", ("høy bane",), ""),
"20": (
r"Ulykkeskostnaden ($K_U$) uten skalering etter enhetsstørrelse",
("K_U uten skalering",),
"",
),
"21": (
"Effektkostnaden (S47) regner bare økningen ut over dimensjonerende feil",
("dimensjonerende feil", "S47"),
"",
),
"22": (
"Uten tilleggsregelen (S45): overskudd fra kraftverk på nettet regnes med",
("uten S45",),
"",
),
"23": ("Ingen eksportregel", ("ingen eksportregel",), ""),
"24": (
"Statens kontantstrøm og samlet overskudd verdsatt med statens lånerente",
("statens lånerente",),
"",
),
"25": (
"Oppgjøret med private eiere priset med deres egenkapitalkrav",
("egenkapitalkravet",),
"",
),
"26": (
"Beslutningsår 2030",
("beslutningsår 2030",),
(
"Nåverdiene er regnet til 2030 og kan ikke sammenlignes i størrelse med "
"hovedkjøringens "
"(avklaring 113)."
),
),
"27": (
r"Anlegg på 300~MW IT i alle sju løsningene",
("300 MW",),
(
"Programmet på trinnet er mindre enn hovedkjøringens, og M6 faller tilsvarende "
"(avklaring 113)."
),
),
"28": (
r"Kostnadene for direkte eierskap og heleid selskap ganges med $1 + \epsilon_e$",
("1 + eps_e",),
"",
),
"29": (
r"Statens andel av overskridelsene lik eierandelen ($\zeta_e = s_e$)",
("zeta lik eierandelen",),
"",
),
"30": (
"M6 mot medianen av de ti årene i stedet for snittet",
("medianen av de ti årene",),
"Ingen egen kjøring (avklaring 117).",
),
"31a": (
r"$\varepsilon_d = 0{,}5$: inntekten faller halvt så mye som etterspørselen",
("0,5",),
"",
),
"31b": (r"$\varepsilon_d = 2$: inntekten faller dobbelt så mye", ("og 2",), ""),
"32a": (r"Moduler på 50~MW", ("50",), ""),
"32b": (r"Moduler på 200~MW", ("200 MW",), ""),
"33": (r"Taket i første trinn 650~MW per år", ("650 MW per år",), ""),
"34": ("Full fortrengning i første trinn", ("full fortrengning",), ""),
"35": (
r"C bygd i moduler på 100~MW: T-F uten første trinn",
("100 MW", "uten første trinn"),
(
"En egen bane, som i fila står på plassen til C; M7 og dommen over hypotesen er "
"hovedkjøringens "
"(avklaring 117)."
),
),
"36": ("T-K uten vilkåret (S49)", ("uten vilkåret (S49)",), ""),
"37": (
"Ny fornybar kraft ut over nullalternativet først fra 2031",
("først fra 2031",),
"",
),
}
class Samler:
"""Collects the numbers under their keys and refuses one key with two values."""
def __init__(self) -> None:
"""Start empty."""
self.tall: dict[str, Tall] = {}
def __call__(self, nokkel: str, tall: Tall) -> Tall:
"""Store one number and give it back."""
if nokkel in self.tall and self.tall[nokkel] != tall:
melding = f"{nokkel} har to ulike verdier"
raise ValueError(melding)
self.tall[nokkel] = tall
return tall
def _pst(t: Tall) -> str:
return t.vist if t.raa is None else t.vist + r"~\%"
def _dom(x: Any, maal: str) -> str: # noqa: ANN401 - a dict or a string from the file
v = x[maal]
return v if isinstance(v, str) else v["dom"]
def _sjekk_beskrivelser(data: Path, f: dict[str, Any]) -> None:
"""Every value a description names stands in its line of the frozen list."""
fil = data.parent.parent / "modell" / "parametere.json"
liste = json.loads(fil.read_text(encoding="utf-8"))["foelsomheter"]
for navn, rad in f["rader"].items():
linje = liste[rad["linje"] - 1].lower()
for biter in RADTEKST[navn][1]:
if biter.lower() not in linje:
melding = f"rad {navn}: {biter!r} står ikke i linje {rad['linje']}: {linje!r}"
raise ValueError(melding)
# ------------------------------------------------------------------ one solution in one scenario
def _losningstall(
s: Samler, f: dict[str, Any], forst: tuple[Steg, ...], nokkel: str
) -> dict[str, Tall]:
"""The figures the table shows for one solution: shares, median, not buildable, verdicts."""
ut = {
"m1": s(f"{nokkel}.m1-andel", fra_fil(f, FIL, (*forst, "M1", "andel_holder"), "pst", 2)),
"median": s(f"{nokkel}.median", fra_fil(f, FIL, (*forst, "median_M1"), "mrd", 1)),
"ikke": s(
f"{nokkel}.ikke-byggbar", fra_fil(f, FIL, (*forst, "M1", "ikke_byggbar"), "pst", 2)
),
}
for m in ANDELER:
ut[m] = s(
f"{nokkel}.{m.lower()}-andel", fra_fil(f, FIL, (*forst, m, "andel_holder"), "pst", 2)
)
for m in MAAL:
sti = (*forst, m) if m == "M5" else (*forst, m, "dom")
ut["dom-" + m] = fra_fil(f, FIL, sti, "tekst")
return ut
def _rad_sti(rad: str, scenario: str, losning: str) -> tuple[Steg, ...]:
return ("rader", rad, "tabell", scenario, "losninger", losning)
def _hoved_sti(scenario: str, losning: str) -> tuple[Steg, ...]:
return ("hovedkjoringen", scenario, "losninger", losning)
def _endringer(f: dict[str, Any], rad: str, scenario: str, losning: str) -> list[str]:
"""The targets whose verdict word differs between the row and the main run."""
x = hent(f, _rad_sti(rad, scenario, losning))
y = hent(f, _hoved_sti(scenario, losning))
return [m for m in MAAL if _dom(x, m) != _dom(y, m)]
# ------------------------------------------------------------------ the counts
def _tellinger(s: Samler, f: dict[str, Any]) -> list[tuple[str, str, str, str]]:
"""Per scenario: rows read there, rows that change a verdict word, rows that change none.
Returns the list of changes (row, scenario, solution, target) in the order of the list.
"""
endringer: list[tuple[str, str, str, str]] = []
per_scenario: dict[str, list[str]] = {sc: [] for sc in f["scenarioer"]}
endrer: dict[str, list[str]] = {sc: [] for sc in f["scenarioer"]}
for navn, rad in f["rader"].items():
if rad["tabell"] is None:
continue
for sc in rad["tabell"]:
per_scenario[sc].append(navn)
funnet = False
for a in rad["gjelder"]:
for m in _endringer(f, navn, sc, a):
endringer.append((navn, sc, a, m))
funnet = True
if funnet:
endrer[sc].append(navn)
hvordan = (
"For hver rad i folsomheter.json med en tabell i scenarioet "
"(rader.<rad>.tabell.<scenario>) og hver løsning i rader.<rad>.gjelder er dommeordet i "
"M1 til M6 (feltet dom, for M5 "
"strengen) sammenlignet med hovedkjoringen.<scenario>.losninger.<løsning>."
)
for sc in f["scenarioer"]:
k = SCENARIO[sc]
lest = per_scenario[sc]
s(
f"folsomheter.antall.{k}.rader",
avledet(len(lest), 0, FIL, f"Antall rader med en tabell i scenarioet «{sc}»: {lest}."),
)
s(
f"folsomheter.antall.{k}.endrer",
avledet(
len(endrer[sc]),
0,
FIL,
f"Antall rader der minst ett dommeord er ulikt for minst én løsning. {hvordan} "
f"Radene: {endrer[sc]}.",
),
)
s(
f"folsomheter.antall.{k}.uendret",
avledet(
len(lest) - len(endrer[sc]),
0,
FIL,
f"Rader med en tabell i «{sc}» minus radene som endrer et dommeord der. {hvordan}",
),
)
s(
"folsomheter.antall.rader",
avledet(len(f["rader"]), 0, FIL, "Antall nøkler under rader."),
)
linjer = sorted({r["linje"] for r in f["rader"].values()})
s(
"folsomheter.antall.linjer",
avledet(len(linjer), 0, FIL, f"Antall ulike verdier av rader.<rad>.linje: {linjer}."),
)
eier = [n for n, r in f["rader"].items() if r["tabell"] is None]
s(
"folsomheter.antall.eierrader",
avledet(len(eier), 0, FIL, f"Rader uten tabell og med eierformer: {eier}."),
)
endret_del = [
(n, sc)
for n, r in f["rader"].items()
if r["tabell"] is not None
for sc in r["tabell"]
if r["tabell"][sc]["del_I"] != f["hovedkjoringen"][sc]["del_I"]
]
s(
"folsomheter.antall.del-i-endret",
avledet(
len(endret_del),
0,
FIL,
"Antall (rad, scenario) der rader.<rad>.tabell.<scenario>.del_I er ulik "
f"hovedkjoringen.<scenario>.del_I: {endret_del}.",
),
)
return endringer
# ------------------------------------------------------------------ the tables
def _overskrift_lang() -> str:
hode = (
r"Løsning & \multicolumn{2}{c}{M1: andel (\%)} & \multicolumn{2}{c}{Median M1 (mrd.~kr)} "
r"& \multicolumn{4}{c}{Andel «holder» i raden (\%)} & Dommer som endres, og annet \\"
"\n"
r"\cmidrule(lr){2-3}\cmidrule(lr){4-5}\cmidrule(lr){6-9}"
"\n"
r" & hoved & rad & hoved & rad & M2 & M3 & M4 & M6 & \\"
)
return f"\\toprule\n{hode}\n\\midrule\n"
def _lang_tabell(s: Samler, f: dict[str, Any], ut: Path) -> None:
"""The fixed table, row by row and solution by solution, with the main run beside."""
kolonner = (
r"@{}P{9mm}*{2}{>{\raggedleft\arraybackslash}p{9mm}}"
r"*{2}{>{\raggedleft\arraybackslash}p{11mm}}"
r"*{4}{>{\raggedleft\arraybackslash}p{8mm}}>{\raggedright\arraybackslash}X@{}"
)
linjer = [
"{\\scriptsize",
"\\setlength{\\tabcolsep}{2.5pt}",
"\\renewcommand{\\arraystretch}{1.1}",
f"\\begin{{xltabular}}{{\\linewidth}}{{{kolonner}}}",
(
"\\caption{Følsomhetslista rad for rad på trinnet dommene leses av på, med "
"hovedkjøringen "
"ved siden av, fra samme scenario som raden. «hoved» er hovedkjøringen, «rad» er "
"raden. "
"Andelen i M1 er andelen trekninger med positiv netto nåverdi (vilkåret for «holder»); "
"medianen er netto nåverdi i milliarder reelle 2025-kroner, nåverdi i beslutningsåret. "
"Andelene for M2, M3, M4 og M6 er andelen som oppfyller vilkåret for «holder» i raden; "
"hovedkjøringens står i \\cref{tab:res-fols-hoved}. Bare løsningene raden gjelder, "
"står "
"her; de andre har hovedkjøringens tall. Den siste kolonnen viser dommeord som er "
"ulike "
"hovedkjøringens, andelen der banen ikke lar seg bygge når den ikke er null, og når "
"alle tallene for løsningen er lik hovedkjøringens til siste siffer. Ingen dom i en "
"følsomhet teller.}\\label{tab:res-fols-rader}\\\\"
),
_overskrift_lang() + "\\endfirsthead",
_overskrift_lang() + "\\endhead",
"\\bottomrule\n\\endfoot",
]
for navn, rad in f["rader"].items():
tekst, _, notat = RADTEKST[navn]
gjelder = ", ".join(LOSNING_TEX[a] for a in rad["gjelder"])
merknad = ""
if rad["merknad"]:
t = s(
f"folsomheter.rad.{navn}.merknad",
fra_fil(f, FIL, ("rader", navn, "merknad"), "tekst"),
)
merknad = f" Merknad: {t.vist}"
hode = (
f"\\textbf{{Rad {navn}}} (linje {_linje(s, f, navn).vist}). {tekst}. "
f"Gjelder {gjelder}; "
f"leses av i {AVLESNING_TEX[rad['avlesning']]}."
+ (f" {notat}" if notat else "")
+ merknad
)
linjer.append(
"\\multicolumn{10}{@{}>{\\raggedright\\arraybackslash}p{\\linewidth}@{}}"
f"{{{hode}}} \\\\*"
)
if rad["tabell"] is None:
linjer.append(
"\\multicolumn{10}{@{}l@{}}{\\quad Gjelder bare eierformene: se "
"\\cref{tab:res-fols-eierverdi,tab:res-fols-eierrang}.} \\\\"
)
linjer.append("\\addlinespace")
continue
flere = len(rad["tabell"]) > 1
for sc in rad["tabell"]:
if flere:
linjer.append(
f"\\multicolumn{{10}}{{@{{}}l@{{}}}}{{\\quad {SCENARIO_TEX[sc]}}} \\\\*"
)
for a in rad["gjelder"]:
k = f"folsomheter.rad.{navn}.{SCENARIO[sc]}.{LOSNING[a]}"
kh = f"folsomheter.hoved.{SCENARIO[sc]}.{LOSNING[a]}"
r = _losningstall(s, f, _rad_sti(navn, sc, a), k)
h = _losningstall(s, f, _hoved_sti(sc, a), kh)
annet = []
for m in _endringer(f, navn, sc, a):
fra = s(f"{kh}.dom-{m.lower()}", h["dom-" + m])
til = s(f"{k}.dom-{m.lower()}", r["dom-" + m])
annet.append(f"{m}: {fra.vist} $\\to$ {til.vist}")
if r["ikke"].raa:
annet.append(f"ikke byggbar {_pst(r['ikke'])}")
if hent(f, _rad_sti(navn, sc, a)) == hent(f, _hoved_sti(sc, a)):
annet.append("alle tall som i hovedkjøringen")
celler = [
LOSNING_TEX[a],
h["m1"].vist,
r["m1"].vist,
h["median"].vist,
r["median"].vist,
*(r[m].vist for m in ANDELER),
"; ".join(annet),
]
linjer.append(" & ".join(celler) + r" \\")
linjer.append("\\addlinespace")
linjer += ["\\end{xltabular}", "}"]
(ut / "folsomheter-rader.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _hovedtabell(s: Samler, f: dict[str, Any], ut: Path) -> None:
"""The main run's figures in the scenarios the rows are read in."""
linjer = [
r"\begin{tabular}{@{}llrrrrrr@{}}",
r"\toprule",
(
r"Scenario & Løsning & M1 (\%) & Median M1 (mrd.~kr) & M2 (\%) & M3 (\%) & M4 (\%) "
r"& M6 (\%) \\"
),
r"\midrule",
]
for sc in f["hovedkjoringen"]:
for i, a in enumerate(LOSNINGER):
h = _losningstall(
s, f, _hoved_sti(sc, a), f"folsomheter.hoved.{SCENARIO[sc]}.{LOSNING[a]}"
)
celler = [
SCENARIO_TEX[sc] if i == 0 else "",
LOSNING_TEX[a],
h["m1"].vist,
h["median"].vist,
*(h[m].vist for m in ANDELER),
]
linjer.append(" & ".join(celler) + r" \\")
linjer.append(r"\addlinespace")
linjer[-1] = r"\bottomrule"
linjer.append(r"\end{tabular}")
(ut / "folsomheter-hoved.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _linje(s: Samler, f: dict[str, Any], navn: str) -> Tall:
"""The line of the frozen list a row comes from."""
return s(f"folsomheter.rad.{navn}.linje", fra_fil(f, FIL, ("rader", navn, "linje"), "tall", 0))
def _endringstabell(
s: Samler, f: dict[str, Any], endringer: list[tuple[str, str, str, str]], ut: Path
) -> None:
"""Every verdict word a row changes: row, line, scenario, solution, target, from, to."""
linjer: list[str] = []
for navn, sc, a, m in endringer:
kh = f"folsomheter.hoved.{SCENARIO[sc]}.{LOSNING[a]}.dom-{m.lower()}"
kr = f"folsomheter.rad.{navn}.{SCENARIO[sc]}.{LOSNING[a]}.dom-{m.lower()}"
sti_m = (m,) if m == "M5" else (m, "dom")
fra = s(kh, fra_fil(f, FIL, (*_hoved_sti(sc, a), *sti_m), "tekst"))
til = s(kr, fra_fil(f, FIL, (*_rad_sti(navn, sc, a), *sti_m), "tekst"))
linje = _linje(s, f, navn).vist
linjer.append(
f"{navn} & {linje} & {SCENARIO_TEX[sc]} & {LOSNING_TEX[a]} & {m} & {fra.vist} & "
f"{til.vist} \\\\"
)
(ut / "folsomheter-endringer.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _del1_tabell(s: Samler, f: dict[str, Any], dommer: dict[str, Any], ut: Path) -> None:
"""The hypothesis word of the main run: in this file (no thresholds) and in dommer.json."""
linjer = [
r"\begin{tabular}{@{}lll@{}}",
r"\toprule",
r"Scenario & Følsomhetstabellen & \texttt{dommer.json} \\",
r"\midrule",
]
for sc in f["scenarioer"]:
k = SCENARIO[sc]
if sc in f["hovedkjoringen"]:
her = s(
f"folsomheter.hoved.{k}.del-i",
fra_fil(f, FIL, ("hovedkjoringen", sc, "del_I"), "tekst"),
).vist
else:
her = "ingen rad leses av her"
der = s(
f"folsomheter.dommerfil.{k}.del-i",
fra_fil(dommer, DOM, ("per_scenario", ("navn", sc), "del_I"), "tekst"),
).vist
linjer.append(f"{SCENARIO_TEX[sc]} & {her} & {der} \\\\")
linjer += [r"\bottomrule", r"\end{tabular}"]
(ut / "folsomheter-del1.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _scenariotabell(f: dict[str, Any], ut: Path) -> None:
"""The counts per scenario (the numbers are keys made by ``_tellinger``)."""
linjer = [
r"\begin{tabular}{@{}lrrr@{}}",
r"\toprule",
r"Scenario & Rader lest av der & Endrer minst ett dommeord & Endrer ingen \\",
r"\midrule",
]
for sc in f["scenarioer"]:
k = f"folsomheter.antall.{SCENARIO[sc]}"
linjer.append(
f"{SCENARIO_TEX[sc]} & \\tall{{{k}.rader}} & \\tall{{{k}.endrer}} & "
f"\\tall{{{k}.uendret}} \\\\"
)
linjer += [r"\bottomrule", r"\end{tabular}"]
(ut / "folsomheter-scenarioer.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _m7_tall(s: Samler, f: dict[str, Any], forst: tuple[Steg, ...], nokkel: str) -> list[str]:
celler = [
s(
f"{nokkel}.{LOSNING[a]}.best-alene",
fra_fil(f, FIL, (*forst, a, "best_alene"), "pst", 2),
).vist
for a in FEM
]
celler.append(s(f"{nokkel}.delt", fra_fil(f, FIL, (*forst, "delt", "andel"), "pst", 2)).vist)
celler.append(s(f"{nokkel}.ingen", fra_fil(f, FIL, (*forst, "ingen", "andel"), "pst", 2)).vist)
return celler
def _m7_tabell(s: Samler, f: dict[str, Any], ut: Path) -> None:
"""The comparison M7 per row, with the main run's first in each scenario."""
hode = (
r"Rad & A & B & C & T-F & T-K & Delt & Ingen \\"
"\n"
r"\cmidrule(lr){2-6}"
"\n"
r" & \multicolumn{5}{c}{Best alene (\%)} & (\%) & (\%) \\"
)
linjer = [
"{\\footnotesize",
"\\setlength{\\tabcolsep}{4pt}",
r"\begin{xltabular}{\linewidth}{@{}>{\raggedright\arraybackslash}X*{7}{>{\raggedleft\arraybackslash}p{12mm}}@{}}",
(
"\\caption{Sammenligningen av de fem kraftløsningene (M7) i hver rad, på trinnet "
"dommene "
"leses av på: andelen trekninger der løsningen alene har høyest netto nåverdi, andelen "
"der plassen deles, og andelen der ingen lar seg bygge. Hovedkjøringen står først i "
"hvert "
"scenario. Ingen dom. I rad 35 og i radene for eierformene er sammenligningen "
"hovedkjøringens (avklaring 116 og 117).}\\label{tab:res-fols-m7}\\\\"
),
f"\\toprule\n{hode}\n\\midrule\n\\endfirsthead",
f"\\toprule\n{hode}\n\\midrule\n\\endhead",
"\\bottomrule\n\\endfoot",
]
rekkefolge = [sc for sc in f["scenarioer"] if sc in f["hovedkjoringen"]]
for sc in rekkefolge:
linjer.append(f"\\multicolumn{{8}}{{@{{}}l@{{}}}}{{\\textit{{{SCENARIO_TEX[sc]}}}}} \\\\*")
celler = _m7_tall(
s, f, ("hovedkjoringen", sc, "M7"), f"folsomheter.hoved.{SCENARIO[sc]}.m7"
)
linjer.append("Hovedkjøringen & " + " & ".join(celler) + r" \\")
for navn, rad in f["rader"].items():
if rad["tabell"] is None or sc not in rad["tabell"]:
continue
celler = _m7_tall(
s,
f,
("rader", navn, "tabell", sc, "M7"),
f"folsomheter.rad.{navn}.{SCENARIO[sc]}.m7",
)
linjer.append(f"Rad {navn} & " + " & ".join(celler) + r" \\")
linjer.append(r"\addlinespace")
linjer += ["\\end{xltabular}", "}"]
(ut / "folsomheter-m7.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _rad16(s: Samler, f: dict[str, Any], ut: Path) -> None:
"""The circular's discount rate for every solution, with the main run beside."""
linjer = [
r"\begin{tabular}{@{}lrrrrllrr@{}}",
r"\toprule",
(
r"Løsning & \multicolumn{2}{c}{M1: andel (\%)} & \multicolumn{2}{c}{Median "
r"(mrd.~kr)} & "
r"\multicolumn{2}{c}{Dom i M1} & \multicolumn{2}{c}{M7: best alene (\%)} \\"
),
r"\cmidrule(lr){2-3}\cmidrule(lr){4-5}\cmidrule(lr){6-7}\cmidrule(lr){8-9}",
r" & hoved & rad & hoved & rad & hoved & rad & hoved & rad \\",
r"\midrule",
]
for a in f["rader"]["16"]["gjelder"]:
k = f"folsomheter.rad.16.normalisering.{LOSNING[a]}"
kh = f"folsomheter.hoved.normalisering.{LOSNING[a]}"
r = _losningstall(s, f, _rad_sti("16", TELLER, a), k)
h = _losningstall(s, f, _hoved_sti(TELLER, a), kh)
dh = s(f"{kh}.dom-m1", h["dom-M1"])
dr = s(f"{k}.dom-m1", r["dom-M1"])
if a in FEM:
m7h = s(
f"folsomheter.hoved.normalisering.m7.{LOSNING[a]}.best-alene",
fra_fil(f, FIL, ("hovedkjoringen", TELLER, "M7", a, "best_alene"), "pst", 2),
).vist
m7r = s(
f"folsomheter.rad.16.normalisering.m7.{LOSNING[a]}.best-alene",
fra_fil(f, FIL, ("rader", "16", "tabell", TELLER, "M7", a, "best_alene"), "pst", 2),
).vist
else:
m7h = m7r = "ikke med"
celler = [
LOSNING_TEX[a],
h["m1"].vist,
r["m1"].vist,
h["median"].vist,
r["median"].vist,
dh.vist,
dr.vist,
m7h,
m7r,
]
linjer.append(" & ".join(celler) + r" \\")
linjer += [r"\bottomrule", r"\end{tabular}"]
(ut / "folsomheter-rad16.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
# ------------------------------------------------------------------ the ownership forms
def _eier_sti(rad: str, a: str, *rest: Steg) -> tuple[str, tuple[Steg, ...]]:
"""The file and the path for one ownership figure: the main run or one of the four rows."""
if rad == "hoved":
return EIER, ("per_losning", a, *rest)
return FIL, ("rader", rad, "eierformer", a, *rest)
def _eiertall( # noqa: PLR0917 - one figure is picked by all of them
s: Samler,
filer: dict[str, Any],
rad: str,
a: str,
rest: tuple[Steg, ...],
navn: str,
omregning: str,
desimaler: int,
) -> Tall:
fil, sti = _eier_sti(rad, a, *rest)
return s(
f"folsomheter.eier.{rad}.{LOSNING[a]}.{navn}",
fra_fil(filer[fil], fil, sti, omregning, desimaler),
)
def _eiertabeller(s: Samler, filer: dict[str, Any], ut: Path) -> None:
"""Value for the public and probability of loss per form, and the ranking, per row."""
kolonner = ("hoved", *EIERRADER)
hode = (
r"Løsning & Eierform & \multicolumn{5}{c}{Verdi for fellesskapet (mrd.~kr)} & "
r"\multicolumn{5}{c}{Sannsynlighet for tap (\%)} \\"
"\n"
r"\cmidrule(lr){3-7}\cmidrule(lr){8-12}"
"\n"
r" & & hoved & 24 & 25 & 28 & 29 & hoved & 24 & 25 & 28 & 29 \\"
)
linjer = [
"{\\scriptsize",
"\\setlength{\\tabcolsep}{3.2pt}",
r"\begin{xltabular}{\linewidth}{@{}lX*{10}{r}@{}}",
(
"\\caption{Eierformene i hovedkjøringen (\\texttt{eierformer.json}) og i de fire "
"radene som "
"bare gjelder dem (24, 25, 28 og 29), i «normalisering» på trinnet dommene leses av "
"på. "
"Verdien for fellesskapet er forventet nåverdi av statens netto kontantstrøm med "
"oppgjøret, i milliarder reelle 2025-kroner; sannsynligheten for tap er andelen "
"trekninger der nåverdien av statens kontantstrøm (S30) er negativ. Grensen for "
"statens "
"risiko er 25~\\%.}\\label{tab:res-fols-eierverdi}\\\\"
),
]
linjer += [
f"\\toprule\n{hode}\n\\midrule\n\\endfirsthead",
f"\\toprule\n{hode}\n\\midrule\n\\endhead",
"\\bottomrule\n\\endfoot",
]
for a in FEM:
for i, form in enumerate(FORMER):
fk = FORM_NOKKEL[form]
verdi = [
_eiertall(
s, filer, r, a, ("kriterier", form, "verdi"), f"{fk}.verdi", "mrd", 1
).vist
for r in kolonner
]
tap = [
_eiertall(
s,
filer,
r,
a,
("kriterier", form, "tapssannsynlighet"),
f"{fk}.tap",
"pst",
2,
).vist
for r in kolonner
]
celler = [LOSNING_TEX[a] if i == 0 else "", FORM_TEX[form], *verdi, *tap]
linjer.append(" & ".join(celler) + r" \\")
linjer.append(r"\addlinespace")
linjer += ["\\end{xltabular}", "}"]
(ut / "folsomheter-eierverdi.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
# the ranking and the state's cash flow next to M6
hode2 = (
r"Løsning & Rad & Rangert innenfor risikogrensen & Går ut & Statens kontantstrøm "
r"ved siden av M6, median (\%) \\"
)
linjer = [
"{\\footnotesize",
"\\setlength{\\tabcolsep}{3pt}",
r"\begin{xltabular}{\linewidth}{@{}llXP{38mm}>{\raggedleft\arraybackslash}p{24mm}@{}}",
(
"\\caption{Rangeringen av eierformene i hovedkjøringen og i radene 24, 25, 28 og 29: "
"formene som er rangert etter verdi for fellesskapet blant dem med sannsynlighet for "
"tap under 25~\\% (likhetstegn der formene deler plassen), og formene som går ut "
"fordi en "
"annen form er bedre på alle de tre første kriteriene. «Ingen» betyr at alle fire er "
"over risikogrensen. Statens kontantstrøm ved siden av M6 er tallet i avklaring 123 "
"for heleid selskap, som andel av nevneren i M6; det endrer ingen dom.}"
"\\label{tab:res-fols-eierrang}\\\\"
),
f"\\toprule\n{hode2}\n\\midrule\n\\endfirsthead",
f"\\toprule\n{hode2}\n\\midrule\n\\endhead",
"\\bottomrule\n\\endfoot",
]
for a in FEM:
for i, r in enumerate(kolonner):
fil, sti = _eier_sti(r, a, "rangering")
rang = hent(filer[fil], sti)
rangert = _rangert_tekst(rang)
ute = ", ".join(FORM_TEX[x] for x in rang["ute"]) or "ingen"
hvor = f"{fil}: {'.'.join(str(x) for x in sti)}"
t = s(
f"folsomheter.eier.{r}.{LOSNING[a]}.rangering",
_tekst_avledet(
rangert,
fil,
f"Feltet rangert i {hvor}, i rekkefølge, med formene i like slått sammen "
"med likhetstegn; «ingen» når lista er tom.",
),
)
u = s(
f"folsomheter.eier.{r}.{LOSNING[a]}.ute",
_tekst_avledet(
ute, fil, f"Nøklene i feltet ute i {hvor}; «ingen» når det er tomt."
),
)
k = _eiertall(
s, filer, r, a, ("statens_kontantstrom", "median"), "skst-median", "pst", 2
)
radnavn = "hovedkjøringen" if r == "hoved" else r
celler = [LOSNING_TEX[a] if i == 0 else "", radnavn, t.vist, u.vist, k.vist]
linjer.append(" & ".join(celler) + r" \\")
linjer.append(r"\addlinespace")
linjer += ["\\end{xltabular}", "}"]
(ut / "folsomheter-eierrang.tex").write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _rangert_tekst(rang: dict[str, Any]) -> str:
"""The ranked forms in order; forms that share their place joined with an equals sign."""
if not rang["rangert"]:
return "ingen"
like = {x: g for g in rang["like"] for x in g}
deler: list[str] = []
brukt: set[str] = set()
for x in rang["rangert"]:
if x in brukt:
continue
gruppe = like.get(x, [x])
brukt.update(gruppe)
deler.append(" = ".join(FORM_TEX[y] for y in gruppe))
return ", ".join(deler)
# ------------------------------------------------------------------ the figure
def _figur(s: Samler, f: dict[str, Any], ut: Path) -> None:
"""For A, B and C: the rows that move the median of M1 most in «normalisering» on the step."""
for a in FIGUR:
hoved = hent(f, (*_hoved_sti(TELLER, a), "median_M1"))
kandidater = []
for navn, rad in f["rader"].items():
if (
rad["tabell"] is None
or TELLER not in rad["tabell"]
or a not in rad["gjelder"]
or navn in FIGUR_UTENFOR
):
continue
verdi = hent(f, (*_rad_sti(navn, TELLER, a), "median_M1"))
if verdi is None:
continue
kandidater.append((abs(verdi - hoved), navn, verdi))
rekkefolge = list(f["rader"])
kandidater.sort(key=lambda x: (-x[0], rekkefolge.index(x[1])))
valgt = kandidater[:FIGUR_ANTALL]
s(
f"folsomheter.figur.{LOSNING[a]}.rader",
_tekst_avledet(
", ".join(n for _, n, _ in valgt),
FIL,
"Radene med tabell i «normalisering» som gjelder løsningen, unntatt 26 og 27, "
"ordnet etter absolutt forskjell mellom rader.<rad>.tabell.normalisering.losninger."
f"{a}.median_M1 og hovedkjoringen.normalisering.losninger.{a}.median_M1; "
f"de {FIGUR_ANTALL} største.",
),
)
linjer = [
(
f"# kilde: {FIL}, hovedkjoringen.normalisering.losninger.{a}.median_M1 (hoved) og "
f"rader.<rad>.tabell.normalisering.losninger.{a}.median_M1 (rad), "
"ganget med 1e-9 i desimal (mrd. kr); d = rad - hoved, regnet i desimal i kroner"
),
"y rad hoved verdi d",
]
n = len(valgt)
for i, (_, navn, verdi) in enumerate(valgt):
y = n - i
linjer.append(
f"{y} {navn} {_mrd(_desimal(hoved))} {_mrd(_desimal(verdi))} "
f"{_mrd(_desimal(verdi) - _desimal(hoved))}"
)
navn_fil = f"folsomheter-figur-{LOSNING[a]}.dat"
(ut / navn_fil).write_text("\n".join(linjer) + "\n", encoding="utf-8")
def _tekst_avledet(tekst: str, fil: str, forklaring: str) -> Tall:
"""A text put together from several fields of one file, with how."""
return Tall(tekst, fil, (), tekst, "avledet", 0, forklaring)
def _desimal(x: float) -> Decimal:
"""A value of the file as the shortest decimal that gives back the same float."""
if not math.isfinite(x):
melding = f"ikke et endelig tall: {x}"
raise ValueError(melding)
return Decimal(repr(float(x)))
def _mrd(x: Decimal) -> str:
"""Kroner as milliard kroner for the figure data, exact in decimal, without an exponent."""
return format(x * Decimal("1e-9"), "f")
# ------------------------------------------------------------------ prose figures
def _prosa(s: Samler, f: dict[str, Any], tid: dict[str, Any]) -> None:
s("folsomheter.trinn", fra_fil(f, FIL, ("trinn",), "tall", 0))
s("folsomheter.grunnlag-trinn", fra_fil(f, FIL, ("grunnlag_for_trinnet",), "tekst"))
for sc in f["hovedkjoringen"]:
s(
f"folsomheter.hoved.{SCENARIO[sc]}.del-i",
fra_fil(f, FIL, ("hovedkjoringen", sc, "del_I"), "tekst"),
)
for navn, rad in f["rader"].items():
if rad["tabell"] is None:
continue
for sc in rad["tabell"]:
s(
f"folsomheter.rad.{navn}.{SCENARIO[sc]}.del-i",
fra_fil(f, FIL, ("rader", navn, "tabell", sc, "del_I"), "tekst"),
)
# T-K on nuclear power on the step: the largest share of draws over the years
trinn = f["trinn"]
serie = hent(
tid,
("per_losning", "T-K", ("trinn", trinn), "typer", "kjernekraft paa nettet"),
)
storst = max(e["andel_minst_100_MW"] for e in serie)
s(
"folsomheter.tk-kjernekraft-maks",
Tall(
norsk(storst, 2, "100"),
TID,
(),
storst,
"avledet",
2,
f"Største verdi over årene av per_losning.T-K.trinn {trinn}.typer."
"«kjernekraft paa nettet».andel_minst_100_MW i tidslinje.json, i prosent.",
),
)
# ------------------------------------------------------------------ entry point
def lag(data: Path, ut: Path) -> dict[str, Tall]:
"""Write the tables and the figure data of the section and return its numbers."""
f = les(data, FIL)
filer = {FIL: f, EIER: les(data, EIER)}
tid = les(data, TID)
_sjekk_beskrivelser(data, f)
if set(f["rader"]) != set(RADTEKST):
melding = (
f"radene i fila er ikke radene i RADTEKST: {sorted(set(f['rader']) ^ set(RADTEKST))}"
)
raise ValueError(melding)
s = Samler()
endringer = _tellinger(s, f)
_prosa(s, f, tid)
_hovedtabell(s, f, ut)
_lang_tabell(s, f, ut)
_endringstabell(s, f, endringer, ut)
_scenariotabell(f, ut)
_del1_tabell(s, f, les(data, DOM), ut)
_m7_tabell(s, f, ut)
_rad16(s, f, ut)
_eiertabeller(s, filer, ut)
_figur(s, f, ut)
return s.tall