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>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-14 19:41:41 +01:00
commit 4defd09580
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
22 changed files with 5439 additions and 58 deletions

View file

@ -0,0 +1 @@
"""Chapter 6 of the report, generated from the result files in ``data/resultater/``."""

View file

@ -0,0 +1,594 @@
r"""The verdicts and the comparison of the power solutions (chapter 6, sections 6.1 and 6.2).
Reads ``dommer.json`` (the verdicts per scenario, step and solution, part I, the conditions and
the comparison M7), ``fordelinger.json`` (the percentiles behind the figures) and the two lists of
contents, ``innhold.json`` and ``tillegg.json`` (the provenance paragraph of chapter 6). Writes
the tables (``dommer-*.tex``) and the figure data (``dommer-*.dat``) and returns every number the
three files ``kap6-resultater.tex``, ``kap6-dommer.tex`` and ``kap6-m7.tex`` show, under keys
that start with ``dommer.``.
Standard library only. Nothing is computed beyond picking values out, except the few
``avledet`` figures, each with its explanation: the lists of targets per verdict word, what fells
a solution, and the share of the draws with a year of stable operation.
"""
from __future__ import annotations
from typing import TYPE_CHECKING, Any
from resultater.felles import LOSNING, SCENARIO, Tall, avledet, fra_fil, hent, les
if TYPE_CHECKING:
from pathlib import Path
from resultater.felles import Steg
DOM = "dommer.json"
FORD = "fordelinger.json"
INNHOLD = "innhold.json"
TILLEGG = "tillegg.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")
PRIS = ("knapphet varer", "normalisering", "overkapasitet")
TELLER = "normalisering"
SIDE_M6 = ("snitt", "median av ti aar", "2050", "toppaar")
SIDE_NOKKEL = {"snitt": "snitt", "median av ti aar": "median10", "2050": "y2050", "toppaar": "topp"}
# What the reader sees for a solution and a scenario. The names stand in the pre-registration.
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",
}
ORD = ("holder", "holder under betingelser", "holder ikke")
def _sti(scenario: str, trinn: int, *rest: Steg) -> tuple[Steg, ...]:
"""The path to a field under one scenario and one step of a result file."""
return ("per_scenario", ("navn", scenario), "trinn", ("trinn", trinn), *rest)
def _k(scenario: str, trinn: int, losning: str, *rest: str) -> str:
return ".".join(("dommer", SCENARIO[scenario], f"t{trinn}", LOSNING[losning], *rest))
def _pst(t: Tall) -> str:
"""A share for a table cell, with the per cent sign; an en dash when there is no value."""
return t.vist if t.raa is None else t.vist + r"~\%"
class Samler:
"""Collects the numbers under their keys and refuses a key twice."""
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:
if self.tall[nokkel] != tall:
melding = f"{nokkel} har to ulike verdier"
raise ValueError(melding)
return tall
self.tall[nokkel] = tall
return tall
# ------------------------------------------------------------------ provenance
def _innhold(d: Any, t: Any, s: Samler) -> None: # noqa: ANN401
"""The head of the run and the checksums of the files, for the provenance paragraph."""
s("dommer.innhold.antall", fra_fil(d, INNHOLD, ("antall_trekninger",), "tall", 0))
s("dommer.innhold.merke", fra_fil(d, INNHOLD, ("grunnlag", "merke"), "tekst"))
for i in range(len(d["stige"])):
s(f"dommer.innhold.stige.{i}", fra_fil(d, INNHOLD, ("stige", i), "tall", 0))
s(
"dommer.innhold.antall-scenarioer",
avledet(len(d["scenarioer"]), 0, INNHOLD, "len(scenarioer)"),
)
s("dommer.innhold.antall-losninger", avledet(len(d["losninger"]), 0, INNHOLD, "len(losninger)"))
for navn in ("parametere", "trekninger", "aarshendelser"):
_sjekksum(
s, f"dommer.innhold.grunnlag.{navn}", d, INNHOLD, ("grunnlag", "sjekksummer", navn)
)
for fil in d["filer"]:
_sjekksum(s, f"dommer.innhold.fil.{fil.removesuffix('.json')}", d, INNHOLD, ("filer", fil))
for fil in t["filer"]:
_sjekksum(s, f"dommer.innhold.fil.{fil.removesuffix('.json')}", t, TILLEGG, ("filer", fil))
# The two heads must be the same run; the paragraph says so.
for felt in ("grunnlag", "antall_trekninger", "stige", "scenarioer", "losninger"):
if d[felt] != t[felt]:
melding = f"innhold.json og tillegg.json har ulikt hode ({felt})"
raise ValueError(melding)
def _sjekksum(s: Samler, nokkel: str, data: Any, fil: str, sti: tuple[Steg, ...]) -> None: # noqa: ANN401
t = fra_fil(data, fil, sti, "tekst")
s(nokkel, Tall(r"\texttt{" + str(t.raa)[:12] + "}", t.fil, t.sti, t.raa, t.omregning, 0))
# ------------------------------------------------------------------ the verdicts
def _dom(d: Any, s: Samler, sc: str, tr: int, los: str, *, maal: str) -> Tall: # noqa: ANN401
"""The verdict word of one target, with the shares behind it."""
if maal == "M5":
return s(
_k(sc, tr, los, "m5"), fra_fil(d, DOM, _sti(sc, tr, "losninger", los, "M5"), "tekst")
)
sti = _sti(sc, tr, "losninger", los, maal)
m = maal.lower()
s(_k(sc, tr, los, m, "andel"), fra_fil(d, DOM, (*sti, "andel_holder"), "pst"))
s(_k(sc, tr, los, m, "andel-ikke"), fra_fil(d, DOM, (*sti, "andel_holder_ikke"), "pst"))
s(_k(sc, tr, los, m, "ikke-byggbar"), fra_fil(d, DOM, (*sti, "ikke_byggbar"), "pst"))
s(_k(sc, tr, los, m, "blant"), fra_fil(d, DOM, (*sti, "oppfylt_blant_byggbare"), "pst"))
return s(_k(sc, tr, los, m, "dom"), fra_fil(d, DOM, (*sti, "dom"), "tekst"))
def _median(d: Any, s: Samler, sc: str, tr: int, los: str) -> Tall: # noqa: ANN401
return s(
_k(sc, tr, los, "nnv-median"),
fra_fil(d, DOM, _sti(sc, tr, "losninger", los, "median_M1"), "mrd"),
)
def _celle_dom(d: Any, s: Samler, sc: str, tr: int, los: str, *, maal: str) -> str: # noqa: ANN401
"""One cell of the main table: the verdict word, and below it the share(s) it was set from."""
dom = _dom(d, s, sc, tr, los, maal=maal)
if maal == "M5":
return dom.vist
m = maal.lower()
a = s.tall[_k(sc, tr, los, m, "andel")]
if maal in ("M1", "M2"):
return rf"{dom.vist}\newline{{\scriptsize {a.vist}}}"
b = s.tall[_k(sc, tr, los, m, "andel-ikke")]
return rf"{dom.vist}\newline{{\scriptsize {a.vist} / {b.vist}}}"
def _maal_med(d: Any, s: Samler, sc: str, tr: int, los: str, *, ord_: str) -> Tall: # noqa: ANN401
"""The targets of one solution whose verdict is the given word, as a list of names."""
navn = []
for maal in MAAL:
verdi = d_dom(d, sc, tr, los, maal)
if verdi == ord_:
navn.append(maal)
tekst = ", ".join(navn) if navn else "--"
nokkel = {"holder": "liste-holder", "holder under betingelser": "liste-betinget"}.get(
ord_, "liste-ikke"
)
forklaring = (
f"the targets among M1..M6 whose verdict is '{ord_}' at per_scenario[navn={sc}]"
f".trinn[trinn={tr}].losninger.{los}.<M>.dom (M5: .M5)"
)
return s(_k(sc, tr, los, nokkel), Tall(tekst, DOM, (), tekst, "avledet", 0, forklaring))
def d_dom(d: Any, sc: str, tr: int, los: str, maal: str) -> str: # noqa: ANN401
"""The verdict word of one target as it stands in ``dommer.json``."""
v = hent(d, _sti(sc, tr, "losninger", los, maal))
return str(v if maal == "M5" else v["dom"])
def _tabell_teller(d: Any, s: Samler, tr: int) -> str: # noqa: ANN401
"""Table: the verdict per target and solution in «normalisering» on the step."""
sc = TELLER
hode = " & ".join(LOSNING_TEX[x] for x in LOSNINGER)
linjer = [
(
r"\begin{tabular}{@{}>{\raggedright\arraybackslash}p{17mm}"
r"*{7}{>{\raggedright\arraybackslash}p{17.2mm}}@{}}"
),
r"\toprule",
rf"Mål & {hode} \\",
r"\midrule",
]
for maal in MAAL:
celler = [_celle_dom(d, s, sc, tr, los, maal=maal) for los in LOSNINGER]
linjer.append(rf"{maal} & " + " & ".join(celler) + r" \\[2pt]")
linjer.append(r"\midrule")
med = [_median(d, s, sc, tr, los).vist for los in LOSNINGER]
linjer.append(r"Median M1, mrd.~kr & " + " & ".join(med) + r" \\")
ib = [s.tall[_k(sc, tr, los, "m1", "ikke-byggbar")].vist for los in LOSNINGER]
linjer.append(r"Ikke byggbar, \% & " + " & ".join(ib) + r" \\")
linjer += [r"\bottomrule", r"\end{tabular}"]
return "\n".join(linjer) + "\n"
def _grunn(d: Any, s: Samler, sc: str, tr: int, los: str) -> str: # noqa: ANN401
"""One cell of the table over part I: felled or not, and why, from the file's own fields."""
sti = ("per_scenario", ("navn", sc), "betingelser", los)
felt = s(_k(sc, tr, los, "felt"), fra_fil(d, DOM, (*sti, "felt"), "tekst"))
navngis = s(_k(sc, tr, los, "kan-navngis"), fra_fil(d, DOM, (*sti, "kan_navngis"), "tekst"))
if felt.raa:
ikke = _maal_med(d, s, sc, tr, los, ord_="holder ikke")
med = _median(d, s, sc, tr, los)
deler = [x for x in ikke.vist.split(", ") if x in ("M1", "M2", "M3", "M4", "M5")]
negativ = med.raa is None or float(med.raa) < 0
if negativ:
deler.append("negativ median")
grunn = ", ".join(deler)
forklaring = (
f"the targets among M1..M5 that are 'holder ikke', and 'negativ median' when "
f"median_M1 < 0 or null, at per_scenario[navn={sc}].trinn[trinn={tr}].losninger.{los}"
)
s(_k(sc, tr, los, "grunn"), Tall(grunn, DOM, (), grunn, "avledet", 0, forklaring))
return rf"felt: {grunn}"
return "ikke felt; betingelsene kan " + ("" if navngis.raa else "ikke ") + "navngis"
def _terskeltall(d: Any, s: Samler, sc: str, tr: int, los: str) -> None: # noqa: ANN401
"""How many thresholds the file has per target that holds under conditions, and how many count.
The thresholds themselves are shown in section 6.5; here only the counts the text on part I
needs, so a reader sees why the conditions can or cannot be named.
"""
sti = ("per_scenario", ("navn", sc), "betingelser", los, "terskler")
for maal, rad in hent(d, sti).items():
hvor = f"per_scenario[navn={sc}].betingelser.{los}.terskler.{maal}"
m = maal.lower()
s(
_k(sc, tr, los, m, "terskler"),
avledet(len(rad), 0, DOM, f"len({hvor}): the thresholds found"),
)
s(
_k(sc, tr, los, m, "terskler-kilde"),
avledet(sum(1 for x in rad if x["kilde"]), 0, DOM, f"count of {hvor}[*].kilde == true"),
)
s(
_k(sc, tr, los, m, "terskler-teller"),
avledet(
sum(1 for x in rad if x["teller"]), 0, DOM, f"count of {hvor}[*].teller == true"
),
)
def _tabell_del1(d: Any, s: Samler, tr: int) -> str: # noqa: ANN401
"""Table: the verdict over the hypothesis per scenario, and what fells each of the five."""
linjer = [
(
r"\begin{tabular}{@{}>{\raggedright\arraybackslash}p{24mm}"
r">{\raggedright\arraybackslash}p{15mm}*{5}{>{\raggedright\arraybackslash}p{19.5mm}}@{}}"
),
r"\toprule",
r"Scenario & Hypotesen & " + " & ".join(FEM) + r" \\",
r"\midrule",
]
for sc in d["scenarioer"]:
del1 = s(
f"dommer.{SCENARIO[sc]}.del1",
fra_fil(d, DOM, ("per_scenario", ("navn", sc), "del_I"), "tekst"),
)
s(
f"dommer.{SCENARIO[sc]}.del1-avgjort",
fra_fil(d, DOM, ("per_scenario", ("navn", sc), "del_I_avgjort"), "tekst"),
)
celler = [_grunn(d, s, sc, tr, los) for los in FEM]
for los in FEM:
_terskeltall(d, s, sc, tr, los)
linjer.append(rf"{SCENARIO_TEX[sc]} & {del1.vist} & " + " & ".join(celler) + r" \\[2pt]")
linjer += [r"\bottomrule", r"\end{tabular}"]
return "\n".join(linjer) + "\n"
def _tabell_andre(d: Any, s: Samler, tr: int) -> str: # noqa: ANN401
"""Table: the five other scenarios on the step, per solution."""
linjer = [
(
r"\begin{tabular}{@{}l>{\raggedleft\arraybackslash}p{14mm}>{\raggedleft\arraybackslash}p{17mm}"
r">{\raggedright\arraybackslash}p{24mm}>{\raggedright\arraybackslash}p{24mm}"
r">{\raggedright\arraybackslash}p{24mm}@{}}"
),
r"\toprule",
(
r"Løsning & Positiv NNV & Median M1, mrd.~kr & «holder» & «holder under betingelser» & "
r"«holder ikke» \\"
),
r"\midrule",
]
andre = [x for x in d["scenarioer"] if x != TELLER]
for i, sc in enumerate(andre):
if i:
linjer.append(r"\addlinespace")
linjer.append(rf"\multicolumn{{6}}{{@{{}}l}}{{\textit{{{SCENARIO_TEX[sc]}}}}} \\")
for los in LOSNINGER:
for maal in MAAL:
_dom(d, s, sc, tr, los, maal=maal)
a = _pst(s.tall[_k(sc, tr, los, "m1", "andel")])
med = _median(d, s, sc, tr, los).vist
lister = [_maal_med(d, s, sc, tr, los, ord_=o).vist for o in ORD]
linjer.append(
rf"\quad {LOSNING_TEX[los]} & {a} & {med} & " + " & ".join(lister) + r" \\"
)
linjer += [r"\bottomrule", r"\end{tabular}"]
return "\n".join(linjer) + "\n"
def _side_m6(d: Any, f: Any, s: Samler, tr: int) -> str: # noqa: ANN401
"""Table: M6 in the year of stable operation and the four figures beside it, «normalisering»."""
sc = TELLER
linjer = [
r"\begin{tabular}{@{}l*{5}{>{\centering\arraybackslash}p{24mm}}@{}}",
r"\toprule",
(
r"Løsning & M6, første år med stabil drift & Snitt over $L_H$ år"
r" & Mot medianen av de ti årene & I 2050 & I toppåret \\"
),
r"\midrule",
]
for los in LOSNINGER:
sti = _sti(sc, tr, "losninger", los, "M6")
celler = []
p = [
s(_k(sc, tr, los, "m6", f"p{q}"), fra_fil(f, FORD, (*sti, "persentiler", q), "pst"))
for q in (10, 50, 90)
]
s(_k(sc, tr, los, "m6", "antall"), fra_fil(f, FORD, (*sti, "antall"), "tall", 0))
celler.append(_tre(p))
for felt in SIDE_M6:
sti2 = _sti(sc, tr, "losninger", los, "ved_siden_av_M6", felt)
n = SIDE_NOKKEL[felt]
q = [
s(_k(sc, tr, los, n, x), fra_fil(d, DOM, (*sti2, x), "pst"))
for x in ("p10", "median", "p90")
]
s(_k(sc, tr, los, n, "antall"), fra_fil(d, DOM, (*sti2, "antall"), "tall", 0))
celler.append(_tre(q))
linjer.append(rf"{LOSNING_TEX[los]} & " + " & ".join(celler) + r" \\[2pt]")
linjer += [r"\bottomrule", r"\end{tabular}"]
return "\n".join(linjer) + "\n"
def _tre(p: list[Tall]) -> str:
"""Median with the 10th and 90th percentile below it, in per cent."""
lav, med, hoy = p
return rf"{med.vist}\newline {{\scriptsize [{lav.vist}; {hoy.vist}]}}"
def _tabell_stige(d: Any, f: Any, s: Samler) -> str: # noqa: ANN401
"""Table: «ikke byggbar» and the median of M1 on every step of the ladder, «normalisering»."""
sc = TELLER
stige = d["stige"]
hode = " & ".join(str(x) for x in stige)
linjer = [
r"\begin{tabular}{@{}l*{5}{r}@{\hspace{10pt}}*{5}{r}@{}}",
r"\toprule",
r" & \multicolumn{5}{c}{Ikke byggbar, \%} & \multicolumn{5}{c}{Median M1, mrd.~kr} \\",
r"\cmidrule(lr){2-6}\cmidrule(l){7-11}",
rf"Løsning (anlegg:) & {hode} & {hode} \\",
r"\midrule",
]
for los in LOSNINGER:
ib, med = [], []
for tr in stige:
for maal in MAAL:
_dom(d, s, sc, tr, los, maal=maal)
ib.append(s.tall[_k(sc, tr, los, "m1", "ikke-byggbar")].vist)
med.append(_median(d, s, sc, tr, los).vist)
sti = _sti(sc, tr, "losninger", los, "M6", "antall")
antall = s(_k(sc, tr, los, "m6", "antall"), fra_fil(f, FORD, sti, "tall", 0))
s(
_k(sc, tr, los, "stabil"),
avledet(
100.0 * int(antall.raa or 0) / int(d["antall_trekninger"]),
1,
FORD,
f"100 * per_scenario[navn={sc}].trinn[trinn={tr}].losninger.{los}.M6.antall"
" / antall_trekninger: the share of the draws with a year of stable operation",
),
)
linjer.append(rf"{LOSNING_TEX[los]} & " + " & ".join(ib) + " & " + " & ".join(med) + r" \\")
linjer += [r"\bottomrule", r"\end{tabular}"]
# The share «ikke byggbar» is shown without the per cent sign in this table (the head says it).
return "\n".join(linjer) + "\n"
# ------------------------------------------------------------------ figures
def _dat_fordeling(f: Any, sc: str, tr: int, storrelse: str) -> str: # noqa: ANN401
"""Figure data: percentiles 10, 25, 50, 75, 90 of one quantity per solution, raw values."""
linjer = [
(
f"# kilde: {FORD}, per_scenario[navn={sc}].trinn[trinn={tr}].losninger.<losning>"
f".{storrelse}.persentiler[10,25,50,75,90] (raw, not rounded) and .antall"
),
"pos losning p10 p25 p50 p75 p90 antall",
]
for i, los in enumerate(LOSNINGER):
v = hent(f, _sti(sc, tr, "losninger", los, storrelse))
p = v["persentiler"]
verdier = " ".join(repr(float(p[q])) for q in (10, 25, 50, 75, 90))
linjer.append(f"{len(LOSNINGER) - i} {LOSNING[los]} {verdier} {v['antall']}")
return "\n".join(linjer) + "\n"
# ------------------------------------------------------------------ M7
def _m7(d: Any, s: Samler, sc: str, tr: int) -> None: # noqa: ANN401
"""Every share of the comparison on one step in one scenario."""
base = _sti(sc, tr, "M7")
for los in FEM:
for felt, navn in (
("best_alene", "alene"),
("deler_plassen", "deler"),
("ikke_byggbar", "ikke-byggbar"),
("best_alene_blant_byggbare", "blant"),
):
s(
f"dommer.m7.{SCENARIO[sc]}.t{tr}.{LOSNING[los]}.{navn}",
fra_fil(d, DOM, (*base, los, felt), "pst", 2),
)
s(f"dommer.m7.{SCENARIO[sc]}.t{tr}.delt", fra_fil(d, DOM, (*base, "delt", "andel"), "pst", 2))
s(f"dommer.m7.{SCENARIO[sc]}.t{tr}.ingen", fra_fil(d, DOM, (*base, "ingen", "andel"), "pst", 2))
for i, par in enumerate(hent(d, (*base, "delt", "par"))):
a, b = par["losninger"]
s(
f"dommer.m7.{SCENARIO[sc]}.t{tr}.par.{LOSNING[a]}-{LOSNING[b]}",
fra_fil(d, DOM, (*base, "delt", "par", i, "andel"), "pst", 2),
)
def _m7_stige(d: Any, s: Samler) -> str: # noqa: ANN401
"""Table: the comparison in «normalisering» on every step of the ladder."""
sc = TELLER
stige = d["stige"]
for tr in stige:
_m7(d, s, sc, tr)
hode = " & ".join(str(x) for x in stige)
linjer = [
r"\begin{tabular}{@{}l*{5}{r}@{}}",
r"\toprule",
rf"Antall anlegg i trinnet & {hode} \\",
r"\midrule",
]
blokker = (
("alene", "Best alene, andel av alle trekningene"),
("deler", "Deler plassen, andel av alle trekningene"),
("blant", "Best alene blant trekningene der løsningen lar seg bygge"),
("ikke-byggbar", "Løsningen lar seg ikke bygge"),
)
for j, (navn, tittel) in enumerate(blokker):
if j:
linjer.append(r"\addlinespace")
linjer.append(rf"\multicolumn{{6}}{{@{{}}l}}{{\textit{{{tittel}}}}} \\")
for los in FEM:
celler = [
_pst(s.tall[f"dommer.m7.{SCENARIO[sc]}.t{tr}.{LOSNING[los]}.{navn}"])
for tr in stige
]
linjer.append(rf"\quad {LOSNING_TEX[los]} & " + " & ".join(celler) + r" \\")
linjer.append(r"\midrule")
for navn, tittel in (("delt", "Plassen er delt"), ("ingen", "Ingen lar seg bygge")):
celler = [_pst(s.tall[f"dommer.m7.{SCENARIO[sc]}.t{tr}.{navn}"]) for tr in stige]
linjer.append(rf"{tittel} & " + " & ".join(celler) + r" \\")
linjer += [r"\bottomrule", r"\end{tabular}"]
return "\n".join(linjer) + "\n"
def _m7_scenarioer(d: Any, s: Samler, tr: int) -> str: # noqa: ANN401
"""Table: the comparison on the step in all six scenarios, with the pairs that share."""
scenarioer = d["scenarioer"]
for sc in scenarioer:
_m7(d, s, sc, tr)
hode = " & ".join(
{
"knapphet varer": "Knapphet varer",
"normalisering": "Normali\\-sering",
"overkapasitet": "Overkapa\\-sitet",
"kildenes lave forlop": "Kildenes lave forløp",
"80 % paa egne maskiner, lav": r"80~\% på egne, lav",
"80 % paa egne maskiner, hoy": r"80~\% på egne, høy",
}[sc]
for sc in scenarioer
)
linjer = [
r"\begin{tabular}{@{}l*{6}{>{\raggedleft\arraybackslash}p{17mm}}@{}}",
r"\toprule",
rf" & {hode} \\",
r"\midrule",
]
for j, (navn, tittel) in enumerate((("alene", "Best alene"), ("deler", "Deler plassen"))):
if j:
linjer.append(r"\addlinespace")
linjer.append(rf"\multicolumn{{7}}{{@{{}}l}}{{\textit{{{tittel}}}}} \\")
for los in FEM:
celler = [
_pst(s.tall[f"dommer.m7.{SCENARIO[sc]}.t{tr}.{LOSNING[los]}.{navn}"])
for sc in scenarioer
]
linjer.append(rf"\quad {LOSNING_TEX[los]} & " + " & ".join(celler) + r" \\")
linjer.append(r"\addlinespace")
linjer.append(r"\multicolumn{7}{@{}l}{\textit{Par som deler plassen}} \\")
for par in hent(d, (*_sti(TELLER, tr, "M7"), "delt", "par")):
a, b = par["losninger"]
celler = [
_pst(s.tall[f"dommer.m7.{SCENARIO[sc]}.t{tr}.par.{LOSNING[a]}-{LOSNING[b]}"])
for sc in scenarioer
]
linjer.append(
rf"\quad {LOSNING_TEX[a]} og {LOSNING_TEX[b]} & " + " & ".join(celler) + r" \\"
)
linjer.append(r"\midrule")
for navn, tittel in (("delt", "Plassen er delt"), ("ingen", "Ingen lar seg bygge")):
celler = [_pst(s.tall[f"dommer.m7.{SCENARIO[sc]}.t{tr}.{navn}"]) for sc in scenarioer]
linjer.append(rf"{tittel} & " + " & ".join(celler) + r" \\")
linjer += [r"\bottomrule", r"\end{tabular}"]
return "\n".join(linjer) + "\n"
def _dat_m7(d: Any) -> str: # noqa: ANN401
"""Figure data: «best alene» per solution, «delt» and «ingen» per step, «normalisering»."""
linjer = [
(
f"# kilde: {DOM}, per_scenario[navn={TELLER}].trinn[trinn=<trinn>].M7"
".<losning>.best_alene, .M7.delt.andel, .M7.ingen.andel (shares of all the draws, raw)"
),
"pos trinn " + " ".join(LOSNING[x] for x in FEM) + " delt ingen",
]
for i, tr in enumerate(d["stige"]):
m7 = hent(d, _sti(TELLER, tr, "M7"))
verdier = [repr(float(m7[x]["best_alene"])) for x in FEM]
verdier += [repr(float(m7["delt"]["andel"])), repr(float(m7["ingen"]["andel"]))]
linjer.append(f"{i + 1} {tr} " + " ".join(verdier))
return "\n".join(linjer) + "\n"
# ------------------------------------------------------------------ the step
def _trinnet(d: Any, s: Samler) -> int: # noqa: ANN401
s("dommer.antall", fra_fil(d, DOM, ("antall_trekninger",), "tall", 0))
tr = s("dommer.trinn", fra_fil(d, DOM, ("trinn",), "tall", 0))
s("dommer.grunnlag", fra_fil(d, DOM, ("grunnlag_for_trinnet",), "tekst"))
s("dommer.teller", fra_fil(d, DOM, ("teller",), "tekst"))
s("dommer.del1", fra_fil(d, DOM, ("del_I",), "tekst"))
for i in range(len(d["stige"])):
s(f"dommer.stige.{i}", fra_fil(d, DOM, ("stige", i), "tall", 0))
return int(tr.raa) # type: ignore[arg-type]
def _skriv(ut: Path, navn: str, tekst: str) -> None:
(ut / navn).write_text(tekst, encoding="utf-8")
def lag(data: Path, ut: Path) -> dict[str, Tall]:
"""Write the tables and figure data of sections 6.1 and 6.2, and return their numbers."""
d = les(data, DOM)
f = les(data, FORD)
s = Samler()
_innhold(les(data, INNHOLD), les(data, TILLEGG), s)
for felt in ("grunnlag", "antall_trekninger", "stige", "scenarioer", "losninger"):
if d[felt] != f[felt]:
melding = f"dommer.json og fordelinger.json har ulikt hode ({felt})"
raise ValueError(melding)
tr = _trinnet(d, s)
_skriv(ut, "dommer-teller.tex", _tabell_teller(d, s, tr))
_skriv(ut, "dommer-del1.tex", _tabell_del1(d, s, tr))
_skriv(ut, "dommer-andre.tex", _tabell_andre(d, s, tr))
_skriv(ut, "dommer-m6.tex", _side_m6(d, f, s, tr))
_skriv(ut, "dommer-stige.tex", _tabell_stige(d, f, s))
_skriv(ut, "dommer-m7-stige.tex", _m7_stige(d, s))
_skriv(ut, "dommer-m7-scenarioer.tex", _m7_scenarioer(d, s, tr))
_skriv(ut, "dommer-m7.dat", _dat_m7(d))
for sc in PRIS:
_skriv(ut, f"dommer-nnv-{SCENARIO[sc]}.dat", _dat_fordeling(f, sc, tr, "NNV"))
_skriv(ut, f"dommer-m6-{SCENARIO[sc]}.dat", _dat_fordeling(f, sc, tr, "M6"))
for los in LOSNINGER:
sti = _sti(sc, tr, "losninger", los, "NNV")
s(_k(sc, tr, los, "nnv", "antall"), fra_fil(f, FORD, (*sti, "antall"), "tall", 0))
for q in (1, 10, 25, 50, 75, 90, 99):
s(
_k(sc, tr, los, "nnv", f"p{q}"),
fra_fil(f, FORD, (*sti, "persentiler", q), "mrd"),
)
return dict(sorted(s.tall.items()))

View file

@ -0,0 +1,200 @@
"""Chapter 6, «Eierformene»: the four ownership forms on the step the verdicts are read on.
Reads ``eierformer.json`` (clarifications 98, 123 and 128 c of the specification) and writes four
table bodies to ``rapport/generert/``:
- ``eierformer-verdi.tex``: value for the public (``verdi``, ``oppgjor``, ``andel_av_overskudd``,
``andel_for_oppgjor``) per solution and form;
- ``eierformer-risiko.tex``: cost of capital (``r_e``, ``LCOC``) and risk for the state
(``tapssannsynlighet``, ``daarligste``, ``kapital_ute``) per solution and form;
- ``eierformer-rangering.tex``: the draws the table rests on and the rule of the pre-registration
(``antall_byggbare``, ``rangering``) per solution;
- ``eierformer-kontantstrom.tex``: the state's net cash flow next to M6 (``statens_kontantstrom``).
Every number shown is returned as a ``Tall`` under a key that starts with ``eierformer.``.
Standard library only.
"""
from __future__ import annotations
from typing import TYPE_CHECKING, Any
from resultater.felles import LOSNING, Tall, fra_fil, les
if TYPE_CHECKING:
from pathlib import Path
FIL = "eierformer.json"
# (name in the file, short name in keys, label in the tables). The labels are the
# pre-registration's candidates, shortened; the chapter gives the full names.
FORMER = (
("direkte", "direkte", "Direkte"),
("heleid_selskap", "heleid", "Heleid selskap"),
("majoritet_boers", "majoritet", "Majoritet med børs"),
("petroleumsmodell", "petroleum", "Petroleumsmodellen"),
)
NAVN = {fil: etikett for fil, _, etikett in FORMER}
KORT = {fil: kort for fil, kort, _ in FORMER}
# (field, key, conversion, decimals) per column, in the order of the tables.
VERDI = (
("verdi", "verdi", "mrd", 1),
("oppgjor", "oppgjor", "mrd", 1),
("andel_av_overskudd", "andel-overskudd", "pst", 1),
("andel_for_oppgjor", "andel-for-oppgjor", "pst", 1),
)
RISIKO = (
("r_e", "re", "pst", 1),
("LCOC", "lcoc", "mill", 1),
("tapssannsynlighet", "tap", "pst", 2),
("daarligste", "daarligste", "mrd", 1),
("kapital_ute", "kapital-ute", "mrd", 1),
)
# The column specification and the head of each table (the head may span several lines).
RAMME = {
"verdi": (
"@{}llrrrr@{}",
"Løsning & Eierform & Verdi & Oppgjør & Andel av samlet overskudd & Andel før oppgjør \\\\",
),
"risiko": (
"@{}llrrrrr@{}",
(
"& & \\multicolumn{2}{c}{Kapitalkostnad} & \\multicolumn{3}{c}{Risiko for staten} "
"\\\\\n\\cmidrule(lr){3-4}\\cmidrule(l){5-7}\n"
"Løsning & Eierform & $r_e$ & Kostnad for regnekraft & Tap & 5~\\% dårligste & "
"Kapital ute \\\\"
),
),
"rangering": (
"@{}lrllll@{}",
"Løsning & Trekninger & Rangert & Over grensen på 25~\\% & Går ut & Står likt \\\\",
),
"kontantstrom": (
"@{}lrrrr@{}",
"Løsning & Trekninger & Median & 10-persentil & 90-persentil \\\\",
),
}
KONTANTSTROM = (("antall", "tall", 0), ("median", "pst", 1), ("p10", "pst", 1), ("p90", "pst", 1))
def _losning_tekst(losning: str) -> str:
"""The code of a solution as the tables print it (B' with a prime in math mode)."""
return "$B'$" if losning == "B'" else losning
def _former(navn: list[str]) -> str:
"""A list of ownership forms as words, in the order of the parameter file."""
if not navn:
return "ingen"
if len(navn) == len(FORMER):
return "alle fire"
rekke = [NAVN[f] for f, _, _ in FORMER if f in navn]
return ", ".join(rekke)
def lag(data: Path, ut: Path) -> dict[str, Tall]:
"""Write the four table bodies and return every number they and the prose show."""
fil = les(data, FIL)
tall: dict[str, Tall] = {
"eierformer.trinn": fra_fil(fil, FIL, ("trinn",), "tall", 0),
"eierformer.grunnlag-for-trinnet": fra_fil(fil, FIL, ("grunnlag_for_trinnet",), "tekst"),
"eierformer.scenario": fra_fil(fil, FIL, ("scenario",), "tekst"),
"eierformer.antall-trekninger": fra_fil(fil, FIL, ("antall_trekninger",), "tall", 0),
}
verdi_rader: list[str] = []
risiko_rader: list[str] = []
rangering_rader: list[str] = []
strom_rader: list[str] = []
for losning, tabell in fil["per_losning"].items():
lk = LOSNING[losning]
navn = _losning_tekst(losning)
if tabell is None:
tom = f"{navn} & \\multicolumn{{5}}{{l}}{{ingen tabell}} \\\\"
verdi_rader.append(tom)
risiko_rader.append(tom)
rangering_rader.append(tom)
strom_rader.append(tom)
continue
antall = fra_fil(fil, FIL, ("per_losning", losning, "antall_byggbare"), "tall", 0)
tall[f"eierformer.{lk}.antall-byggbare"] = antall
for nr, (form, _, etikett) in enumerate(FORMER):
forste = f"\\multirow{{4}}{{*}}{{{navn}}}" if nr == 0 else ""
celler_v = _celler(fil, tall, losning, form, VERDI)
celler_r = _celler(fil, tall, losning, form, RISIKO)
verdi_rader.append(f"{forste} & {etikett} & {' & '.join(celler_v)} \\\\")
risiko_rader.append(f"{forste} & {etikett} & {' & '.join(celler_r)} \\\\")
verdi_rader.append("\\midrule")
risiko_rader.append("\\midrule")
rangering_rader.append(_rangering(tabell["rangering"], navn, antall))
strom_rader.append(_kontantstrom(fil, tall, losning, navn))
for rader in (verdi_rader, risiko_rader):
if rader and rader[-1] == "\\midrule":
rader.pop()
for navn_fil, rader in (
("verdi", verdi_rader),
("risiko", risiko_rader),
("rangering", rangering_rader),
("kontantstrom", strom_rader),
):
spec, hode = RAMME[navn_fil]
tekst = "\n".join(
[
f"\\begin{{tabular}}{{{spec}}}",
"\\toprule",
hode,
"\\midrule",
*rader,
"\\bottomrule",
"\\end{tabular}",
]
)
(ut / f"eierformer-{navn_fil}.tex").write_text(tekst + "\n", encoding="utf-8")
return tall
def _celler(
fil: Any, # noqa: ANN401
tall: dict[str, Tall],
losning: str,
form: str,
kolonner: tuple[tuple[str, str, str, int], ...],
) -> list[str]:
"""The cells of one row: one ``Tall`` per field, registered under its key."""
celler = []
for felt, nokkel, omregning, desimaler in kolonner:
sti = ("per_losning", losning, "kriterier", form, felt)
t = fra_fil(fil, FIL, sti, omregning, desimaler)
tall[f"eierformer.{LOSNING[losning]}.{KORT[form]}.{nokkel}"] = t
celler.append(t.vist)
return celler
def _rangering(rangering: dict[str, Any], navn: str, antall: Tall) -> str:
"""One row of the table of the rule: who is ranked, who is over the limit, who goes out."""
rangert = _former(list(rangering["rangert"]))
over = _former(list(rangering["over_risikogrensen"]))
ute = (
"; ".join(f"{NAVN[f]} ({grunn})" for f, grunn in rangering["ute"].items())
if rangering["ute"]
else "ingen"
)
like = (
"; ".join(", ".join(NAVN[f] for f in gruppe) for gruppe in rangering["like"])
if rangering["like"]
else "ingen"
)
return f"{navn} & {antall.vist} & {rangert} & {over} & {ute} & {like} \\\\"
def _kontantstrom(fil: Any, tall: dict[str, Tall], losning: str, navn: str) -> str: # noqa: ANN401
"""One row of the state's net cash flow next to M6 (clarification 123)."""
if fil["per_losning"][losning]["statens_kontantstrom"] is None:
return f"{navn} & \\multicolumn{{4}}{{l}}{{ingen trekning med stabil drift}} \\\\"
celler = []
for felt, omregning, desimaler in KONTANTSTROM:
sti = ("per_losning", losning, "statens_kontantstrom", felt)
t = fra_fil(fil, FIL, sti, omregning, desimaler)
tall[f"eierformer.{LOSNING[losning]}.kontantstrom.{felt}"] = t
celler.append(t.vist)
return f"{navn} & {' & '.join(celler)} \\\\"

