tokenfabrikker/rapport/resultater/terskler.py
Kjell Tore Guttormsen 2b20f81152
docs(rapport): the price threshold as per cent above the model's path in the summaries and the conclusion
A derived number per solution and scenario, (k - 1) * 100, replaces
'1,068 times as high' with '7 % above' where a reader meets it first.

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

702 lines
30 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""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
if p["k"] is not None:
# How far above the model's price path the threshold lies, in per cent.
tall[f"{nokkel}.pst-over"] = avledet(
(p["k"] - 1.0) * 100.0,
0,
FIL,
f"(k - 1) * 100 for pristerskler.{losning}.{scenario}.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")