Clarifications 105 to 111, on invented outcomes and made-up draws only. The price threshold runs the model with the price multiplied by a factor; the thresholds in a quantity, the indices and two of the surfaces are read from the outcomes per draw. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
856 lines
38 KiB
Python
856 lines
38 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."""
|
|
|
|
|
|
def _ti_trekninger_der_A_er_positiv_til_og_med(grense: int) -> Kjoring:
|
|
"""Ten 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(10)])
|
|
|
|
|
|
def test_del_I_avgjores_med_tersklene() -> None:
|
|
"""M1 is positive in 7 of 10 draws: at most 8 of the quantity gives 7 of 8."""
|
|
kjoring = _ti_trekninger_der_A_er_positiv_til_og_med(7)
|
|
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": X10, "z": [11.0 - v for v in X10]}
|
|
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 b.terskler == {
|
|
"M1": (
|
|
Terskel("x", Retning.HOYST, 8.0, 0.8, 0.875, teller=True),
|
|
Terskel("z", Retning.MINST, 3.0, 0.8, 0.875, teller=False),
|
|
)
|
|
}
|
|
# 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 [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] * 10}, 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_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
|
|
assert norm.terskler_M7 == (Terskel("x", Retning.HOYST, 8.0, 0.8, 0.5, teller=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 = _ti_trekninger_der_A_er_positiv_til_og_med(7)
|
|
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)
|