feat(verktoy): the command tilleggsfiler writes fordelinger.json and miljo.json

Clarifications 140 (e), 141 and 142. fordelinger.json is read off the run over
the draws; miljo.json has a pass of its own with the same build-out and
programme per scenario, and S32, S53 and S54 from the functions of miljo. None
of the modules behind the six files of the main run is edited. 30 tests on
made-up numbers; not run on the freeze.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-14 09:58:04 +01:00
commit 1c9afbd146
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
3 changed files with 991 additions and 2 deletions

View file

@ -0,0 +1,453 @@
"""The two files made next to the main run: ``fordelinger.json`` and ``miljo.json``.
Chapter 16, clarifications 140 (e), 141 and 142. The six files of the main run
hold shares and medians. ``fordelinger.json`` holds, for the figures, the
percentiles 0 to 100 over the draws of five quantities the verdicts and the
surfaces build on. ``miljo.json`` holds what clarifications 15 and 16 of the
pre-registration require reported per solution and that no other file has:
the life-cycle emissions per year (S32), the emissions "with deduction" (S53)
and cooling water (S54). Neither enters any verdict, and neither belongs to
the six files: ``innhold.json`` and ``kontroll`` are as before, and the
checksums of the two stand in ``tillegg.json``.
``fordelinger.json`` is read off the run over the draws as the main run
computes it (``kjoring.kjor``). ``miljo.json`` needs the programme year by
year, which the run does not keep, so it has a pass of its own: the same
build-out and the same programme per scenario as ``kjoring.regn_bane``, and
from them the series with the functions of ``miljo``. Nothing here computes a
figure of its own beyond the difference U_liv - U_unngaatt (as
``miljo.utslipp_med_fradrag``), the sum over the years and the percentiles
(``dommer.persentil``).
The format and the head are those of ``datafiler``. A value that is not a
finite number stops the command: it is never sorted in or left out silently.
With several processes the draws are shared out and put together in their
order, so the files have the same bytes however many processes there are.
"""
from __future__ import annotations
import hashlib
import json
import math
from concurrent.futures import ProcessPoolExecutor
from dataclasses import dataclass
from typing import TYPE_CHECKING, Final, cast
import numpy as np
from tokenfabrikker import datafiler as df
from tokenfabrikker import dommer as dm
from tokenfabrikker import kjoring as kj
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import miljo
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Callable, Iterable, Mapping, Sequence
from pathlib import Path
import numpy.typing as npt
from tokenfabrikker.datafiler import Json
from tokenfabrikker.grunnlag import Grunnlag
from tokenfabrikker.inndata import Inndata
from tokenfabrikker.kjoring import Kjoring, Scenario
from tokenfabrikker.kontantstrom import Programresultat
Tabell = npt.NDArray[np.float64]
FORDELINGER: Final = "fordelinger.json"
MILJO: Final = "miljo.json"
TILLEGG: Final = "tillegg.json"
TILLEGGSFILER: Final = (FORDELINGER, MILJO)
"""The two files with figures, in the order they are written."""
PROSENTER: Final = tuple(range(101))
"""The percentiles of ``fordelinger.json``, in per cent (clarification 140 e)."""
FORDELTE: Final = ("NNV", "S42", "M3", "M6", "c_snitt")
"""The five quantities of ``fordelinger.json``, by their names in ``kjoring.Utfall``."""
NULLANSLAG: Final = "null"
"""The estimate of u_alt that is zero: U_med is U_liv there, so it is left out (141)."""
VANNSERIER: Final = ("uttak", "uttak_egen_bruk", "forbruk_kjernekraft", "forbruk_hoyst")
"""The four series of cooling water, by their names in ``miljo.Kjolevann``."""
ENHETER: Final = {
"utslipp": "tonn CO2-ekvivalenter per år",
"kjolevann": "m3 per år",
}
class TilleggError(ValueError):
"""The two files cannot be made as asked; the message is shown to the user as it stands."""
# --------------------------------------------------------------- fordelinger.json
def fordeling(verdier: Iterable[float | None], hvor: str) -> dict[str, Json]:
"""The count of the values and their percentiles 0 to 100; no percentiles without a value.
None is a draw without a value. A value that is not a finite number is an error.
"""
tall = [float(v) for v in verdier if v is not None]
ikke_tall = [v for v in tall if not math.isfinite(v)]
if ikke_tall:
msg = (
f"{hvor}: {len(ikke_tall)} values are not finite numbers (the first is {ikke_tall[0]})"
)
raise ValueError(msg)
tall.sort()
return {
"antall": len(tall),
"persentiler": [dm.persentil(tall, p / 100) for p in PROSENTER] if tall else None,
}
def lag_fordelinger(hodet: Mapping[str, Json], kjoring: Kjoring) -> dict[str, Json]:
"""``fordelinger.json`` (clarifications 140 e and 142 c)."""
per_scenario = []
for scenario in kjoring.scenarioer:
per_trinn = []
for n in kjoring.stige:
losninger: dict[str, Json] = {}
for a in kjoring.losninger:
utfall = kjoring.utfall(scenario, a, n)
losninger[a.value] = {
navn: fordeling(
(
None if u is None else cast("float | None", getattr(u, navn))
for u in utfall
),
f"{scenario.navn}, trinn {n}, {a.value}, {navn}",
)
for navn in FORDELTE
}
per_trinn.append({"trinn": n, "losninger": losninger})
per_scenario.append({"navn": scenario.navn, "trinn": per_trinn})
return {
**hodet,
"storrelser": list(FORDELTE),
"prosenter": list(PROSENTER),
"per_scenario": per_scenario,
}
# --------------------------------------------------------------------- miljo.json
def anslagene(trekninger: Sequence[Inndata]) -> tuple[str, ...]:
"""The estimates of u_alt in the order of the table, without zero; the same in every draw."""
if not trekninger:
msg = "the run needs at least one draw"
raise ValueError(msg)
anslag = tuple(navn for navn in trekninger[0].u_alt if navn != NULLANSLAG)
for i, inn in enumerate(trekninger):
if tuple(navn for navn in inn.u_alt if navn != NULLANSLAG) != anslag:
msg = f"draw {i} has other estimates of u_alt than the first draw"
raise ValueError(msg)
return anslag
def aarene(trekninger: Sequence[Inndata]) -> tuple[int, ...]:
"""The years T_0 + 1 to T_s; the same in every draw."""
forste = (trekninger[0].heltall("T0"), trekninger[0].heltall("T_slutt"))
for i, inn in enumerate(trekninger):
if (inn.heltall("T0"), inn.heltall("T_slutt")) != forste:
msg = f"draw {i} has another decision year or final year than the first draw"
raise ValueError(msg)
return tuple(range(forste[0] + 1, forste[1] + 1))
def serienavn(anslag: Sequence[str]) -> tuple[str, ...]:
"""The names of the rows ``miljoserier`` gives, in its order."""
med_fradrag = [f"{navn}.{a}" for a in anslag for navn in ("U_unngaatt", "U_med")]
return ("U_liv", *med_fradrag, *VANNSERIER)
def miljoserier(inn: Inndata, res: Programresultat, anslag: Sequence[str]) -> Tabell:
"""S32, S53 and S54 for one programme: one row per series, one column per year from T_0 + 1.
The rows are U_liv, then U_unngaatt and U_med for each estimate, then the
four series of cooling water (``serienavn``). The year T_0 is left out,
and a value there is an error: nothing is in operation in the decision year.
"""
U_liv = miljo.utslipp_livslop(inn, res)
rader = [U_liv]
for a in anslag:
unngaatt = miljo.unngaatt_utslipp(inn, res, anslag=a)
rader += [unngaatt, U_liv - unngaatt]
vann = miljo.kjolevann(inn, res)
rader += [cast("Tabell", getattr(vann, navn)) for navn in VANNSERIER]
tabell = np.array(rader, dtype=np.float64)
if res.aar[0] != res.plan.T_0 or np.any(tabell[:, 0] != 0.0):
msg = f"{res.losning.value}: a series has a value in the decision year {res.aar[0]}"
raise ValueError(msg)
return tabell[:, 1:]
def programmer(
inn: Inndata, losning: Losning, trinn: int, scenarioer: Sequence[Scenario]
) -> dict[str, Programresultat] | None:
"""The programme per scenario for one solution on one step in one draw; None when unbuildable.
The same build-out and the same programme as ``kjoring.regn_bane`` (clarification 95).
"""
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=trinn)
if not plan.gjennomforbar:
return None
return {
s.navn: ks.regn_program(
inn,
losning,
plan,
s.knapphet,
dim=dim,
bortfall=None if s.bortfall is None else ks.bortfall_i_scenario(inn, s.bortfall),
)
for s in scenarioer
}
def miljo_for_trekning(
inn: Inndata,
losning: Losning,
trinn: int,
scenarioer: Sequence[Scenario],
anslag: Sequence[str],
) -> Tabell | None:
"""The series of every scenario for one path in one draw: scenario, series, year; or None."""
prog = programmer(inn, losning, trinn, scenarioer)
if prog is None:
return None
return np.array([miljoserier(inn, prog[s.navn], anslag) for s in scenarioer], dtype=np.float64)
def _navn_p() -> list[str]:
return [f"p{round(100 * p)}" for p in kj.PERSENTILER]
def _tre(sortert: list[float]) -> tuple[float, ...]:
"""The median and the percentiles of the timeline (clarification 99) of sorted values."""
return (dm.persentil(sortert, 0.5), *(dm.persentil(sortert, p) for p in kj.PERSENTILER))
def serie(stabel: Tabell, hvor: str) -> dict[str, Json]:
"""One series over the draws: ``stabel`` has one row per draw and one column per year.
The sum over the years is taken per draw, as an exactly rounded sum, before
its percentiles. Each year has the median and the percentiles over the draws.
"""
if stabel.ndim != 2 or stabel.shape[0] == 0: # noqa: PLR2004
msg = f"{hvor}: a series needs at least one draw, one row per draw"
raise ValueError(msg)
if not np.all(np.isfinite(stabel)):
msg = f"{hvor}: {int(np.sum(~np.isfinite(stabel)))} values are not finite numbers"
raise ValueError(msg)
navn = ("median", *_navn_p())
summer = sorted(math.fsum(rad) for rad in stabel.tolist())
per_aar = [_tre(np.sort(stabel[:, j]).tolist()) for j in range(stabel.shape[1])]
return {
"sum": dict(zip(navn, _tre(summer), strict=True)),
**{n: [verdier[i] for verdier in per_aar] for i, n in enumerate(navn)},
}
def miljo_for_bane(
per_trekning: Sequence[Tabell | None],
scenarioer: Sequence[Scenario],
anslag: Sequence[str],
hvor: str,
) -> dict[str, dict[str, Json]]:
"""One solution on one step, per scenario: the count and the series over the draws.
``per_trekning`` holds what ``miljo_for_trekning`` gave per draw. Without a
draw where the path can be built, the count is zero and the series are None.
"""
byggbare = [t for t in per_trekning if t is not None]
ut: dict[str, dict[str, Json]] = {}
for i, scenario in enumerate(scenarioer):
if not byggbare:
ut[scenario.navn] = {"antall": 0, "U_liv": None, "med_fradrag": None, "kjolevann": None}
continue
stabel = np.stack([t[i] for t in byggbare])
rader = {
navn: serie(stabel[:, q, :], f"{hvor}, {scenario.navn}, {navn}")
for q, navn in enumerate(serienavn(anslag))
}
ut[scenario.navn] = {
"antall": len(byggbare),
"U_liv": rader["U_liv"],
"med_fradrag": {
a: {navn: rader[f"{navn}.{a}"] for navn in ("U_unngaatt", "U_med")} for a in anslag
},
"kjolevann": {navn: rader[navn] for navn in VANNSERIER},
}
return ut
_DELT: dict[str, tuple[Inndata, ...]] = {}
"""The draws, set once in each process that runs jobs."""
def _sett_trekninger(trekninger: tuple[Inndata, ...]) -> None:
_DELT["trekninger"] = trekninger
@dataclass(frozen=True)
class _Bane:
"""One solution on one step, for the draw with a given number."""
losning: Losning
trinn: int
scenarioer: tuple[Scenario, ...]
anslag: tuple[str, ...]
def __call__(self, nr: int) -> Tabell | None:
return miljo_for_trekning(
_DELT["trekninger"][nr], self.losning, self.trinn, self.scenarioer, self.anslag
)
def lag_miljo(
hodet: Mapping[str, Json],
grunnlag: Grunnlag,
stige: Sequence[int],
scenarioer: Sequence[Scenario],
losninger: Sequence[Losning],
*,
prosesser: int = 1,
) -> dict[str, Json]:
"""``miljo.json`` (clarifications 141 and 142 d): a pass of its own over the draws."""
trekninger = grunnlag.trekninger
anslag = anslagene(trekninger)
aar = aarene(trekninger)
numre = range(len(trekninger))
baner = [_Bane(a, n, tuple(scenarioer), anslag) for a in losninger for n in stige]
per_bane: dict[tuple[Losning, int], dict[str, dict[str, Json]]] = {}
def oppsummer(bane: _Bane, per_trekning: Sequence[Tabell | None]) -> None:
feil = [t.shape for t in per_trekning if t is not None and t.shape[2] != len(aar)]
if feil:
msg = (
f"{bane.losning.value}, step {bane.trinn}: the series do not cover {len(aar)} years"
)
raise ValueError(msg)
per_bane[bane.losning, bane.trinn] = miljo_for_bane(
per_trekning, scenarioer, anslag, f"{bane.losning.value}, trinn {bane.trinn}"
)
if prosesser > 1:
with ProcessPoolExecutor(
max_workers=prosesser, initializer=_sett_trekninger, initargs=(trekninger,)
) as utforer:
for bane in baner:
oppsummer(bane, list(utforer.map(bane, numre)))
else:
_sett_trekninger(trekninger)
for bane in baner:
oppsummer(bane, [bane(nr) for nr in numre])
return {
**hodet,
"aar": list(aar),
"anslag": list(anslag),
"enheter": dict(ENHETER),
"per_scenario": [
{
"navn": s.navn,
"trinn": [
{
"trinn": n,
"losninger": {a.value: per_bane[a, n][s.navn] for a in losninger},
}
for n in stige
],
}
for s in scenarioer
],
}
# ---------------------------------------------------------------------- writing
def _samme_hode(mappe: Path, navn: str, hodet: Mapping[str, Json]) -> None:
"""Stop when a file in the folder is from another run (another basis, ladder or frame)."""
sti = mappe / navn
if not sti.is_file():
return
innhold = cast("dict[str, Json]", json.loads(sti.read_bytes().decode("utf-8")))
if any(innhold.get(felt) != df.rein(verdi) for felt, verdi in hodet.items()):
msg = (
f"{navn} i {mappe} er ikke fra samme kjøring (annet grunnlag, andre trinn eller ramme)"
)
raise TilleggError(msg)
def skriv_tillegg(mappe: Path, hodet: Mapping[str, Json]) -> str:
"""Write ``tillegg.json``: the head and the SHA-256 of the two files that are in the folder."""
sjekksummer: dict[str, Json] = {}
for navn in TILLEGGSFILER:
if (mappe / navn).is_file():
_samme_hode(mappe, navn, hodet)
sjekksummer[navn] = hashlib.sha256((mappe / navn).read_bytes()).hexdigest()
return df.skriv(mappe / TILLEGG, {**hodet, "filer": sjekksummer})
def skriv_tilleggsfiler(
grunnlag: Grunnlag,
mappe: Path,
*,
stige: Sequence[int] = kj.STIGE,
scenarioer: Sequence[Scenario] = kj.SCENARIOER,
losninger: Sequence[Losning] = tuple(Losning),
prosesser: int = 1,
filer: Sequence[str] = TILLEGGSFILER,
laget: Callable[[str], None] | None = None,
) -> tuple[str, ...]:
"""Write the chosen files and ``tillegg.json``; returns the names in the order written.
The head is that of the six files. With ``innhold.json`` in the folder the
head must be the same as there, and so must the head of a file of the two
that is already there; otherwise nothing is computed (clarification 142 a).
"""
ukjent = [f for f in filer if f not in TILLEGGSFILER]
if ukjent or not filer:
msg = f"ukjent fil {', '.join(ukjent)}; filene er {', '.join(TILLEGGSFILER)}"
raise TilleggError(msg)
stige_, scenarioer_, losninger_ = df.ordne(stige, scenarioer, losninger)
hodet = df.hode(grunnlag, stige_, scenarioer_, losninger_)
for navn in (df.INNHOLD, *(f for f in TILLEGGSFILER if f not in filer)):
_samme_hode(mappe, navn, hodet)
skrevet: list[str] = []
def ferdig(navn: str, data: dict[str, Json]) -> None:
df.skriv(mappe / navn, data)
skrevet.append(navn)
if laget is not None:
laget(navn)
if FORDELINGER in filer:
kjoring = kj.kjor(
grunnlag.trekninger,
stige=stige_,
scenarioer=scenarioer_,
losninger=losninger_,
prosesser=prosesser,
)
ferdig(FORDELINGER, lag_fordelinger(hodet, kjoring))
del kjoring
if MILJO in filer:
ferdig(
MILJO, lag_miljo(hodet, grunnlag, stige_, scenarioer_, losninger_, prosesser=prosesser)
)
skriv_tillegg(mappe, hodet)
skrevet.append(TILLEGG)
if laget is not None:
laget(TILLEGG)
return tuple(skrevet)

