fix: findings from the independent review

Scenario runner: stops when overridden base parameters leave the start out
of balance (new field startlikevekt: krev, kalibrer, ubalanse); stops on
non-finite results; says that models with a court queue drift slowly even
without a shock and prints the drift before the shock; queue in months of
inflow; never deletes files it did not write; stricter limits.
Check: anchored on the note's own checksums for core and reference files,
runs the scenario files too, exact comparison for the diagnosis, honest
wording when parts were skipped or an extension is broken.
Launcher: unknown field names in input are rejected with a suggestion;
unwritable folders give a message, not a traceback.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-11 15:27:14 +01:00
commit 776325c680
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
14 changed files with 1524 additions and 199 deletions

View file

@ -22,6 +22,7 @@ import importlib.util
import itertools
import json
import math
import os
import re
import sys
from contextlib import contextmanager
@ -87,9 +88,10 @@ SATT_AV_TILTAK = {
("CH2", "xiBfun"): "tiltak.andel_utenom",
}
TOPPFELT = ("navn", "beskrivelse", "merknad", "modell", "styring", "parametere", "regel", "sjokk",
"tiltak", "slutt", "sveip", "utdata", "utvidelse")
SVEIPBARE = ("styring", "parametere", "regel", "sjokk", "tiltak", "slutt", "utvidelse")
TOPPFELT = ("navn", "beskrivelse", "merknad", "modell", "startlikevekt", "styring", "parametere", "regel",
"sjokk", "tiltak", "slutt", "sveip", "utdata", "utvidelse")
STARTVALG = ("krev", "kalibrer", "ubalanse")
SVEIPBARE = ("styring", "parametere", "regel", "sjokk", "tiltak", "slutt", "utvidelse", "startlikevekt")
STYRINGSFELT = ("regulator", "forsinkelse", "reaktivitet", "mpc_kjenner_kjeden")
SJOKKFELT = ("faktor", "fra", "til")
TILTAKSFELT = ("andel_utenom", "kapasitet", "trommel_buffer_tau")
@ -105,6 +107,7 @@ STANDARD_TILTAK_FRA = 24.0 # T_TILTAK i sim.py
STANDARD_TILTAK_OVER = 24.0 # T_UTV i sim.py
STANDARD_SOC_SJOKK = (1.6, 12.0, 36.0) # simulate_soc: shock, t_on, t_off
MAKS_SLUTT = 2400.0
MIN_SLUTT = 1.0 # kjernen trenger minst to tidssteg; én måned er minste meningsfulle horisont
MAKS_KJORINGER = 400
RUTENETT = 2 # høyst to parametere i et sveip
SEN_FASE = 60.0 # spennet i K måles etter denne måneden (som amp(K,t>60) i sim.py)
@ -112,6 +115,11 @@ SNITT_FRA = 12.0 # summary_endo: gjennomsnitt fra måned 12
MAKS_KOLONNER_I_TABELL = 6
CSV_HVERT = 20 # standard: én rad per måned (DT = 0,05)
NOTAT_HVERT = 10 # write_csv i sim.py
LIKEVEKT_TOL = 1e-12 # største tillatte rest i dK/dt ved start (pådraget er om lag 0,12 per måned)
FLYTPARAMETERE = ("gamma", "Lam0", "T0") # gir strømmen J0 = gamma Lam0 T0 som domstolen er kalibrert for
ENDO_FAST_STROM = 0.1 # simulate_endo: observert strøm de første lagD månedene (sim.py:588), fast i kjernen
UTEN_SJOKK_MND = 12.0 # måneden driften vises for når det ikke er noe sjokk (notatets sjokkmåned)
K_OMRADE = (0.01, 12.0) # merknad utenfor: området soc_equilibria i sim.py leter i (notatets K: 0,83-9,82)
class ScenarioFeil(Exception):
@ -156,12 +164,13 @@ GRENSER: dict[tuple[str, str], Grense] = {
("ENDO", "k_xi"): IKKE_NEG, ("ENDO", "tau_xi"): POSITIV, ("ENDO", "ups_star"): POSITIV,
("ENDO", "ups_hi"): POSITIV, ("ENDO", "ups_lo"): IKKE_NEG, ("ENDO", "kZ"): IKKE_NEG,
("ENDO", "L1"): IKKE_NEG, ("ENDO", "L2"): POSITIV, ("ENDO", "tau_down"): POSITIV,
("ENDO", "T_clear"): POSITIV_INF, ("ENDO", "H_pred"): POSITIV, ("ENDO", "period"): POSITIV,
("ENDO", "T_clear"): POSITIV_INF, ("ENDO", "H_pred"): POSITIV, ("ENDO", "period"): Grense(1.0),
("ENDO", "mu3"): IKKE_NEG, ("ENDO", "Lam_star"): APEN_ANDEL, ("ENDO", "k_q"): IKKE_NEG,
("ENDO", "q_max"): IKKE_NEG, ("ENDO", "lag_survey"): IKKE_NEG,
("SOC", "eps"): IKKE_NEG, ("SOC", "Kh"): POSITIV,
}
HELTALLSGRENSER = {("CH2", "c"): (1, 50), ("SOC", "pexp"): (1, 20)}
HELE_MAANEDER = {("ENDO", "period")} # budsjettsyklusen: vedtak når t % period == 0 i hele måneder (sim.py:614)
# --------------------------------------------------------------------------- kjernen
@ -455,6 +464,9 @@ class Kjoring:
tiltak: dict[str, object]
dicts: dict[str, dict[str, object]]
utvidelse: dict[str, object] = field(default_factory=dict)
startlikevekt: str = "krev"
ubalanse: list[str] = field(default_factory=list) # hvorfor starten ikke er en likevekt
kalibrert: list[tuple[str, float, float]] = field(default_factory=list) # (sti, notatets, ny)
@dataclass
@ -545,7 +557,10 @@ def parameterverdi(navn: str, nokkel: str, standard: object, verdi: object, sti:
if isinstance(standard, int):
nedre, ovre = HELTALLSGRENSER.get((navn, nokkel), (-10**9, 10**9))
return heltall(verdi, sti, nedre, ovre)
return tallverdi(verdi, sti, GRENSER.get((navn, nokkel), Grense()))
x = tallverdi(verdi, sti, GRENSER.get((navn, nokkel), Grense()))
if (navn, nokkel) in HELE_MAANEDER and not x.is_integer():
feil(sti, f"må være et helt antall måneder (kjernen gjør vedtak bare i hele måneder), ikke {vis(verdi)}.")
return x
def les_styring(raa: object, modell: str, slutt: float) -> tuple[str, float, float, bool | None]:
@ -553,8 +568,10 @@ def les_styring(raa: object, modell: str, slutt: float) -> tuple[str, float, flo
s = objekt(raa if raa is not None else {}, "styring", STYRINGSFELT)
regulatorer = REGULATORER.get(modell, ("P", "MPC", "fast"))
regulator = tekst(s.get("regulator", "P"), "styring.regulator", regulatorer)
forsinkelse = tallverdi(s.get("forsinkelse", STANDARD_FORSINKELSE), "styring.forsinkelse",
Grense(0.0, ovre=slutt))
forsinkelse = tallverdi(s.get("forsinkelse", STANDARD_FORSINKELSE), "styring.forsinkelse", IKKE_NEG)
if forsinkelse > slutt:
feil("slutt", f"horisonten ({tall_kort(slutt)} mnd) er kortere enn forsinkelsen i styringen "
f"(styring.forsinkelse = {tall_kort(forsinkelse)} mnd). Øk slutt eller kort ned forsinkelsen.")
reaktivitet = tallverdi(s.get("reaktivitet", STANDARD_REAKTIVITET), "styring.reaktivitet",
Grense(0.0, ovre=100.0))
mpc: bool | None = None
@ -725,6 +742,166 @@ def sjekk_kombinasjoner(k: Kjoring, sim: ModuleType, utv: ModuleType | None) ->
sjekk_endo(k)
# --------------------------------------------------------------------------- startlikevekten
def tall_g(x: float) -> str:
"""Et tall med fire gjeldende sifre, norsk desimaltegn."""
return f"{x:.4g}".replace(".", ",")
def oppgitte_nokler(parametere: object) -> dict[str, set[str]]:
"""Nøklene fila setter selv under parametere, per gruppe."""
ut: dict[str, set[str]] = {}
if isinstance(parametere, dict):
for navn, d in parametere.items():
if isinstance(d, dict):
ut[str(navn)] = {str(n) for n in d}
return ut
def paadragsrest(sim: ModuleType, k: Kjoring) -> float:
"""dK/dt ved start (K = 1, Lambda = Lam0, T = T0, før sjokket), regnet med kjernens funksjoner."""
p = k.dicts["P"]
om = tallfelt(p, "Omega0")
if k.modell == "simulate_soc": # kjernen rekalibrerer Omega0 for rekrutteringsleddet (sim.py:455)
s = k.dicts["SOC"]
om = om - tallfelt(s, "eps") * float(sim.hill(1.0, s)) + tallfelt(s, "eps") * float(sim.hill(1.0, s))
fjernet = float(sim.removal(1.0, tallfelt(p, "Lam0"), tallfelt(p, "T0"), p))
return om - fjernet - tallfelt(p, "delta") * 1.0
def strom_j0(p: dict[str, object]) -> float:
"""Strømmen til domstolen ved start slik kjernen kalibrerer den (J0 i sim.py:154, uten eta)."""
return tallfelt(p, "gamma") * tallfelt(p, "Lam0") * tallfelt(p, "T0") * 1.0
class Startfunn(NamedTuple):
"""Det som gjør at starten ikke er en likevekt."""
kan_kalibreres: list[str]
kan_ikke: list[str]
rettinger: list[tuple[str, str, float, float]] # (gruppe, nøkkel, gammel, ny)
def funn_grunnmodell(sim: ModuleType, k: Kjoring, oppgitt: dict[str, set[str]], f: Startfunn) -> None:
"""Pådrag, mål, tak og proporsjonalitet i grunnmodellen."""
p = k.dicts["P"]
rest = paadragsrest(sim, k)
if abs(rest) > LIKEVEKT_TOL:
ny = tallfelt(p, "Omega0") - rest
tekst_ = (f"pådraget Omega0 ({tall_g(tallfelt(p, 'Omega0'))}) er ikke lik det politiets innsats fjerner "
f"pluss det som faller fra av seg selv ved K = 1 ({tall_g(ny)}), så kriminaliteten ville "
"drevet bort fra 1,00 også uten sjokk")
if "Omega0" in oppgitt.get("P", set()):
f.kan_ikke.append(tekst_ + " (Omega0 er satt i fila)")
else:
f.kan_kalibreres.append(tekst_)
f.rettinger.append(("P", "Omega0", tallfelt(p, "Omega0"), ny))
t0, kstar = tallfelt(p, "T0"), tallfelt(p, "Kstar")
regel_virker = k.regulator == "MPC" or (k.regulator == "P" and k.reaktivitet > 0)
if regel_virker and kstar != 1.0:
f.kan_ikke.append(f"målet Kstar er {tall_g(kstar)}, ikke 1, så styringen flytter innsatsen bort fra T0 "
"allerede ved start")
if k.regulator != "fast" and t0 > tallfelt(p, "Tmax"):
f.kan_ikke.append(f"T0 ({tall_g(t0)}) er over taket Tmax ({tall_g(tallfelt(p, 'Tmax'))})")
if t0 > tallfelt(p, "Tprop") * 1.0:
f.kan_ikke.append(f"T0 ({tall_g(t0)}) er over Tprop ({tall_g(tallfelt(p, 'Tprop'))}) ganger K, så "
"innsatsen regnes som uforholdsmessig og tilliten faller fra start")
def funn_domstol(sim: ModuleType, k: Kjoring, navn: str, oppgitt: dict[str, set[str]], f: Startfunn) -> None:
"""Domstolens kapasitet og behandlingstid mot strømmen ved start (CH0 eller CH2)."""
p, ch = k.dicts["P"], k.dicts[navn]
if tallfelt(p, "eta") != 1.0:
f.kan_ikke.append(f"eta er {tall_g(tallfelt(p, 'eta'))}, men kjernen regner strømmen til domstolen ved "
"start uten eta (init_chain og simulate_chain2 i sim.py), så køen starter ikke i balanse")
j0 = strom_j0(p)
if j0 <= 0:
f.kan_ikke.append("strømmen til domstolen er 0 ved start (gamma, Lam0 eller T0 er 0), så domstolen kan "
"ikke kalibreres")
return
satt = oppgitt.get(navn, set())
flyt_endret = any(n in oppgitt.get("P", set()) and p[n] != sim.P[n] for n in FLYTPARAMETERE)
z = tallfelt(ch, "Z")
if flyt_endret and not {"Z", "m"} <= satt:
z_ny = z if "Z" in satt else j0 / float(sim.UPS0)
f.kan_kalibreres.append(
f"domstolens kapasitet og minste behandlingstid ({navn}.Z, {navn}.m) er notatets, regnet for en "
f"strøm på {tall_g(strom_j0(sim.P))} saker per måned, men strømmen er nå {tall_g(j0)}, så "
"kapasitet og saksbehandlingstid passer ikke lenger til strømmen")
if "Z" not in satt:
f.rettinger.append((navn, "Z", z, z_ny))
if "m" not in satt:
f.rettinger.append((navn, "m", tallfelt(ch, "m") if ch["m"] != "kalibrer" else math.nan, math.nan))
z = z_ny
andel = (tallfelt(ch, "xi") if navn == "CH0"
else tallfelt(ch, "piA") * tallfelt(ch, "xiA") + (1 - tallfelt(ch, "piA")) * tallfelt(ch, "xiB"))
if andel * j0 >= z:
f.kan_ikke.append(f"domstolen får {tall_g(andel * j0)} saker per måned ved start, minst like mye som "
f"kapasiteten {navn}.Z = {tall_g(z)}, så køen kan ikke stå i ro")
def kalibrert_m(sim: ModuleType, k: Kjoring, navn: str) -> float:
"""Minste behandlingstid m som gir saksbehandlingstid TAU_REF ved start.
Som MD i sim.py:155, eller calibrate_m for flere spor.
"""
ch, p = k.dicts[navn], k.dicts["P"]
j0, z, tau = strom_j0(p), tallfelt(ch, "Z"), float(sim.TAU_REF)
if navn == "CH2" and ch["c"] != 1:
return float(sim.calibrate_m(dict(ch, m=None), p))
return tau - j0 / (z * (1.0 / tau + tallfelt(ch, "varsigma")))
def startmelding(f: Startfunn, kan_kalibrere: bool) -> str: # noqa: FBT001 - intern hjelper
"""Melding når starten ikke er en likevekt og fila ikke har valgt hva som skal skje."""
grunner = "; ".join([*f.kan_kalibreres, *f.kan_ikke])
ut = (f"startpunktet er ikke en likevekt: {grunner}. Tallene ville da vist en drift som ikke kommer av "
"sjokket eller tiltakene. To veier: ")
if kan_kalibrere:
ut += ('"startlikevekt": "kalibrer" regner referansetilstanden om (' + ", ".join(
f"{g}.{n}" for g, n, _, _ in f.rettinger) + ") slik at startpunktet blir notatets referansetilstand; ")
else:
ut += '"startlikevekt": "kalibrer" kan ikke rette dette (verdiene er satt i fila eller ligger fast); '
return ut + ('"startlikevekt": "ubalanse" kjører fra ubalansen med vilje og viser i sammendraget hvor '
"langt modellen driver før sjokket. Se docs/scenarioformat.md.")
def vurder_start(sim: ModuleType, k: Kjoring, parametere: object) -> None:
"""Stopp, kalibrer eller merk kjøringen når startpunktet ikke er en likevekt ("startlikevekt")."""
oppgitt = oppgitte_nokler(parametere)
f = Startfunn([], [], [])
funn_grunnmodell(sim, k, oppgitt, f)
kjede = next((n for n in ("CH0", "CH2") if n in k.dicts), None)
if kjede is not None and not math.isinf(tallfelt(k.dicts[kjede], "Z")):
funn_domstol(sim, k, kjede, oppgitt, f)
if k.modell == "simulate_endo":
f0 = float(sim.removal(1.0, tallfelt(k.dicts["P"], "Lam0"), tallfelt(k.dicts["P"], "T0"), k.dicts["P"]))
if abs(f0 - ENDO_FAST_STROM) > LIKEVEKT_TOL:
feil("parametere.P", f"simulate_endo i kjernen bruker {tall_g(ENDO_FAST_STROM)} som observert strøm de "
f"første månedene (sim.py:588), men med disse parametrene er strømmen ved start {tall_g(f0)}. Det "
"endrer hva den koordinerte regelen gjør, og kan ikke rettes fra scenariofila. Å endre gamma, "
"Lam0, T0, eta eller ksat i simulate_endo er derfor en endring i kjernen (arbeidskopi og "
"ferdigheten forbedre).")
if not f.kan_kalibreres and not f.kan_ikke:
return
if k.startlikevekt == "krev":
feil("startlikevekt", startmelding(f, kan_kalibrere=not f.kan_ikke))
if k.startlikevekt == "ubalanse":
k.ubalanse = [*f.kan_kalibreres, *f.kan_ikke]
return
if f.kan_ikke:
feil("startlikevekt", '"kalibrer" kan ikke gjøre starten til en likevekt: ' + "; ".join(f.kan_ikke)
+ '. Endre verdiene, eller bruk "startlikevekt": "ubalanse".')
for gruppe, nokkel, gammel, ny in f.rettinger:
verdi = kalibrert_m(sim, k, gruppe) if (gruppe, nokkel) in {("CH0", "m"), ("CH2", "m")} else ny
k.dicts[gruppe][nokkel] = verdi
k.kalibrert.append((f"{gruppe}.{nokkel}", gammel, verdi))
if abs(paadragsrest(sim, k)) > LIKEVEKT_TOL:
feil("startlikevekt", "kalibreringen ga ikke en likevekt; dette er en feil i scenariokjøreren.")
def les_utvidelse(raa: object, utv: ModuleType | None) -> dict[str, object]:
"""Valider utvidelsens parametere mot PARAMETERE (samme type som standardverdien)."""
if utv is None:
@ -766,7 +943,7 @@ def los_opp(sim: ModuleType, raa: dict[str, object], modell: str, utv: ModuleTyp
variant: Variant) -> Kjoring:
"""Valider én variant av scenariofila og lag en kjøring."""
objekt(raa, "", TOPPFELT)
slutt = tallverdi(raa.get("slutt", float(sim.TEND)), "slutt", Grense(0.0, nedre_med=False, ovre=MAKS_SLUTT))
slutt = tallverdi(raa.get("slutt", float(sim.TEND)), "slutt", Grense(MIN_SLUTT, ovre=MAKS_SLUTT))
regel = les_regel(raa, modell)
regulator, forsinkelse, reaktivitet, mpc = les_styring(raa.get("styring"), modell, slutt)
dicts = les_parametere(sim, raa.get("parametere"), parameterdicts(sim, modell, utv), modell)
@ -781,6 +958,8 @@ def los_opp(sim: ModuleType, raa: dict[str, object], modell: str, utv: ModuleTyp
mpc_kjenner_kjeden=mpc, regel=regel, slutt=slutt, sjokk=sjokk,
tiltak=les_tiltak(raa.get("tiltak"), modell, regel), dicts=dicts,
utvidelse=les_utvidelse(raa.get("utvidelse"), utv))
k.startlikevekt = tekst(raa.get("startlikevekt", "krev"), "startlikevekt", STARTVALG)
vurder_start(sim, k, raa.get("parametere"))
sjekk_kombinasjoner(k, sim, utv)
return k
@ -1008,7 +1187,9 @@ def kjor(sim: ModuleType, k: Kjoring, utv: ModuleType | None) -> Resultat:
mpc_knows_chain=bool(k.mpc_kjenner_kjeden)))
avledet_kjede(sim, ch, raa)
elif k.modell == "simulate_chain2":
raa = dict(sim.simulate_chain2(tau, bygg_tiltak(k, "CH2", k.dicts["CH2"]), p=p, kp=kp))
ch2 = bygg_tiltak(k, "CH2", k.dicts["CH2"])
raa = dict(sim.simulate_chain2(tau, ch2, p=p, kp=kp))
avledet_kjede2(ch2, raa)
elif k.modell == "simulate_soc":
raa = fra_tuppel(sim.simulate_soc(k.regulator, tau, p, s=k.dicts["SOC"], kp=kp,
shock=k.sjokk["faktor"], t_on=k.sjokk["fra"],
@ -1031,6 +1212,20 @@ def avledet_kjede(sim: ModuleType, ch: dict[str, object], raa: dict[str, object]
raa["Z_rel"] = z / tallfelt(ch, "Z")
def avledet_kjede2(ch2: dict[str, object], raa: dict[str, object]) -> None:
"""Kapasitet og andelen av alle saker som går til domstolen over tid i simulate_chain2 (som court2)."""
t = raa["t"]
if not isinstance(t, np.ndarray):
return
zfun, xibfun = ch2.get("Zfun"), ch2.get("xiBfun")
z = np.array([float(zfun(float(x))) if callable(zfun) else tallfelt(ch2, "Z") for x in t])
xib = np.array([float(xibfun(float(x))) if callable(xibfun) else tallfelt(ch2, "xiB") for x in t])
pia = tallfelt(ch2, "piA")
raa["Z"] = z
raa["Z_rel"] = z / tallfelt(ch2, "Z")
raa["xi"] = pia * tallfelt(ch2, "xiA") + (1.0 - pia) * xib
def del_opp(raa: dict[str, object], k: Kjoring) -> Resultat:
"""Skill tidsserier, skalarer og logg."""
t = raa.get("t")
@ -1052,13 +1247,19 @@ def del_opp(raa: dict[str, object], k: Kjoring) -> Resultat:
def kjor_trygt(sim: ModuleType, k: Kjoring, utv: ModuleType | None) -> Resultat:
"""Som kjor, men regnefeil i kjernen blir en norsk melding (exit-kode 2)."""
hvem = f" ({kolonneoverskrift(k, 1)})" if k.sveipverdier else ""
try:
return kjor(sim, k, utv)
r = kjor(sim, k, utv)
except (ArithmeticError, ValueError) as e:
hvem = f" ({kolonneoverskrift(k, 1)})" if k.sveipverdier else ""
melding = (f"Kjøringen{hvem} stoppet i kjernen: {e}. Parameterkombinasjonen gir trolig ingen "
"likevekt ved start eller en løsning som vokser over alle grenser.")
"likevekt ved start eller en løsning som vokser over alle grenser. Ingenting er skrevet.")
raise ScenarioFeil(melding) from None
ikke_tall = [navn for navn, v in r.serier.items() if not np.all(np.isfinite(v))]
if ikke_tall:
melding = (f"Kjøringen{hvem} ga verdier som ikke er endelige tall (uendelig eller NaN) i "
f"{', '.join(ikke_tall)}: løsningen har vokst over alle grenser. Ingenting er skrevet.")
raise ScenarioFeil(melding)
return r
# --------------------------------------------------------------------------- nøkkeltall
@ -1115,16 +1316,17 @@ def tall_innsats_tillit(n: Nokkeltall, s: dict[str, Arr]) -> None:
n.legg("L_slutt", "Tillit, ved slutt", s["L"][-1], 3)
def tall_kjede(n: Nokkeltall, s: dict[str, Arr], endo: bool) -> None: # noqa: FBT001 - intern hjelper
"""Saksbehandlingstid, kø og strøm i kjeden (summary, summary2)."""
def tall_kjede(n: Nokkeltall, s: dict[str, Arr], endo: bool, j0: float) -> None: # noqa: FBT001 - intern hjelper
"""Saksbehandlingstid, kø og strøm i kjeden (summary, summary2). Køen i måneder av strømmen J0."""
for navn, tekst_ in (("tauD", "Saksbehandlingstid i domstolen"), ("tauA", "Saksbehandlingstid klasse A"),
("tauB", "Saksbehandlingstid klasse B")):
if navn in s:
n.legg(f"{navn}_maks", f"{tekst_}, lengste (mnd)", s[navn].max(), 1)
n.legg(f"{navn}_slutt", f"{tekst_}, ved slutt (mnd)", s[navn][-1], 1)
for navn in ("Q", "QA", "QB"):
for navn, hva in (("Q", "Kø i domstolen"), ("QA", "Kø klasse A"), ("QB", "Kø klasse B")):
if navn in s:
n.legg(f"{navn}_slutt", f"Kø {navn}, ved slutt", s[navn][-1], 2)
n.legg(f"{navn}_slutt_mnd", f"{hva} ved slutt (mnd innstrømning før sjokket)",
float(s[navn][-1]) / j0 if j0 > 0 else None, 1)
if "JD" in s and "RD" in s and not endo:
rd = float(s["RD"][-1])
n.legg("inn_ut_slutt", "Saker inn / avgjort, ved slutt", float(s["JD"][-1]) / rd if rd > 0 else None, 2)
@ -1146,7 +1348,7 @@ def tall_endo(n: Nokkeltall, s: dict[str, Arr], ch: dict[str, object], p: dict[s
"""Frafall og kapasitetsår (summary_endo; frafallet i måneder av innstrømningen, som i notatets tabell)."""
t = s["t"]
z0 = tallfelt(ch, "Z")
j0 = tallfelt(p, "gamma") * tallfelt(p, "Lam0") * tallfelt(p, "T0") # J0 i sim.py
j0 = strom_j0(p)
n.legg("frafall", "Frafall fra køen, i måneder av innstrømningen før sjokket",
float(np.trapezoid(tallfelt(ch, "varsigma") * s["Q"], t)) / j0 if j0 > 0 else None, 1)
n.legg("kapasitetsaar", "Kapasitetsår over utgangsnivået",
@ -1161,7 +1363,7 @@ def nokkeltall(r: Resultat, k: Kjoring) -> list[Tall]:
if "K" in s:
tall_krim(n, s, endo)
tall_innsats_tillit(n, s)
tall_kjede(n, s, endo)
tall_kjede(n, s, endo, strom_j0(k.dicts["P"]))
tall_tiltak(n, s)
if endo and "Z" in s and "Q" in s:
tall_endo(n, s, k.dicts["CH0"], k.dicts["P"])
@ -1308,6 +1510,16 @@ def hode(u: Utfall) -> list[str]:
linjer += ["", ("Parametrene er notatets stiliserte verdier (tabell 3 i notatet), ikke kalibrert på norske "
f"data, unntatt det scenariofila setter selv: {valgt}. Tallene viser modellens dynamikk, "
"ikke prognoser."), ""]
kalibrert = [(k, k.kalibrert) for k in sc.kjoringer if k.kalibrert]
if kalibrert:
linjer += [('Referansetilstanden er kalibrert på nytt ("startlikevekt": "kalibrer"): pådraget og domstolen '
"er regnet om som i notatets kalibrering, for de nye verdiene:"), ""]
for k, endr in kalibrert:
hvem = f"{kolonneoverskrift(k, len(sc.sveip))}: " if sc.sveip else ""
linjer.append("- " + hvem + "; ".join(
f"{sti} {tall_g(ny)}" + ("" if math.isnan(gammel) else f" (var {tall_g(gammel)})")
for sti, gammel, ny in endr))
linjer.append("")
return linjer
@ -1325,14 +1537,130 @@ def vedtakslinjer(u: Utfall) -> list[str]:
return linjer
def sjokkstart(k: Kjoring, r: Resultat) -> float | None:
"""Måneden sjokket (eller pådraget fra utvidelsen) begynner; None uten sjokk."""
s = r.serier
if k.modell == "simulate_soc":
return k.sjokk["fra"] if k.sjokk["faktor"] != 1.0 else None
if "Omega_faktor" in s:
endret = np.flatnonzero(s["Omega_faktor"] != 1.0)
return float(s["t"][endret[0]]) if endret.size else None
p = k.dicts["P"]
return tallfelt(p, "t_shock") if tallfelt(p, "shock") != 1.0 else None
def drift_maaned(k: Kjoring, r: Resultat) -> float:
"""Måneden driften før sjokket vises for: sjokkets start, eller måned 12 uten sjokk (høyst slutt)."""
m = sjokkstart(k, r)
return min(UTEN_SJOKK_MND if m is None else m, k.slutt)
def har_ko(r: Resultat) -> bool:
"""Sann for modeller med kø i domstolen (simulate_chain, simulate_chain2, simulate_endo, utvidelse med kjede)."""
return "Q" in r.serier or "QA" in r.serier
def driftlinje(k: Kjoring, r: Resultat, dt: float, antall_sveip: int, *, med_grunner: bool) -> str:
"""Hvor langt en kjøring har drevet fra start til sjokket (ubalanse, eller kø i domstolen)."""
s = r.serier
m = drift_maaned(k, r)
i = min(round(m / dt), len(s["t"]) - 1)
deler = [f"{hva} fra {tall(float(s[navn][0]), d)} til {tall(float(s[navn][i]), d)}"
for navn, hva, d in (("K", "K", 3), ("T", "innsatsen T", 2), ("L", "tilliten", 3),
("tauD", "saksbehandlingstiden (mnd)", 1), ("tauA", "tiden i klasse A (mnd)", 1),
("tauB", "tiden i klasse B (mnd)", 1))
if navn in s]
hvem = f"{kolonneoverskrift(k, antall_sveip)}: " if antall_sveip else ""
grunner = f"{'; '.join(k.ubalanse)}. " if med_grunner else ""
deler[0] = deler[0].replace(" fra ", " gått fra ", 1)
return f"- {hvem}{grunner}Fram til måned {tall_kort(m)} har " + ", ".join(deler) + "."
KO_DRIFT = ("I modeller med kø i domstolen er dette nesten, men ikke helt, en likevekt: det som faller fra køen, "
"blir aldri fjernet fra kriminaliteten, så K og saksbehandlingstiden kryper sakte oppover også uten sjokk.")
def ko_driftlinjer(u: Utfall, kjoringer: list[tuple[Kjoring, Resultat]]) -> list[str]:
"""Driften før sjokket i kjøringer med kø som starter i notatets referansetilstand."""
med_sjokk = [(k, r) for k, r in kjoringer if (sjokkstart(k, r) or 0.0) > 0.0]
uten = len(med_sjokk) < len(kjoringer)
linjer: list[str] = []
if med_sjokk:
linjer += ["", "Slik har modellen drevet før sjokket:", ""]
linjer += [driftlinje(k, r, u.dt, len(u.sc.sveip), med_grunner=False) for k, r in med_sjokk]
if uten:
linjer += ["", ("Uten sjokk (eller med sjokk fra måned 0) kryper modellen med kø sakte oppover av seg selv; en "
'kjøring uten sjokk ("sjokk": {"faktor": 1}) viser hvor mye.')]
return linjer
def forklaring(u: Utfall) -> list[str]:
"""Hvordan tallene leses; byttes ut når starten ikke er en likevekt."""
k0 = u.sc.kjoringer[0]
lam0 = {tallfelt(k.dicts["P"], "Lam0") for k in u.sc.kjoringer}
tillit = f"tilliten er {tall(lam0.pop(), 2)} der" if len(lam0) == 1 else "tilliten er Lam0 der"
ko = any(har_ko(r) for r in u.resultater)
resten = ("Kapasitet: 1,00 er kapasiteten ved start. Tider i måneder."
+ (f" Køen er målt i måneder av innstrømningen til domstolen før sjokket (J0 = "
f"{tall_g(strom_j0(k0.dicts['P']))} i modellens enheter); i datafilene står køen i modellens "
"enheter." if ko else ""))
alle = list(zip(u.sc.kjoringer, u.resultater))
skjeve = [(k, r) for k, r in alle if k.ubalanse]
rette_med_ko = [(k, r) for k, r in alle if not k.ubalanse and har_ko(r)]
if not skjeve and not ko:
return [(f"Slik leses tallene: 1,00 er nivået i referanselikevekten før sjokket for kriminaliteten K og "
f"politiets innsats T; {tillit}. {resten}")]
if not skjeve:
return [(f"Slik leses tallene: 1,00 er nivået ved start for kriminaliteten K og politiets innsats T "
f"(notatets referansetilstand); {tillit}. {KO_DRIFT} {resten}"), *ko_driftlinjer(u, rette_med_ko)]
like = len({tuple(k.ubalanse) for k, _ in skjeve}) == 1
linjer = [('Slik leses tallene: startpunktet er ikke en likevekt ("startlikevekt": "ubalanse")'
+ (": " + "; ".join(skjeve[0][0].ubalanse) if like else "") + ". Tallene er målt fra "
"startverdiene (K og T er 1,00 ved start), men modellen ville drevet bort fra dem også uten sjokk, "
f"så 1,00 er ikke et nivå den holder seg på. {resten} Slik har modellen drevet før sjokket:"), ""]
linjer += [driftlinje(k, r, u.dt, len(u.sc.sveip), med_grunner=not like) for k, r in skjeve]
if len(skjeve) < len(u.sc.kjoringer):
linjer += ["", ("Kjøringene som ikke er nevnt, starter i notatets referansetilstand." + (f" {KO_DRIFT}" if
rette_med_ko else ""))]
linjer += ko_driftlinjer(u, rette_med_ko) if rette_med_ko else []
return linjer
def merknader(u: Utfall) -> list[str]:
"""Merknader (ikke stopp): K langt utenfor modellens område, og sjokk utenfor horisonten."""
ut: list[str] = []
for k, r in zip(u.sc.kjoringer, u.resultater):
hvem = f" ({kolonneoverskrift(k, len(u.sc.sveip))})" if u.sc.sveip else ""
if "K" in r.serier:
kmax, kmin = float(r.serier["K"].max()), float(r.serier["K"].min())
if kmax > K_OMRADE[1] or kmin < K_OMRADE[0]:
ut.append(f"Kriminaliteten{hvem} går fra {tall(kmin, 3)} til {tall(kmax, 3)}, utenfor området "
f"kjernen selv regner på (K mellom {tall(K_OMRADE[0], 2)} og {tall(K_OMRADE[1], 0)}, der "
"soc_equilibria i sim.py leter etter likevekter; notatets egne kjøringer ligger mellom "
"0,83 og 9,82). Tallene er regnet slik modellen sier, men ligningene er ikke laget for "
"så store utslag.")
if k.modell == "simulate_soc":
if k.sjokk["fra"] >= k.slutt:
ut.append(f"Sjokket{hvem} begynner i måned {tall_kort(k.sjokk['fra'])}, ikke før slutt "
f"({tall_kort(k.slutt)}): kjøringen viser ingen virkning av det.")
elif k.sjokk["til"] > k.slutt:
ut.append(f"Sjokket{hvem} varer til måned {tall_kort(k.sjokk['til'])}, etter slutt "
f"({tall_kort(k.slutt)}): kjøringen viser ikke at det går over.")
elif k.sjokk and k.sjokk["faktor"] != 1.0 and k.sjokk["fra"] >= k.slutt:
ut.append(f"Sjokket{hvem} kommer i måned {tall_kort(k.sjokk['fra'])}, ikke før slutt "
f"({tall_kort(k.slutt)}): kjøringen viser ingen virkning av det.")
return list(dict.fromkeys(ut))
def sammendrag(u: Utfall) -> str:
"""Teksten i sammendrag.md (og på skjermen)."""
linjer = [*hode(u), "## Nøkkeltall", "", *nokkeltabeller(u.sc, u.alle)]
if len(u.sc.sveip) == RUTENETT:
linjer += matrise(u.sc, u.alle)
linjer.append("Slik leses tallene: 1,00 er nivået i referanselikevekten før sjokket for kriminaliteten K "
"og politiets innsats T; tilliten er 0,80 der. Kapasitet: 1,00 er kapasiteten ved start. "
"Tider i måneder.")
linjer += forklaring(u)
merk = merknader(u)
if merk:
linjer += ["", "## Merknader (kjøringen er ikke stoppet)", "", *(f"- {m}" for m in merk)]
linjer += vedtakslinjer(u)
linjer += ["", "## Filer", ""]
linjer.extend(f"- {navn}: {', '.join(kolonner)}" for navn, kolonner in u.filer)
@ -1378,6 +1706,11 @@ def resultatjson(sim: ModuleType, u: Utfall) -> str:
post["skalarer"] = r.skalarer
if r.logg:
post["vedtak"] = r.logg
post["startlikevekt"] = {
"valg": k.startlikevekt,
"kalibrert": {sti: {"for": gammel, "etter": ny} for sti, gammel, ny in k.kalibrert},
"ubalanse": k.ubalanse,
}
kjoringer.append(post)
forklaring: dict[str, str] = {}
for tallene in u.alle:
@ -1403,33 +1736,64 @@ def resultatjson(sim: ModuleType, u: Utfall) -> str:
return json.dumps(json_verdi(data), ensure_ascii=False, indent=2) + "\n"
EGNE_NOKLER = ("scenario", "scenariofil_sha256", "kjerne_sha256", "kjoringer") # i resultat.json
EGEN_DATAFIL = re.compile(r"[^/\\]+\.(csv|dat)")
def egne_filer(gammel: Path) -> list[str] | None:
"""Filene et tidligere resultat laget, eller None hvis resultat.json ikke er kjørerens."""
try:
data = json.loads(gammel.read_text(encoding="utf-8"))
except (OSError, ValueError):
return None
if not isinstance(data, dict) or not all(n in data for n in EGNE_NOKLER):
return None
kjoringer = data["kjoringer"]
if not isinstance(kjoringer, list):
return None
filer = [str(x.get("fil", "")) for x in kjoringer if isinstance(x, dict)]
return [f for f in filer if EGEN_DATAFIL.fullmatch(f) and f not in {".csv", ".dat"}]
def klargjor_mappe(ut: Path) -> None:
"""Lag mappa; fjern bare filer et tidligere resultat i samme mappe har laget."""
"""Lag mappa; fjern bare datafilene, sammendraget og resultat.json et tidligere resultat laget."""
if ut.exists() and not ut.is_dir():
melding = f"--ut: {ut} finnes og er ikke en mappe."
raise ScenarioFeil(melding)
if ut.exists() and any(ut.iterdir()):
gammel = ut / "resultat.json"
if not gammel.is_file():
melding = (f"--ut: mappa {ut} finnes og har filer som ikke er et tidligere resultat. Velg en "
"annen mappe med --ut.")
filer = egne_filer(ut / "resultat.json")
if filer is None:
melding = (f"--ut: mappa {ut} finnes og har filer som ikke er et tidligere resultat fra "
"scenariokjøreren. Velg en annen mappe med --ut.")
raise ScenarioFeil(melding)
try:
data = json.loads(gammel.read_text(encoding="utf-8"))
filer = [str(x["fil"]) for x in data.get("kjoringer", [])]
except (OSError, ValueError, TypeError, KeyError, AttributeError):
filer = []
for navn in [*filer, "sammendrag.md", "resultat.json"]:
sti = ut / navn
if sti.parent == ut and sti.is_file():
if sti.parent == ut and sti.is_file() and not sti.is_symlink():
sti.unlink()
ut.mkdir(parents=True, exist_ok=True)
def skriv_alt(sim: ModuleType, sc: Scenario, fil: Path, mappe: Path,
resultater: list[Resultat]) -> str:
"""Skriv datafilene, sammendraget og resultat.json. Returnerer sammendraget."""
alle = [nokkeltall(r, k) for r, k in zip(resultater, sc.kjoringer)]
klargjor_mappe(mappe)
filer: list[tuple[str, list[str]]] = []
for k, r in zip(sc.kjoringer, resultater):
navn = filnavn(sc, k)
filer.append((navn, skriv_csv(sim, sc, r, mappe / navn)))
u = Utfall(sc=sc, fil=fil, alle=alle, resultater=resultater, filer=filer, dt=float(sim.DT))
tekst_ = sammendrag(u)
(mappe / "sammendrag.md").write_text(tekst_, encoding="utf-8")
(mappe / "resultat.json").write_text(resultatjson(sim, u), encoding="utf-8")
return tekst_
# --------------------------------------------------------------------------- inngang
BRUK = ("Bruk: python3 modell/kjor.py scenario <fil.json> [--ut <mappe>]\n"
PYTHON = "python" if os.name == "nt" else "python3" # tolken heter python på Windows
BRUK = (f"Bruk: {PYTHON} modell/kjor.py scenario <fil.json> [--ut <mappe>]\n"
"Formatet er beskrevet i docs/scenarioformat.md.")
@ -1468,18 +1832,14 @@ def kjor_scenario(fil: Path, ut: Path | None) -> tuple[str, Path]:
sim = last_kjerne()
mappe = ut if ut is not None else Path.cwd() / "resultater" / slug(sc.navn)
resultater = [kjor_trygt(sim, k, sc.utvidelse) for k in sc.kjoringer]
alle = [nokkeltall(r, k) for r, k in zip(resultater, sc.kjoringer)]
for r in resultater:
kolonner_for(sc, r)
klargjor_mappe(mappe)
filer: list[tuple[str, list[str]]] = []
for k, r in zip(sc.kjoringer, resultater):
navn = filnavn(sc, k)
filer.append((navn, skriv_csv(sim, sc, r, mappe / navn)))
u = Utfall(sc=sc, fil=fil, alle=alle, resultater=resultater, filer=filer, dt=float(sim.DT))
tekst_ = sammendrag(u)
(mappe / "sammendrag.md").write_text(tekst_, encoding="utf-8")
(mappe / "resultat.json").write_text(resultatjson(sim, u), encoding="utf-8")
try:
tekst_ = skriv_alt(sim, sc, fil, mappe, resultater)
except OSError as e:
grunn = e.strerror or str(e)
melding = f"Kan ikke skrive i {mappe}: {grunn}. Velg en annen mappe med --ut."
raise ScenarioFeil(melding) from None
return tekst_, mappe