View file

@ -0,0 +1,129 @@
r"""What the modules behind chapter 6 share: numbers with their origin, and Norwegian number format.
Every number chapter 6 shows (in the prose, in a table cell) is a ``Tall``: the string that is
printed, and where in which result file the value stands. The driver ``rapport/lag_resultater.py``
writes them to ``rapport/generert/tall.tex`` (read in the prose with ``\tall{key}``) and to
``rapport/generert/tall.json`` (the list a reader checks against the files).
Standard library only.
"""
from __future__ import annotations
import json
from dataclasses import dataclass
from decimal import ROUND_HALF_UP, Decimal
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from pathlib import Path
Steg = str | int | tuple[str, Any]
"""One step of a path into a result file: a key, a list index, or (field, value) picking the
element of a list whose field has that value, e.g. ("navn", "normalisering") or ("trinn", 1)."""
MINUS = r"\textminus{}"
TUSEN = r"\,"
# Short names used in keys (ASCII, no spaces). The texts shown to the reader are written in the
# chapter, not here.
LOSNING = {"A": "A", "B": "B", "B'": "Bm", "C": "C", "R": "R", "T-F": "TF", "T-K": "TK"}
SCENARIO = {
"knapphet varer": "knapphet",
"normalisering": "normalisering",
"overkapasitet": "overkapasitet",
"kildenes lave forlop": "lavt",
"80 % paa egne maskiner, lav": "egne-lav",
"80 % paa egne maskiner, hoy": "egne-hoy",
}
OMREGNINGER = ("tall", "pst", "mill", "mrd", "tekst", "avledet")
@dataclass(frozen=True)
class Tall:
"""One number as chapter 6 shows it, with where it comes from.
``omregning`` says how ``raa`` became ``vist``: "tall" (as it stands), "pst" (times 100),
"mill" (divided by 1e6), "mrd" (divided by 1e9), "tekst" (a word from the file, ``vist``
written by the module), or
"avledet" (computed from several values: ``sti`` is then empty, ``raa`` the computed value
and ``forklaring`` says exactly from what and how).
"""
vist: str
fil: str
sti: tuple[Steg, ...]
raa: float | int | str | bool | None
omregning: str
desimaler: int
forklaring: str = ""
def les(mappe: Path, fil: str) -> Any: # noqa: ANN401
"""Read one result file."""
return json.loads((mappe / fil).read_text(encoding="utf-8"))
def hent(data: Any, sti: tuple[Steg, ...]) -> Any: # noqa: ANN401
"""Follow a path from the root of a result file. Stops with an error when it does not exist."""
her = data
for steg in sti:
if isinstance(steg, tuple):
felt, verdi = steg
treff = [x for x in her if x[felt] == verdi]
if len(treff) != 1:
melding = f"{sti}: {len(treff)} elementer med {felt} = {verdi!r}"
raise KeyError(melding)
her = treff[0]
else:
her = her[steg]
return her
def norsk(x: float, desimaler: int, faktor: str = "1") -> str:
"""Write a number the Norwegian way for LaTeX text: decimal comma, thin space, real minus.
The number is rounded in decimal, from the shortest decimal that gives back the same float
(``repr``), times ``faktor`` (a decimal written as a string, "100" or "1e-9"), and a tie goes
away from zero. A share of 0.2515 is then 25,2 per cent, never 25,1 because 25.15 has no
exact binary form.
"""
verdi = Decimal(repr(float(x))) * Decimal(faktor)
avrundet = verdi.quantize(Decimal(1).scaleb(-desimaler), rounding=ROUND_HALF_UP)
tekst = f"{abs(avrundet):,f}".replace(",", " ").replace(".", ",").replace(" ", TUSEN)
return MINUS + tekst if avrundet < 0 else tekst
def fra_fil(
data: Any, # noqa: ANN401
fil: str,
sti: tuple[Steg, ...],
omregning: str = "tall",
desimaler: int = 1,
) -> Tall:
"""Make the ``Tall`` for the value at a path.
A value that is ``null`` in the file is shown as an en dash; a "tekst" is shown as it stands
(the module may replace ``vist`` afterwards).
"""
raa = hent(data, sti)
if omregning not in ("tall", "pst", "mill", "mrd", "tekst"):
melding = f"ukjent omregning {omregning!r}"
raise ValueError(melding)
if raa is None:
vist = "--"
elif omregning == "tekst":
vist = str(raa)
else:
faktor = {"tall": "1", "pst": "100", "mill": "1e-6", "mrd": "1e-9"}[omregning]
vist = norsk(float(raa), desimaler, faktor)
return Tall(vist, fil, sti, raa, omregning, desimaler)
def avledet(verdi: float, desimaler: int, fil: str, forklaring: str) -> Tall:
"""Make the ``Tall`` for a value computed from several values of one file."""
if not forklaring:
melding = "et avledet tall må ha en forklaring"
raise ValueError(melding)
return Tall(norsk(verdi, desimaler), fil, (), verdi, "avledet", desimaler, forklaring)

View file

@ -0,0 +1,993 @@
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

402
rapport/resultater/miljo.py Normal file
View file

