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>
993 lines
39 KiB
Python
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
|