A threshold counts when the quantity has a source, its first-order index for the condition is above the chi-square limit, and, for rho_N, the target holds under the condition in each half of the draws by rho_D. For a solution whose conditions can be named, the share of the draws that meets the chosen conditions together is given, and the share of them in which M1 to M4 hold. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
966 lines
43 KiB
Python
966 lines
43 KiB
Python
"""The run over the draws (chapter 11; clarifications 95 to 111).
|
|
|
|
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 dataclasses
|
|
import math
|
|
import statistics
|
|
from typing import TYPE_CHECKING
|
|
|
|
import pytest
|
|
|
|
from tokenfabrikker import dommer, eierskap, nivaaisert, skala, terskler
|
|
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.terskler import Pristerskel, Retning, Rute, Terskel
|
|
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 dommer.persentil(x, 0.1) == pytest.approx(1.3)
|
|
assert dommer.persentil(x, 0.9) == pytest.approx(3.7)
|
|
assert dommer.persentil(x, 0.5) == statistics.median(x) == 2.5
|
|
assert (dommer.persentil(x, 0.0), dommer.persentil(x, 1.0)) == (1.0, 4.0)
|
|
# a whole h is the value itself: five values, p = 0.25 gives the second
|
|
assert dommer.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.25) == 20.0
|
|
assert dommer.persentil([7.0], 0.1) == dommer.persentil([7.0], 0.9) == 7.0
|
|
with pytest.raises(ValueError, match="at least one value"):
|
|
dommer.persentil([], 0.5)
|
|
with pytest.raises(ValueError, match="between 0 and 1"):
|
|
dommer.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
|
|
|
|
|
|
# ------------------------------ thresholds, conditions and indices over the draws
|
|
|
|
|
|
X10 = [float(v) for v in range(1, 11)]
|
|
"""An invented quantity over ten draws: its 10th percentile is 1.9 and its 90th 9.1."""
|
|
|
|
X40 = [float(v) for v in range(1, 41)]
|
|
"""An invented quantity over forty draws: its 10th percentile is 4.9 and its 90th 36.1."""
|
|
|
|
Z40 = [
|
|
float(v)
|
|
for v in (
|
|
*(*range(1, 12), *range(15, 24), *range(28, 36)), # the draws 1 to 28
|
|
*(12, 13, 14, 24, 25, 26, 27, 36, 37, 38, 39, 40), # the draws 29 to 40
|
|
)
|
|
]
|
|
"""A quantity that says next to nothing about an outcome that turns at draw 28."""
|
|
|
|
|
|
def _trekninger_der_A_er_positiv_til_og_med(grense: int, antall: int = 40) -> Kjoring:
|
|
"""Draws of A on step 5: net present value positive in the first ``grense`` of them."""
|
|
return _kjoring(
|
|
[{(Losning.A, 5): _alle(_u(1.0 if j < grense else -1.0))} for j in range(antall)]
|
|
)
|
|
|
|
|
|
def _kjerne(t: Terskel) -> tuple[object, ...]:
|
|
"""A threshold without its index, which is tested in ``test_terskler.py``."""
|
|
return (t.storrelse, t.retning, t.verdi, t.sannsynlighet, t.andel_oppfylt, t.teller)
|
|
|
|
|
|
def test_del_I_avgjores_med_tersklene() -> None:
|
|
"""M1 is positive in 28 of 40 draws: at most 35 of the quantity gives 28 of 35."""
|
|
kjoring = _trekninger_der_A_er_positiv_til_og_med(28)
|
|
M5 = {Losning.A: Dom.HOLDER}
|
|
uten = kj.sett_dommer(kjoring, M5)
|
|
assert uten.del_I is Dom.BETINGELSER
|
|
assert uten.scenarioer[NORM.navn].betingelser is None
|
|
assert not uten.scenarioer[NORM.navn].del_I_avgjort
|
|
|
|
storrelser = {"x": X40, "z": [41.0 - v for v in X40]}
|
|
d = kj.sett_dommer(
|
|
kjoring, M5, storrelser=storrelser, status={"x": "kilde", "z": "åpen forutsetning"}
|
|
)
|
|
norm = d.scenarioer[NORM.navn]
|
|
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_25)
|
|
assert (d.del_I, norm.del_I_avgjort) == (Dom.BETINGELSER, True)
|
|
assert norm.betingelser is not None
|
|
b = norm.betingelser[Losning.A]
|
|
assert (b.felt, b.maal, b.kan_navngis, b.bare_skalaen_mangler) == (False, ("M1",), True, False)
|
|
assert {m: [_kjerne(t) for t in rad] for m, rad in b.terskler.items()} == {
|
|
"M1": [
|
|
("x", Retning.HOYST, 35.0, 0.875, 0.8, True),
|
|
("z", Retning.MINST, 6.0, 0.875, 0.8, False),
|
|
]
|
|
}
|
|
assert [(t.kilde, t.paavist) for t in b.terskler["M1"]] == [(True, True), (False, True)]
|
|
# one target under conditions: taken together it is that one condition
|
|
assert b.samtidig is not None
|
|
assert b.samtidig.valgt == {"M1": b.terskler["M1"][0]}
|
|
assert (b.samtidig.sannsynlighet, b.samtidig.andel_oppfylt) == (0.875, 0.8)
|
|
# the same threshold in a quantity without a source does not count: part I does not hold
|
|
d = kj.sett_dommer(
|
|
kjoring,
|
|
M5,
|
|
storrelser=storrelser,
|
|
status={"x": "modellvalg", "z": "åpen forutsetning"},
|
|
)
|
|
norm = d.scenarioer[NORM.navn]
|
|
assert d.del_I is Dom.HOLDER_IKKE
|
|
assert norm.betingelser is not None
|
|
assert not norm.betingelser[Losning.A].kan_navngis
|
|
assert norm.betingelser[Losning.A].samtidig is None
|
|
assert [t.teller for t in norm.betingelser[Losning.A].terskler["M1"]] == [False, False]
|
|
# and with a quantity that says nothing there is no threshold at all
|
|
d = kj.sett_dommer(kjoring, M5, storrelser={"c": [1.0] * 40}, status={"c": "kilde"})
|
|
assert d.del_I is Dom.HOLDER_IKKE
|
|
norm = d.scenarioer[NORM.navn]
|
|
assert norm.betingelser is not None
|
|
assert norm.betingelser[Losning.A].terskler == {"M1": ()}
|
|
|
|
|
|
def test_en_terskel_uten_paavist_virkning_gir_ingen_betingelse() -> None:
|
|
"""Pre-registration, clarification 22: «at most 35» of z holds, but z has no shown effect."""
|
|
kjoring = _trekninger_der_A_er_positiv_til_og_med(28)
|
|
d = kj.sett_dommer(
|
|
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"z": Z40}, status={"z": "kilde"}
|
|
)
|
|
norm = d.scenarioer[NORM.navn]
|
|
assert norm.betingelser is not None
|
|
b = norm.betingelser[Losning.A]
|
|
(t,) = b.terskler["M1"]
|
|
assert _kjerne(t) == ("z", Retning.HOYST, 35.0, 0.875, 0.8, False)
|
|
assert (t.kilde, t.paavist) == (True, False)
|
|
assert (b.kan_navngis, b.samtidig, d.del_I) == (False, None, Dom.HOLDER_IKKE)
|
|
# with ten draws no effect can be shown, whatever the quantity
|
|
faa = _trekninger_der_A_er_positiv_til_og_med(7, antall=10)
|
|
d = kj.sett_dommer(faa, {Losning.A: Dom.HOLDER}, storrelser={"x": X10}, status={"x": "kilde"})
|
|
assert d.del_I is Dom.HOLDER_IKKE
|
|
|
|
|
|
def test_en_terskel_i_rho_N_teller_ikke_naar_den_baerer_virkningen_av_rho_D() -> None:
|
|
"""Pre-registration, clarification 23, through the run."""
|
|
kjoring = _trekninger_der_A_er_positiv_til_og_med(30)
|
|
M5 = {Losning.A: Dom.HOLDER}
|
|
status = {"rho_N": "kilde", "rho_D": "åpen forutsetning"}
|
|
veksler = [float(j % 2) for j in range(40)]
|
|
d = kj.sett_dommer(kjoring, M5, storrelser={"rho_N": X40, "rho_D": veksler}, status=status)
|
|
assert d.del_I is Dom.BETINGELSER
|
|
d = kj.sett_dommer(kjoring, M5, storrelser={"rho_N": X40, "rho_D": X40}, status=status)
|
|
assert d.del_I is Dom.HOLDER_IKKE
|
|
b = d.scenarioer[NORM.navn].betingelser
|
|
assert b is not None
|
|
assert [(t.storrelse, t.begge_halvdeler) for t in b[Losning.A].terskler["M1"]] == [
|
|
("rho_N", False),
|
|
("rho_D", None),
|
|
]
|
|
|
|
|
|
def test_betingelsene_samtidig() -> None:
|
|
"""Clarification 115 d: M1 fails where x is above 28, M3 where it is below 13.
|
|
|
|
«At most 35» for M1 and «at least 6» for M3 each cover 35 of 40 draws. Together they
|
|
cover the 30 draws from 6 to 35, and M1 to M4 are all met in the 16 from 13 to 28.
|
|
"""
|
|
|
|
def trekning(x: float) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
|
|
return {(Losning.A, 5): _alle(_u(1.0 if x <= 28 else -1.0, M3=0.0 if x >= 13 else 0.1))}
|
|
|
|
kjoring = _kjoring([trekning(x) for x in X40])
|
|
d = kj.sett_dommer(
|
|
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"x": X40}, status={"x": "kilde"}
|
|
)
|
|
b = d.scenarioer[NORM.navn].betingelser
|
|
assert b is not None
|
|
a = b[Losning.A]
|
|
assert (a.maal, a.kan_navngis, d.del_I) == (("M1", "M3"), True, Dom.BETINGELSER)
|
|
assert a.samtidig is not None
|
|
assert {m: _kjerne(t) for m, t in a.samtidig.valgt.items()} == {
|
|
"M1": ("x", Retning.HOYST, 35.0, 0.875, 0.8, True),
|
|
"M3": ("x", Retning.MINST, 6.0, 0.875, 0.8, True),
|
|
}
|
|
assert (a.samtidig.sannsynlighet, a.samtidig.andel_oppfylt) == (0.75, 16 / 30)
|
|
|
|
|
|
def test_betingelser_som_utelukker_hverandre_har_ingen_andel() -> None:
|
|
"""M2 is met up to 14 («at most 17») and M3 from 27 («at least 24»): no draw meets both."""
|
|
|
|
def trekning(x: float) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
|
|
return {(Losning.A, 5): _alle(_u(S42=1.0 if x <= 14 else -1.0, M3=0.0 if x >= 27 else 0.1))}
|
|
|
|
kjoring = _kjoring([trekning(x) for x in X40])
|
|
d = kj.sett_dommer(
|
|
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"x": X40}, status={"x": "kilde"}
|
|
)
|
|
b = d.scenarioer[NORM.navn].betingelser
|
|
assert b is not None
|
|
a = b[Losning.A]
|
|
assert a.samtidig is not None
|
|
assert {m: (t.retning, t.verdi) for m, t in a.samtidig.valgt.items()} == {
|
|
"M2": (Retning.HOYST, 17.0),
|
|
"M3": (Retning.MINST, 24.0),
|
|
}
|
|
assert (a.samtidig.sannsynlighet, a.samtidig.andel_oppfylt) == (0.0, None)
|
|
|
|
|
|
def test_M5_under_betingelser_er_navngitt_og_M6_trenger_ingen_terskel() -> None:
|
|
"""Clarifications 93 and 109: A has M5 and M6 under conditions and no threshold anywhere."""
|
|
kjoring = _kjoring([{(Losning.A, 5): _alle(_u(M6=0.1))} for _ in range(10)])
|
|
d = kj.sett_dommer(
|
|
kjoring, {Losning.A: Dom.BETINGELSER}, storrelser={"x": X10}, status={"x": "kilde"}
|
|
)
|
|
norm = d.scenarioer[NORM.navn]
|
|
assert (d.valg.trinn, d.valg.grunnlag) == (5, Grunnlag.TRINN_5)
|
|
assert norm.per_trinn[5][Losning.A].maal["M6"].dom is Dom.BETINGELSER
|
|
assert d.del_I is Dom.BETINGELSER
|
|
assert norm.betingelser is not None
|
|
b = norm.betingelser[Losning.A]
|
|
assert (b.maal, b.kan_navngis, b.terskler) == (("M5",), True, {"M6": ()})
|
|
# with M5 holding only the scale is missing (clarification 103 g)
|
|
d = kj.sett_dommer(
|
|
kjoring, {Losning.A: Dom.HOLDER}, storrelser={"x": X10}, status={"x": "kilde"}
|
|
)
|
|
norm = d.scenarioer[NORM.navn]
|
|
assert d.del_I is Dom.BETINGELSER
|
|
assert norm.betingelser is not None
|
|
assert norm.betingelser[Losning.A].bare_skalaen_mangler
|
|
|
|
|
|
def test_tersklene_for_M7_vises_og_endrer_ingenting() -> None:
|
|
"""A is best in the first 4 of 10 draws: at most 8 of the quantity gives 4 of 8."""
|
|
|
|
def trekning(j: int) -> dict[tuple[Losning, int], dict[str, Utfall] | None]:
|
|
return {
|
|
(Losning.A, 5): _alle(_u(1.0 if j < 4 else 0.2)),
|
|
(Losning.C, 5): _alle(_u(0.5)),
|
|
}
|
|
|
|
kjoring = _kjoring([trekning(j) for j in range(10)])
|
|
M5 = dict.fromkeys((Losning.A, Losning.C), Dom.HOLDER)
|
|
d = kj.sett_dommer(kjoring, M5, storrelser={"x": X10}, status={"x": "åpen forutsetning"})
|
|
norm = d.scenarioer[NORM.navn]
|
|
assert norm.M7[5].dom is Dom.BETINGELSER
|
|
(t,) = norm.terskler_M7
|
|
assert _kjerne(t) == ("x", Retning.HOYST, 8.0, 0.8, 0.5, False)
|
|
assert (d.del_I, d.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
|
|
assert kj.sett_dommer(kjoring, M5).scenarioer[NORM.navn].terskler_M7 == ()
|
|
|
|
|
|
def test_tersklene_trenger_verdier_og_status_for_hver_trekning() -> None:
|
|
kjoring = _trekninger_der_A_er_positiv_til_og_med(7, antall=10)
|
|
M5 = {Losning.A: Dom.HOLDER}
|
|
with pytest.raises(ValueError, match="both the drawn values and the status"):
|
|
kj.sett_dommer(kjoring, M5, storrelser={"x": X10})
|
|
with pytest.raises(ValueError, match="one value per draw"):
|
|
kj.sett_dommer(kjoring, M5, storrelser={"x": [1.0]}, status={"x": "kilde"})
|
|
|
|
|
|
def test_tallene_ved_siden_av_M6_over_trekningene_som_har_verdi() -> None:
|
|
"""Clarification 103 c. One draw cannot be built, one has no year of stable operation."""
|
|
utfall: list[Utfall | None] = [
|
|
None,
|
|
_u(M6=None),
|
|
dataclasses.replace(_u(M6=0.1), M6_2050=0.2),
|
|
dataclasses.replace(_u(M6=0.3), M6_2050=0.4),
|
|
]
|
|
side = kj.ved_siden_av_m6(utfall)
|
|
assert side["snitt"] == side["median av ti aar"]
|
|
assert side["snitt"].antall == 2
|
|
assert side["snitt"].median == pytest.approx(0.2)
|
|
assert side["snitt"].persentiler == pytest.approx((0.12, 0.28))
|
|
assert side["2050"].antall == 2
|
|
assert side["2050"].median == pytest.approx(0.3)
|
|
assert side["2050"].persentiler == pytest.approx((0.22, 0.38))
|
|
# the peak year has a value for every path that can be built: 0, 0.1 and 0.3
|
|
assert (side["toppaar"].antall, side["toppaar"].median) == (3, 0.1)
|
|
assert side["toppaar"].persentiler == pytest.approx((0.02, 0.26))
|
|
ingen = kj.ved_siden_av_m6([None, None])
|
|
assert all(x == kj.Sidetall(antall=0, median=None, persentiler=None) for x in ingen.values())
|
|
|
|
|
|
def test_utfallene_indeksene_gis_for() -> None:
|
|
"""Four draws of A and C on step 5; A cannot be built in the last."""
|
|
a: list[Utfall | None] = [_u(2.0), _u(1.0, M3=0.2, M6=0.01), _u(-1.0, S42=-1.0, M4=False), None]
|
|
kjoring = _kjoring(
|
|
[
|
|
{(Losning.A, 5): None if u is None else _alle(u), (Losning.C, 5): _alle(_u(1.5))}
|
|
for u in a
|
|
]
|
|
)
|
|
y = kj.utfall_for_indeksene(kjoring, Losning.A, 5)
|
|
assert y == {
|
|
"NNV": [2.0, 1.0, -1.0, None],
|
|
"byggbar": [1.0, 1.0, 1.0, 0.0],
|
|
"M1 holder": [1.0, 1.0, 0.0, 0.0],
|
|
"M2 holder": [1.0, 1.0, 0.0, 0.0],
|
|
"M3 holder": [1.0, 0.0, 1.0, 0.0],
|
|
"M4 holder": [1.0, 1.0, 0.0, 0.0],
|
|
"M6 holder": [1.0, 0.0, 1.0, 0.0],
|
|
"M3 holder ikke": [0.0, 1.0, 0.0, 0.0],
|
|
"M4 holder ikke": [0.0, 0.0, 1.0, 0.0],
|
|
# a path that cannot be built counts as under 5 % in M6
|
|
"M6 holder ikke": [0.0, 1.0, 0.0, 1.0],
|
|
"M7": [1.0, 0.0, 0.0, 0.0],
|
|
}
|
|
assert "M7" not in kj.utfall_for_indeksene(kjoring, Losning.C, 5)
|
|
indekser = kj.sobol_indekser(kjoring, {"x": [1.0, 2.0, 3.0, 4.0]}, Losning.A, 5)
|
|
assert set(indekser) == set(y)
|
|
# two classes of two draws: M1 follows the class exactly, M3 not at all
|
|
assert indekser["M1 holder"] == {"x": 1.0}
|
|
assert indekser["M3 holder"] == {"x": 0.0}
|
|
# the net present value among the three draws that can be built. With three draws and
|
|
# two classes the class is floor(2 r / 3): {2, 1} with the average 1.5, and {-1}
|
|
snitt = 2.0 / 3.0
|
|
mellom = 2 * (1.5 - snitt) ** 2 + (-1.0 - snitt) ** 2
|
|
total = (2.0 - snitt) ** 2 + (1.0 - snitt) ** 2 + (-1.0 - snitt) ** 2
|
|
assert indekser["NNV"]["x"] == pytest.approx(mellom / total)
|
|
assert kj.sobol_indekser(kjoring, {"x": [1.0, 2.0, 3.0, 4.0]}, Losning.C, 5)["M1 holder"] == {
|
|
"x": None
|
|
}
|
|
|
|
|
|
def test_flatene_leses_av_utfallene() -> None:
|
|
"""Four draws; A cannot be built in the second. Two of the 25 cells are filled per pair."""
|
|
a: list[Utfall | None] = [
|
|
dataclasses.replace(_u(2.0), c_snitt=300.0),
|
|
None,
|
|
dataclasses.replace(_u(-1.0), c_snitt=500.0),
|
|
dataclasses.replace(_u(4.0), c_snitt=400.0),
|
|
]
|
|
kjoring = _kjoring([{(Losning.A, 5): None if u is None else _alle(u)} for u in a])
|
|
rho = [0.05, 0.05, 0.09, 0.09]
|
|
kost = [100.0, 100.0, 200.0, 200.0]
|
|
flate = kj.flate_over_trekningene(kjoring, rho, kost, Losning.A, 5)
|
|
assert flate[0][0] == Rute(antall=2, andel_positiv=0.5, median=-math.inf)
|
|
assert flate[2][2] == Rute(antall=2, andel_positiv=0.5, median=1.5)
|
|
assert sum(rute.antall for rad in flate for rute in rad) == 4
|
|
# the competitor's price against the Norwegian cost, among the three that can be built:
|
|
# classes 0, 1 and 3 of five for both, since class is floor(5 r / 3)
|
|
antall, flate = kj.kraftprisflate(kjoring, [800.0, 850.0, 900.0, 950.0], Losning.A, 5)
|
|
assert antall == 3
|
|
assert flate[0][0] == Rute(antall=1, andel_positiv=1.0, median=2.0)
|
|
assert flate[1][3] == Rute(antall=1, andel_positiv=0.0, median=-1.0)
|
|
assert flate[3][1] == Rute(antall=1, andel_positiv=1.0, median=4.0)
|
|
uten_kost = _kjoring([{(Losning.A, 5): _alle(_u())}])
|
|
with pytest.raises(ValueError, match="cost of Norwegian power"):
|
|
kj.kraftprisflate(uten_kost, [800.0], Losning.A, 5)
|
|
|
|
|
|
# ------------------------------------------------ the price threshold, through the model
|
|
|
|
|
|
def test_prisfaktoren_en_gir_de_samme_tallene_til_siste_siffer(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
for losning in Losning:
|
|
dim = ks.dimensjoner(inn, losning)
|
|
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
|
|
uten = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim)
|
|
med = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, prisfaktor=1.0)
|
|
assert med.NNV == uten.NNV
|
|
assert kj.nnv_med_prisfaktor(
|
|
inn, losning=losning, trinn=2, knapphet=Knapphet.VARER, k=1.0
|
|
) == (uten.NNV)
|
|
with pytest.raises(ValueError, match="cannot be negative"):
|
|
ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, prisfaktor=-0.1)
|
|
|
|
|
|
def test_netto_naaverdi_avtar_ikke_med_prisen_og_faktoren_er_som_et_bortfall(
|
|
oppdiktet: LagInndata,
|
|
) -> None:
|
|
"""17.3: a loss d for every vintage is the price times 1 - eps_d d. Here eps_d is one."""
|
|
inn = oppdiktet()
|
|
for losning in Losning:
|
|
dim = ks.dimensjoner(inn, losning)
|
|
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
|
|
|
|
def nnv(k: float, losning: Losning = losning) -> float:
|
|
verdi = kj.nnv_med_prisfaktor(
|
|
inn, losning=losning, trinn=2, knapphet=Knapphet.NORMALISERING, k=k
|
|
)
|
|
assert verdi is not None
|
|
return verdi
|
|
|
|
rekke = [nnv(k) for k in (0.0, 0.5, 0.8, 1.0, 1.3, 2.0, 5.0)]
|
|
assert rekke == sorted(rekke)
|
|
assert rekke[0] < rekke[-1]
|
|
med_bortfall = ks.regn_program(
|
|
inn, losning, plan, Knapphet.NORMALISERING, dim=dim, bortfall=ks.fast_bortfall(0.2)
|
|
)
|
|
assert nnv(0.8) == pytest.approx(med_bortfall.NNV, rel=1e-12)
|
|
# the avoided emissions follow the capacity sold, not the price
|
|
dobbel = ks.regn_program(
|
|
inn, losning, plan, Knapphet.NORMALISERING, dim=dim, prisfaktor=2.0
|
|
)
|
|
assert dobbel.mu_d.andel(2040) == 1.0
|
|
assert dobbel.mu_d(2040) == 2.0
|
|
|
|
|
|
def test_pristerskelen_gjennom_modellen(oppdiktet: LagInndata) -> None:
|
|
"""Four made-up draws; the median at the threshold is not negative, and negative just below."""
|
|
trekninger = _trekninger(oppdiktet)
|
|
for losning in (Losning.A, Losning.C, Losning.T_F):
|
|
funnet = kj.pristerskel_for_losning(trekninger, losning, 1, NORM)
|
|
assert funnet.k is not None
|
|
|
|
def median(k: float, losning: Losning = losning) -> float:
|
|
return dommer.median(
|
|
[
|
|
kj.nnv_med_prisfaktor(
|
|
inn, losning=losning, trinn=1, knapphet=Knapphet.NORMALISERING, k=k
|
|
)
|
|
for inn in trekninger
|
|
]
|
|
)
|
|
|
|
assert median(funnet.k) >= 0
|
|
assert funnet.k == 0.0 or median(funnet.k - terskler.K_TOLERANSE) < 0
|
|
# shared out over processes the same factors are tried, and the answer is the same
|
|
en = kj.pristerskel_for_losning(trekninger, Losning.C, 1, NORM)
|
|
assert kj.pristerskel_for_losning(trekninger, Losning.C, 1, NORM, prosesser=2) == en
|
|
with pytest.raises(ValueError, match="price scenarios on the main path"):
|
|
kj.pristerskel_for_losning(trekninger, Losning.C, 1, LAVT)
|
|
with pytest.raises(ValueError, match="at least one draw"):
|
|
kj.pristerskel_for_losning([], Losning.C, 1, NORM)
|
|
|
|
|
|
def test_pristerskelen_finnes_ikke_naar_halvparten_ikke_lar_seg_bygge(
|
|
oppdiktet: LagInndata,
|
|
) -> None:
|
|
"""Step 3 of the slow nuclear path cannot be built; with two of four such draws: no median."""
|
|
trekninger = [oppdiktet(), oppdiktet(p_v=3000.0), *[oppdiktet(n_reaktor=100.0)] * 2]
|
|
assert kj.pristerskel_for_losning(trekninger, Losning.A, 3, NORM) == Pristerskel(
|
|
k=None, uten_median=True
|
|
)
|
|
|
|
|
|
def test_prisflaten_gir_terskelen_per_klasse_av_reaktorkostnaden(oppdiktet: LagInndata) -> None:
|
|
"""Ten made-up draws in five classes of two; each class has the threshold of its own draws."""
|
|
kost = [80e6, 90e6, 100e6, 110e6, 120e6, 130e6, 140e6, 150e6, 160e6, 170e6]
|
|
trekninger = [oppdiktet(c_N_ref=c) for c in kost]
|
|
flate = kj.prisflate(trekninger, kost, Losning.A, 1, NORM)
|
|
assert [None if p is None else (p.antall, p.c_N_ref) for p in flate] == [
|
|
(2, 85e6),
|
|
(2, 105e6),
|
|
(2, 125e6),
|
|
(2, 145e6),
|
|
(2, 165e6),
|
|
]
|
|
forste = kj.pristerskel_for_losning(trekninger[:2], Losning.A, 1, NORM)
|
|
assert flate[0] is not None
|
|
assert flate[0].terskel == forste
|
|
terskel = [p.terskel.k for p in flate if p is not None]
|
|
assert all(k is not None for k in terskel)
|
|
# a dearer reactor needs a higher price
|
|
assert terskel == sorted(terskel) # type: ignore[type-var]
|
|
with pytest.raises(ValueError, match="reactor cost of every draw"):
|
|
kj.prisflate(trekninger, kost[:3], Losning.A, 1, NORM)
|
|
|
|
|
|
def test_kraftkostnaden_i_utfallet_er_snittet_over_aargangsleddene(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
bane = kj.regn_bane(inn, Losning.C, 2, (NORM,))
|
|
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, dim=dim)
|
|
ledd = nivaaisert.kraftkostnad(inn, res, bedrift=True).aarganger
|
|
vekter = [(1.0 + inn["rho_D"]) ** -(a.t_v - plan.T_0) for a in ledd]
|
|
snitt = sum(w * a.c_a for w, a in zip(vekter, ledd, strict=True)) / sum(vekter)
|
|
assert bane.utfall[NORM.navn].c_snitt == pytest.approx(snitt, rel=1e-12)
|
|
assert min(a.c_a for a in ledd) <= snitt <= max(a.c_a for a in ledd)
|
|
assert kj.lcoc_v_2025(inn) == ks.regnekraftpris(inn, Knapphet.VARER, 2040).lcoc_v(2025)
|