For every draw the seven solutions on every step of the ladder in six scenarios, with the outcomes the verdicts need; the verdicts per target, the step they are read on, part I and part II; S50 summarised over the draws; and the ownership forms on that step. Tested on made-up draws and invented outcomes only. Written and committed before the independent reader's code was opened. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
526 lines
23 KiB
Python
526 lines
23 KiB
Python
"""The run over the draws (chapter 11; clarifications 95 to 102).
|
|
|
|
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
|
|
|
|
|
|
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
|