feat(kjoring): thresholds, the conditions of part I, Sobol indices and threshold surfaces
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>
This commit is contained in:
parent
7e3ab007f8
commit
8d13501653
10 changed files with 1561 additions and 79 deletions
|
|
@ -1,4 +1,4 @@
|
|||
"""The run over the draws (chapter 11; clarifications 95 to 103).
|
||||
"""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.
|
||||
|
|
@ -10,19 +10,21 @@ 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
|
||||
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:
|
||||
|
|
@ -409,17 +411,17 @@ def test_dommene_paa_oppdiktede_trekninger_henger_sammen_med_utfallene(
|
|||
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)
|
||||
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 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
|
||||
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"):
|
||||
kj.persentil([], 0.5)
|
||||
dommer.persentil([], 0.5)
|
||||
with pytest.raises(ValueError, match="between 0 and 1"):
|
||||
kj.persentil([1.0], 10.0)
|
||||
dommer.persentil([1.0], 10.0)
|
||||
|
||||
|
||||
def test_tidslinjen_over_trekningene_har_med_baner_som_ikke_lar_seg_bygge() -> None:
|
||||
|
|
@ -529,3 +531,326 @@ def test_de_seks_scenarioene_og_stigen_er_de_forhaandsregistrerte() -> None:
|
|||
]
|
||||
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)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue