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>
694 lines
30 KiB
Python
694 lines
30 KiB
Python
"""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")
|