@ -0,0 +1,402 @@
r"""Emissions over the life cycle, «med fradrag», and cooling water (chapter 6, section «Utslipp»).
Reads ``miljo.json`` (clarifications 141 and 142: S32, S53 per estimate of u_alt, and S54, per
scenario, step and solution; median, p10 and p90 over the draws where the path can be built, per
year and of the sum over the years), ``dommer.json`` (the step the verdicts are read on, the share
of paths that cannot be built, and the verdict in M5) and ``modell/parametere.json`` (the four
estimates of u_alt and the fixed fresh-water consumption of nuclear power with sea-water cooling,
read as data).
Before anything is written it checks the file against itself and against ``dommer.json``, and
stops when a check fails: ``antall`` against the share «ikke byggbar»; that U_liv and the water do
not differ between the scenarios, and that the deduction does not differ between the three price
scenarios; that a solution without nuclear power withdraws only the data centres' water; that in
A all nuclear power is the data centres' own use; that the withdrawal for own use is never above
the withdrawal; that the nuclear plants' fresh-water consumption is zero when the parameter file
fixes it at zero; and that p10 <= median <= p90 for every series.
Writes the tables ``miljo-*.tex`` and the figure data ``miljo-vann.dat``, and returns every number
``kap6-miljo.tex`` shows, under keys that start with ``miljo.``.
Standard library only.
"""
from __future__ import annotations
import json
import math
from typing import TYPE_CHECKING, Any
from resultater.felles import LOSNING, SCENARIO, Tall, fra_fil, hent, les, norsk
if TYPE_CHECKING:
from pathlib import Path
from resultater.felles import Steg
MILJO = "miljo.json"
DOM = "dommer.json"
PARAM = "modell/parametere.json"
LOSNINGER = ("A", "B", "B'", "C", "R", "T-F", "T-K")
UTEN_KJERNEKRAFT = ("C", "R", "T-F")
TELLER = "normalisering"
PRIS = ("knapphet varer", "normalisering", "overkapasitet")
BORTFALL = ("kildenes lave forlop", "80 % paa egne maskiner, lav", "80 % paa egne maskiner, hoy")
ANSLAG = ("hoved", "lav", "hoy_nedre", "hoy_ovre")
VANN = ("uttak", "uttak_egen_bruk", "forbruk_kjernekraft", "forbruk_hoyst")
LOSNING_TEX = {"A": "A", "B": "B", "B'": "$B'$", "C": "C", "R": "R", "T-F": "T-F", "T-K": "T-K"}
ANSLAG_KEY = {"hoved": "hoved", "lav": "lav", "hoy_nedre": "hoy410", "hoy_ovre": "hoy626"}
VANN_KEY = {
"uttak": "uttak",
"uttak_egen_bruk": "egen",
"forbruk_kjernekraft": "forbruk-kjerne",
"forbruk_hoyst": "forbruk-hoyst",
}
PERT_FORM = 4
# Relative tolerance when two medians that should be equal are compared after the file's rounding.
TOLERANSE = 1e-9
# The body of a table ends with its bottom rule: \bottomrule cannot follow \input in a tabular.
BUNN = "\\bottomrule\n"
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 _sti(scenario: str, trinn: int, *rest: Steg) -> tuple[Steg, ...]:
return ("per_scenario", ("navn", scenario), "trinn", ("trinn", trinn), *rest)
def _mill(data: Any, fil: str, sti: tuple[Steg, ...], desimaler: int = 1) -> Tall: # noqa: ANN401
"""A value in millions (tonnes or cubic metres)."""
return fra_fil(data, fil, sti, "mill", desimaler)
def _aar(aar: int, fil: str, sti: tuple[Steg, ...]) -> Tall:
return Tall(str(aar), fil, sti, aar, "tekst", 0)
# ------------------------------------------------------------------ the checks
def _feil(melding: str) -> None:
raise ValueError(melding)
def _sjekk_rekkefolge(serie: Any, hvor: str) -> None: # noqa: ANN401
"""p10 <= median <= p90 for the sum and for every year of one series."""
s = serie["sum"]
if not s["p10"] <= s["median"] <= s["p90"]:
_feil(f"{hvor}: sum har p10 > median eller median > p90")
for j, (a, b, c) in enumerate(zip(serie["p10"], serie["median"], serie["p90"], strict=True)):
if not a <= b <= c:
_feil(f"{hvor}: år nr. {j} har p10 > median eller median > p90")
def _sjekk_vann(k: Any, los: str, hvor: str, w_N_forbruk: float) -> None: # noqa: ANN401
"""The water of one path.
Zero fresh water from nuclear power when the parameter file fixes it at zero; only the data
centres' water without nuclear power; all nuclear power own use in A; and the withdrawal for
own use never above the withdrawal (it is so per draw, so also per percentile).
"""
if w_N_forbruk == 0.0 and any(
x != 0.0 for f in ("median", "p10", "p90") for x in k["forbruk_kjernekraft"][f]
):
_feil(f"{hvor}: forbruk_kjernekraft er ikke null")
if los in UTEN_KJERNEKRAFT and not (k["uttak"] == k["forbruk_hoyst"] == k["uttak_egen_bruk"]):
_feil(f"{hvor}: en løsning uten kjernekraft tar ut mer enn datasentrenes vann")
if los == "A" and k["uttak"] != k["uttak_egen_bruk"]:
_feil(f"{hvor}: i A er ikke all kjernekraft egen bruk")
for f in ("median", "p10", "p90"):
par = zip(k["uttak_egen_bruk"][f], k["uttak"][f], strict=True)
if any(e > u * (1 + TOLERANSE) for e, u in par):
_feil(f"{hvor}: uttak for egen bruk over uttaket ({f})")
def _sjekk_bane(v: Any, *, ib: float, n: int, los: str, hvor: str, w_N_forbruk: float) -> None: # noqa: ANN401
"""One scenario, step and solution: the count against «ikke byggbar», and its series."""
if v["antall"] != round(n * (1.0 - ib)):
_feil(f"{hvor}: antall {v['antall']} mot ikke byggbar {ib}")
if v["antall"] == 0:
if v["U_liv"] is not None or v["med_fradrag"] is not None:
_feil(f"{hvor}: antall null men verdier")
return
_sjekk_rekkefolge(v["U_liv"], hvor + ", U_liv")
for a in ANSLAG:
for felt in ("U_unngaatt", "U_med"):
_sjekk_rekkefolge(v["med_fradrag"][a][felt], f"{hvor}, {a}, {felt}")
for felt in VANN:
_sjekk_rekkefolge(v["kjolevann"][felt], f"{hvor}, {felt}")
_sjekk_vann(v["kjolevann"], los, hvor, w_N_forbruk)
def _sjekk(m: Any, d: Any, p: Any) -> None: # noqa: ANN401
"""The internal checks; stops at the first that fails."""
n = m["antall_trekninger"]
for felt in ("antall_trekninger", "stige", "scenarioer"):
if m[felt] != d[felt]:
_feil(f"miljo.json og dommer.json hører ikke til samme kjøring ({felt})")
w_N_forbruk = hent(p, ("parametere", ("id", "w_N_forbruk"), "fordeling", "verdi"))
for sc in m["scenarioer"]:
for trinn in m["stige"]:
for los in LOSNINGER:
hvor = f"{sc}, trinn {trinn}, {los}"
v = hent(m, _sti(sc, trinn, "losninger", los))
ib = hent(d, _sti(sc, trinn, "losninger", los, "M1", "ikke_byggbar"))
_sjekk_bane(v, ib=ib, n=n, los=los, hvor=hvor, w_N_forbruk=w_N_forbruk)
# Not the price: U_liv and the water are the same in every scenario, and the
# deduction in the three price scenarios (clarifications 95 and 99, S51).
base = hent(m, _sti(TELLER, trinn, "losninger", los))
if v["U_liv"] != base["U_liv"] or v["kjolevann"] != base["kjolevann"]:
_feil(f"{hvor}: U_liv eller vannet er ulikt «normalisering»")
if sc in PRIS and v["med_fradrag"] != base["med_fradrag"]:
_feil(f"{hvor}: fradraget er ulikt «normalisering»")
# ------------------------------------------------------------------ the numbers and tables
def _celle(t: Tall, lav: Tall, hoy: Tall) -> str:
return (
r"\begin{tabular}[c]{@{}r@{}}"
rf"{t.vist}\\{{\footnotesize ({lav.vist} til {hoy.vist})}}"
r"\end{tabular}"
)
def _serie_tall(
m: Any, # noqa: ANN401
s: Samler,
nokkel: str,
sti: tuple[Steg, ...],
desimaler: int = 1,
) -> tuple[Tall, Tall, Tall]:
"""The median, p10 and p90 of the sum over the years of one series, in millions."""
return (
s(f"{nokkel}.median", _mill(m, MILJO, (*sti, "sum", "median"), desimaler)),
s(f"{nokkel}.p10", _mill(m, MILJO, (*sti, "sum", "p10"), desimaler)),
s(f"{nokkel}.p90", _mill(m, MILJO, (*sti, "sum", "p90"), desimaler)),
)
def _tabell_liv(m: Any, d: Any, s: Samler, trinn: int, neste: int) -> str: # noqa: ANN401
"""S32 summed over the years, the number of draws, and the verdict in M5 (rule-based)."""
linjer = []
for los in LOSNINGER:
k = f"miljo.t{trinn}.{LOSNING[los]}"
ant = s(
f"{k}.antall",
fra_fil(m, MILJO, _sti(TELLER, trinn, "losninger", los, "antall"), "tall", 0),
)
ant5 = s(
f"miljo.t{neste}.{LOSNING[los]}.antall",
fra_fil(m, MILJO, _sti(TELLER, neste, "losninger", los, "antall"), "tall", 0),
)
med, lav, hoy = _serie_tall(
m, s, f"{k}.liv", _sti(TELLER, trinn, "losninger", los, "U_liv")
)
m5 = s(f"{k}.m5", fra_fil(d, DOM, _sti(TELLER, trinn, "losninger", los, "M5"), "tekst"))
linjer.append(
f"{LOSNING_TEX[los]} & {ant.vist} & {med.vist} & {lav.vist} & {hoy.vist} & "
f"{m5.vist} & {ant5.vist} \\\\"
)
return "\n".join(linjer) + "\n" + BUNN
def _tabell_fradrag(m: Any, s: Samler, trinn: int, felt: str) -> str: # noqa: ANN401
"""S53 per estimate of u_alt, over the years: U_unngaatt (medians) or U_med (with range)."""
linjer = []
navn = "unngaatt" if felt == "U_unngaatt" else "med"
for los in LOSNINGER:
celler = []
for a in ANSLAG:
k = f"miljo.t{trinn}.{LOSNING[los]}.{navn}.{ANSLAG_KEY[a]}"
med, lav, hoy = _serie_tall(
m, s, k, _sti(TELLER, trinn, "losninger", los, "med_fradrag", a, felt)
)
celler.append(med.vist if felt == "U_unngaatt" else _celle(med, lav, hoy))
linjer.append(LOSNING_TEX[los] + " & " + " & ".join(celler) + r" \\")
return "\n".join(linjer) + "\n" + BUNN
def _tabell_bortfall(m: Any, s: Samler, trinn: int) -> str: # noqa: ANN401
"""U_unngaatt in the main estimate in «normalisering» and the three scenarios of lost demand."""
linjer = []
for los in LOSNINGER:
celler = []
for sc in (TELLER, *BORTFALL):
k = f"miljo.{SCENARIO[sc]}.t{trinn}.{LOSNING[los]}.unngaatt.hoved.median"
sti = _sti(sc, trinn, "losninger", los, "med_fradrag", "hoved", "U_unngaatt")
t = s(k, _mill(m, MILJO, (*sti, "sum", "median")))
celler.append(t.vist)
linjer.append(LOSNING_TEX[los] + " & " + " & ".join(celler) + r" \\")
return "\n".join(linjer) + "\n" + BUNN
def _tabell_vann(m: Any, s: Samler, trinn: int) -> str: # noqa: ANN401
"""S54 summed over the years, millions of cubic metres."""
linjer = []
for los in LOSNINGER:
celler = []
for felt in VANN:
k = f"miljo.t{trinn}.{LOSNING[los]}.vann.{VANN_KEY[felt]}"
med, lav, hoy = _serie_tall(
m, s, k, _sti(TELLER, trinn, "losninger", los, "kjolevann", felt)
)
celler.append(med.vist if felt == "forbruk_kjernekraft" else _celle(med, lav, hoy))
linjer.append(LOSNING_TEX[los] + " & " + " & ".join(celler) + r" \\")
return "\n".join(linjer) + "\n" + BUNN
def _dat_vann(m: Any, trinn: int) -> str: # noqa: ANN401
"""The water per year for the figure, every second year from the first.
Withdrawal (median, p10, p90) for the nuclear solutions, and the data centres' own water
(median) for all solutions.
"""
kjerne = ("A", "B", "B'")
alle = ("A", "C", "R", "T-F", "T-K")
hode = f"# kilde: {MILJO}, per_scenario[navn={TELLER}].trinn[trinn={trinn}].losninger.<L>"
linjer = [
f"{hode}.kjolevann.uttak.median, .p10, .p90 [year] for L in {', '.join(kjerne)}; m3/year",
(
f"{hode}.kjolevann.forbruk_hoyst.median [year] for L in {', '.join(alle)}; m3/year "
"(the data centres' own withdrawal, since the nuclear plants' fresh-water use is zero)"
),
"# every second year from the first; aar from miljo.json, aar",
]
navn = [f"{LOSNING[x]}{f}" for x in kjerne for f in ("med", "p10", "p90")]
navn += [f"{LOSNING[x]}dc" for x in alle]
linjer.append("aar " + " ".join(navn))
aar = m["aar"]
serier = {los: hent(m, _sti(TELLER, trinn, "losninger", los, "kjolevann")) for los in LOSNINGER}
# The figure draws A's own water for A, B and B'; stop if they are not the same series.
for los in ("B", "B'"):
if serier[los]["forbruk_hoyst"] != serier["A"]["forbruk_hoyst"]:
_feil(f"datasentrenes vann i {los} er ikke likt A på trinn {trinn}")
for j in range(0, len(aar), 2):
verdier = [
repr(float(serier[los]["uttak"][f][j]))
for los in kjerne
for f in ("median", "p10", "p90")
]
verdier += [repr(float(serier[los]["forbruk_hoyst"]["median"][j])) for los in alle]
linjer.append(f"{aar[j]} " + " ".join(verdier))
return "\n".join(linjer) + "\n"
def _anslag(p: Any, s: Samler) -> None: # noqa: ANN401
"""The four estimates of u_alt as the parameter file states them, g CO2 per kWh."""
base = ("parametere", ("id", "u_alt"), "fordeling", "verdi")
for aar in ("2024", "2030", "2035", "2040", "2050"):
s(
f"miljo.ualt.hoved.{aar}",
fra_fil(p, PARAM, (*base, "hoved", aar), "tall", 1 if aar in ("2040", "2050") else 0),
)
for aar in ("2025", "2030"):
s(f"miljo.ualt.lav.{aar}", fra_fil(p, PARAM, (*base, "lav", aar), "tall", 0))
s("miljo.ualt.hoy.lav", fra_fil(p, PARAM, (*base, "hoy", "lav"), "tall", 0))
s("miljo.ualt.hoy.hoy", fra_fil(p, PARAM, (*base, "hoy", "hoy"), "tall", 0))
s("miljo.ualt.null", fra_fil(p, PARAM, (*base, "null"), "tall", 0))
s(
"miljo.wN-forbruk",
fra_fil(p, PARAM, ("parametere", ("id", "w_N_forbruk"), "fordeling", "verdi"), "tall", 0),
)
def _tekst(m: Any, s: Samler, trinn: int) -> None: # noqa: ANN401
"""Single figures the prose reads: the years, the yearly medians against the sum, and step 5."""
s("miljo.forste-aar", _aar(m["aar"][0], MILJO, ("aar", 0)))
s("miljo.siste-aar", _aar(m["aar"][-1], MILJO, ("aar", len(m["aar"]) - 1)))
s("miljo.antall", fra_fil(m, MILJO, ("antall_trekninger",), "tall", 0))
s("miljo.enhet.utslipp", fra_fil(m, MILJO, ("enheter", "utslipp"), "tekst"))
s("miljo.enhet.vann", fra_fil(m, MILJO, ("enheter", "kjolevann"), "tekst"))
# The sum of the yearly medians, next to the median of the sums, for A: why the two differ.
sti = _sti(TELLER, trinn, "losninger", "A", "U_liv", "median")
verdi = math.fsum(hent(m, sti))
s(
f"miljo.t{trinn}.A.liv.sum-av-medianer",
Tall(
norsk(verdi, 1, "1e-6"),
MILJO,
(),
verdi,
"avledet",
1,
f"the sum (math.fsum) over the years of per_scenario[navn={TELLER}]"
f".trinn[trinn={trinn}].losninger.A.U_liv.median, in tonnes; shown in millions",
),
)
def _kraftutslipp(p: Any, s: Samler) -> None: # noqa: ANN401
"""The drawn distributions of life-cycle emissions per kWh (S32), and their means.
A PERT distribution with form 4 has the mean (low + 4 mode + high) / 6.
"""
for pid, navn in (("u_kjerne", "kjerne"), ("u_vind", "vind"), ("u_vann", "vann")):
sti = ("parametere", ("id", pid), "fordeling")
fordeling = hent(p, sti)
if fordeling["type"] != "pert" or fordeling["form"] != PERT_FORM:
_feil(f"{pid} er ikke en PERT-fordeling med form 4")
for felt in ("lav", "modus", "hoy"):
desimaler = 0 if float(fordeling[felt]).is_integer() else 2 if pid == "u_vann" else 1
s(f"miljo.u.{navn}.{felt}", fra_fil(p, PARAM, (*sti, felt), "tall", desimaler))
snitt = (fordeling["lav"] + PERT_FORM * fordeling["modus"] + fordeling["hoy"]) / (
PERT_FORM + 2
)
s(
f"miljo.u.{navn}.snitt",
Tall(
norsk(snitt, 1),
PARAM,
(),
snitt,
"avledet",
1,
f"the mean of the PERT distribution of {pid} in the parameter file: "
"(lav + 4 modus + hoy) / 6, g CO2e per kWh",
),
)
def lag(data: Path, ut: Path) -> dict[str, Tall]:
"""Check ``miljo.json``, write the tables and figure data, and return the numbers."""
m = les(data, MILJO)
d = les(data, DOM)
p = json.loads((data.parent.parent / PARAM).read_text(encoding="utf-8"))
_sjekk(m, d, p)
s = Samler()
trinn = hent(d, ("trinn",))
stige = list(m["stige"])
neste = stige[stige.index(trinn) + 1]
s("miljo.domstrinn", fra_fil(d, DOM, ("trinn",), "tall", 0))
s("miljo.nestetrinn", fra_fil(m, MILJO, ("stige", stige.index(neste)), "tall", 0))
_anslag(p, s)
_kraftutslipp(p, s)
_tekst(m, s, trinn)
(ut / "miljo-liv.tex").write_text(_tabell_liv(m, d, s, trinn, neste), encoding="utf-8")
(ut / "miljo-unngaatt.tex").write_text(
_tabell_fradrag(m, s, trinn, "U_unngaatt"), encoding="utf-8"
)
(ut / "miljo-med.tex").write_text(_tabell_fradrag(m, s, trinn, "U_med"), encoding="utf-8")
(ut / "miljo-bortfall.tex").write_text(_tabell_bortfall(m, s, trinn), encoding="utf-8")
(ut / "miljo-vann.tex").write_text(_tabell_vann(m, s, trinn), encoding="utf-8")
(ut / "miljo-vann.dat").write_text(_dat_vann(m, trinn), encoding="utf-8")
return s.tall

