"""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...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.[].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")