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>
711 lines
26 KiB
Python
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())
|