View file

@ -0,0 +1,694 @@
"""Chapter 6, «Tersklene og betingelsene»: the price threshold, the thresholds and the indices.
Reads ``terskler.json`` (clarifications 105 to 111, 128 d and 134 of the specification), the
block ``per_scenario[...].betingelser`` of ``dommer.json`` (clarifications 108, 109 and 115) and,
for the names, symbols, units and status of the drawn quantities, the frozen parameter file
``modell/parametere.json`` (read as data; no figure is taken from it). Writes to
``rapport/generert/``:
- ``terskler-pris.tex`` and ``terskler-pris.dat``: the price threshold per solution and scenario;
- ``terskler-bortfall.tex``: S52 from the price threshold, for the three values of eps_d;
- ``terskler-normalisering.tex``: every threshold in a drawn quantity in «normalisering»;
- ``terskler-betingelser.tex``: the conditions per solution in all six scenarios, compactly;
- ``terskler-samtidig.tex``: one sentence on ``bare_skalaen_mangler`` and ``samtidig``;
- ``terskler-sobol.tex`` and ``terskler-sobol-uten.tex``: the largest first-order indices, and
the outcomes without an index;
- ``terskler-flater.tex`` and ``terskler-prisflate.dat``: the threshold surfaces;
- ``terskler-storrelser.tex``: the drawn quantities named in these tables.
Every number shown is returned as a ``Tall`` under a key that starts with ``terskler.``.
Standard library only.
"""
from __future__ import annotations
import dataclasses
import json
from typing import TYPE_CHECKING, Any
from resultater.felles import LOSNING, SCENARIO, Tall, avledet, fra_fil, hent, les
if TYPE_CHECKING:
from pathlib import Path
FIL = "terskler.json"
DOMMER = "dommer.json"
HOVED = "normalisering"
PRISSCENARIOER = ("knapphet varer", "normalisering", "overkapasitet")
SCENARIONAVN = {
"knapphet varer": "«knapphet varer»",
"normalisering": "«normalisering»",
"overkapasitet": "«overkapasitet»",
"kildenes lave forlop": "«kildenes lave forløp»",
"80 % paa egne maskiner, lav": "«80~\\% på egne maskiner», lav",
"80 % paa egne maskiner, hoy": "«80~\\% på egne maskiner», høy",
}
# The outcomes the indices are given for (clarification 110), with key and label.
UTFALL = (
("NNV", "nnv", "Netto nåverdi"),
("byggbar", "byggbar", "Lar seg bygge"),
("M1 holder", "m1-holder", "M1 «holder»"),
("M2 holder", "m2-holder", "M2 «holder»"),
("M3 holder", "m3-holder", "M3 «holder»"),
("M4 holder", "m4-holder", "M4 «holder»"),
("M6 holder", "m6-holder", "M6 «holder»"),
("M3 holder ikke", "m3-holder-ikke", "M3 «holder ikke»"),
("M4 holder ikke", "m4-holder-ikke", "M4 «holder ikke»"),
("M6 holder ikke", "m6-holder-ikke", "M6 «holder ikke»"),
("M7", "m7", "Best i M7"),
)
UTFALLSNAVN = {navn: etikett for navn, _, etikett in UTFALL}
UTFALLSNOKKEL = {navn: nokkel for navn, nokkel, _ in UTFALL}
STORSTE = 4
"""How many of the largest indices each row of the index table shows."""
# Status marks after a symbol in the tables: «kilde» has none.
STATUSMERKE = {
"kilde": "",
"avledet": "",
"åpen forutsetning": "$^{\\ast}$",
"modellvalg": "$^{\\dagger}$",
}
STATUSNAVN = {
"kilde": "kilde",
"avledet": "regnet ut fra kilder",
"åpen forutsetning": "åpen forutsetning",
"modellvalg": "valg av oppsett",
}
RETNING = {"høyst": ("\\le", "hoyst"), "minst": ("\\ge", "minst")}
def _losning_tekst(losning: str) -> str:
"""The code of a solution as the tables print it."""
return "$B'$" if losning == "B'" else losning
def _nokkel(navn: str) -> str:
"""A drawn quantity's id as a key segment: underscores become hyphens."""
return navn.replace("_", "-")
def _desimaler(x: float) -> int:
"""Decimals for a threshold in the parameter file's unit: enough to tell it apart."""
if float(x).is_integer():
return 0
if abs(x) < 0.1: # noqa: PLR2004
return 4
if abs(x) < 1:
return 3
if abs(x) < 100: # noqa: PLR2004
return 2
return 1
def _escape(tekst: str) -> str:
"""Escape the characters LaTeX treats specially in a name from the parameter file."""
for tegn, erstatning in (("\\", "\\textbackslash{}"), ("&", "\\&"), ("%", "\\%"), ("#", "\\#")):
tekst = tekst.replace(tegn, erstatning)
return tekst.replace("_", "\\_")
def _ord(t: Tall, sann: str = "ja", usann: str = "nei") -> Tall:
"""A boolean from a file shown as a word; None as an en dash."""
vist = "--" if t.raa is None else (sann if t.raa else usann)
return dataclasses.replace(t, vist=vist)
def _skriv(
ut: Path,
navn: str,
spec: str,
hode: str,
rader: list[str],
*,
miljo: tuple[str, str] | None = None,
) -> None:
r"""Write a whole table environment: the head, the rows and the rules.
The rules after the rows must be in the same file: after ``\input`` in a tabular,
``\bottomrule`` is a misplaced ``\noalign``.
"""
navn_miljo, bredde = miljo or ("tabular", "")
start = f"\\begin{{{navn_miljo}}}" + (f"{{{bredde}}}" if bredde else "") + f"{{{spec}}}"
tekst = [
start,
"\\toprule",
hode,
"\\midrule",
*rader,
"\\bottomrule",
f"\\end{{{navn_miljo}}}",
]
(ut / f"{navn}.tex").write_text("\n".join(tekst) + "\n", encoding="utf-8")
# ------------------------------------------------------------------ the parameter file
@dataclasses.dataclass(frozen=True)
class Storrelse:
"""What the tables say about one drawn quantity, from the parameter file."""
symbol: str
navn: str
enhet: str
status: str
def _storrelser(data: Path) -> dict[str, Storrelse]:
"""The drawn quantities by id, with the components of a composite as «parent.component»."""
fil = json.loads((data.parent.parent / "modell" / "parametere.json").read_text("utf-8"))
ut: dict[str, Storrelse] = {}
for p in fil["parametere"]:
fordeling = p["fordeling"]
if fordeling.get("type") == "sammensatt":
hode, _, deler = p["navn"].partition(":")
delnavn = [d.strip() for d in deler.split("/")]
enheter = [e.strip() for e in p["enhet"].split(";")]
komponenter = [k for k in fordeling if k != "type"]
for nr, komponent in enumerate(komponenter):
ut[f"{p['id']}.{komponent}"] = Storrelse(
symbol="",
navn=f"{hode.strip()}: {delnavn[nr] if nr < len(delnavn) else komponent}",
enhet=enheter[nr] if nr < len(enheter) else "",
status=p["status"],
)
else:
ut[p["id"]] = Storrelse(p["symbol"], p["navn"], p["enhet"], p["status"])
return ut
def _symbol(navn: str, s: Storrelse, *, merke: bool = True) -> str:
"""The symbol of a quantity in math mode, or its name in text when it has none."""
if s.symbol and s.symbol != "–":
tekst = f"${s.symbol}$"
else:
# a component of a composite quantity has no symbol: its id, as «vind (investering)»
hode, _, komponent = navn.partition(".")
tekst = f"{_escape(hode)} ({_escape(komponent)})"
return tekst + (STATUSMERKE.get(s.status, "") if merke else "")
# ------------------------------------------------------------------ the module
def lag(data: Path, ut: Path) -> dict[str, Tall]:
"""Write the tables and figure data and return every number they and the prose show."""
fil = les(data, FIL)
dommer = les(data, DOMMER)
storrelser = _storrelser(data)
tall: dict[str, Tall] = {
"terskler.trinn": fra_fil(fil, FIL, ("trinn",), "tall", 0),
"terskler.grunnlag-for-trinnet": fra_fil(fil, FIL, ("grunnlag_for_trinnet",), "tekst"),
"terskler.antall-trekninger": fra_fil(fil, FIL, ("antall_trekninger",), "tall", 0),
"terskler.y-obs-maks": fra_fil(fil, FIL, ("y_obs_maks",), "mill", 0),
"terskler.median-lcoc-v-2025": fra_fil(fil, FIL, ("median_lcoc_v_2025",), "mill", 1),
"terskler.eps-d": fra_fil(fil, FIL, ("eps_d",), "tall", 1),
}
tall["terskler.k-grense"] = avledet(
fil["y_obs_maks"] / fil["median_lcoc_v_2025"],
3,
FIL,
"y_obs_maks / median_lcoc_v_2025: the largest k that is «innenfor kontraktsprisene» "
"(clarification 106)",
)
for blokk in dommer["per_scenario"]:
sti = ("per_scenario", ("navn", blokk["navn"]), "del_I")
tall[f"terskler.del-i.{SCENARIO[blokk['navn']]}"] = fra_fil(dommer, DOMMER, sti, "tekst")
brukt: set[str] = set()
_pris(fil, tall, ut)
_bortfall(fil, tall, ut)
_normalisering(dommer, tall, storrelser, brukt, ut)
_betingelser(dommer, tall, storrelser, brukt, ut)
_sobol(fil, tall, storrelser, brukt, ut)
_flater(fil, tall, ut)
_storrelsestabell(storrelser, brukt, ut)
return tall
# ------------------------------------------------------------------ price threshold and d*
def _pris(fil: Any, tall: dict[str, Tall], ut: Path) -> None: # noqa: ANN401
"""The table and the figure data of the price threshold (clarifications 105 and 106)."""
rader: list[str] = []
dat = [
(
f"# kilde: {FIL}, pristerskler.<losning>.<scenario>.k "
"(nr: the solution's place in the file; nan: no value)"
),
"nr losning " + " ".join(SCENARIO[s] for s in PRISSCENARIOER),
]
for nr, (losning, per_scenario) in enumerate(fil["pristerskler"].items()):
lk = LOSNING[losning]
celler: list[str] = []
punkter: list[str] = []
for scenario in PRISSCENARIOER:
sk = SCENARIO[scenario]
p = per_scenario[scenario]
sti = ("pristerskler", losning, scenario)
nokkel = f"terskler.pris.{lk}.{sk}"
k = fra_fil(fil, FIL, (*sti, "k"), "tall", 3)
if p["k"] is None:
grunn = "over_maks" if p["over_maks"] else "uten_median"
k = dataclasses.replace(
fra_fil(fil, FIL, (*sti, grunn), "tekst"),
vist="over søkegrensen" if p["over_maks"] else "finnes ikke",
)
tall[f"{nokkel}.k"] = k
innenfor = _ord(fra_fil(fil, FIL, (*sti, "innenfor_kontraktsprisene"), "tekst"))
tall[f"{nokkel}.innenfor"] = innenfor
andel = fra_fil(fil, FIL, (*sti, "andel_innenfor"), "pst", 1)
tall[f"{nokkel}.andel-innenfor"] = andel
merke = "\\rlap{$^{\\ast}$}" if p["innenfor_kontraktsprisene"] is False else ""
celler += [k.vist + merke, andel.vist]
punkter.append("nan" if p["k"] is None else repr(p["k"]))
rader.append(f"{_losning_tekst(losning)} & {' & '.join(celler)} \\\\")
dat.append(f"{nr} {lk} {' '.join(punkter)}")
hode = (
"& \\multicolumn{2}{c}{«knapphet varer»} & \\multicolumn{2}{c}{«normalisering»} & "
"\\multicolumn{2}{c}{«overkapasitet»} \\\\\n"
"\\cmidrule(lr){2-3}\\cmidrule(lr){4-5}\\cmidrule(l){6-7}\n"
"Løsning & $k$ & Innenfor & $k$ & Innenfor & $k$ & Innenfor \\\\"
)
_skriv(ut, "terskler-pris", "@{}lrrrrrr@{}", hode, rader)
(ut / "terskler-pris.dat").write_text("\n".join(dat) + "\n", encoding="utf-8")
def _bortfall(fil: Any, tall: dict[str, Tall], ut: Path) -> None: # noqa: ANN401
"""The table of S52: d* per solution for the fixed eps_d and for 0.5 and 2 (107)."""
forste = next(iter(fil["d_stjerne"]))
hode = ["Løsning", "$k$ i «normalisering»"]
for nr in range(len(fil["d_stjerne"][forste]["verdier"])):
eps = fra_fil(fil, FIL, ("d_stjerne", forste, "verdier", nr, "eps_d"), "tall", 1)
tall[f"terskler.bortfall.eps.{nr}"] = eps
hode.append(f"$d^{{*}}$, $\\varepsilon_d$~=~{eps.vist}")
rader: list[str] = []
for losning in fil["d_stjerne"]:
lk = LOSNING[losning]
k = fra_fil(fil, FIL, ("d_stjerne", losning, "k_a"), "tall", 3)
tall[f"terskler.bortfall.{lk}.k"] = k
celler = [k.vist]
for nr in range(len(fil["d_stjerne"][losning]["verdier"])):
sti = ("d_stjerne", losning, "verdier", nr, "d_stjerne")
d = fra_fil(fil, FIL, sti, "pst", 1)
tall[f"terskler.bortfall.{lk}.{nr}"] = d
celler.append(d.vist + "~\\%" if d.raa is not None else d.vist)
rader.append(f"{_losning_tekst(losning)} & {' & '.join(celler)} \\\\")
_skriv(ut, "terskler-bortfall", "@{}lrrrr@{}", " & ".join(hode) + " \\\\", rader)
# ------------------------------------------------------------------ thresholds in quantities
Hvor = tuple[str, str, str, int]
"""Where a threshold stands in ``dommer.json``: scenario, solution, target, place in the list."""
def _terskel(dommer: Any, tall: dict[str, Tall], hvor: Hvor) -> dict[str, Tall]: # noqa: ANN401
"""Register every field of one threshold and return them by field name."""
scenario, losning, maal, nr = hvor
t = _scenarioblokk(dommer, scenario)["betingelser"][losning]["terskler"][maal][nr]
sti = ("per_scenario", ("navn", scenario), "betingelser", losning, "terskler", maal, nr)
retning = RETNING[t["retning"]][1]
nokkel = (
f"terskler.betingelse.{SCENARIO[scenario]}.{LOSNING[losning]}.{maal.lower()}"
f".{_nokkel(t['storrelse'])}.{retning}"
)
felter = {
"verdi": fra_fil(dommer, DOMMER, (*sti, "verdi"), "tall", _desimaler(t["verdi"])),
"sannsynlighet": fra_fil(dommer, DOMMER, (*sti, "sannsynlighet"), "pst", 1),
"andel_oppfylt": fra_fil(dommer, DOMMER, (*sti, "andel_oppfylt"), "pst", 1),
"indeks": fra_fil(dommer, DOMMER, (*sti, "indeks"), "tall", 4),
"kilde": _ord(fra_fil(dommer, DOMMER, (*sti, "kilde"), "tekst")),
"paavist": _ord(fra_fil(dommer, DOMMER, (*sti, "paavist"), "tekst")),
"begge_halvdeler": _ord(fra_fil(dommer, DOMMER, (*sti, "begge_halvdeler"), "tekst")),
"teller": _ord(fra_fil(dommer, DOMMER, (*sti, "teller"), "tekst")),
}
for felt, verdi in felter.items():
tall[f"{nokkel}.{felt.replace('_', '-')}"] = verdi
return felter
def _betingelse(t: Any, verdi: Tall, storrelser: dict[str, Storrelse]) -> str: # noqa: ANN401
"""«symbol >= value» for one threshold."""
s = storrelser[t["storrelse"]]
return f"{_symbol(t['storrelse'], s)}~${RETNING[t['retning']][0]}$~{verdi.vist}"
def _scenarioblokk(dommer: Any, scenario: str) -> Any: # noqa: ANN401
return next(s for s in dommer["per_scenario"] if s["navn"] == scenario)
def _normalisering(
dommer: Any, # noqa: ANN401
tall: dict[str, Tall],
storrelser: dict[str, Storrelse],
brukt: set[str],
ut: Path,
) -> None:
"""Every threshold in a drawn quantity in «normalisering», one row each."""
rader: list[str] = []
for losning, b in _scenarioblokk(dommer, HOVED)["betingelser"].items():
for maal, rekke in b["terskler"].items():
if not rekke:
rader.append(
f"{_losning_tekst(losning)} & {maal} & \\multicolumn{{8}}{{l}}"
"{ingen terskel mellom 10- og 90-persentilen} \\\\"
)
continue
for nr, t in enumerate(rekke):
f = _terskel(dommer, tall, (HOVED, losning, maal, nr))
brukt.add(t["storrelse"])
celler = [
_betingelse(t, f["verdi"], storrelser),
f["sannsynlighet"].vist,
f["andel_oppfylt"].vist,
f["indeks"].vist,
f["kilde"].vist,
f["paavist"].vist,
f["begge_halvdeler"].vist,
f["teller"].vist,
]
rader.append(f"{_losning_tekst(losning)} & {maal} & {' & '.join(celler)} \\\\")
hode = (
"Løsning & Mål & Betingelse & Sannsynl. & Oppfylt & Indeks & Kilde & Påvist & "
"Halvdeler & Teller \\\\"
)
_skriv(ut, "terskler-normalisering", "@{}lllrrrcccc@{}", hode, rader)
def _betingelser(
dommer: Any, # noqa: ANN401
tall: dict[str, Tall],
storrelser: dict[str, Storrelse],
brukt: set[str],
ut: Path,
) -> None:
"""The conditions per solution in all six scenarios, «normalisering» first."""
rekkefolge = [HOVED, *(s["navn"] for s in dommer["per_scenario"] if s["navn"] != HOVED)]
rader: list[str] = []
skalaen: list[str] = []
samtidig: list[str] = []
for scenario in rekkefolge:
blokk = _scenarioblokk(dommer, scenario)
if rader:
rader.append("\\midrule")
rader.append(f"\\multicolumn{{7}}{{@{{}}l}}{{\\emph{{{SCENARIONAVN[scenario]}}}}} \\\\")
for losning, b in blokk["betingelser"].items():
teller: list[str] = []
ikke: list[str] = []
uten: list[str] = []
for maal, rekke in b["terskler"].items():
if not rekke:
uten.append(maal)
for nr, t in enumerate(rekke):
f = _terskel(dommer, tall, (scenario, losning, maal, nr))
brukt.add(t["storrelse"])
tekst = f"{maal}: {_betingelse(t, f['verdi'], storrelser)}"
(teller if t["teller"] else ikke).append(tekst)
sti = ("per_scenario", ("navn", scenario), "betingelser", losning)
nokkel = f"terskler.betingelse.{SCENARIO[scenario]}.{LOSNING[losning]}"
felt = _ord(fra_fil(dommer, DOMMER, (*sti, "felt"), "tekst"))
navngis = _ord(fra_fil(dommer, DOMMER, (*sti, "kan_navngis"), "tekst"))
tall[f"{nokkel}.felt"] = felt
tall[f"{nokkel}.kan-navngis"] = navngis
maal_ub = ", ".join(b["maal"]) if b["maal"] else "ingen"
celler = [
felt.vist,
maal_ub,
"\\newline ".join(teller) or "--",
"\\newline ".join(ikke) or "--",
", ".join(uten) or "--",
navngis.vist,
]
rader.append(f"{_losning_tekst(losning)} & {' & '.join(celler)} \\\\")
if b["bare_skalaen_mangler"]:
skalaen.append(f"{_losning_tekst(losning)} i {SCENARIONAVN[scenario]}")
if b["samtidig"] is not None:
samtidig.append(f"{_losning_tekst(losning)} i {SCENARIONAVN[scenario]}")
(ut / "terskler-betingelser.tex").write_text("\n".join(rader) + "\n", encoding="utf-8")
setning = (
"Ingen løsning har «bare skalaen mangler» i noe scenario"
if not skalaen
else "«Bare skalaen mangler» gjelder " + ", ".join(skalaen)
)
setning += (
", og betingelsene samlet (avklaring 115~(d)) har ingen verdi for noen løsning i noe "
"scenario, fordi ingen løsning som ikke er felt, har betingelser som kan navngis og ett "
"av M1 til M4 «holder under betingelser»."
if not samtidig
else ". Betingelsene samlet (avklaring 115~(d)) er regnet for " + ", ".join(samtidig) + "."
)
(ut / "terskler-samtidig.tex").write_text(setning + "\n", encoding="utf-8")
# ------------------------------------------------------------------ Sobol indices
def _sobol(
fil: Any, # noqa: ANN401
tall: dict[str, Tall],
storrelser: dict[str, Storrelse],
brukt: set[str],
ut: Path,
) -> None:
"""The largest first-order indices per solution and outcome, and the outcomes with none."""
forste = next(iter(fil["sobol"]))
tall["terskler.sobol.forventning"] = fra_fil(
fil, FIL, ("sobol", forste, "NNV", "forventning_uten_virkning"), "tall", 4
)
tall["terskler.sobol.klasser"] = fra_fil(
fil, FIL, ("sobol", forste, "NNV", "antall_klasser"), "tall", 0
)
rader: list[str] = []
uten_rader: list[str] = []
for losning, per_utfall in fil["sobol"].items():
lk = LOSNING[losning]
uten: list[str] = []
forste_rad = True
for utfall, blokk in per_utfall.items():
med_verdi = [
(navn, x["indeks"])
for navn, x in blokk["storrelser"].items()
if x["indeks"] is not None
]
if not med_verdi:
uten.append(UTFALLSNAVN[utfall])
continue
# the largest first; equal indices keep the order of the parameter file
storst = sorted(med_verdi, key=lambda par: -par[1])[:STORSTE]
nokkel = f"terskler.sobol.{lk}.{UTFALLSNOKKEL[utfall]}"
n = fra_fil(fil, FIL, ("sobol", losning, utfall, "antall_trekninger"), "tall", 0)
tall[f"{nokkel}.antall"] = n
celler = []
for navn, _ in storst:
sti = ("sobol", losning, utfall, "storrelser", navn, "indeks")
t = fra_fil(fil, FIL, sti, "tall", 3)
tall[f"{nokkel}.{_nokkel(navn)}"] = t
brukt.add(navn)
celler.append(f"{_symbol(navn, storrelser[navn])} {t.vist}")
celler += [""] * (STORSTE - len(celler))
if not forste_rad:
rader.append("\\addlinespace[1pt]")
rader.append(
f"{_losning_tekst(losning) if forste_rad else ''} & {UTFALLSNAVN[utfall]} & "
f"{' & '.join(celler)} \\\\"
)
forste_rad = False
rader.append("\\midrule")
uten_rader.append(f"{_losning_tekst(losning)} & {_uten_tekst(uten)} \\\\")
if rader and rader[-1] == "\\midrule":
rader.pop()
(ut / "terskler-sobol.tex").write_text("\n".join(rader) + "\n", encoding="utf-8")
_skriv(
ut,
"terskler-sobol-uten",
"@{}lL@{}",
"Løsning & Utfall uten indeks \\\\",
uten_rader,
miljo=("tabularx", "\\linewidth"),
)
def _uten_tekst(uten: list[str]) -> str:
"""The outcomes without an index, grouped: whether it can be built, «holder», «holder ikke»."""
if not uten:
return "ingen"
deler = []
if UTFALLSNAVN["byggbar"] in uten:
deler.append("om banen lar seg bygge")
for ord_ in ("«holder»", "«holder ikke»"):
maal = [u.split(" ")[0] for u in uten if u.endswith(f" {ord_}")]
if maal:
deler.append(f"vilkåret for {ord_} i {', '.join(maal)}")
andre = [
u
for u in uten
if u != UTFALLSNAVN["byggbar"] and not u.endswith(("«holder»", "«holder ikke»"))
]
deler += andre
return "; ".join(deler)
# ------------------------------------------------------------------ surfaces
def _flater(fil: Any, tall: dict[str, Tall], ut: Path) -> None: # noqa: ANN401
"""The surfaces: figure data for (a), and a summary per solution of (b) and (c)."""
_flate_a(fil, tall, ut)
rader = [*_flate_b(fil, tall), "\\midrule", *_flate_c(fil, tall)]
hode = (
"Flate & Løsning & Trekninger & Norsk kraft & Positiv median & Høyeste andel & "
"Høyeste median \\\\"
)
_skriv(ut, "terskler-flater", "@{}llrrrrr@{}", hode, rader)
def _flate_a(fil: Any, tall: dict[str, Tall], ut: Path) -> None: # noqa: ANN401
"""Surface (a): the figure data, and the classes at the two ends with the range of k."""
pris = fil["flater"]["pris_mot_reaktorkostnad"]
kolonner = [f"cN_{LOSNING[a]} k_{LOSNING[a]}" for a in pris]
dat = [
(
f"# kilde: {FIL}, flater.pris_mot_reaktorkostnad.<losning>[<klasse>].c_N_ref (kr/kW) "
"and .terskel.k (nan: no value)"
),
"klasse " + " ".join(kolonner),
]
for q in range(max(len(v) for v in pris.values())):
verdier: list[str] = []
for punkter in pris.values():
p = punkter[q] if q < len(punkter) else None
k = None if p is None else p["terskel"]["k"]
verdier += [
"nan" if p is None else repr(p["c_N_ref"]),
"nan" if k is None else repr(k),
]
dat.append(f"{q} {' '.join(verdier)}")
(ut / "terskler-prisflate.dat").write_text("\n".join(dat) + "\n", encoding="utf-8")
for losning, punkter in pris.items():
lk = LOSNING[losning]
klasser = [
q for q, p in enumerate(punkter) if p is not None and p["terskel"]["k"] is not None
]
if klasser:
# the smallest and the largest k over the classes, each read at its own path
for navn, velg in (("min", min), ("maks", max)):
q = velg(klasser, key=lambda q: punkter[q]["terskel"]["k"])
sti = ("flater", "pris_mot_reaktorkostnad", losning, q, "terskel", "k")
tall[f"terskler.flate-a.{lk}.{navn}"] = fra_fil(fil, FIL, sti, "tall", 3)
for q in (0, len(punkter) - 1):
sti = ("flater", "pris_mot_reaktorkostnad", losning, q)
nokkel = f"terskler.flate-a.{lk}.{q}"
tall[f"{nokkel}.k"] = fra_fil(fil, FIL, (*sti, "terskel", "k"), "tall", 3)
tall[f"{nokkel}.c-n-ref"] = fra_fil(fil, FIL, (*sti, "c_N_ref"), "tall", 0)
tall[f"{nokkel}.antall"] = fra_fil(fil, FIL, (*sti, "antall"), "tall", 0)
def _flate_b(fil: Any, tall: dict[str, Tall]) -> list[str]: # noqa: ANN401
"""Surface (b): one summary row per solution."""
rader: list[str] = []
for losning, v in fil["flater"]["kraftpris_mot_kostnad_for_norsk_kraft"].items():
sti = ("flater", "kraftpris_mot_kostnad_for_norsk_kraft", losning)
nokkel = f"terskler.flate-b.{LOSNING[losning]}"
n = fra_fil(fil, FIL, (*sti, "antall_trekninger"), "tall", 0)
tall[f"{nokkel}.antall"] = n
siste = len(v["akser"]["c_snitt"]) - 1
lav = fra_fil(fil, FIL, (*sti, "akser", "c_snitt", 0, "median"), "tall", 0)
hoy = fra_fil(fil, FIL, (*sti, "akser", "c_snitt", siste, "median"), "tall", 0)
tall[f"{nokkel}.c-lav"] = lav
tall[f"{nokkel}.c-hoy"] = hoy
sammendrag = _ruter(fil, tall, nokkel, (*sti, "ruter"))
rader.append(
f"(b) & {_losning_tekst(losning)} & {n.vist} & {lav.vist}--{hoy.vist} & "
f"{' & '.join(sammendrag)} \\\\"
)
return rader
def _flate_c(fil: Any, tall: dict[str, Tall]) -> list[str]: # noqa: ANN401
"""Surface (c): one summary row per solution and required return, and the axes."""
avkastning = fil["flater"]["avkastningskrav_mot_reaktorkostnad"]
rader: list[str] = []
for losning, v in avkastning.items():
for krav, etikett in (("rho_D", "$\\rho_D$"), ("rho_N", "$\\rho_N$")):
sti = ("flater", "avkastningskrav_mot_reaktorkostnad", losning, krav)
nokkel = f"terskler.flate-c.{LOSNING[losning]}.{_nokkel(krav)}"
n = avledet(
sum(r["antall"] for rad in v[krav] for r in rad),
0,
FIL,
f"sum of «antall» over the cells of {'.'.join(sti)}",
)
tall[f"{nokkel}.antall"] = n
sammendrag = _ruter(fil, tall, nokkel, sti)
rader.append(
f"(c) & {_losning_tekst(losning)}, {etikett} & {n.vist} & -- & "
f"{' & '.join(sammendrag)} \\\\"
)
# the axes of (c) are made over all the draws and are the same for every solution
forste = next(iter(avkastning))
for krav in ("rho_D", "rho_N", "c_N_ref"):
siste = len(avkastning[forste]["akser"][krav]) - 1
omregning, des = ("tall", 0) if krav == "c_N_ref" else ("pst", 1)
for q in (0, siste):
sti = ("flater", "avkastningskrav_mot_reaktorkostnad", forste, "akser", krav, q)
tall[f"terskler.flate-c.akse.{_nokkel(krav)}.{q}"] = fra_fil(
fil, FIL, (*sti, "median"), omregning, des
)
return rader
def _ruter(fil: Any, tall: dict[str, Tall], nokkel: str, sti: tuple[str, ...]) -> list[str]: # noqa: ANN401
"""Three figures for the 5 x 5 cells of one surface at ``sti`` in the file.
How many cells have a positive median (a count), and the cell with the largest share of
positive values and the cell with the largest median, each read from the file at its own
path (the first such cell, row by row, when several are equal).
"""
ruter = hent(fil, sti)
plass = [(i, j) for i, rad in enumerate(ruter) for j, r in enumerate(rad) if r["antall"] > 0]
tekst = ".".join(sti)
positive = sum(
1 for i, j in plass if ruter[i][j]["median"] is not None and ruter[i][j]["median"] > 0
)
ut = {
"positive": avledet(
positive, 0, FIL, f"count of cells of {tekst} with «median» > 0 (of {len(plass)})"
),
"celler": avledet(len(plass), 0, FIL, f"count of cells of {tekst} with «antall» > 0"),
}
# max() keeps the first of equal cells, row by row
i, j = max(plass, key=lambda ij: ruter[ij[0]][ij[1]]["andel_positiv"])
ut["andel"] = fra_fil(fil, FIL, (*sti, i, j, "andel_positiv"), "pst", 1)
med_median = [ij for ij in plass if ruter[ij[0]][ij[1]]["median"] is not None]
if med_median:
hoyest = max(ruter[i][j]["median"] for i, j in med_median)
i, j = next(ij for ij in med_median if ruter[ij[0]][ij[1]]["median"] == hoyest)
ut["median"] = fra_fil(fil, FIL, (*sti, i, j, "median"), "mrd", 1)
for navn, t in ut.items():
tall[f"{nokkel}.{navn}"] = t
return [
f"{ut['positive'].vist} av {ut['celler'].vist}",
ut["andel"].vist,
ut["median"].vist if "median" in ut else "--",
]
# ------------------------------------------------------------------ the quantities named
def _storrelsestabell(storrelser: dict[str, Storrelse], brukt: set[str], ut: Path) -> None:
"""One row per drawn quantity named in the tables, in the order of the parameter file."""
rader = []
for navn, s in storrelser.items():
if navn not in brukt:
continue
rader.append(
f"{_symbol(navn, s, merke=False)} & {_escape(s.navn)} & {_escape(s.enhet)} & "
f"{STATUSNAVN.get(s.status, s.status)} \\\\"
)
(ut / "terskler-storrelser.tex").write_text("\n".join(rader) + "\n", encoding="utf-8")

