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

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

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()))