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:
parent
2669759f5a
commit
776325c680
14 changed files with 1524 additions and 199 deletions
|
|
@ -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
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue