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>
594 lines
25 KiB
Python
594 lines
25 KiB
Python
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()))
|