View file

@ -0,0 +1,552 @@
r"""The timeline (chapter 6, section «Tidslinjen»; S50, chapter 17.2, clarifications 75 and 99).
Reads ``tidslinje.json`` (MW IT in operation per year, solution, step and type of power: median,
p10, p90 and the shares of the draws with at least 100 MW and at least 1 000 MW) and, for the
step the verdicts are read on and the share of paths that cannot be built, ``dommer.json``.
To explain why the share of the draws with capacity in operation has a ceiling and falls
towards 2100, it also reads three inputs as data, never through the model code:
``modell/parametere.json`` (the ranges of phi_X, D_X, L_N, L_H, T0 and T_slutt),
``data/trekninger.npy`` with ``data/trekninger.json`` (the drawn values) and
``data/aarshendelser.npy`` (the stream for the export rule). From them it computes, under the
rules as the code states them (``utbygging.eksportstopp``, ``ligninger.avrundet_varighet``,
``ligninger.forste_driftsaar``, S33), two kinds of derived numbers: the share of the draws with
an export stop in force in a year, and the share of the draws in which a facility that started
in its earliest possible year (S33) would have passed the end of its life before T_slutt.
Writes the tables ``tidslinje-start.tex`` and ``tidslinje-neste.tex`` and the figure data
``tidslinje-andel.dat`` and ``tidslinje-neste.dat``, and returns every number
``kap6-tidslinje.tex`` shows, under keys that start with ``tidslinje.``.
Standard library only.
"""
from __future__ import annotations
import ast
import json
import math
import sys
from array import array
from typing import TYPE_CHECKING, Any
from resultater.felles import LOSNING, Tall, fra_fil, hent, les, norsk
if TYPE_CHECKING:
from collections.abc import Callable
from pathlib import Path
from resultater.felles import Steg
TID = "tidslinje.json"
DOM = "dommer.json"
PARAM = "modell/parametere.json"
TREKN = "data/trekninger.npy"
HEND = "data/aarshendelser.npy"
LOSNINGER = ("A", "B", "B'", "C", "R", "T-F", "T-K")
# In the figures A, B and B' are one line: the module checks that their series are identical.
FIGUR = ("A", "C", "R", "T-F", "T-K")
ALLE = "alle"
KJERNE_NETT = "kjernekraft paa nettet"
FORNYBAR = "ny fornybar kraft"
TELLER = "normalisering"
LOSNING_TEX = {"A": "A", "B": "B", "B'": "$B'$", "C": "C", "R": "R", "T-F": "T-F", "T-K": "T-K"}
HALV = 0.5
# Clarification 6: a tolerance in the last digit when a point in time is rounded up to a year.
TOLERANSE = 1e-12
# The body of a table ends with its bottom rule: \bottomrule cannot follow \input in a tabular.
BUNN = "\\bottomrule\n"
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 _aar(aar: int, fil: str, forklaring: str) -> Tall:
"""A derived calendar year, shown without a thousands space."""
return Tall(str(aar), fil, (), aar, "avledet", 0, forklaring)
def _aar_fra_fil(data: Any, fil: str, sti: tuple[Steg, ...]) -> Tall: # noqa: ANN401
"""A calendar year that stands in a file, shown without a thousands space."""
t = fra_fil(data, fil, sti, "tekst")
return Tall(str(t.raa), t.fil, t.sti, t.raa, t.omregning, 0)
def _andel(teller: int, n: int, fil: str, forklaring: str) -> Tall:
"""A derived share, kept as a share and shown in per cent (rounded in decimal, felles.norsk)."""
verdi = teller / n
return Tall(
norsk(verdi, 1, "100"), fil, (), verdi, "avledet", 1, forklaring + "; shown in per cent"
)
def _pst(t: Tall) -> str:
return t.vist if t.raa is None else t.vist + r"~\%"
# ------------------------------------------------------------------ the timeline file
def _trinn_indeks(t: Any, trinn: int) -> int: # noqa: ANN401
return list(t["stige"]).index(trinn)
def _serie_sti(los: str, trinn: int, typ: str = ALLE) -> tuple[Steg, ...]:
return ("per_losning", los, ("trinn", trinn), "typer", typ)
def _serie(t: Any, los: str, trinn: int, typ: str = ALLE) -> list[dict[str, Any]]: # noqa: ANN401
return hent(t, _serie_sti(los, trinn, typ))
def _forste(rader: list[dict[str, Any]], vilkaar: Callable[[dict[str, Any]], bool]) -> int | None:
return next((r["aar"] for r in rader if vilkaar(r)), None)
def _sjekk_like(t: Any) -> None: # noqa: ANN401
"""A, B and B' are drawn as one line; stop if their series are not identical on every step."""
for trinn in t["stige"]:
a = hent(t, ("per_losning", "A", ("trinn", trinn), "typer", ALLE))
for los in ("B", "B'"):
if hent(t, ("per_losning", los, ("trinn", trinn), "typer", ALLE)) != a:
melding = f"tidslinjen for {los} er ikke lik A på trinn {trinn}"
raise ValueError(melding)
def _start(t: Any, s: Samler, los: str, trinn: int, navn: str) -> list[str]: # noqa: ANN401
"""When a solution first has capacity, its highest share and its share in the last year."""
k = f"tidslinje.{navn}.{LOSNING[los]}"
rader = _serie(t, los, trinn)
sti = _serie_sti(los, trinn)
hvor = f"per_losning.{los}[trinn={trinn}].typer.alle"
celler = []
forste = _forste(rader, lambda r: r["andel_minst_100_MW"] > 0)
median = _forste(rader, lambda r: r["median"] > 0)
halv = _forste(rader, lambda r: r["andel_minst_1000_MW"] >= HALV)
for nokkel, verdi, hva in (
("forste-aar", forste, "andel_minst_100_MW > 0"),
("median-aar", median, "median > 0"),
("halv-1000-aar", halv, "andel_minst_1000_MW >= 0.5"),
):
if verdi is None:
tall = Tall("--", TID, (), None, "avledet", 0, f"no year in {hvor} with {hva}")
else:
tall = _aar(verdi, TID, f"the first year in {hvor} with {hva}")
celler.append(s(f"{k}.{nokkel}", tall).vist)
topp = max(r["andel_minst_100_MW"] for r in rader)
toppaar = _forste(rader, lambda r: r["andel_minst_100_MW"] == topp)
if toppaar is None: # pragma: no cover - max is always attained
raise ValueError(hvor)
s(
f"{k}.toppaar",
_aar(toppaar, TID, f"the first year of the largest andel_minst_100_MW in {hvor}"),
)
s(f"{k}.topp", fra_fil(t, TID, (*sti, ("aar", toppaar), "andel_minst_100_MW"), "pst", 1))
slutt = rader[-1]["aar"]
s(f"{k}.slutt", fra_fil(t, TID, (*sti, ("aar", slutt), "andel_minst_100_MW"), "pst", 1))
celler += [
_pst(s.tall[f"{k}.topp"]),
s.tall[f"{k}.toppaar"].vist,
_pst(s.tall[f"{k}.slutt"]),
]
return celler
def _neste(t: Any, d: Any, s: Samler, los: str, trinn: int) -> list[str]: # noqa: ANN401
"""The larger step: paths that cannot be built, first median above zero, the largest median."""
k = f"tidslinje.neste.{LOSNING[los]}"
rader = _serie(t, los, trinn)
sti = _serie_sti(los, trinn)
hvor = f"per_losning.{los}[trinn={trinn}].typer.alle"
ib = s(
f"{k}.ikke-byggbar",
fra_fil(
d,
DOM,
(
"per_scenario",
("navn", TELLER),
"trinn",
("trinn", trinn),
"losninger",
los,
"M1",
"ikke_byggbar",
),
"pst",
1,
),
)
median = _forste(rader, lambda r: r["median"] > 0)
m_aar = s(
f"{k}.median-aar",
_aar(median, TID, f"the first year in {hvor} with median > 0")
if median is not None
else Tall("--", TID, (), None, "avledet", 0, f"no year in {hvor} with median > 0"),
)
maks = max(r["median"] for r in rader)
maks_aar = _forste(rader, lambda r: r["median"] == maks)
if maks_aar is None: # pragma: no cover - max is always attained
raise ValueError(hvor)
s(f"{k}.maks-aar", _aar(maks_aar, TID, f"the first year of the largest median in {hvor}"))
mk = s(f"{k}.maks", fra_fil(t, TID, (*sti, ("aar", maks_aar), "median"), "tall", 0))
slutt = rader[-1]["aar"]
sl = s(f"{k}.slutt", fra_fil(t, TID, (*sti, ("aar", slutt), "median"), "tall", 0))
p90 = s(f"{k}.slutt-p90", fra_fil(t, TID, (*sti, ("aar", slutt), "p90"), "tall", 0))
return [_pst(ib), m_aar.vist, mk.vist, s.tall[f"{k}.maks-aar"].vist, sl.vist, p90.vist]
def _forste_aar(
s: Samler,
nokkel: str,
*,
rader: list[dict[str, Any]],
hvor: str,
felt: str,
terskel: float,
) -> int | None:
"""Store the first year a field is above zero (``terskel`` 0) or at least ``terskel``."""
if terskel == 0:
aar, hva = _forste(rader, lambda r: r[felt] > 0), f"{felt} > 0"
else:
aar, hva = _forste(rader, lambda r: r[felt] >= terskel), f"{felt} >= {terskel}"
if aar is not None:
s(nokkel, _aar(aar, TID, f"the first year in {hvor} with {hva}"))
return aar
def _storste(
t: Any, # noqa: ANN401
s: Samler,
nokkel: str,
*,
sti: tuple[Steg, ...],
felt: str,
omregning: tuple[str, int],
) -> int:
"""Store the largest value of a field over the years, and the first year it is reached."""
rader = hent(t, sti)
hoyest = max(r[felt] for r in rader)
aar = next(r["aar"] for r in rader if r[felt] == hoyest)
hvor = ".".join(f"[{x[0]}={x[1]}]" if isinstance(x, tuple) else str(x) for x in sti)
s(f"{nokkel}-aar", _aar(aar, TID, f"the first year of the largest {felt} in {hvor}"))
s(nokkel, fra_fil(t, TID, (*sti, ("aar", aar), felt), *omregning))
return aar
def _tk_overgang(t: Any, s: Samler, trinn: int, navn: str) -> None: # noqa: ANN401
"""T-K: when modules on nuclear power on the grid appear, and how much renewable is there."""
k = f"tidslinje.{navn}.TK"
kjerne = _serie(t, "T-K", trinn, KJERNE_NETT)
hvor = f"per_losning.T-K[trinn={trinn}].typer.{KJERNE_NETT}"
sti = _serie_sti("T-K", trinn, KJERNE_NETT)
fsti = _serie_sti("T-K", trinn, FORNYBAR)
_forste_aar(
s, f"{k}.kjerne-forste-aar", rader=kjerne, hvor=hvor, felt="andel_minst_100_MW", terskel=0
)
_storste(t, s, f"{k}.kjerne-topp", sti=sti, felt="andel_minst_100_MW", omregning=("pst", 2))
median = _forste_aar(
s, f"{k}.kjerne-median-aar", rader=kjerne, hvor=hvor, felt="median", terskel=0
)
if median is None:
return
s(f"{k}.kjerne-median", fra_fil(t, TID, (*sti, ("aar", median), "median"), "tall", 0))
_forste_aar(
s, f"{k}.kjerne-halv-aar", rader=kjerne, hvor=hvor, felt="andel_minst_100_MW", terskel=HALV
)
_storste(t, s, f"{k}.kjerne-maks", sti=sti, felt="median", omregning=("tall", 0))
s(f"{k}.fornybar-ved-kjerne", fra_fil(t, TID, (*fsti, ("aar", median), "median"), "tall", 0))
_storste(t, s, f"{k}.fornybar-maks", sti=fsti, felt="median", omregning=("tall", 0))
# ------------------------------------------------------------------ the inputs read as data
def _les_npy(sti: Path) -> tuple[int, int, array[float]]:
"""Read a two-dimensional float64 table in numpy's .npy format, version 1 or 2, C order."""
raa = sti.read_bytes()
if raa[:6] != b"\x93NUMPY":
melding = f"{sti} er ikke en .npy-fil"
raise ValueError(melding)
versjon = raa[6]
if versjon == 1:
lengde, start = int.from_bytes(raa[8:10], "little"), 10
elif versjon in {2, 3}:
lengde, start = int.from_bytes(raa[8:12], "little"), 12
else:
melding = f"{sti}: ukjent .npy-versjon {versjon}"
raise ValueError(melding)
hode = ast.literal_eval(raa[start : start + lengde].decode("latin1"))
if hode["descr"] != "<f8" or hode["fortran_order"] or len(hode["shape"]) != 2: # noqa: PLR2004
melding = f"{sti}: ventet en todimensjonal tabell av <f8 i C-rekkefølge, fikk {hode}"
raise ValueError(melding)
rader, kolonner = hode["shape"]
tall = array("d")
tall.frombytes(raa[start + lengde :])
if sys.byteorder != "little": # pragma: no cover - the project's machines are little-endian
tall.byteswap()
if len(tall) != rader * kolonner:
melding = f"{sti}: {len(tall)} tall, ventet {rader * kolonner}"
raise ValueError(melding)
return rader, kolonner, tall
def _parameter(p: Any, pid: str) -> tuple[Steg, ...]: # noqa: ANN401
"""The path to one parameter's distribution in the parameter file."""
hent(p, ("parametere", ("id", pid)))
return ("parametere", ("id", pid), "fordeling")
def _rundet(varighet: float) -> int:
"""Clarification 21 as ``ligninger.avrundet_varighet``: nearest year, halves up, at least 1."""
return max(1, math.floor(varighet + 0.5))
def _tak(tidspunkt: float) -> int:
"""Clarification 21 as ``ligninger.forste_driftsaar``: up to a whole year, with tolerance."""
return math.ceil(tidspunkt * (1.0 - TOLERANSE))
def _inndata(rot: Path, s: Samler, aar_stopp: tuple[int, ...]) -> None:
"""The ranges behind the explanation, and what the draws and the stream give under the rules."""
p = json.loads((rot / PARAM).read_text(encoding="utf-8"))
s("tidslinje.param.phi-lav", fra_fil(p, PARAM, (*_parameter(p, "phi_X"), "lav"), "pst", 0))
s("tidslinje.param.phi-hoy", fra_fil(p, PARAM, (*_parameter(p, "phi_X"), "hoy"), "pst", 0))
s("tidslinje.param.DX-lav", fra_fil(p, PARAM, (*_parameter(p, "D_X"), "lav"), "tall", 0))
s("tidslinje.param.DX-hoy", fra_fil(p, PARAM, (*_parameter(p, "D_X"), "hoy"), "tall", 0))
s("tidslinje.param.LN-lav", fra_fil(p, PARAM, (*_parameter(p, "L_N"), "lav"), "tall", 0))
s("tidslinje.param.LN-modus", fra_fil(p, PARAM, (*_parameter(p, "L_N"), "modus"), "tall", 0))
s("tidslinje.param.LN-hoy", fra_fil(p, PARAM, (*_parameter(p, "L_N"), "hoy"), "tall", 0))
s("tidslinje.param.LH-lav", fra_fil(p, PARAM, (*_parameter(p, "L_H"), "verdier", 0), "tall", 0))
s(
"tidslinje.param.LH-hoy",
fra_fil(p, PARAM, (*_parameter(p, "L_H"), "verdier", -1), "tall", 0),
)
T0 = int(hent(p, (*_parameter(p, "T0"), "verdi")))
Ts = int(hent(p, (*_parameter(p, "T_slutt"), "verdi")))
tau_reg = float(hent(p, (*_parameter(p, "tau_reg_min"), "verdi")))
s("tidslinje.param.Ts", _aar_fra_fil(p, PARAM, (*_parameter(p, "T_slutt"), "verdi")))
beskrivelse = json.loads((rot / "data" / "trekninger.json").read_text(encoding="utf-8"))
navn = [k["navn"] for k in beskrivelse["kolonner"]]
n, m, x = _les_npy(rot / TREKN)
n2, aar_n, u = _les_npy(rot / HEND)
hend_aar = json.loads((rot / "data" / "aarshendelser.json").read_text(encoding="utf-8"))["aar"]
if (
n != n2
or m != len(navn)
or aar_n != len(hend_aar)
or hend_aar != list(range(T0 + 1, Ts + 1))
):
melding = "trekningene og strømmen passer ikke sammen"
raise ValueError(melding)
def kol(navn_: str) -> list[float]:
j = navn.index(navn_)
return [x[i * m + j] for i in range(n)]
phi, D = kol("phi_X"), kol("D_X")
i_kraft = dict.fromkeys(aar_stopp, 0)
noen = 0
for i in range(n):
stopp = [False] * aar_n
varighet = _rundet(D[i])
for j in range(aar_n):
if u[i * aar_n + j] < phi[i]:
for jj in range(j, min(j + varighet, aar_n)):
stopp[jj] = True
noen += any(stopp)
for a in aar_stopp:
i_kraft[a] += stopp[a - T0 - 1]
regel = (
"the export rule as utbygging.eksportstopp states it, applied to data/aarshendelser.npy "
"and the columns phi_X and D_X of data/trekninger.npy: a rule starts in year t when the "
"stream's number is below phi_X and lasts D_X years rounded (clarification 21); "
)
for a in aar_stopp:
s(
f"tidslinje.stopp.{a}",
_andel(
i_kraft[a],
n,
f"{TREKN}, {HEND}",
regel + f"share of the draws with a stop in force in {a}",
),
)
s(
"tidslinje.stopp.noen",
_andel(
noen,
n,
f"{TREKN}, {HEND}",
regel + f"share of the draws with a stop in force in at least one year {T0 + 1}..{Ts}",
),
)
# A facility of A (and B, B') or R cannot start before its first possible operating year
# (S33), so it cannot reach the end of its life before that year plus L_N - 1.
L = [_rundet(v) for v in kol("L_N")]
tidligst = {
"A": [
_tak(T0 + max(f, tau_reg + nn))
for f, nn in zip(kol("tau_F"), kol("tau_N"), strict=True)
],
"R": [_tak(T0 + v) for v in kol("tau_nett")],
}
hva = {
"A": "ceil(T0 + max(tau_F, tau_reg_min + tau_N)) (S33, A, B, B')",
"R": "ceil(T0 + tau_nett) (S33, C, R)",
}
for los, t1 in tidligst.items():
utlevd = sum(t + l_ - 1 < Ts for t, l_ in zip(t1, L, strict=True))
s(
f"tidslinje.utlevd.{los}",
_andel(
utlevd,
n,
f"{TREKN}, {PARAM}",
f"share of the draws in which {hva[los]} + round(L_N) - 1 < T_slutt: a "
"facility that starts in its earliest possible year has passed the end of its life "
"before the last year; an upper bound, since a facility never starts earlier",
),
)
s(
f"tidslinje.tidligst.{los}",
_aar(min(t1), TREKN, f"the smallest {hva[los]} over the draws"),
)
# ------------------------------------------------------------------ tables and figures
def _tabell_start(t: Any, s: Samler, trinn: int) -> str: # noqa: ANN401
linjer = []
for los in LOSNINGER:
celler = _start(t, s, los, trinn, "dom")
linjer.append(LOSNING_TEX[los] + " & " + " & ".join(celler) + r" \\")
return "\n".join(linjer) + "\n" + BUNN
def _tabell_neste(t: Any, d: Any, s: Samler, trinn: int) -> str: # noqa: ANN401
linjer = []
for los in LOSNINGER:
celler = _neste(t, d, s, los, trinn)
linjer.append(LOSNING_TEX[los] + " & " + " & ".join(celler) + r" \\")
return "\n".join(linjer) + "\n" + BUNN
def _dat_andel(t: Any, trinn: int) -> str: # noqa: ANN401
"""The share with at least 100 MW per year on the verdicts' step, for the figure's solutions."""
linjer = [
(
f"# kilde: {TID}, per_losning.<L>[trinn={trinn}].typer.alle[aar].andel_minst_100_MW "
f"for L in {', '.join(FIGUR)} (A stands for A, B and B', whose series are identical)"
),
]
linjer.append("aar " + " ".join(LOSNING[x] for x in FIGUR))
serier = [_serie(t, los, trinn) for los in FIGUR]
for j, rad in enumerate(serier[0]):
verdier = [repr(float(sr[j]["andel_minst_100_MW"])) for sr in serier]
linjer.append(f"{rad['aar']} " + " ".join(verdier))
return "\n".join(linjer) + "\n"
def _dat_neste(t: Any, trinn: int) -> str: # noqa: ANN401
"""Median, p10 and p90 of MW in operation every second year on the larger step."""
linjer = [
(
f"# kilde: {TID}, per_losning.<L>[trinn={trinn}].typer.alle[aar].median, .p10, .p90 "
f"for L in {', '.join(FIGUR)}; every second year from the first"
),
f"# kilde: {TID}, per_losning.T-K[trinn={trinn}].typer.{KJERNE_NETT}[aar].median, TKkjerne",
]
navn = [f"{LOSNING[x]}{f}" for x in FIGUR for f in ("med", "p10", "p90")]
linjer.append("aar " + " ".join(navn) + " TKkjerne")
serier = [_serie(t, los, trinn) for los in FIGUR]
kjerne = _serie(t, "T-K", trinn, KJERNE_NETT)
for j in range(0, len(serier[0]), 2):
verdier = [repr(float(sr[j][f])) for sr in serier for f in ("median", "p10", "p90")]
linjer.append(
f"{serier[0][j]['aar']} " + " ".join(verdier) + f" {float(kjerne[j]['median'])!r}"
)
return "\n".join(linjer) + "\n"
def lag(data: Path, ut: Path) -> dict[str, Tall]:
"""Write the tables and figure data of the timeline, and return its numbers."""
t = les(data, TID)
d = les(data, DOM)
s = Samler()
_sjekk_like(t)
if t["antall_trekninger"] != d["antall_trekninger"] or t["stige"] != d["stige"]:
melding = "tidslinje.json og dommer.json hører ikke til samme kjøring"
raise ValueError(melding)
trinn = hent(d, ("trinn",))
s("tidslinje.domstrinn", fra_fil(d, DOM, ("trinn",), "tall", 0))
stige = list(t["stige"])
neste = stige[stige.index(trinn) + 1]
s("tidslinje.nestetrinn", fra_fil(t, TID, ("stige", stige.index(neste)), "tall", 0))
s("tidslinje.forste-aar", _aar_fra_fil(t, TID, (*_serie_sti("A", trinn), 0, "aar")))
s("tidslinje.antall", fra_fil(t, TID, ("antall_trekninger",), "tall", 0))
(ut / "tidslinje-start.tex").write_text(_tabell_start(t, s, trinn), encoding="utf-8")
(ut / "tidslinje-neste.tex").write_text(_tabell_neste(t, d, s, neste), encoding="utf-8")
for los in LOSNINGER:
s(
f"tidslinje.dom.{LOSNING[los]}.ikke-byggbar",
fra_fil(
d,
DOM,
(
"per_scenario",
("navn", TELLER),
"trinn",
("trinn", trinn),
"losninger",
los,
"M1",
"ikke_byggbar",
),
"pst",
1,
),
)
_tk_overgang(t, s, trinn, "dom")
_tk_overgang(t, s, neste, "neste")
(ut / "tidslinje-andel.dat").write_text(_dat_andel(t, trinn), encoding="utf-8")
(ut / "tidslinje-neste.dat").write_text(_dat_neste(t, neste), encoding="utf-8")
# The explanation of the ceiling and the fall: the stop shares in A's peak year and the end.
toppaar = int(s.tall["tidslinje.dom.A.toppaar"].raa) # type: ignore[arg-type]
sluttaar = int(_serie(t, "A", trinn)[-1]["aar"])
_inndata(data.parent.parent, s, (toppaar, sluttaar))
# The earliest year a facility of A can have passed the end of its life: its earliest
# operating year in any draw plus the shortest lifetime, minus one.
forste_a = int(s.tall["tidslinje.dom.A.forste-aar"].raa) # type: ignore[arg-type]
ln_lav = int(s.tall["tidslinje.param.LN-lav"].raa) # type: ignore[arg-type]
s(
"tidslinje.A.tidligst-utlevd",
_aar(
forste_a + ln_lav - 1,
f"{TID}, {PARAM}",
"the first year in per_losning.A[trinn=<the verdicts' step>].typer.alle with "
"andel_minst_100_MW > 0, plus the low end of L_N in the parameter file, minus 1: the "
"last operating year of the earliest facility with the shortest lifetime",
),
)
return s.tall