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:
parent
73fa883210
commit
4defd09580
22 changed files with 5439 additions and 58 deletions
1
rapport/resultater/__init__.py
Normal file
1
rapport/resultater/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
"""Chapter 6 of the report, generated from the result files in ``data/resultater/``."""
|
||||
594
rapport/resultater/dommer.py
Normal file
594
rapport/resultater/dommer.py
Normal 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()))
|
||||
200
rapport/resultater/eierformer.py
Normal file
200
rapport/resultater/eierformer.py
Normal 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)} \\\\"
|
||||
129
rapport/resultater/felles.py
Normal file
129
rapport/resultater/felles.py
Normal 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)
|
||||
993
rapport/resultater/folsomheter.py
Normal file
993
rapport/resultater/folsomheter.py
Normal 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
402
rapport/resultater/miljo.py
Normal 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
|
||||
694
rapport/resultater/terskler.py
Normal file
694
rapport/resultater/terskler.py
Normal 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")
|
||||
552
rapport/resultater/tidslinje.py
Normal file
552
rapport/resultater/tidslinje.py
Normal 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
|
||||
Loading…
Add table
Add a link
Reference in a new issue