tokenfabrikker/tests/test_kjoring.py
Kjell Tore Guttormsen 1a3a2fd5a8
test(kjoring): the median when exactly half the draws cannot be built
And the docstring of the percentile says how it is computed
(clarification 103).

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-13 15:48:11 +01:00

531 lines
23 KiB
Python

"""The run over the draws (chapter 11; clarifications 95 to 103).
Made-up draws only: variants of the made-up set of ``conftest.py``, and invented outcomes per
draw for the verdicts and the timeline. Nothing here says anything about the hypothesis.
The slow nuclear path used below is solution A with reactor deliveries of 100 MW a year: one
facility needs 1 500 MW of reactors, so the facilities start in 2042 and 2057, and a third
does not start within the final year 2060.
"""
from __future__ import annotations
import math
import statistics
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import dommer, eierskap, nivaaisert, skala
from tokenfabrikker import kjoring as kj
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag
from tokenfabrikker.kjoring import Bane, Kjoring, Scenario, Utfall
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.miljo import Kildeverdier
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
NORM = Scenario("normalisering", Knapphet.NORMALISERING)
VARER = Scenario("knapphet varer", Knapphet.VARER)
LAVT = Scenario("lavt", Knapphet.NORMALISERING, "lavt")
SCENARIOER = (VARER, NORM, LAVT)
"""Two price scenarios and one marked scenario of the made-up set."""
EOS = {
"direkte": "består",
"heleid_selskap": "består",
"majoritet_boers": "usikker",
"petroleumsmodell": "består",
}
def _trekninger(oppdiktet: LagInndata) -> list[Inndata]:
"""Four made-up draws: the set itself and three variants."""
return [
oppdiktet(),
oppdiktet(p_v=3000.0),
oppdiktet(n_reaktor=100.0),
oppdiktet(c_H0=150e6, g_fornybar=3e6),
]
# ------------------------------------------------------------------ one draw
def test_utfallene_er_de_samme_som_modulene_gir_hver_for_seg(oppdiktet: LagInndata) -> None:
inn = oppdiktet(p_v=3000.0)
bane = kj.regn_bane(inn, Losning.C, 2, SCENARIOER)
dim = ks.dimensjoner(inn, Losning.C)
plan = ks.lag_plan(inn, Losning.C, dim, N_anlegg=2)
res = ks.regn_program(
inn, Losning.C, plan, Knapphet.NORMALISERING, bortfall=ks.bortfall_i_scenario(inn, "lavt")
)
m6 = skala.skala(inn, res)
u = bane.utfall["lavt"]
assert bane.byggbar
assert u.NNV == res.NNV
assert u.S42 == nivaaisert.kraftkostnad(inn, res, bedrift=True).S42
assert u.M3 == dommer.m3_verste_prisvirkning(inn, res)
assert u.M4 == dommer.m4_forsyning(inn, res)
assert (u.M6, u.M6_snitt, u.M6_median, u.M6_2050, u.M6_topp) == (
m6.M6,
m6.M6_snitt,
m6.M6_median,
m6.M6_2050,
m6.M6_topp,
)
assert (u.stabilt_aar, u.toppaar) == (m6.stabilt_aar, m6.toppaar)
def test_scenarioene_deler_utbyggingen_og_skiller_seg_i_inntekten(oppdiktet: LagInndata) -> None:
bane = kj.regn_bane(oppdiktet(), Losning.C, 2, SCENARIOER)
varer, norm, lavt = (bane.utfall[s.navn] for s in SCENARIOER)
assert varer.NNV > norm.NNV > lavt.NNV
assert varer.M3 == norm.M3 == lavt.M3
assert varer.M4 == norm.M4 == lavt.M4
assert varer.stabilt_aar == norm.stabilt_aar == lavt.stabilt_aar == 2032
assert bane.forste_aar == 2028
# facilities of 1 000 MW start in 2030 and 2032 and are operated for twenty years each:
# both from 2032 to 2049, the second alone in 2050 and 2051, none from 2052 to 2060
assert bane.tidslinje == {
Kraft.NY_FORNYBAR: (0.0,) * 2 + (1000.0,) * 2 + (2000.0,) * 18 + (1000.0,) * 2 + (0.0,) * 9
}
def test_en_bane_som_ikke_lar_seg_bygge_har_ingen_utfall_men_en_tidslinje(
oppdiktet: LagInndata,
) -> None:
inn = oppdiktet(n_reaktor=100.0)
to, tre = (kj.regn_bane(inn, Losning.A, n, SCENARIOER) for n in (2, 3))
assert to.byggbar
assert set(to.utfall) == {s.navn for s in SCENARIOER}
assert not tre.byggbar
assert tre.utfall == {}
# what was built is reported: 1 000 MW from 2042 and 2 000 MW from 2057
linje = tre.tidslinje[Kraft.EGET_KJERNEKRAFTVERK]
assert linje == (0.0,) * 14 + (1000.0,) * 15 + (2000.0,) * 4
assert linje == to.tidslinje[Kraft.EGET_KJERNEKRAFTVERK]
def test_en_bane_uten_aar_med_stabil_drift_har_alt_unntatt_M6(oppdiktet: LagInndata) -> None:
# with ten years of operation the first facility (2042 to 2051) is out before the second starts
bane = kj.regn_bane(oppdiktet(n_reaktor=100.0, L_N=10.0), Losning.A, 2, (NORM,))
u = bane.utfall[NORM.navn]
assert bane.byggbar
assert (u.M6, u.M6_snitt, u.M6_median, u.stabilt_aar) == (None, None, None, None)
assert math.isfinite(u.NNV)
assert math.isfinite(u.S42)
assert math.isfinite(u.M6_topp)
def test_et_tallsett_utbyggingen_avviser_stanser_kjoringen(oppdiktet: LagInndata) -> None:
# one facility of 1 000 MW is not a whole number of modules of 300 MW (clarification 90)
inn = oppdiktet().med({"P_m": 300.0})
with pytest.raises(ValueError, match="whole number of modules"):
kj.kjor([inn], stige=(1,), scenarioer=(NORM,), losninger=(Losning.T_F,))
# ------------------------------------------------------------- over the draws
def test_kjoringen_holder_trekningenes_rekkefolge(oppdiktet: LagInndata) -> None:
trekninger = _trekninger(oppdiktet)
kjoring = kj.kjor(trekninger, stige=(1, 2), scenarioer=SCENARIOER, losninger=(Losning.A,))
assert kjoring.antall == 4
for inn, utfall in zip(trekninger, kjoring.trekninger, strict=True):
assert utfall == kj.regn_trekning(
inn, stige=(1, 2), scenarioer=SCENARIOER, losninger=(Losning.A,)
)
assert [u is not None for u in kjoring.utfall(NORM, Losning.A, 2)] == [True] * 4
assert [b.byggbar for b in kjoring.baner(Losning.A, 2)] == [True] * 4
def test_kjoringen_er_lik_paa_flere_prosesser_og_i_annen_rekkefolge(oppdiktet: LagInndata) -> None:
trekninger = _trekninger(oppdiktet)
losninger = (Losning.A, Losning.C, Losning.T_K)
en = kj.kjor(trekninger, stige=(1, 3), scenarioer=SCENARIOER, losninger=losninger)
to = kj.kjor(trekninger, stige=(1, 3), scenarioer=SCENARIOER, losninger=losninger, prosesser=2)
snudd = kj.kjor(
trekninger, stige=(3, 1), scenarioer=SCENARIOER[::-1], losninger=losninger[::-1]
)
assert en == to
assert en.trekninger == snudd.trekninger
M5 = dict.fromkeys(losninger, Dom.HOLDER)
assert kj.sett_dommer(en, M5) == kj.sett_dommer(to, M5)
a, b = kj.sett_dommer(en, M5), kj.sett_dommer(snudd, M5)
assert a.valg == b.valg
assert a.scenarioer == b.scenarioer
@pytest.mark.parametrize(
("stige", "scenarioer", "losninger"),
[
((1, 1), (NORM,), (Losning.A,)),
((1,), (NORM, NORM), (Losning.A,)),
((1,), (NORM,), (Losning.A, Losning.A)),
((), (NORM,), (Losning.A,)),
],
)
def test_trinn_scenarioer_og_losninger_staar_en_gang_hver(
oppdiktet: LagInndata,
stige: tuple[int, ...],
scenarioer: tuple[Scenario, ...],
losninger: tuple[Losning, ...],
) -> None:
with pytest.raises(ValueError, match="each of them once"):
kj.kjor([oppdiktet()], stige=stige, scenarioer=scenarioer, losninger=losninger)
def test_kjoringen_trenger_en_trekning() -> None:
with pytest.raises(ValueError, match="at least one draw"):
kj.kjor([], stige=(1,), scenarioer=(NORM,), losninger=(Losning.A,))
# ---------------------------------------- the verdicts, on invented outcomes per draw
def _u(
NNV: float = 1.0,
*,
S42: float = 1.0,
M3: float = 0.0,
M4: bool = True,
M6: float | None = 0.3,
) -> Utfall:
return Utfall(
NNV=NNV,
S42=S42,
M3=M3,
M4=Forsyning(ikke_svakere_uten_tiltak=M4, svakere_ogsaa_med_tiltak=not M4),
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,
)
def _bane(utfall: dict[str, Utfall] | None, mw: tuple[float, ...] = ()) -> Bane:
linje = {Kraft.NY_FORNYBAR: mw} if any(mw) else {}
return Bane(byggbar=utfall is not None, forste_aar=2028, tidslinje=linje, utfall=utfall or {})
def _kjoring(
per_trekning: list[dict[tuple[Losning, int], dict[str, Utfall] | None]],
scenarioer: tuple[Scenario, ...] = (NORM, VARER),
) -> Kjoring:
"""A run put together from invented outcomes: ``per_trekning[omega][losning, trinn]``."""
nokler = list(per_trekning[0])
return Kjoring(
stige=tuple(dict.fromkeys(n for _, n in nokler)),
scenarioer=scenarioer,
losninger=tuple(dict.fromkeys(a for a, _ in nokler)),
trekninger=tuple({k: _bane(v) for k, v in t.items()} for t in per_trekning),
)
def _alle(u: Utfall) -> dict[str, Utfall]:
return {NORM.navn: u, VARER.navn: u}
def test_dommene_per_maal_teller_trekninger_som_ikke_lar_seg_bygge_i_nevneren() -> None:
# ten draws: three cannot be built, one can but has no year of stable operation
utfall: list[Utfall | None] = [
None,
None,
None,
_u(-1.0, S42=-1.0, M3=0.2, M4=False, M6=None),
*[_u(2.0, M3=0.05, M6=0.25)] * 6,
]
d = kj.losningsdommer(utfall, Dom.BETINGELSER)
assert {m: x.dom for m, x in d.maal.items()} == dict.fromkeys(
("M1", "M2", "M3", "M4", "M6"), Dom.BETINGELSER
)
for maal in d.maal.values():
assert maal.andel_holder == 0.6
assert maal.ikke_byggbar == 0.3
assert maal.oppfylt_blant_byggbare == pytest.approx(6 / 7)
assert d.maal["M1"].andel_holder_ikke is None
assert d.maal["M2"].andel_holder_ikke is None
assert d.maal["M3"].andel_holder_ikke == 0.1
assert d.maal["M4"].andel_holder_ikke == 0.1
# in M6 a draw without a value does not reach 5 %: three that cannot be built and one without
assert d.maal["M6"].andel_holder_ikke == 0.4
assert d.median_M1 == 2.0
assert d.dommer["M5"] is Dom.BETINGELSER
assert not d.felt
def test_en_losning_er_felt_av_negativ_median_eller_et_maal_som_ikke_holder() -> None:
negativ = kj.losningsdommer([_u(-1.0)] * 3 + [_u(1.0)] * 2, Dom.HOLDER)
assert negativ.maal["M1"].dom is Dom.BETINGELSER
assert negativ.median_M1 == -1.0
assert negativ.felt
assert kj.losningsdommer([_u()] * 5, Dom.HOLDER_IKKE).felt
assert not kj.losningsdommer([_u()] * 5, Dom.HOLDER).felt
# more than half cannot be built: the median ranks below every value
assert kj.losningsdommer([None, None, _u()], Dom.HOLDER).median_M1 == -math.inf
# exactly half cannot be built: the two middle draws are one without a value and one with,
# the median is below every value and the solution cannot carry part I (clarification 103)
halvt = kj.losningsdommer([None, _u(5.0), None, _u(7.0)], Dom.HOLDER)
assert halvt.median_M1 == -math.inf
assert halvt.felt
def test_trinnet_settes_i_normalisering_og_gjelder_alle_scenarioene() -> None:
# C reaches 25 % on step 5 in «normalisering»; in «knapphet varer» it would on step 1
def trekning() -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
return {
(Losning.A, 1): _alle(_u(-1.0, M6=0.01)),
(Losning.A, 5): _alle(_u(-1.0, M6=0.02)),
(Losning.C, 1): {NORM.navn: _u(M6=0.1), VARER.navn: _u(M6=0.4)},
(Losning.C, 5): {NORM.navn: _u(M6=0.3), VARER.navn: _u(M6=0.9)},
# R is not part of the ladder, even where it reaches 25 % on step 1
(Losning.R, 1): _alle(_u(M6=0.5)),
(Losning.R, 5): _alle(_u(M6=0.6)),
}
M5 = dict.fromkeys((Losning.A, Losning.C, Losning.R), Dom.HOLDER)
d = kj.sett_dommer(_kjoring([trekning() for _ in range(5)]), M5)
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_25)
assert d.teller == NORM.navn
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.HOLDER_IKKE)
varer = d.scenarioer[VARER.navn]
assert (varer.del_I, varer.del_II) == (Dom.HOLDER, Dom.HOLDER_IKKE)
assert varer.per_trinn[1][Losning.C].maal["M6"].dom is Dom.HOLDER
assert d.scenarioer[NORM.navn].per_trinn[1][Losning.C].maal["M6"].dom is Dom.BETINGELSER
assert set(varer.per_trinn[5]) == {Losning.A, Losning.C, Losning.R}
assert varer.per_trinn[5][Losning.R].maal["M6"].dom is Dom.HOLDER
assert set(varer.M7) == {1, 5}
assert varer.M7[5].andel_holder == 0.0
def test_del_I_leses_paa_trinnet_fra_normalisering_ogsaa_naar_scenarioet_er_svakere() -> None:
# on the main path A holds on step 2; in the marked scenario its net present value is negative
def trekning() -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
return {
(Losning.A, 1): {NORM.navn: _u(M6=0.2), LAVT.navn: _u(-1.0, M6=0.0)},
(Losning.A, 2): {NORM.navn: _u(M6=0.3), LAVT.navn: _u(-1.0, M6=0.0)},
}
kjoring = _kjoring([trekning() for _ in range(4)], scenarioer=(LAVT, NORM))
d = kj.sett_dommer(kjoring, {Losning.A: Dom.HOLDER})
assert (d.valg.trinn, d.valg.grunnlag) == (2, Grunnlag.TRINN_25)
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.HOLDER)
lavt = d.scenarioer[LAVT.navn]
assert lavt.per_trinn[2][Losning.A].felt
# part II follows M7: A is alone in the run and is best wherever it can be built
assert (lavt.del_I, lavt.del_II) == (Dom.HOLDER_IKKE, Dom.HOLDER)
def test_M7_teller_A_mot_de_som_lar_seg_bygge_og_viser_tallene_for_A() -> None:
# A is best in draws 0, 2 (C cannot be built there) and 4; equal in 1; not built in 3
per_trekning: list[dict[tuple[Losning, int], dict[str, Utfall] | None]] = [
{(Losning.A, 1): _alle(_u(5.0)), (Losning.C, 1): _alle(_u(1.0))},
{(Losning.A, 1): _alle(_u(1.0)), (Losning.C, 1): _alle(_u(1.0))},
{(Losning.A, 1): _alle(_u(-3.0)), (Losning.C, 1): None},
{(Losning.A, 1): None, (Losning.C, 1): _alle(_u(1.0))},
{(Losning.A, 1): _alle(_u(5.0)), (Losning.C, 1): _alle(_u(1.0))},
]
M5 = {Losning.A: Dom.HOLDER, Losning.C: Dom.HOLDER}
d = kj.sett_dommer(_kjoring(per_trekning), M5)
m7 = d.scenarioer[NORM.navn].M7[1]
assert m7.andel_holder == 0.6
assert m7.dom is Dom.HOLDER
assert m7.andel_holder_ikke is None
assert m7.ikke_byggbar == 0.2
assert m7.oppfylt_blant_byggbare == 0.75
# step 1 holds 25 % but a single facility cannot give «holder» for part I
assert (d.valg.trinn, d.del_I, d.del_II) == (1, Dom.BETINGELSER, Dom.HOLDER)
def test_uten_noe_trinn_holder_ikke_del_I_og_del_II_har_ingen_dom() -> None:
# the path is built in half the draws on both steps: no step can be built in 80 %
per_trekning: list[dict[tuple[Losning, int], dict[str, Utfall] | None]] = [
{(Losning.A, 1): _alle(_u()), (Losning.A, 2): _alle(_u())},
{(Losning.A, 1): None, (Losning.A, 2): None},
]
d = kj.sett_dommer(_kjoring(per_trekning), {Losning.A: Dom.HOLDER})
assert (d.valg.trinn, d.valg.grunnlag) == (None, Grunnlag.INGEN)
assert d.del_I is Dom.HOLDER_IKKE
assert d.del_II is None
# M7 is still shown on every step
assert d.scenarioer[NORM.navn].M7[2].andel_holder == 0.5
def test_dommene_trenger_normalisering_paa_hovedforlopet_en_gang() -> None:
kjoring = _kjoring([{(Losning.A, 1): {VARER.navn: _u()}}], scenarioer=(VARER,))
with pytest.raises(ValueError, match="exactly once"):
kj.sett_dommer(kjoring, {Losning.A: Dom.HOLDER})
def test_M5_per_losning_fra_kildenes_tall_og_arealene() -> None:
# invented figures: nuclear power above the lower of wind and hydro in one source
kilder = (Kildeverdier("X", 12.0, 11.0, 24.0, 56.0), Kildeverdier("Y", 5.0, 12.0, 11.0, 16.0))
M5 = kj.dommer_m5(tuple(Losning), kilder, kjernekraft=1.0, vind_direkte=2.0, vind_plan=30.0)
assert M5 == {
Losning.A: Dom.BETINGELSER,
Losning.B: Dom.BETINGELSER,
Losning.B_MERKET: Dom.BETINGELSER,
Losning.C: Dom.HOLDER,
Losning.R: Dom.HOLDER,
Losning.T_F: Dom.HOLDER,
Losning.T_K: Dom.BETINGELSER,
}
bredt = kj.dommer_m5((Losning.A,), kilder, kjernekraft=3.0, vind_direkte=2.0, vind_plan=30.0)
assert bredt == {Losning.A: Dom.HOLDER_IKKE}
def test_dommene_paa_oppdiktede_trekninger_henger_sammen_med_utfallene(
oppdiktet: LagInndata,
) -> None:
trekninger = _trekninger(oppdiktet)
losninger = (Losning.A, Losning.C, Losning.R)
kjoring = kj.kjor(trekninger, stige=(1, 2), scenarioer=SCENARIOER, losninger=losninger)
d = kj.sett_dommer(kjoring, dict.fromkeys(losninger, Dom.HOLDER))
for scenario in SCENARIOER:
for trinn in (1, 2):
for a in losninger:
utfall = kjoring.utfall(scenario, a, trinn)
nnv = [None if u is None else u.NNV for u in utfall]
maal = d.scenarioer[scenario.navn].per_trinn[trinn][a].maal
assert maal["M1"].dom is dommer.dom_m1(nnv)
assert maal["M1"].andel_holder == dommer.andel_positiv(nnv)
assert maal["M1"].ikke_byggbar == 0.0
# nothing in the made-up set reaches 5 % of the petroleum cash flow
assert d.valg.grunnlag is Grunnlag.HOYESTE
assert d.valg.trinn == 2
# ------------------------------------------------- the timeline over the draws
def test_persentilen_er_lineaer_mellom_naboverdiene() -> None:
x = [4.0, 1.0, 3.0, 2.0]
# h = 1 + 3 p: 1.3 gives 1 + 0.3 (2 - 1); 3.7 gives 3 + 0.7 (4 - 3)
assert kj.persentil(x, 0.1) == pytest.approx(1.3)
assert kj.persentil(x, 0.9) == pytest.approx(3.7)
assert kj.persentil(x, 0.5) == statistics.median(x) == 2.5
assert (kj.persentil(x, 0.0), kj.persentil(x, 1.0)) == (1.0, 4.0)
# a whole h is the value itself: five values, p = 0.25 gives the second
assert kj.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.25) == 20.0
assert kj.persentil([7.0], 0.1) == kj.persentil([7.0], 0.9) == 7.0
with pytest.raises(ValueError, match="at least one value"):
kj.persentil([], 0.5)
with pytest.raises(ValueError, match="between 0 and 1"):
kj.persentil([1.0], 10.0)
def test_tidslinjen_over_trekningene_har_med_baner_som_ikke_lar_seg_bygge() -> None:
# five draws, two years; the second and the last path cannot be built
mw = [(0.0, 1000.0), (0.0, 500.0), (100.0, 1000.0), (50.0, 2000.0), (0.0, 0.0)]
byggbar = [True, False, True, True, False]
kjoring = Kjoring(
stige=(1,),
scenarioer=(NORM,),
losninger=(Losning.T_F,),
trekninger=tuple(
{(Losning.T_F, 1): _bane({NORM.navn: _u()} if ok else None, linje)}
for linje, ok in zip(mw, byggbar, strict=True)
),
)
linje = kj.tidslinje_over_trekningene(kjoring, Losning.T_F, 1)
assert set(linje) == {x.value for x in Kraft} | {kj.ALLE_TYPER}
assert linje[kj.ALLE_TYPER] == linje[Kraft.NY_FORNYBAR.value]
forste, andre = linje[kj.ALLE_TYPER]
# 2028: 0, 0, 0, 50, 100: h = 1.4 gives 0, h = 4.6 gives 50 + 0.6 * 50
assert (forste.aar, forste.median) == (2028, 0.0)
assert forste.persentiler == pytest.approx((0.0, 80.0))
assert forste.andel_minst == (0.2, 0.0)
# 2029: 0, 500, 1000, 1000, 2000: h = 1.4 gives 200, h = 4.6 gives 1000 + 0.6 * 1000
assert (andre.aar, andre.median) == (2029, 1000.0)
assert andre.persentiler == pytest.approx((200.0, 1600.0))
assert andre.andel_minst == (0.8, 0.6)
ingen = linje[Kraft.KJERNEKRAFT_PAA_NETTET.value]
assert [(x.median, x.persentiler, x.andel_minst) for x in ingen] == [
(0.0, (0.0, 0.0), (0.0, 0.0))
] * 2
def test_tidslinjen_summerer_typene_av_kraft_i_T_K(oppdiktet: LagInndata) -> None:
trekninger = [oppdiktet(), oppdiktet(g_fornybar=3e6)]
kjoring = kj.kjor(trekninger, stige=(5,), scenarioer=(NORM,), losninger=(Losning.T_K,))
linje = kj.tidslinje_over_trekningene(kjoring, Losning.T_K, 5)
assert [x.aar for x in linje[kj.ALLE_TYPER]] == list(range(2028, 2061))
baner = kjoring.baner(Losning.T_K, 5)
assert all(set(b.tidslinje) == {Kraft.KJERNEKRAFT_PAA_NETTET, Kraft.NY_FORNYBAR} for b in baner)
for j, rad in enumerate(linje[kj.ALLE_TYPER]):
summer = [sum(mw[j] for mw in b.tidslinje.values()) for b in baner]
assert rad.median == statistics.median(summer)
assert rad.andel_minst[1] == sum(s >= 1000.0 for s in summer) / 2
# in the made-up set itself all fifty modules are in operation in 2036: 5 000 MW IT
assert sum(mw[2036 - 2028] for mw in baner[0].tidslinje.values()) == 5000.0
# ----------------------------------------------------------- the ownership forms
def test_eierformene_regnes_paa_trinnet_over_trekningene_som_lar_seg_bygge(
oppdiktet: LagInndata,
) -> None:
trekninger = [oppdiktet(), oppdiktet(p_v=3000.0), oppdiktet(n_reaktor=40.0)]
valg = dommer.Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
tabeller = kj.eierformer_paa_trinnet(
trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A, Losning.C)
)
a, c = tabeller[Losning.A], tabeller[Losning.C]
assert a is not None
assert c is not None
# with 40 MW of reactors a year the second facility of A does not start by 2060
assert (a.antall_byggbare, c.antall_byggbare) == (2, 3)
assert (a.trinn, a.losning) == (2, Losning.A)
assert [k.navn for k in a.kriterier] == list(EOS)
# the same figures as the functions of chapter 8 give one by one
utfall, lcoc = [], []
for inn in trekninger[:2]:
dim = ks.dimensjoner(inn, Losning.A)
plan = ks.lag_plan(inn, Losning.A, dim, N_anlegg=2)
res = ks.regn_program(inn, Losning.A, plan, Knapphet.NORMALISERING, dim=dim)
form = inn.eierformer["majoritet_boers"]
strom = eierskap.bedriftsstrom(inn, res, tilleggsregel=True)
utfall.append(eierskap.eierresultat(inn, strom, form))
lcoc.append(eierskap.lcoc_med_kapitalkostnad(inn, res, eierskap.krav_for_skatt(inn, form)))
assert a.kriterier[2] == eierskap.eierkriterier("majoritet_boers", utfall, lcoc)
assert a.rangering == eierskap.ranger_eierformer(a.kriterier, EOS)
flere = kj.eierformer_paa_trinnet(
trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,), prosesser=2
)
assert flere[Losning.A] == a
def test_eierformene_har_ingen_tabell_uten_trinn_eller_uten_baner(oppdiktet: LagInndata) -> None:
trekninger = [oppdiktet(n_reaktor=40.0)]
uten = dommer.Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN)
assert kj.eierformer_paa_trinnet(trekninger, uten, EOS, scenario=NORM) == dict.fromkeys(
dommer.DOMSLOSNINGER
)
valg = dommer.Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
ingen = kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,))
assert ingen == {Losning.A: None}
with pytest.raises(ValueError, match="main path"):
kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=VARER)
def test_de_seks_scenarioene_og_stigen_er_de_forhaandsregistrerte() -> None:
assert kj.STIGE == (1, 5, 10, 20, 40)
assert [(s.knapphet, s.bortfall is None) for s in kj.SCENARIOER] == [
(Knapphet.VARER, True),
(Knapphet.NORMALISERING, True),
(Knapphet.OVERKAPASITET, True),
(Knapphet.NORMALISERING, False),
(Knapphet.NORMALISERING, False),
(Knapphet.NORMALISERING, False),
]
assert [s.teller for s in kj.SCENARIOER] == [False, True, False, False, False, False]
assert len({s.navn for s in kj.SCENARIOER}) == 6