View file

@ -8,7 +8,9 @@ stored ones (129). ``scenario``, ``folsomhet`` and ``terskel`` are runs of
one's own from an input file in JSON, and ``sammenlign`` compares two folders
that each hold a ``dommer.json`` (130). ``arbeidskopi`` copies the code, the
tests, the parameter file, the draws, the stream, the specification and the
map to a folder the user owns (132).
map to a folder the user owns (132). ``tilleggsfiler`` writes the two files
made next to the main run, ``fordelinger.json`` and ``miljo.json``, with their
checksums in ``tillegg.json`` (140 e, 141, 142); the six files are not touched.
Every command that computes takes the basis from exactly one of
``--grunnlag FIL`` (a made-up basis file) or ``--frys`` (the freeze, with the
@ -37,6 +39,7 @@ from tokenfabrikker import datafiler as df
from tokenfabrikker import folsomheter as fs
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import kjoring as kj
from tokenfabrikker import tilleggsfiler as tf
from tokenfabrikker.parametere import ParameterError
from tokenfabrikker.utbygging import Losning
@ -271,6 +274,27 @@ def kjor_hovedkjoring(valg: argparse.Namespace) -> int:
return 0
def kjor_tilleggsfiler(valg: argparse.Namespace) -> int:
"""``tilleggsfiler``: write ``fordelinger.json`` and ``miljo.json`` (clarification 142)."""
filer = tf.TILLEGGSFILER if valg.filer is None else tuple(valg.filer.split(","))
ukjent = [f for f in filer if f not in tf.TILLEGGSFILER]
if ukjent:
msg = f"--filer: ukjent fil {', '.join(ukjent)}; filene er {', '.join(tf.TILLEGGSFILER)}"
raise InngangsError(msg)
stige = kj.STIGE if valg.stige is None else _stige_fra_tekst(valg.stige)
grunnlag = hent_grunnlag(valg)
skrevet = tf.skriv_tilleggsfiler(
grunnlag,
Path(valg.ut),
stige=stige,
prosesser=valg.prosesser,
filer=filer,
laget=skriv_laget,
)
sys.stdout.write(f"Grunnlaget er merket «{grunnlag.merke}». Skrevet: {', '.join(skrevet)}\n")
return 0
def kjor_kontroll(valg: argparse.Namespace) -> int:
"""``kontroll``: make the six files anew and compare them with the stored ones (129)."""
fasit = Path(valg.fasit)
@ -598,6 +622,12 @@ def tolker() -> argparse.ArgumentParser:
t.add_argument("--stige", metavar="1,5,10")
t.add_argument("--filer", metavar="dommer.json,...")
t.set_defaults(kjor=kjor_hovedkjoring)
t = under.add_parser("tilleggsfiler", help="skriv fordelinger.json og miljo.json")
_grunnlagsvalg(t)
t.add_argument("--ut", required=True, metavar="MAPPE")
t.add_argument("--stige", metavar="1,5,10")
t.add_argument("--filer", metavar="fordelinger.json,miljo.json")
t.set_defaults(kjor=kjor_tilleggsfiler)
t = under.add_parser("kontroll", help="lag filene på nytt og sammenlign med de lagrede")
_grunnlagsvalg(t)
t.add_argument("--fasit", required=True, metavar="MAPPE")
@ -634,7 +664,7 @@ def main(argumenter: Sequence[str] | None = None) -> int:
return 2
try:
return cast("int", valg.kjor(valg))
except (gl.GrunnlagError, InngangsError, ParameterError) as feil:
except (gl.GrunnlagError, InngangsError, ParameterError, tf.TilleggError) as feil:
sys.stderr.write(f"Feil: {feil}\n")
return 2

506
tests/test_tilleggsfiler.py Normal file
View file

@ -0,0 +1,506 @@
"""The two files made next to the main run (chapter 16, clarifications 140 e, 141 and 142).
Invented outcomes and invented series for the builders, the made-up set of ``conftest.py`` for
the series of one programme, and the first three draws of the made-up basis through the
command line. Made-up numbers only; nothing here says anything about the hypothesis.
"""
from __future__ import annotations
import hashlib
import json
import math
from pathlib import Path
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import datafiler as df
from tokenfabrikker import dommer as dm
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import kjoring as kj
from tokenfabrikker import miljo
from tokenfabrikker import tilleggsfiler as tf
from tokenfabrikker import verktoy as vt
from tokenfabrikker.dommer import Forsyning
from tokenfabrikker.kjoring import Bane, Kjoring, Scenario, Utfall
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
from conftest import LagInndata
OPPDIKTET = Path(__file__).resolve().parent / "oppdiktet"
STIGE = (1, 2)
NORM, VARER = kj.SCENARIOER[1], kj.SCENARIOER[0]
LAVT = Scenario("lavt", Knapphet.NORMALISERING, "lavt")
"""A marked scenario of the made-up set of ``conftest.py``."""
X40 = [float(v) for v in range(1, 41)]
HODE: dict[str, object] = {"grunnlag": {"merke": "oppdiktet", "sjekksummer": {}}}
# ------------------------------------------------------------ fordelinger.json
def test_fordelingen_er_antallet_og_persentilene_0_til_100() -> None:
"""Forty values 1..40: h = 39 p, so p10 is 4.9, the median 20.5 and p90 36.1."""
f = tf.fordeling([*reversed(X40), None, None], "x")
assert f["antall"] == 40
p = f["persentiler"]
assert isinstance(p, list)
assert len(p) == 101
assert p[0] == 1.0
assert p[100] == 40.0
assert p[50] == 20.5
assert p[10] == pytest.approx(4.9, rel=1e-15)
assert p[90] == pytest.approx(36.1, rel=1e-15)
assert p == [dm.persentil(X40, k / 100) for k in range(101)]
assert p == sorted(p)
def test_uten_verdier_er_antallet_null_og_ingen_persentiler() -> None:
assert tf.fordeling([None, None], "x") == {"antall": 0, "persentiler": None}
assert tf.fordeling([], "x") == {"antall": 0, "persentiler": None}
def test_en_verdi_gir_den_i_alle_persentilene() -> None:
assert tf.fordeling([None, 7.5], "x") == {"antall": 1, "persentiler": [7.5] * 101}
@pytest.mark.parametrize("verdi", [math.nan, math.inf, -math.inf])
def test_en_verdi_som_ikke_er_et_endelig_tall_stanser(verdi: float) -> None:
with pytest.raises(ValueError, match="A, NNV: 1 values are not finite"):
tf.fordeling([1.0, verdi, 3.0], "A, NNV")
def _u(NNV: float, M6: float | None, c_snitt: float | None = 400.0) -> Utfall:
return Utfall(
NNV=NNV,
S42=2.0 * NNV,
M3=0.01,
M4=Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False),
M6=M6,
M6_snitt=M6,
M6_median=M6,
M6_2050=None,
M6_topp=0.0 if M6 is None else M6,
stabilt_aar=None if M6 is None else 2040,
toppaar=2040,
c_snitt=c_snitt,
)
def _bane(utfall: dict[str, Utfall] | None) -> Bane:
return Bane(
byggbar=utfall is not None,
forste_aar=2028,
tidslinje={Kraft.NY_FORNYBAR: (0.0, 100.0)},
utfall={} if utfall is None else utfall,
)
def _kjoring() -> Kjoring:
"""Forty invented draws: A always built, with M6 in the first 30; B built in the first 15."""
return Kjoring(
stige=(5,),
scenarioer=(VARER, NORM),
losninger=(Losning.A, Losning.B),
trekninger=tuple(
{
(Losning.A, 5): _bane(
{
VARER.navn: _u(100.0 + j, 0.5 if j < 30 else None),
NORM.navn: _u(float(j + 1), 0.25 if j < 30 else None),
}
),
(Losning.B, 5): _bane(
{VARER.navn: _u(-2.0, None, None), NORM.navn: _u(-3.0, None, None)}
if j < 15
else None
),
}
for j in range(40)
),
)
def test_fordelingsfila_har_hver_storrelse_per_scenario_trinn_og_losning() -> None:
fil = tf.lag_fordelinger(HODE, _kjoring())
assert list(fil) == ["grunnlag", "storrelser", "prosenter", "per_scenario"]
assert fil["storrelser"] == ["NNV", "S42", "M3", "M6", "c_snitt"]
assert fil["prosenter"] == list(range(101))
scenarioer = fil["per_scenario"]
assert isinstance(scenarioer, list)
assert [s["navn"] for s in scenarioer] == [VARER.navn, NORM.navn]
norm = scenarioer[1]["trinn"]
assert [t["trinn"] for t in norm] == [5]
a, b = norm[0]["losninger"]["A"], norm[0]["losninger"]["B"]
assert list(norm[0]["losninger"]) == ["A", "B"]
assert list(a) == ["NNV", "S42", "M3", "M6", "c_snitt"]
assert a["NNV"] == tf.fordeling(X40, "x")
assert a["S42"]["persentiler"] == [2.0 * p for p in a["NNV"]["persentiler"]]
assert a["M3"] == {"antall": 40, "persentiler": [0.01] * 101}
assert a["M6"] == {"antall": 30, "persentiler": [0.25] * 101}
assert a["c_snitt"] == {"antall": 40, "persentiler": [400.0] * 101}
assert b["NNV"] == {"antall": 15, "persentiler": [-3.0] * 101}
assert b["M6"] == {"antall": 0, "persentiler": None}
assert b["c_snitt"] == {"antall": 0, "persentiler": None}
assert scenarioer[0]["trinn"][0]["losninger"]["A"]["NNV"]["persentiler"][0] == 100.0
# ----------------------------------------------------------------- miljo.json
def test_en_serie_har_summen_per_trekning_og_persentilene_per_aar() -> None:
"""Five draws and two years. The sums are 11, 22, 33, 44 and 55.
With five values h = 4 p: the median is the third, p10 is x_1 + 0.4 (x_2 - x_1) and p90 is
x_4 + 0.6 (x_5 - x_4).
"""
stabel = np.array([[30.0, 3.0], [10.0, 1.0], [50.0, 5.0], [20.0, 2.0], [40.0, 4.0]])
s = tf.serie(stabel, "x")
assert list(s) == ["sum", "median", "p10", "p90"]
assert s["sum"] == {
"median": 33.0,
"p10": pytest.approx(11.0 + 0.4 * 11.0),
"p90": pytest.approx(44.0 + 0.6 * 11.0),
}
assert s["median"] == [30.0, 3.0]
assert s["p10"] == [pytest.approx(14.0), pytest.approx(1.4)]
assert s["p90"] == [pytest.approx(46.0), pytest.approx(4.6)]
assert s["p10"] == [
dm.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.1),
dm.persentil(X40[:5], 0.1),
]
def test_medianen_av_summen_er_ikke_summen_av_medianene() -> None:
"""Two years that move against each other: every sum is 10, the medians per year are 5."""
stabel = np.array([[1.0, 9.0], [5.0, 5.0], [9.0, 1.0]])
s = tf.serie(stabel, "x")
assert s["sum"] == {"median": 10.0, "p10": 10.0, "p90": 10.0}
assert s["median"] == [5.0, 5.0]
def test_en_serie_med_noe_som_ikke_er_et_tall_stanser() -> None:
with pytest.raises(ValueError, match="x: 1 values are not finite"):
tf.serie(np.array([[1.0, math.nan]]), "x")
with pytest.raises(ValueError, match="at least one draw"):
tf.serie(np.zeros((0, 3)), "x")
def test_serienavnene_folger_anslagene() -> None:
assert tf.serienavn(("hoved", "lav")) == (
"U_liv",
"U_unngaatt.hoved",
"U_med.hoved",
"U_unngaatt.lav",
"U_med.lav",
"uttak",
"uttak_egen_bruk",
"forbruk_kjernekraft",
"forbruk_hoyst",
)
def test_en_bane_over_trekningene_teller_bare_de_som_lar_seg_bygge() -> None:
"""Three draws, one unbuilt; two scenarios, seven series (one estimate), two years."""
anslag = ("hoved",)
def tabell(grunn: float) -> np.ndarray[tuple[int, ...], np.dtype[np.float64]]:
en = np.array([[grunn * (q + 1), grunn * (q + 1) + 1.0] for q in range(7)])
return np.array([en, 10.0 * en])
per_trekning = [tabell(1.0), None, tabell(3.0)]
ut = tf.miljo_for_bane(per_trekning, (VARER, NORM), anslag, "A, trinn 1")
assert list(ut) == [VARER.navn, NORM.navn]
v = ut[VARER.navn]
assert list(v) == ["antall", "U_liv", "med_fradrag", "kjolevann"]
assert v["antall"] == 2
assert v["U_liv"] == {
"sum": {"median": 5.0, "p10": pytest.approx(3.4), "p90": pytest.approx(6.6)},
"median": [2.0, 3.0],
"p10": [pytest.approx(1.2), pytest.approx(2.2)],
"p90": [pytest.approx(2.8), pytest.approx(3.8)],
}
med = v["med_fradrag"]
assert isinstance(med, dict)
assert list(med) == ["hoved"]
assert list(med["hoved"]) == ["U_unngaatt", "U_med"]
assert med["hoved"]["U_unngaatt"]["median"] == [4.0, 5.0]
assert med["hoved"]["U_med"]["median"] == [6.0, 7.0]
vann = v["kjolevann"]
assert isinstance(vann, dict)
assert list(vann) == ["uttak", "uttak_egen_bruk", "forbruk_kjernekraft", "forbruk_hoyst"]
assert vann["uttak"]["median"] == [8.0, 9.0]
assert vann["forbruk_hoyst"]["median"] == [14.0, 15.0]
u_liv_norm = ut[NORM.navn]["U_liv"]
assert isinstance(u_liv_norm, dict)
assert u_liv_norm["median"] == [20.0, 30.0]
def test_uten_en_trekning_som_lar_seg_bygge_er_antallet_null_og_ingen_serier() -> None:
ut = tf.miljo_for_bane([None, None], (NORM,), ("hoved",), "A, trinn 40")
assert ut == {NORM.navn: {"antall": 0, "U_liv": None, "med_fradrag": None, "kjolevann": None}}
@pytest.mark.parametrize("losning", [Losning.A, Losning.C, Losning.T_K])
def test_programmene_er_de_kjoringen_regner(oppdiktet: LagInndata, losning: Losning) -> None:
"""The same build-out and programme as ``kjoring.regn_bane``, also with a loss of demand."""
inn = oppdiktet()
scenarioer = (VARER, NORM, LAVT)
prog = tf.programmer(inn, losning, 2, scenarioer)
bane = kj.regn_bane(inn, losning, 2, scenarioer)
assert prog is not None
assert bane.byggbar
assert list(prog) == [s.navn for s in scenarioer]
for s in scenarioer:
assert prog[s.navn].NNV == bane.utfall[s.navn].NNV
assert prog[LAVT.navn].NNV != prog[NORM.navn].NNV
def test_en_bane_som_ikke_lar_seg_bygge_har_ingen_serier(oppdiktet: LagInndata) -> None:
"""Reactor deliveries of 100 MW a year: the third facility of A does not start by 2060."""
inn = oppdiktet(n_reaktor=100.0)
assert not kj.regn_bane(inn, Losning.A, 3, (NORM,)).byggbar
assert tf.programmer(inn, Losning.A, 3, (NORM,)) is None
assert tf.miljo_for_trekning(inn, Losning.A, 3, (NORM,), ("hoved",)) is None
@pytest.mark.parametrize("losning", [Losning.A, Losning.B, Losning.C, Losning.T_K])
def test_seriene_er_de_miljomodulen_gir(oppdiktet: LagInndata, losning: Losning) -> None:
"""Row by row the functions of ``miljo``, from the year after the decision year."""
inn = oppdiktet()
anslag = tf.anslagene([inn])
assert anslag == ("hoved", "fast")
scenarioer = (NORM, LAVT)
prog = tf.programmer(inn, losning, 2, scenarioer)
assert prog is not None
alle = tf.miljo_for_trekning(inn, losning, 2, scenarioer, anslag)
assert alle is not None
aar = tf.aarene([inn])
assert aar == tuple(range(inn.heltall("T0") + 1, inn.heltall("T_slutt") + 1))
assert alle.shape == (2, 9, len(aar))
for i, s in enumerate(scenarioer):
res = prog[s.navn]
vann = miljo.kjolevann(inn, res)
venter = [
miljo.utslipp_livslop(inn, res),
miljo.unngaatt_utslipp(inn, res, anslag="hoved"),
miljo.utslipp_med_fradrag(inn, res, anslag="hoved"),
miljo.unngaatt_utslipp(inn, res, anslag="fast"),
miljo.utslipp_med_fradrag(inn, res, anslag="fast"),
vann.uttak,
vann.uttak_egen_bruk,
vann.forbruk_kjernekraft,
vann.forbruk_hoyst,
]
assert res.aar[1:] == aar
for q, rad in enumerate(venter):
assert alle[i, q].tolist() == rad[1:].tolist()
assert rad[0] == 0.0
assert float(alle[i, 0].sum()) > 0.0
assert alle[0, 0].tolist() == alle[1, 0].tolist()
assert alle[0, 1].tolist() != alle[1, 1].tolist()
def test_anslagene_og_aarene_maa_vaere_like_i_alle_trekningene(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
with pytest.raises(ValueError, match="draw 1 has another decision year or final year"):
tf.aarene([inn, oppdiktet(T_slutt=2059.0)])
with pytest.raises(ValueError, match="at least one draw"):
tf.anslagene([])
# ------------------------------------------------------------ the command line
@pytest.fixture(scope="module")
def liten(tmp_path_factory: pytest.TempPathFactory) -> Path:
"""A basis file with the first three made-up draws."""
data = json.loads((OPPDIKTET / "grunnlag.json").read_text(encoding="utf-8"))
data["trekninger"] = data["trekninger"][:3]
sti = tmp_path_factory.mktemp("grunnlag") / "grunnlag.json"
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
return sti
@pytest.fixture(scope="module")
def tillegg(liten: Path, tmp_path_factory: pytest.TempPathFactory) -> Path:
"""The two files of the three draws, written on one process through the command line."""
ut = tmp_path_factory.mktemp("tillegg")
assert (
vt.main(["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(ut), "--stige", "1,2"]) == 0
)
return ut
def _les(sti: Path) -> dict[str, object]:
data: dict[str, object] = json.loads(sti.read_text(encoding="utf-8"))
return data
def test_kommandoen_skriver_de_to_filene_og_sjekksummene(tillegg: Path, liten: Path) -> None:
assert sorted(p.name for p in tillegg.iterdir()) == [
"fordelinger.json",
"miljo.json",
"tillegg.json",
]
hode = {
"grunnlag": {
"merke": "oppdiktet",
"sjekksummer": {"grunnlagsfil": hashlib.sha256(liten.read_bytes()).hexdigest()},
},
"antall_trekninger": 3,
"stige": [1, 2],
"scenarioer": [s.navn for s in kj.SCENARIOER],
"losninger": [a.value for a in Losning],
}
assert _les(tillegg / "tillegg.json") == {
**hode,
"filer": {
navn: hashlib.sha256((tillegg / navn).read_bytes()).hexdigest()
for navn in tf.TILLEGGSFILER
},
}
for navn in tf.TILLEGGSFILER:
data = _les(tillegg / navn)
assert {k: data[k] for k in hode} == hode
assert list(data)[:5] == list(hode)
def test_filene_har_formatet_til_de_seks(tillegg: Path) -> None:
for navn in (*tf.TILLEGGSFILER, tf.TILLEGG):
raa = (tillegg / navn).read_bytes()
assert raa.endswith(b"\n")
assert not raa.endswith(b"\n\n")
assert b"\r" not in raa
assert b"\\u" not in raa
assert df.json_tekst(json.loads(raa)).encode("utf-8") == raa
def test_de_seks_filene_er_ikke_blant_de_to() -> None:
assert not set(tf.TILLEGGSFILER) & set(df.ALLE_FILER)
assert tf.TILLEGG not in df.ALLE_FILER
def test_tallene_i_filene_er_de_funksjonene_gir(tillegg: Path, liten: Path) -> None:
g = gl.fra_fil(liten)
kjoring = kj.kjor(g.trekninger, stige=STIGE)
fordelinger = _les(tillegg / "fordelinger.json")
assert fordelinger == json.loads(
df.json_tekst(tf.lag_fordelinger(df.hode(g, STIGE, kj.SCENARIOER, tuple(Losning)), kjoring))
)
miljofil = _les(tillegg / "miljo.json")
assert miljofil["aar"] == list(tf.aarene(g.trekninger))
anslag = tf.anslagene(g.trekninger)
assert anslag == ("hoved", "fast") # the made-up basis; the freeze has the four of 17.4
assert miljofil["anslag"] == list(anslag)
assert miljofil["enheter"] == {
"utslipp": "tonn CO2-ekvivalenter per år",
"kjolevann": "m3 per år",
}
per_scenario = miljofil["per_scenario"]
assert isinstance(per_scenario, list)
assert [s["navn"] for s in per_scenario] == [s.navn for s in kj.SCENARIOER]
for i, scenario in enumerate(kj.SCENARIOER):
assert [t["trinn"] for t in per_scenario[i]["trinn"]] == [1, 2]
for j, n in enumerate(STIGE):
losninger = per_scenario[i]["trinn"][j]["losninger"]
assert list(losninger) == [a.value for a in Losning]
for a in (Losning.A, Losning.T_K):
prog = [tf.programmer(inn, a, n, (scenario,)) for inn in g.trekninger]
byggbare = [
(inn, p[scenario.navn])
for inn, p in zip(g.trekninger, prog, strict=True)
if p is not None
]
celle = losninger[a.value]
assert celle["antall"] == len(byggbare)
assert celle["antall"] == sum(b.byggbar for b in kjoring.baner(a, n))
if not byggbare:
assert celle["U_liv"] is None
continue
U_liv = [miljo.utslipp_livslop(inn, res)[1:] for inn, res in byggbare]
assert celle["U_liv"]["median"] == [
dm.persentil([float(u[k]) for u in U_liv], 0.5) for k in range(len(U_liv[0]))
]
assert celle["U_liv"]["sum"]["median"] == dm.persentil(
[math.fsum(u.tolist()) for u in U_liv], 0.5
)
U_med = [
miljo.utslipp_med_fradrag(inn, res, anslag="fast")[1:] for inn, res in byggbare
]
assert celle["med_fradrag"]["fast"]["U_med"]["p90"] == [
dm.persentil([float(u[k]) for u in U_med], 0.9) for k in range(len(U_med[0]))
]
uttak = [miljo.kjolevann(inn, res).uttak[1:] for inn, res in byggbare]
assert celle["kjolevann"]["uttak"]["p10"] == [
dm.persentil([float(u[k]) for u in uttak], 0.1) for k in range(len(uttak[0]))
]
def test_to_prosesser_gir_de_samme_bytene(tillegg: Path, liten: Path, tmp_path: Path) -> None:
assert (
vt.main(
[
"tilleggsfiler",
"--grunnlag",
str(liten),
"--ut",
str(tmp_path),
"--stige",
"1,2",
"--prosesser",
"2",
]
)
== 0
)
for navn in (*tf.TILLEGGSFILER, tf.TILLEGG):
assert (tmp_path / navn).read_bytes() == (tillegg / navn).read_bytes()
def test_en_fil_om_gangen_gir_de_samme_filene(
tillegg: Path, liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
felles = ["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(tmp_path), "--stige", "1,2"]
assert vt.main([*felles, "--filer", "fordelinger.json"]) == 0
assert sorted(p.name for p in tmp_path.iterdir()) == ["fordelinger.json", "tillegg.json"]
assert list(_les(tmp_path / "tillegg.json")["filer"]) == ["fordelinger.json"] # type: ignore[call-overload]
ut = capsys.readouterr().out
assert ut.splitlines()[:2] == ["Laget fordelinger.json", "Laget tillegg.json"]
assert "Grunnlaget er merket «oppdiktet». Skrevet: fordelinger.json, tillegg.json" in ut
assert vt.main([*felles, "--filer", "miljo.json"]) == 0
for navn in (*tf.TILLEGGSFILER, tf.TILLEGG):
assert (tmp_path / navn).read_bytes() == (tillegg / navn).read_bytes()
def test_en_ukjent_fil_stanser_foer_noe_regnes(
liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
kode = vt.main(
["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(tmp_path), "--filer", "dommer.json"]
)
assert kode == 2
assert "ukjent fil dommer.json" in capsys.readouterr().err
assert not list(tmp_path.iterdir())
def test_en_mappe_fra_en_annen_kjoring_stanser_foer_noe_regnes(
tillegg: Path, liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
"""The folder holds an ``innhold.json`` for another ladder: nothing is computed or written."""
hode = {k: v for k, v in _les(tillegg / "tillegg.json").items() if k != "filer"}
df.skriv(tmp_path / df.INNHOLD, {**hode, "stige": [1, 5], "filer": {}})
foer = sorted(p.name for p in tmp_path.iterdir())
kode = vt.main(
["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(tmp_path), "--stige", "1,2"]
)
assert kode == 2
assert "innhold.json" in capsys.readouterr().err
assert sorted(p.name for p in tmp_path.iterdir()) == foer
with pytest.raises(tf.TilleggError, match=r"miljo\.json"):
tf.skriv_tilleggsfiler(gl.fra_fil(liten), tillegg, stige=(1, 5), filer=(tf.FORDELINGER,))