tokenfabrikker/rapport/lag_vedlegg_parametere.py
Kjell Tore Guttormsen f271f11715
docs(rapport): appendices with the parameters and the change list, the reference list, and the two-page summary
Appendix B, appendix C and the reference list are generated from the frozen
parameter file, the pre-registration and the source bank. Citations link to
their item in the list. The two-page summary states only what the summary in
the report states. Draft PDFs of the report and the summary are in pdf/.

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

711 lines
26 KiB
Python

# ruff: noqa: INP001
r"""Write appendix B of the report: the frozen parameters.
Reads ``modell/parametere.json`` and writes ``rapport/generert/vedlegg-parametere.tex``: a
short lead-in (the version, the number of parameters per status, the SHA-256 of the file), one
table row per parameter in the file's order, and the frozen sensitivity list verbatim.
A parameter row holds the symbol and the id, the name with the unit and where it is used, the
distribution with every number it has in the file, the status and the source-bank entries as
``\kilde{...}``. A line under the row, across the table, holds the source value, the remark and
a fixed value that is a table, when the file has them.
Numbers follow one rule (``tall``): the shortest decimal string that gives back the same value
(Python's ``repr``), without a trailing ``.0``; a decimal comma; a thin space between groups of
three digits when the integer part has five digits or more; a minus sign for negative values;
and a power of ten when the shortest string has an exponent. No digit is dropped.
Free text goes through ``tekst``: every character LaTeX treats specially is escaped, and every
non-ASCII character must be one of those listed in ``TEGN``. A symbol is set in math mode when
it uses only the commands in ``KOMMANDOER`` and plain letters, digits and signs. Anything else
stops the script.
Standard library only. The output depends only on the parameter file and the pre-registration:
same input, same bytes. The script stops with an error, and writes nothing, when the file does
not have the expected form, when a character or a symbol cannot be rendered, or when the
checksum of the file is not the last one stated under «Parameterfrys» in the pre-registration.
Run from anywhere: ``python3 rapport/lag_vedlegg_parametere.py``.
"""
from __future__ import annotations
import hashlib
import json
import math
import re
import sys
from pathlib import Path
ROT = Path(__file__).resolve().parent.parent
PARAMETERE = ROT / "modell" / "parametere.json"
FORHAANDSREG = ROT / "FORHANDSREGISTRERING.md"
UT = ROT / "rapport" / "generert" / "vedlegg-parametere.tex"
ANTALL = 137
ANTALL_FOELSOMHETER = 37
MAKS_DYBDE = 2
FELT = (
"id",
"symbol",
"navn",
"enhet",
"fordeling",
"poster",
"status",
"ligninger",
"kildeverdi",
"merknad",
)
TEKSTFELT = ("id", "symbol", "navn", "enhet", "status", "ligninger", "kildeverdi", "merknad")
FORDELINGSFELT = {
"fast": ("type", "verdi"),
"jevn": ("type", "lav", "hoy"),
"logjevn": ("type", "lav", "hoy"),
"pert": ("type", "lav", "modus", "hoy", "form"),
"lognormal": ("type", "median", "sigma", "min", "maks", "avkorting"),
"diskret": ("type", "verdier", "vekter"),
}
SAMMENSATT = "sammensatt"
INGEN = "\u2013" # the file's en dash for "no symbol" and "no unit"
ID = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$")
POST = re.compile(r"^K\d{2}-(?:\d{3}|K\d{2}|Ka\d{2})$")
SJEKKSUM = re.compile(r"SHA-256: `([0-9a-f]{64})`")
# Characters LaTeX treats specially, written so that they print as themselves.
SPESIELLE = {
"\\": r"\textbackslash{}",
"{": r"\{",
"}": r"\}",
"$": r"\$",
"&": r"\&",
"#": r"\#",
"%": r"\%",
"_": r"\_",
"^": r"\textasciicircum{}",
"~": r"\textasciitilde{}",
"<": r"\textless{}",
">": r"\textgreater{}",
"|": r"\textbar{}",
'"': r"\textquotedbl{}", # an active shorthand under babel norsk
"`": r"\textasciigrave{}",
}
# Every non-ASCII character the text may hold, and how it is written for pdflatex with
# inputenc utf8 and T1. Letters and guillemets are left to inputenc; the rest are named.
TEGN = {
"\u00e6": "\u00e6", # ae
"\u00f8": "\u00f8", # o with stroke
"\u00e5": "\u00e5", # a with ring
"\u00c6": "\u00c6", # AE
"\u00d8": "\u00d8", # O with stroke
"\u00c5": "\u00c5", # A with ring
"\u00e9": "\u00e9", # e with acute
"\u00ab": "\u00ab", # left guillemet
"\u00bb": "\u00bb", # right guillemet
"\u00b0": r"\textdegree{}",
"\u00b2": r"\textsuperscript{2}",
"\u00b3": r"\textsuperscript{3}",
"\u00b7": r"\textperiodcentered{}",
"\u00d7": r"\texttimes{}",
"\u2013": r"\textendash{}",
"\u2212": r"\textminus{}",
"\u2192": r"\textrightarrow{}",
"\u2264": r"\ensuremath{\leq}",
"\u2265": r"\ensuremath{\geq}",
}
# Letters allowed inside \text{...} of a symbol, besides ASCII letters, digits, comma and space.
TEKST_I_SYMBOL = frozenset("\u00e6\u00f8\u00e5\u00c6\u00d8\u00c5")
KOMMANDOER = frozenset(
{
"alpha",
"bar",
"beta",
"chi",
"Delta",
"delta",
"ell",
"epsilon",
"eta",
"Gamma",
"gamma",
"iota",
"kappa",
"lambda",
"mathcal",
"mathit",
"min",
"mu",
"nu",
"omega",
"phi",
"pi",
"psi",
"rho",
"sigma",
"tau",
"theta",
"varepsilon",
"varphi",
"xi",
}
)
SYMBOLTEGN = frozenset("_^{}(),*- ")
TEKSTGRUPPE = re.compile(r"\\text\{([^{}\\]*)\}")
KOMMANDO = re.compile(r"\\([A-Za-z]+)")
STRIPE = r"\textendash{}"
HODE = r"Symbol og id & Størrelse & Fordeling & Status & Poster \\"
SYMBOLBREDDE = "19mm"
KOLONNER = rf"@{{}}P{{{SYMBOLBREDDE}}}LP{{36mm}}P{{17mm}}P{{17mm}}@{{}}"
UNDERLINJE = (
rf"\multicolumn{{4}}{{>{{\raggedright\arraybackslash}}"
rf"p{{\dimexpr\linewidth-{SYMBOLBREDDE}-2\tabcolsep\relax}}@{{}}}}"
)
class ParameterError(Exception):
"""The input does not have the expected form, or something in it cannot be rendered."""
def tekst(s: str) -> str:
"""Free text from the file as LaTeX: special characters escaped, non-ASCII from TEGN."""
ut: list[str] = []
forrige = ""
for c in s:
if c in SPESIELLE:
ut.append(SPESIELLE[c])
elif c in TEGN:
ut.append(TEGN[c])
elif " " <= c <= "~":
# Break the T1 ligatures "--" (dash) and ",," (low quotes) by an empty group.
if c == forrige and c in "-,":
ut.append("{}")
ut.append(c)
else:
msg = f"character {c!r} (U+{ord(c):04X}) has no rendering in TEGN: {s!r}"
raise ParameterError(msg)
forrige = c
return "".join(ut)
def _grupper(siffer: str) -> str:
r"""Digits with \, between groups of three when there are five digits or more."""
if len(siffer) < 5: # noqa: PLR2004 - four-digit numbers are not grouped in Norwegian
return siffer
hode = len(siffer) % 3 or 3
grupper = [siffer[:hode]] + [siffer[i : i + 3] for i in range(hode, len(siffer), 3)]
return r"\,".join(grupper)
def _desimal(s: str) -> str:
"""A decimal string without exponent (as repr writes it) in the Norwegian form."""
minus = s.startswith("-")
s = s.removeprefix("-")
heltall, _, brok = s.partition(".")
if not heltall.isdigit() or (brok and not brok.isdigit()):
msg = f"not a decimal number: {s!r}"
raise ParameterError(msg)
if brok == "0":
brok = ""
ut = _grupper(heltall) + ("," + brok if brok else "")
return (r"\textminus{}" if minus else "") + ut
def tall(x: float) -> str:
"""A number from the file, with every digit it has there (see the module docstring)."""
if isinstance(x, bool):
msg = f"a truth value where a number is expected: {x!r}"
raise ParameterError(msg)
if isinstance(x, int):
return _desimal(str(x))
if not math.isfinite(x):
msg = f"not a finite number: {x!r}"
raise ParameterError(msg)
r = repr(x)
if "e" not in r:
return _desimal(r)
mantisse, _, eksponent = r.partition("e")
e = int(eksponent)
potens = (r"\textminus{}" if e < 0 else "") + str(abs(e))
return _desimal(mantisse) + r"\,\textperiodcentered\,10\textsuperscript{" + potens + "}"
def er_tall(x: object) -> bool:
"""Whether x is a JSON number (not a truth value)."""
return isinstance(x, (int, float)) and not isinstance(x, bool)
def skalar(x: object) -> str:
"""One value inside a fixed value: a number, a text, a truth value or null."""
if x is None:
return "ingen"
if isinstance(x, bool):
return "ja" if x else "nei"
if isinstance(x, (int, float)):
return tall(x)
if isinstance(x, str):
return tekst(x)
msg = f"not a single value: {x!r}"
raise ParameterError(msg)
def er_skalar(x: object) -> bool:
"""Whether x is a single value (not a list or an object)."""
return x is None or isinstance(x, (bool, int, float, str))
def nokkel(k: str) -> str:
r"""A key of a fixed value, as it stands in the file, in \texttt."""
return r"\texttt{" + tekst(k) + "}"
def _liste(v: list[object]) -> str:
if not v or not all(er_skalar(x) for x in v):
msg = f"a list that is empty or not of single values: {v!r}"
raise ParameterError(msg)
return "; ".join(skalar(x) for x in v)
def _indre(v: object) -> str:
"""The second level of a table: a single value, a list, or an object of single values."""
if er_skalar(v):
return skalar(v)
if isinstance(v, list):
return _liste(v)
if isinstance(v, dict):
if not v or not all(er_skalar(x) for x in v.values()):
msg = f"a table deeper than {MAKS_DYBDE} levels: {v!r}"
raise ParameterError(msg)
return "; ".join(f"{nokkel(k)} = {skalar(x)}" for k, x in v.items())
msg = f"unexpected value: {v!r}"
raise ParameterError(msg)
def fast_verdi(v: object) -> tuple[str, list[str]]:
"""The cell text for a fixed value, and the lines under the row when it is a table."""
if er_tall(v):
return "fast " + skalar(v), []
if isinstance(v, list) and all(er_skalar(x) for x in v):
return "fast " + _liste(v), []
if isinstance(v, dict) and v and all(er_skalar(x) for x in v.values()):
celle = "".join(rf"\newline {nokkel(k)}: {skalar(x)}" for k, x in v.items())
return "fast" + celle, []
if isinstance(v, list) and v:
return "fast, tabell (verdiene står under)", [_indre(x) for x in v]
if isinstance(v, dict) and v:
linjer = [f"{nokkel(k)}: {_indre(x)}" for k, x in v.items()]
return "fast, tabell (verdiene står under)", linjer
msg = f"unexpected fixed value: {v!r}"
raise ParameterError(msg)
def _felt(f: dict[str, object], navn: str) -> float:
x = f[navn]
if not isinstance(x, (int, float)) or isinstance(x, bool):
msg = f"field {navn!r} is not a number: {x!r}"
raise ParameterError(msg)
return x
def _talliste(f: dict[str, object], navn: str) -> list[float]:
x = f[navn]
if not isinstance(x, list) or not x:
msg = f"field {navn!r} is not a list of numbers: {x!r}"
raise ParameterError(msg)
ut: list[float] = []
for v in x:
if not isinstance(v, (int, float)) or isinstance(v, bool):
msg = f"field {navn!r} is not a list of numbers: {x!r}"
raise ParameterError(msg)
ut.append(v)
return ut
def _jevn(f: dict[str, object], _pert_form: int) -> str:
return f"jevn {tall(_felt(f, 'lav'))} {STRIPE} {tall(_felt(f, 'hoy'))}"
def _logjevn(f: dict[str, object], _pert_form: int) -> str:
return f"jevn i logaritmen {tall(_felt(f, 'lav'))} {STRIPE} {tall(_felt(f, 'hoy'))}"
def _pert(f: dict[str, object], pert_form: int) -> str:
"""PERT low / mode / high; the form only when it is not the file's common one."""
punkter = " / ".join(tall(_felt(f, k)) for k in ("lav", "modus", "hoy"))
form = _felt(f, "form")
tillegg = "" if form == pert_form else f", form {tall(form)}"
return f"PERT {punkter}{tillegg}"
def _diskret(f: dict[str, object], _pert_form: int) -> str:
verdier = _talliste(f, "verdier")
vekter = _talliste(f, "vekter")
if len(verdier) != len(vekter):
msg = f"{len(verdier)} values but {len(vekter)} weights"
raise ParameterError(msg)
tekst_verdier = "; ".join(tall(v) for v in verdier)
tekst_vekter = "; ".join(tall(v) for v in vekter)
return f"diskret {tekst_verdier}" + r"\newline " + f"vekter {tekst_vekter}"
def _lognormal(f: dict[str, object], _pert_form: int) -> str:
avkorting = f["avkorting"]
if not isinstance(avkorting, str):
msg = f"the truncation of a lognormal distribution is not a text: {avkorting!r}"
raise ParameterError(msg)
return (
f"lognormal, median {tall(_felt(f, 'median'))}, sigma {tall(_felt(f, 'sigma'))}, "
f"minst {tall(_felt(f, 'min'))}, høyst {tall(_felt(f, 'maks'))}, "
f"avkorting: {tekst(avkorting)}"
)
SKRIV = {
"jevn": _jevn,
"logjevn": _logjevn,
"pert": _pert,
"diskret": _diskret,
"lognormal": _lognormal,
}
def _sammensatt(f: dict[str, object], pert_form: int) -> str:
"""One line per part: the name of the part and its distribution (never a table)."""
deler = [k for k in f if k != "type"]
if not deler:
msg = "a composite distribution with no parts"
raise ParameterError(msg)
linjer = []
for k in deler:
celle, under = fordeling(f[k], pert_form, indre=True)
if under:
msg = f"part {k!r} of a composite distribution is a table"
raise ParameterError(msg)
linjer.append(f"{tekst(k)}: {celle}")
return r"\newline ".join(linjer)
def fordeling(f: object, pert_form: int, *, indre: bool = False) -> tuple[str, list[str]]:
"""The cell text for a distribution, and the lines under the row (for a table value)."""
if not isinstance(f, dict):
msg = f"a distribution is not an object: {f!r}"
raise ParameterError(msg)
t = f.get("type")
if t == SAMMENSATT and not indre:
return _sammensatt(f, pert_form), []
if not isinstance(t, str) or t not in FORDELINGSFELT:
msg = f"unknown distribution type {t!r}"
raise ParameterError(msg)
if tuple(f) != FORDELINGSFELT[t]:
msg = f"distribution {t!r} has the fields {tuple(f)}, expected {FORDELINGSFELT[t]}"
raise ParameterError(msg)
if t == "fast":
return fast_verdi(f["verdi"])
return SKRIV[t](f, pert_form), []
def _sjekk_tekstgrupper(s: str) -> None:
r"""Every \text{...} in a symbol holds only letters, digits, commas and spaces."""
for innhold in TEKSTGRUPPE.findall(s):
if not innhold or not all(
(c.isascii() and (c.isalnum() or c in ", ")) or c in TEKST_I_SYMBOL for c in innhold
):
msg = f"symbol {s!r}: \\text{{{innhold}}} holds a character that is not allowed"
raise ParameterError(msg)
def _sjekk_resten(s: str, rest: str) -> None:
"""What is left of a symbol: allowed characters, scripts with an argument, balanced braces."""
dybde = 0
for i, c in enumerate(rest):
if not (c.isascii() and c.isalnum()) and c not in SYMBOLTEGN:
msg = f"symbol {s!r}: character {c!r} is not allowed in a symbol"
raise ParameterError(msg)
if c in "_^" and (i + 1 == len(rest) or rest[i + 1] in "_^} "):
msg = f"symbol {s!r}: {c!r} without an argument"
raise ParameterError(msg)
dybde += {"{": 1, "}": -1}.get(c, 0)
if dybde < 0:
break
if dybde != 0:
msg = f"symbol {s!r}: unbalanced braces"
raise ParameterError(msg)
def tex_symbol(s: str) -> str:
"""The symbol in math mode, or a dash for none; stops on anything not known to be safe."""
if s == INGEN:
return STRIPE
if not s or s.strip() != s:
msg = f"empty symbol or symbol with spaces at the ends: {s!r}"
raise ParameterError(msg)
_sjekk_tekstgrupper(s)
rest = TEKSTGRUPPE.sub("x", s)
for kommando in KOMMANDO.findall(rest):
if kommando not in KOMMANDOER:
msg = f"symbol {s!r}: command \\{kommando} is not in KOMMANDOER"
raise ParameterError(msg)
_sjekk_resten(s, KOMMANDO.sub("x", rest))
return "$" + s + "$"
def tex_id(pid: str) -> str:
r"""The parameter id in \texttt, with break points after underscores."""
if not ID.match(pid):
msg = f"not a plain id: {pid!r}"
raise ParameterError(msg)
return r"\texttt{" + pid.replace("_", r"\_\allowbreak{}") + "}"
def tex_poster(poster: list[str]) -> str:
r"""The source-bank entries, each in \kilde, or a dash when there are none."""
for p in poster:
if not POST.match(p):
msg = f"not a source-bank entry: {p!r}"
raise ParameterError(msg)
if not poster:
return STRIPE
# \leavevmode first: the colour in \kilde would otherwise start the cell in vertical mode
# and push its first line below the first line of the other cells.
return r"\leavevmode " + " ".join(r"\kilde{" + p + "}" for p in poster)
def les_parameter(p: object, statuser: dict[str, str]) -> dict[str, object]:
"""Check one parameter object and return it."""
if not isinstance(p, dict) or tuple(p) != FELT:
msg = f"a parameter does not have exactly the fields {FELT}: {p!r}"
raise ParameterError(msg)
for k in TEKSTFELT:
if not isinstance(p[k], str):
msg = f"{p.get('id')!r}: field {k!r} is not a text"
raise ParameterError(msg)
for k in ("id", "symbol", "navn", "enhet", "status"):
if not p[k]:
msg = f"{p.get('id')!r}: field {k!r} is empty"
raise ParameterError(msg)
poster = p["poster"]
if not isinstance(poster, list) or not all(isinstance(x, str) for x in poster):
msg = f"{p['id']!r}: the entries are not a list of texts"
raise ParameterError(msg)
if p["status"] not in statuser:
msg = f"{p['id']!r}: unknown status {p['status']!r}"
raise ParameterError(msg)
return p
def rad(p: dict[str, object], pert_form: int) -> list[str]:
"""The table lines for one parameter: the row, and the line under it when there is one."""
pid, symbol, navn, enhet = str(p["id"]), str(p["symbol"]), str(p["navn"]), str(p["enhet"])
status, ligninger = str(p["status"]), str(p["ligninger"])
kildeverdi, merknad = str(p["kildeverdi"]), str(p["merknad"])
poster = p["poster"]
assert isinstance(poster, list) # noqa: S101 - checked in les_parameter
celle, tabell = fordeling(p["fordeling"], pert_form)
navnecelle = tekst(navn) + r"\newline \textit{Enhet:} " + tekst(enhet)
if ligninger:
navnecelle += r". \textit{Brukes i:} " + tekst(ligninger)
celler = [
tex_symbol(symbol) + r"\newline " + tex_id(pid),
navnecelle,
celle,
tekst(status),
tex_poster(poster),
]
deler = []
if kildeverdi:
deler.append(r"\textit{Kildeverdi:} " + tekst(kildeverdi))
if merknad:
deler.append(r"\textit{Merknad:} " + tekst(merknad))
if tabell:
deler.append(r"\textit{Verdi:}\newline " + tabell[0])
if not deler:
return [" & ".join(celler) + r" \\", r"\addlinespace[3pt]"]
# The row and the first line under it stay on one page; the rest of a table value has one
# table row per line, so that a long table can break across pages.
return [
" & ".join(celler) + r" \\*",
"& " + UNDERLINJE + "{" + r"\newline ".join(deler) + r"} \\",
*("& " + UNDERLINJE + "{" + linje + r"} \\" for linje in tabell[1:]),
r"\addlinespace[3pt]",
]
def sjekksum_registrert(forhaandsreg: str) -> str:
"""The last SHA-256 stated under «Parameterfrys» in the pre-registration."""
_, funnet, etter = forhaandsreg.partition("\n## Parameterfrys\n")
if not funnet:
msg = "the pre-registration has no section «Parameterfrys»"
raise ParameterError(msg)
seksjon = etter.split("\n## ", 1)[0]
summer = SJEKKSUM.findall(seksjon)
if not summer:
msg = "no SHA-256 under «Parameterfrys» in the pre-registration"
raise ParameterError(msg)
return str(summer[-1])
def _uten_dubletter(par: list[tuple[str, object]]) -> dict[str, object]:
"""A JSON object, refusing a key that stands twice (json would keep the last silently)."""
d: dict[str, object] = {}
for k, v in par:
if k in d:
msg = f"the key {k!r} stands twice in one object"
raise ParameterError(msg)
d[k] = v
return d
def _hent(d: dict[str, object], k: str) -> object:
if k not in d:
msg = f"the file has no field {k!r}"
raise ParameterError(msg)
return d[k]
def lag(raa: bytes, forhaandsreg: str) -> str:
"""Return the LaTeX of the appendix."""
sjekksum = hashlib.sha256(raa).hexdigest()
registrert = sjekksum_registrert(forhaandsreg)
if sjekksum != registrert:
msg = (
f"the checksum of the file ({sjekksum}) is not the one the pre-registration "
f"states under «Parameterfrys» ({registrert})"
)
raise ParameterError(msg)
d = json.loads(raa.decode("utf-8"), object_pairs_hook=_uten_dubletter)
if not isinstance(d, dict):
msg = "the file is not a JSON object"
raise ParameterError(msg)
versjon = _hent(d, "versjon")
statuser = _hent(d, "status")
monte_carlo = _hent(d, "monte_carlo")
foelsomheter = _hent(d, "foelsomheter")
parametere = _hent(d, "parametere")
if not isinstance(versjon, str) or not versjon:
msg = f"the version is not a text: {versjon!r}"
raise ParameterError(msg)
if not isinstance(statuser, dict) or not all(
isinstance(k, str) and isinstance(v, str) for k, v in statuser.items()
):
msg = "the field 'status' is not an object of texts"
raise ParameterError(msg)
if not isinstance(monte_carlo, dict) or not isinstance(monte_carlo.get("pert_form"), int):
msg = "monte_carlo.pert_form is not a whole number"
raise ParameterError(msg)
pert_form = int(monte_carlo["pert_form"])
if not isinstance(parametere, list) or len(parametere) != ANTALL:
msg = f"the file does not hold exactly {ANTALL} parameters"
raise ParameterError(msg)
if (
not isinstance(foelsomheter, list)
or len(foelsomheter) != ANTALL_FOELSOMHETER
or not all(isinstance(s, str) and s for s in foelsomheter)
):
msg = f"the sensitivity list is not {ANTALL_FOELSOMHETER} non-empty texts"
raise ParameterError(msg)
rader = [les_parameter(p, statuser) for p in parametere]
ider = [str(p["id"]) for p in rader]
if len(set(ider)) != len(ider):
msg = "an id stands twice"
raise ParameterError(msg)
antall = {s: sum(1 for p in rader if p["status"] == s) for s in statuser}
deler = [f"{n} med status «{tekst(s)}» ({tekst(statuser[s])})" for s, n in antall.items() if n]
opptelling = "; ".join(deler[:-1]) + " og " + deler[-1] if len(deler) > 1 else deler[0]
sum_tekst = r"\allowbreak{}".join(sjekksum[i : i + 16] for i in range(0, len(sjekksum), 16))
innledning = [
(
rf"\noindent Fila er versjon {tekst(versjon)} og har {len(rader)} parametere, som"
rf" står i tabellen i samme rekkefølge som i fila: {opptelling}. Sjekksummen (SHA-256)"
rf" av fila er \texttt{{{sum_tekst}}}, den samme som forhåndsregistreringen oppgir"
r" under «Parameterfrys» for fila som gjelder nå."
),
"",
(
r"Fordelingen skrives som i kapittel~14 i spesifikasjonen: «fast» med verdien,"
r" «jevn lav \textendash{} høy», «jevn i logaritmen lav \textendash{} høy»,"
rf" «PERT lav / modus / høy» (beta-PERT med formparameter {tall(pert_form)}),"
r" «diskret» med verdiene og vektene, og «lognormal» med median, sigma og grensene den"
r" avkortes ved. En sammensatt parameter har én linje per størrelse. Tall står med alle"
r" sifrene de har i fila, med desimalkomma og tynt mellomrom mellom tusener når"
r" heltallsdelen har fem sifre eller flere; flere verdier skilles med semikolon. Id-er"
r" og nøkler står i skrivemaskinskrift slik de står i fila. Under raden står"
r" kildeverdien (kildens tall i kildens egen enhet), merknaden og en fast verdi som er"
r" en tabell, når fila har dem."
r" En strek for symbol eller poster betyr at fila ikke har noe der; som enhet betyr den"
r" at størrelsen er uten enhet."
),
]
ut = [
"% Laget av rapport/lag_vedlegg_parametere.py fra modell/parametere.json.",
"% Rettes ikke for hånd: kjør skriptet på nytt.",
*innledning,
"",
r"{\footnotesize",
r"\setlength{\tabcolsep}{4pt}",
r"\renewcommand{\arraystretch}{1.12}",
r"\begin{xltabular}{\linewidth}{" + KOLONNER + "}",
r"\caption{Parameterne i parameterfila, versjon " + tekst(versjon) + r". Kildeverdien,"
r" merknaden og verdier som er tabeller, står i linja under parameteren.}"
r"\label{tab:parametere}\\",
r"\toprule",
HODE,
r"\midrule",
r"\endfirsthead",
r"\toprule",
HODE,
r"\midrule",
r"\endhead",
r"\bottomrule",
r"\endfoot",
]
for p in rader:
ut += rad(p, pert_form)
ut += [r"\end{xltabular}", "}", ""]
ut += [
(
r"\noindent Parameterfila låser også lista over følsomheter."
rf" \Cref{{tab:folsomhetsliste}} gjengir den ordrett, {len(foelsomheter)} linjer,"
r" nummerert i den rekkefølgen de står i fila."
),
"",
r"{\footnotesize",
r"\setlength{\tabcolsep}{4pt}",
r"\renewcommand{\arraystretch}{1.12}",
r"\begin{xltabular}{\linewidth}{@{}P{8mm}L@{}}",
(
r"\caption{Den frosne følsomhetslista i parameterfila, ordrett.}"
r"\label{tab:folsomhetsliste}\\"
),
r"\toprule",
r"Linje & Følsomhet \\",
r"\midrule",
r"\endfirsthead",
r"\toprule",
r"Linje & Følsomhet \\",
r"\midrule",
r"\endhead",
r"\bottomrule",
r"\endfoot",
]
ut += [f"{i} & {tekst(s)} \\\\" for i, s in enumerate(foelsomheter, start=1)]
ut += [r"\end{xltabular}", "}", ""]
return "\n".join(ut)
def main() -> int:
"""Write the appendix; return 0, or 1 with a message on error."""
try:
tekst_ut = lag(PARAMETERE.read_bytes(), FORHAANDSREG.read_text(encoding="utf-8"))
except (ParameterError, OSError, ValueError) as e:
sys.stderr.write(f"lag_vedlegg_parametere: {e}\n")
return 1
UT.parent.mkdir(exist_ok=True)
UT.write_text(tekst_ut, encoding="utf-8", newline="\n")
sys.stdout.write(f"lag_vedlegg_parametere: skrev {UT.relative_to(ROT)}\n")
return 0
if __name__ == "__main__":
sys.exit(main())