feat(folsomheter): the sensitivity list through the run over the draws, with eleven new switches in the model code
42 rows from the 37 lines: each row is the main run with one change, run on the main run's step for the solutions it applies to and put in the fixed table next to the main run. New switches in dimensjoner and regn_program for lines 4, 7, 8, 10, 12, 13, 16, 17, 18, 20 and 21, the cost factor of line 28 in the ownership pass, and the state's cash flow next to M6. With the switches off every figure is unchanged to the last digit. Made-up draws only; nothing is computed. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
parent
5360e768cf
commit
45aaffcb69
12 changed files with 3275 additions and 220 deletions
688
tests/test_folsomheter.py
Normal file
688
tests/test_folsomheter.py
Normal file
|
|
@ -0,0 +1,688 @@
|
|||
"""The sensitivity list through the run (chapter 11; clarifications 112, 113, 116 to 123).
|
||||
|
||||
Made-up draws only: variants of the made-up set of ``conftest.py``, and invented outcomes per
|
||||
draw for the table. Nothing here says anything about the hypothesis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import dommer, eierskap
|
||||
from tokenfabrikker import folsomheter as fs
|
||||
from tokenfabrikker import kjoring as kj
|
||||
from tokenfabrikker import kontantstrom as ks
|
||||
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag, Trinnvalg
|
||||
from tokenfabrikker.folsomheter import RADER, Avlesning
|
||||
from tokenfabrikker.kjoring import Bane, Brytere, Eierrad, Kjoring, Scenario, Utfall
|
||||
from tokenfabrikker.kontantstrom import Diskontering, Knapphet, Paaslagsform, Skattekostnad
|
||||
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)
|
||||
OVER = Scenario("overkapasitet", Knapphet.OVERKAPASITET)
|
||||
LAVT = Scenario("lavt", Knapphet.NORMALISERING, "lavt")
|
||||
HOYT = Scenario("hoyt", Knapphet.NORMALISERING, "hoyt")
|
||||
SCENARIOER = (VARER, NORM, OVER, LAVT, HOYT)
|
||||
"""The price scenarios and the two marked scenarios of the made-up set."""
|
||||
|
||||
EOS = {
|
||||
"direkte": "består",
|
||||
"heleid_selskap": "består",
|
||||
"majoritet_boers": "usikker",
|
||||
"petroleumsmodell": "består",
|
||||
}
|
||||
|
||||
KARBONBANER = {"lav": {2026: 500.0, 2100: 500.0}, "hoy": {2026: 3000.0, 2100: 4000.0}}
|
||||
"""Made-up low and high paths of the carbon price; the made-up set has 1 000 kr in every year."""
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ the list
|
||||
|
||||
|
||||
def test_lista_har_42_rader_fra_37_linjer() -> None:
|
||||
assert len(RADER) == 42
|
||||
linjer = [rad.linje for rad in RADER.values()]
|
||||
assert sorted(set(linjer)) == list(range(1, fs.ANTALL_LINJER + 1))
|
||||
assert linjer == sorted(linjer)
|
||||
assert sorted({n for n in linjer if linjer.count(n) == 2}) == [11, 17, 19, 31, 32]
|
||||
assert [navn for navn, rad in RADER.items() if not rad.er_kjoring] == [
|
||||
"24",
|
||||
"25",
|
||||
"28",
|
||||
"29",
|
||||
"30",
|
||||
]
|
||||
assert {navn: rad.eierrad for navn, rad in RADER.items() if rad.eierrad is not None} == {
|
||||
"24": Eierrad.STATENS_RENTE,
|
||||
"25": Eierrad.EGENKAPITALKRAV,
|
||||
"28": Eierrad.EFFEKTIVITET,
|
||||
"29": Eierrad.ZETA_LIK_EIERANDEL,
|
||||
}
|
||||
|
||||
|
||||
def test_radene_leses_av_der_avklaring_112_sier() -> None:
|
||||
andre = {
|
||||
navn: rad.avlesning for navn, rad in RADER.items() if rad.avlesning is not Avlesning.HOVED
|
||||
}
|
||||
assert andre == {
|
||||
"12": Avlesning.VARER,
|
||||
"13": Avlesning.VARER,
|
||||
"24": Avlesning.EIERFORMER,
|
||||
"25": Avlesning.EIERFORMER,
|
||||
"28": Avlesning.EIERFORMER,
|
||||
"29": Avlesning.EIERFORMER,
|
||||
"31a": Avlesning.MERKET,
|
||||
"31b": Avlesning.MERKET,
|
||||
}
|
||||
assert fs.scenarioer_for(RADER["14"], SCENARIOER) == (NORM,)
|
||||
assert fs.scenarioer_for(RADER["12"], SCENARIOER) == (VARER,)
|
||||
assert fs.scenarioer_for(RADER["31a"], SCENARIOER) == (LAVT, HOYT)
|
||||
assert fs.scenarioer_for(RADER["24"], SCENARIOER) == ()
|
||||
|
||||
|
||||
def test_hvilke_losninger_radene_gjelder() -> None:
|
||||
"""Clarifications 117 to 122, row by row."""
|
||||
A, B, Bm, C, R, TF, TK = (
|
||||
Losning.A,
|
||||
Losning.B,
|
||||
Losning.B_MERKET,
|
||||
Losning.C,
|
||||
Losning.R,
|
||||
Losning.T_F,
|
||||
Losning.T_K,
|
||||
)
|
||||
alle = (A, B, Bm, C, R, TF, TK)
|
||||
assert set(alle) == set(Losning)
|
||||
ikke_alle = {
|
||||
navn: set(rad.gjelder) for navn, rad in RADER.items() if set(rad.gjelder) != set(alle)
|
||||
}
|
||||
assert ikke_alle == {
|
||||
"1": {A, B, Bm, TK},
|
||||
"2": {A, B, Bm, TK},
|
||||
"3": {A},
|
||||
"4": {B, Bm, TK},
|
||||
"5": {A, Bm},
|
||||
"6": {A, B, Bm, TK},
|
||||
"7": {A, Bm},
|
||||
"8": {A, Bm},
|
||||
"9": {A, Bm},
|
||||
"10": {A},
|
||||
"20": {A, Bm},
|
||||
"21": {B, Bm, TK},
|
||||
"22": {B, Bm, C, TF, TK},
|
||||
"24": {A, B, C, TF, TK},
|
||||
"25": {A, B, C, TF, TK},
|
||||
"28": {A, B, C, TF, TK},
|
||||
"29": {A, B, C, TF, TK},
|
||||
"32a": {TF, TK},
|
||||
"32b": {TF, TK},
|
||||
"33": {TF, TK},
|
||||
"34": {TF, TK},
|
||||
"35": {C},
|
||||
"36": {TK},
|
||||
"37": {C, TF, TK},
|
||||
}
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ one draw
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("rad", "losning", "endring", "grunn"),
|
||||
[
|
||||
# the made-up set has u_xi = 0.9 and w_xi = 0.5: no overrun. With u_xi = 0.3 there is one.
|
||||
("1", Losning.A, {"w_xi": 0.0}, {"u_xi": 0.3}),
|
||||
("2", Losning.B, {"w_xi": 1.0}, {}),
|
||||
("5", Losning.A, {"nu": 0.6}, {}),
|
||||
("6", Losning.B, {"ell": -0.23}, {}),
|
||||
("11a", Losning.C, {"mu_rel": 0.90}, {}),
|
||||
("11b", Losning.R, {"mu_rel": 0.95}, {}),
|
||||
("14", Losning.C, {"p_v": 1198.0}, {}),
|
||||
("15", Losning.B, {"PUE_v": 1.45}, {}),
|
||||
("17a", Losning.A, {"varphi": 0.0}, {}),
|
||||
("27", Losning.C, {"P_IT": 300.0}, {}),
|
||||
("27", Losning.T_F, {"P_IT": 300.0}, {}),
|
||||
("27", Losning.A, {"P_IT": 300.0}, {}),
|
||||
("32a", Losning.T_F, {"P_m": 50.0}, {}),
|
||||
("32b", Losning.T_K, {"P_m": 200.0}, {}),
|
||||
# the first stage of the made-up set takes 150 MW a year; the modules wait for grid
|
||||
("33", Losning.T_F, {"n_1": 650.0}, {"tau_nett": 6.0}),
|
||||
],
|
||||
)
|
||||
def test_en_rad_med_fast_verdi_er_hovedkjoringen_med_verdien_byttet(
|
||||
oppdiktet: LagInndata,
|
||||
rad: str,
|
||||
losning: Losning,
|
||||
endring: dict[str, float],
|
||||
grunn: dict[str, float],
|
||||
) -> None:
|
||||
"""The value is set after the draw: every other quantity keeps its value."""
|
||||
inn = oppdiktet().med(grunn)
|
||||
med = fs.regn_bane(inn, losning, 2, (NORM, VARER), rad=RADER[rad])
|
||||
assert med == kj.regn_bane(inn.med(endring), losning, 2, (NORM, VARER))
|
||||
assert med != kj.regn_bane(inn, losning, 2, (NORM, VARER))
|
||||
|
||||
|
||||
def test_bortfallets_utslag_virker_bare_i_de_merkede_scenarioene(oppdiktet: LagInndata) -> None:
|
||||
"""Line 31: eps_d moves nothing on the main path."""
|
||||
for navn, eps in (("31a", 0.5), ("31b", 2.0)):
|
||||
med = fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM, LAVT), rad=RADER[navn])
|
||||
hoved = kj.regn_bane(oppdiktet(), Losning.C, 2, (NORM, LAVT))
|
||||
assert med == kj.regn_bane(oppdiktet(eps_d=eps), Losning.C, 2, (NORM, LAVT))
|
||||
assert med.utfall[NORM.navn] == hoved.utfall[NORM.navn]
|
||||
assert med.utfall[LAVT.navn] != hoved.utfall[LAVT.navn]
|
||||
|
||||
|
||||
def test_rho_A_lik_rho_N_bruker_trekningens_rho_N(oppdiktet: LagInndata) -> None:
|
||||
"""Line 3. The made-up set has rho_N = 0.06 and rho_D = 0.08."""
|
||||
for rho_N in (0.06, 0.05):
|
||||
inn = oppdiktet(rho_N=rho_N)
|
||||
med = fs.regn_bane(inn, Losning.A, 2, (NORM,), rad=RADER["3"])
|
||||
assert med == kj.regn_bane(
|
||||
inn, Losning.A, 2, (NORM,), brytere=Brytere(dim={"rho_A": rho_N})
|
||||
)
|
||||
# a lower required return for the plant lowers the cost of power, and so helps M2; the
|
||||
# plant's cash flow is costs only in A, so its present value falls
|
||||
hoved = kj.regn_bane(inn, Losning.A, 2, (NORM,))
|
||||
assert med.utfall[NORM.navn].S42 > hoved.utfall[NORM.navn].S42
|
||||
assert med.utfall[NORM.navn].NNV < hoved.utfall[NORM.navn].NNV
|
||||
|
||||
|
||||
def test_halv_byggetid_gjelder_enheter_under_300_MW(oppdiktet: LagInndata) -> None:
|
||||
"""Line 9. The made-up set gives units of 50 MW in A; with chi = 0.5 they are 400 MW."""
|
||||
for losning in (Losning.A, Losning.B_MERKET):
|
||||
med = fs.regn_bane(oppdiktet(), losning, 2, (NORM,), rad=RADER["9"])
|
||||
assert med == kj.regn_bane(oppdiktet(tau_N=2.0), losning, 2, (NORM,))
|
||||
assert med != kj.regn_bane(oppdiktet(), losning, 2, (NORM,))
|
||||
stor = oppdiktet(chi=0.5)
|
||||
assert ks.dimensjoner(stor, Losning.A).P_u == 400.0
|
||||
assert fs.regn_bane(stor, Losning.A, 2, (NORM,), rad=RADER["9"]) == kj.regn_bane(
|
||||
stor, Losning.A, 2, (NORM,)
|
||||
)
|
||||
|
||||
|
||||
def test_karbonprisens_baner_gis_av_den_som_kjorer(oppdiktet: LagInndata) -> None:
|
||||
"""Line 19: the run reads no file, so the two paths are passed in."""
|
||||
inn = oppdiktet()
|
||||
for navn, bane in (("19a", "lav"), ("19b", "hoy")):
|
||||
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER[navn], karbonbaner=KARBONBANER)
|
||||
byttet = dataclasses.replace(inn, karbonpris=KARBONBANER[bane])
|
||||
assert med == kj.regn_bane(byttet, Losning.C, 2, (NORM,))
|
||||
hoved = kj.regn_bane(inn, Losning.C, 2, (NORM,)).utfall[NORM.navn].NNV
|
||||
lav = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["19a"], karbonbaner=KARBONBANER)
|
||||
assert lav.utfall[NORM.navn].NNV > hoved > med.utfall[NORM.navn].NNV
|
||||
with pytest.raises(ValueError, match="low and its high path"):
|
||||
fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["19a"])
|
||||
|
||||
|
||||
def test_beslutningsaar_2030_bruker_eksportradens_tall_for_samme_kalenderaar(
|
||||
oppdiktet: LagInndata,
|
||||
) -> None:
|
||||
"""Line 26, clarification 113: the number stored for year t is used in year t.
|
||||
|
||||
The made-up set runs from 2027 to 2060, so the row has 33 numbers, for 2028 to 2060.
|
||||
With a stop in 2034 only (the seventh number) the path built from 2030 meets it in
|
||||
its fourth year, not in its seventh.
|
||||
"""
|
||||
u = tuple(0.0 if aar == 2034 else 0.9 for aar in range(2028, 2061))
|
||||
inn = oppdiktet(u_eksport=u, phi_X=0.5)
|
||||
senere = fs.med_beslutningsaar(inn, 2030)
|
||||
assert (senere["T0"], len(senere.u_eksport)) == (2030.0, 30)
|
||||
assert senere.u_eksport == u[3:]
|
||||
assert senere.u_eksport.index(0.0) == 2034 - 2031
|
||||
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["26"])
|
||||
assert med == kj.regn_bane(
|
||||
oppdiktet(u_eksport=u[3:], phi_X=0.5, T0=2030), Losning.C, 2, (NORM,)
|
||||
)
|
||||
assert med.forste_aar == 2031
|
||||
assert med != kj.regn_bane(
|
||||
oppdiktet(u_eksport=u[:30], phi_X=0.5, T0=2030), Losning.C, 2, (NORM,)
|
||||
)
|
||||
with pytest.raises(ValueError, match="later, not earlier"):
|
||||
fs.med_beslutningsaar(inn, 2026)
|
||||
|
||||
|
||||
def test_C_i_moduler_er_T_F_uten_forste_trinn_paa_plassen_til_C(oppdiktet: LagInndata) -> None:
|
||||
"""Line 35, clarification 73."""
|
||||
inn = oppdiktet()
|
||||
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["35"])
|
||||
assert med == kj.regn_bane(
|
||||
inn, Losning.T_F, 2, (NORM,), brytere=Brytere(plan={"uten_forste_trinn": True})
|
||||
)
|
||||
assert med != kj.regn_bane(inn, Losning.C, 2, (NORM,))
|
||||
|
||||
|
||||
def test_radene_som_er_brytere_gir_bryteren_til_modellkoden(oppdiktet: LagInndata) -> None:
|
||||
"""Lines 22, 23, 34, 36 and 37 against the model code called directly."""
|
||||
inn = oppdiktet(phi_X=0.5, u_eksport=(0.1,) * 4 + (0.9,) * 29)
|
||||
|
||||
def nnv(
|
||||
losning: Losning, plan_valg: dict[str, object], program_valg: dict[str, object]
|
||||
) -> float:
|
||||
dim = ks.dimensjoner(inn, losning)
|
||||
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2, **plan_valg) # type: ignore[arg-type]
|
||||
return ks.regn_program(
|
||||
inn,
|
||||
losning,
|
||||
plan,
|
||||
Knapphet.NORMALISERING,
|
||||
dim=dim,
|
||||
**program_valg, # type: ignore[arg-type]
|
||||
).NNV
|
||||
|
||||
tilfeller: list[tuple[str, Losning, dict[str, object], dict[str, object]]] = [
|
||||
("22", Losning.C, {}, {"tilleggsregel": False}),
|
||||
("23", Losning.C, {"eksportregel": False}, {}),
|
||||
("34", Losning.T_F, {}, {"full_fortrengning_i_forste_trinn": True}),
|
||||
("36", Losning.T_K, {"uten_s49": True}, {}),
|
||||
("37", Losning.C, {"ny_kraft_fra": 2031}, {}),
|
||||
]
|
||||
for navn, losning, plan_valg, program_valg in tilfeller:
|
||||
med = fs.regn_bane(inn, losning, 2, (NORM,), rad=RADER[navn])
|
||||
assert med.utfall[NORM.navn].NNV == nnv(losning, plan_valg, program_valg), navn
|
||||
|
||||
|
||||
def test_radene_med_ny_modellkode_gir_bryteren_til_modellkoden(oppdiktet: LagInndata) -> None:
|
||||
"""Lines 4, 7, 8, 10, 12, 13, 16, 17, 18, 20 and 21: the switch each row sets."""
|
||||
assert {
|
||||
navn: (dict(r.brytere.dim), dict(r.brytere.program))
|
||||
for navn, r in RADER.items()
|
||||
if r.linje in (4, 7, 8, 10, 12, 13, 16, 18, 20, 21) or navn == "17b"
|
||||
} == {
|
||||
"4": ({"paaslag_kjernekraft": 0.02}, {}),
|
||||
"7": ({"minstelast": 0.20}, {}),
|
||||
"8": ({"fritt_enhetsvalg": True}, {}),
|
||||
"10": ({"gamma_trinn": True}, {}),
|
||||
"12": ({}, {"paaslag": Paaslagsform.VARIG}),
|
||||
"13": ({}, {"paaslag": Paaslagsform.AVTAKENDE}),
|
||||
"16": ({}, {"diskontering": Diskontering.RUNDSKRIV}),
|
||||
"17b": ({}, {"skattekostnad": Skattekostnad.ALL_KAPITAL}),
|
||||
"18": ({}, {"skattekostnad": Skattekostnad.STATENS_RENTE}),
|
||||
"20": ({"skaler_K_U": False}, {}),
|
||||
"21": ({"bare_over_dimensjonerende_feil": True}, {}),
|
||||
}
|
||||
trinn = {"A>=A*": 1.0, "0.99<=A<A*": 0.9, "0.95<=A<0.99": 0.7, "A<0.95": 0.0}
|
||||
grunn = oppdiktet()
|
||||
# what only the rows read, with made-up values
|
||||
v = {"tau_pi": 2.5, "P_dim0": 1450.0, **grunn.v}
|
||||
inn = dataclasses.replace(grunn, v=v, Gamma_trinn=trinn)
|
||||
tilfeller = [
|
||||
("4", Losning.B, NORM),
|
||||
("7", Losning.A, NORM),
|
||||
("8", Losning.A, NORM),
|
||||
("10", Losning.A, NORM),
|
||||
("12", Losning.C, VARER),
|
||||
("13", Losning.C, VARER),
|
||||
("16", Losning.C, NORM),
|
||||
("17b", Losning.C, NORM),
|
||||
("18", Losning.A, NORM),
|
||||
("20", Losning.A, NORM),
|
||||
("21", Losning.B, NORM),
|
||||
]
|
||||
for navn, losning, scenario in tilfeller:
|
||||
rad = RADER[navn]
|
||||
med = fs.regn_bane(inn, losning, 2, (scenario,), rad=rad)
|
||||
assert med == kj.regn_bane(inn, losning, 2, (scenario,), brytere=rad.brytere), navn
|
||||
|
||||
|
||||
def test_en_rad_regnes_bare_for_losningene_den_gjelder(oppdiktet: LagInndata) -> None:
|
||||
with pytest.raises(ValueError, match="row 3 is not computed for solution C"):
|
||||
fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM,), rad=RADER["3"])
|
||||
with pytest.raises(ValueError, match="row 30 is not computed"):
|
||||
fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM,), rad=RADER["30"])
|
||||
with pytest.raises(ValueError, match="row 24 is not computed"):
|
||||
fs.regn_bane(oppdiktet(), Losning.A, 2, (NORM,), rad=RADER["24"])
|
||||
|
||||
|
||||
# ------------------------------------------------------------- over the draws
|
||||
|
||||
|
||||
def test_en_rad_kjores_paa_hovedkjoringens_trinn_for_losningene_den_gjelder(
|
||||
oppdiktet: LagInndata,
|
||||
) -> None:
|
||||
trekninger = [oppdiktet(), oppdiktet(p_v=3000.0), oppdiktet(n_reaktor=100.0)]
|
||||
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.TRINN_5)
|
||||
k = fs.kjor_rad(
|
||||
trekninger, RADER["1"], valg, scenarioer=SCENARIOER, losninger=(Losning.A, Losning.C)
|
||||
)
|
||||
assert k is not None
|
||||
assert (k.stige, k.scenarioer, k.losninger, k.antall) == ((2,), (NORM,), (Losning.A,), 3)
|
||||
assert k.trekninger[1][Losning.A, 2] == kj.regn_bane(
|
||||
oppdiktet(p_v=3000.0, w_xi=0.0), Losning.A, 2, (NORM,)
|
||||
)
|
||||
# the same figures on several processes
|
||||
assert (
|
||||
fs.kjor_rad(
|
||||
trekninger,
|
||||
RADER["1"],
|
||||
valg,
|
||||
scenarioer=SCENARIOER,
|
||||
losninger=(Losning.A, Losning.C),
|
||||
prosesser=2,
|
||||
)
|
||||
== k
|
||||
)
|
||||
# the rows that are read in other scenarios
|
||||
varig = fs.kjor_rad(
|
||||
trekninger[:1], RADER["31a"], valg, scenarioer=SCENARIOER, losninger=(Losning.C,)
|
||||
)
|
||||
assert varig is not None
|
||||
assert varig.scenarioer == (LAVT, HOYT)
|
||||
|
||||
|
||||
def test_en_rad_uten_egen_kjoring_gir_ingen(oppdiktet: LagInndata) -> None:
|
||||
trekninger = [oppdiktet()]
|
||||
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.TRINN_5)
|
||||
uten = Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN)
|
||||
assert fs.kjor_rad(trekninger, RADER["1"], uten, scenarioer=SCENARIOER) is None
|
||||
assert fs.kjor_rad(trekninger, RADER["30"], valg, scenarioer=SCENARIOER) is None
|
||||
assert fs.kjor_rad(trekninger, RADER["24"], valg, scenarioer=SCENARIOER) is None
|
||||
# none of the row's solutions, or none of its scenarios, in the run
|
||||
assert (
|
||||
fs.kjor_rad(trekninger, RADER["3"], valg, scenarioer=SCENARIOER, losninger=(Losning.C,))
|
||||
is None
|
||||
)
|
||||
assert fs.kjor_rad(trekninger, RADER["12"], valg, scenarioer=(NORM,)) is None
|
||||
with pytest.raises(ValueError, match="at least one draw"):
|
||||
fs.kjor_rad([], RADER["1"], valg, scenarioer=SCENARIOER)
|
||||
|
||||
|
||||
# ----------------------------------------- the table, on invented outcomes per draw
|
||||
|
||||
|
||||
def _u(NNV: float = 1.0, *, M6: float | None = 0.3, M6_median: float | None = None) -> Utfall:
|
||||
return Utfall(
|
||||
NNV=NNV,
|
||||
S42=1.0,
|
||||
M3=0.0,
|
||||
M4=Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False),
|
||||
M6=M6,
|
||||
M6_snitt=M6,
|
||||
M6_median=M6 if M6_median is None else M6_median,
|
||||
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 _kjoring(
|
||||
per_trekning: list[dict[Losning, Utfall | None]],
|
||||
scenarioer: tuple[Scenario, ...] = (NORM,),
|
||||
trinn: int = 5,
|
||||
) -> Kjoring:
|
||||
"""A run on one step put together from invented outcomes, the same in every scenario."""
|
||||
|
||||
def bane(u: Utfall | None) -> Bane:
|
||||
linje: dict[Kraft, tuple[float, ...]] = {}
|
||||
utfall = {} if u is None else {s.navn: u for s in scenarioer}
|
||||
return Bane(byggbar=u is not None, forste_aar=2028, tidslinje=linje, utfall=utfall)
|
||||
|
||||
return Kjoring(
|
||||
stige=(trinn,),
|
||||
scenarioer=scenarioer,
|
||||
losninger=tuple(per_trekning[0]),
|
||||
trekninger=tuple({(a, trinn): bane(u) for a, u in t.items()} for t in per_trekning),
|
||||
)
|
||||
|
||||
|
||||
VALG = Trinnvalg(trinn=5, grunnlag=Grunnlag.TRINN_25)
|
||||
M5 = dict.fromkeys(Losning, Dom.HOLDER)
|
||||
|
||||
|
||||
def test_hovedkjoringen_i_tabellen_er_dommene_paa_trinnet() -> None:
|
||||
"""The main run in the format of the table gives what ``sett_dommer`` gives on the step."""
|
||||
hoved = _kjoring(
|
||||
[
|
||||
{Losning.A: _u(1.0 if j < 7 else -1.0), Losning.C: _u(0.5), Losning.R: _u(2.0)}
|
||||
for j in range(10)
|
||||
]
|
||||
)
|
||||
d = kj.sett_dommer(hoved, M5)
|
||||
t = fs.hovedtabell(hoved, M5, d.valg, NORM)
|
||||
norm = d.scenarioer[NORM.navn]
|
||||
assert (t.rad, t.scenario, t.gjelder) == (fs.HOVEDKJORINGEN, NORM.navn, ())
|
||||
assert t.losninger == norm.per_trinn[5]
|
||||
assert (t.M7, t.del_I, t.del_II) == (norm.M7[5], norm.del_I, norm.del_II)
|
||||
assert t.ved_siden_av[Losning.A] == kj.ved_siden_av_m6(hoved.utfall(NORM, Losning.A, 5))
|
||||
with pytest.raises(ValueError, match="no table"):
|
||||
fs.hovedtabell(hoved, M5, Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN), NORM)
|
||||
|
||||
|
||||
def test_en_rad_i_tabellen_har_radens_utfall_der_den_gjelder_og_hovedkjoringens_ellers() -> None:
|
||||
"""Row 3 applies to A. A is best in 7 of 10 draws in the main run and in 2 of 10 in the row."""
|
||||
hoved = _kjoring(
|
||||
[{Losning.A: _u(1.0 if j < 7 else -1.0), Losning.C: _u(0.5)} for j in range(10)]
|
||||
)
|
||||
radkjoring = _kjoring([{Losning.A: _u(1.0 if j < 2 else 0.1)} for j in range(10)])
|
||||
(t,) = fs.tabell(hoved, RADER["3"], radkjoring, M5, VALG).values()
|
||||
assert (t.rad, t.scenario, t.gjelder) == ("3", NORM.navn, (Losning.A,))
|
||||
assert t.losninger[Losning.C] == fs.hovedtabell(hoved, M5, VALG, NORM).losninger[Losning.C]
|
||||
a = t.losninger[Losning.A]
|
||||
assert (a.maal["M1"].andel_holder, a.maal["M1"].dom, a.median_M1) == (1.0, Dom.HOLDER, 0.1)
|
||||
assert t.M7 is not None
|
||||
assert (t.M7.andel_holder, t.M7.dom) == (0.2, Dom.BETINGELSER)
|
||||
assert (t.del_I, t.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
|
||||
# the main run next to it: 7 of 10 positive, and A best in those 7
|
||||
h = fs.hovedtabell(hoved, M5, VALG, NORM)
|
||||
assert h.M7 is not None
|
||||
assert (h.losninger[Losning.A].maal["M1"].andel_holder, h.M7.andel_holder) == (0.7, 0.7)
|
||||
# without a run of the row every solution has the main run's figures
|
||||
(uten,) = fs.tabell(hoved, RADER["3"], None, M5, VALG).values()
|
||||
assert (uten.losninger, uten.M7, uten.del_I) == (h.losninger, h.M7, h.del_I)
|
||||
|
||||
|
||||
def test_M6_mot_medianen_er_en_dom_og_ingen_kjoring() -> None:
|
||||
"""Row 30: M6 is 30 % against the average and 10 % against the median in every draw."""
|
||||
hoved = _kjoring(
|
||||
[{Losning.A: _u(M6=0.3, M6_median=0.1), Losning.C: _u(M6=None)} for _ in range(10)]
|
||||
)
|
||||
(t,) = fs.tabell(hoved, RADER["30"], None, M5, VALG).values()
|
||||
h = fs.hovedtabell(hoved, M5, VALG, NORM)
|
||||
assert h.losninger[Losning.A].maal["M6"].dom is Dom.HOLDER
|
||||
assert t.losninger[Losning.A].maal["M6"].dom is Dom.BETINGELSER
|
||||
assert t.losninger[Losning.A].maal["M6"].andel_holder == 0.0
|
||||
assert t.losninger[Losning.A].maal["M1"] == h.losninger[Losning.A].maal["M1"]
|
||||
# a path without a year of stable operation has neither figure
|
||||
assert t.losninger[Losning.C].maal["M6"] == h.losninger[Losning.C].maal["M6"]
|
||||
assert (h.del_I, t.del_I) == (Dom.HOLDER, Dom.BETINGELSER)
|
||||
assert t.gjelder == (Losning.A, Losning.C)
|
||||
|
||||
|
||||
def test_C_i_moduler_staar_paa_plassen_til_C_og_endrer_ikke_M7_og_del_I() -> None:
|
||||
"""Row 35: the path beats A in every draw, and is still not one of the five solutions."""
|
||||
hoved = _kjoring([{Losning.A: _u(1.0), Losning.C: _u(0.5)} for _ in range(10)])
|
||||
radkjoring = _kjoring([{Losning.C: _u(-2.0 if j < 9 else 3.0)} for j in range(10)])
|
||||
(t,) = fs.tabell(hoved, RADER["35"], radkjoring, M5, VALG).values()
|
||||
h = fs.hovedtabell(hoved, M5, VALG, NORM)
|
||||
assert t.losninger[Losning.C].maal["M1"].andel_holder == 0.1
|
||||
assert t.losninger[Losning.C].median_M1 == -2.0
|
||||
assert (t.M7, t.del_I, t.del_II) == (h.M7, h.del_I, h.del_II)
|
||||
assert h.M7 is not None
|
||||
assert h.M7.andel_holder == 1.0
|
||||
|
||||
|
||||
def test_tabellen_har_en_rad_per_scenario_raden_leses_av_i() -> None:
|
||||
hoved = _kjoring([{Losning.C: _u(1.0)} for _ in range(4)], scenarioer=(NORM, VARER, LAVT, HOYT))
|
||||
radkjoring = _kjoring([{Losning.C: _u(-1.0)} for _ in range(4)], scenarioer=(LAVT, HOYT))
|
||||
t = fs.tabell(hoved, RADER["31a"], radkjoring, M5, VALG)
|
||||
assert list(t) == [LAVT.navn, HOYT.navn]
|
||||
assert all(rad.losninger[Losning.C].median_M1 == -1.0 for rad in t.values())
|
||||
varig = fs.tabell(hoved, RADER["12"], None, M5, VALG)
|
||||
assert list(varig) == [VARER.navn]
|
||||
# the rows of the ownership forms have no table here, and nothing has one without a step
|
||||
assert fs.tabell(hoved, RADER["24"], None, M5, VALG) == {}
|
||||
assert fs.tabell(hoved, RADER["31a"], radkjoring, M5, Trinnvalg(None, Grunnlag.INGEN)) == {}
|
||||
|
||||
|
||||
def test_tabellen_gjennom_modellen_paa_oppdiktede_trekninger(oppdiktet: LagInndata) -> None:
|
||||
"""Row 14 through the model: the row's outcomes are the main run's with the value replaced."""
|
||||
trekninger = [oppdiktet(), oppdiktet(c_H0=150e6), oppdiktet(n_reaktor=100.0)]
|
||||
losninger = (Losning.A, Losning.C)
|
||||
hoved = kj.kjor(trekninger, stige=(2,), scenarioer=(NORM,), losninger=losninger)
|
||||
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
|
||||
m5 = dict.fromkeys(losninger, Dom.HOLDER)
|
||||
radkjoring = fs.kjor_rad(trekninger, RADER["14"], valg, scenarioer=(NORM,), losninger=losninger)
|
||||
(t,) = fs.tabell(hoved, RADER["14"], radkjoring, m5, valg).values()
|
||||
byttet = kj.kjor(
|
||||
[x.med({"p_v": 1198.0}) for x in trekninger],
|
||||
stige=(2,),
|
||||
scenarioer=(NORM,),
|
||||
losninger=losninger,
|
||||
)
|
||||
assert t.losninger == fs.hovedtabell(byttet, m5, valg, NORM).losninger
|
||||
assert t.del_I == dommer.del_I(
|
||||
{a: t.losninger[a].dommer for a in losninger},
|
||||
{a: t.losninger[a].median_M1 for a in losninger},
|
||||
valg,
|
||||
)
|
||||
|
||||
|
||||
# ------------------------------------------- the rows of the ownership forms
|
||||
|
||||
|
||||
def _eiertrekninger(oppdiktet: LagInndata) -> list[Inndata]:
|
||||
"""Three made-up draws with an overrun in A (u_xi below w_xi) and a made-up eps_e."""
|
||||
return [
|
||||
dataclasses.replace(x, v={**x.v, "eps_e": eps})
|
||||
for x, eps in (
|
||||
(oppdiktet(u_xi=0.3), 0.05),
|
||||
(oppdiktet(u_xi=0.3, p_v=3000.0), -0.02),
|
||||
(oppdiktet(u_xi=0.3, c_H0=150e6), 0.08),
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
def _eier(
|
||||
inn: Inndata, losning: Losning = Losning.A
|
||||
) -> tuple[ks.Programresultat, eierskap.Bedriftsstrom]:
|
||||
dim = ks.dimensjoner(inn, losning)
|
||||
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
|
||||
res = ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING, dim=dim)
|
||||
return res, eierskap.bedriftsstrom(inn, res, tilleggsregel=True)
|
||||
|
||||
|
||||
def test_eierformradene_gir_det_avklaring_122_sier(oppdiktet: LagInndata) -> None:
|
||||
trekninger = _eiertrekninger(oppdiktet)
|
||||
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
|
||||
|
||||
def tabell(rad: Eierrad) -> kj.Eierformtabell:
|
||||
t = kj.eierformer_paa_trinnet(
|
||||
trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,), rad=rad
|
||||
)[Losning.A]
|
||||
assert t is not None
|
||||
return t
|
||||
|
||||
hoved = tabell(Eierrad.HOVED)
|
||||
assert (
|
||||
hoved
|
||||
== kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,))[
|
||||
Losning.A
|
||||
]
|
||||
)
|
||||
former = list(EOS)
|
||||
per_trekning = [_eier(x) for x in trekninger]
|
||||
|
||||
def lcoc(navn: str) -> list[float]:
|
||||
return [
|
||||
eierskap.lcoc_med_kapitalkostnad(x, res, eierskap.krav_for_skatt(x, x.eierformer[navn]))
|
||||
for x, (res, _) in zip(trekninger, per_trekning, strict=True)
|
||||
]
|
||||
|
||||
# line 24: the state's cash flow valued with the state's borrowing rate
|
||||
med_24 = tabell(Eierrad.STATENS_RENTE)
|
||||
for j, navn in enumerate(former):
|
||||
utfall = [
|
||||
eierskap.eierresultat(x, strom, x.eierformer[navn], rente=x["r_stat"])
|
||||
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
|
||||
]
|
||||
assert med_24.kriterier[j] == eierskap.eierkriterier(navn, utfall, lcoc(navn))
|
||||
assert med_24.kriterier != hoved.kriterier
|
||||
|
||||
# line 25: the settlement priced with the owners' required return on equity
|
||||
med_25 = tabell(Eierrad.EGENKAPITALKRAV)
|
||||
for j, navn in enumerate(former):
|
||||
utfall = [
|
||||
eierskap.eierresultat(x, strom, x.eierformer[navn])
|
||||
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
|
||||
]
|
||||
assert med_25.kriterier[j] == eierskap.eierkriterier(
|
||||
navn, utfall, lcoc(navn), egenkapitalkrav=True
|
||||
)
|
||||
# the two forms without private owners have no settlement and are unchanged
|
||||
assert med_25.kriterier[:2] == hoved.kriterier[:2]
|
||||
assert med_25.kriterier[2:] != hoved.kriterier[2:]
|
||||
|
||||
# line 28: the costs of direct ownership and the wholly owned company times 1 + eps_e
|
||||
med_28 = tabell(Eierrad.EFFEKTIVITET)
|
||||
assert med_28.kriterier[2:] == hoved.kriterier[2:]
|
||||
for j, navn in enumerate(former[:2]):
|
||||
utfall, kost = [], []
|
||||
for x, (res, _) in zip(trekninger, per_trekning, strict=True):
|
||||
faktor = 1.0 + x["eps_e"]
|
||||
strom = eierskap.bedriftsstrom(x, res, tilleggsregel=True, kostnadsfaktor=faktor)
|
||||
utfall.append(eierskap.eierresultat(x, strom, x.eierformer[navn]))
|
||||
kost.append(
|
||||
eierskap.lcoc_med_kapitalkostnad(
|
||||
x, res, eierskap.krav_for_skatt(x, x.eierformer[navn]), kostnadsfaktor=faktor
|
||||
)
|
||||
)
|
||||
assert med_28.kriterier[j] == eierskap.eierkriterier(navn, utfall, kost)
|
||||
assert med_28.kriterier[j] != hoved.kriterier[j]
|
||||
|
||||
# line 29: zeta equal to the state's share; 1 already for the two forms the state owns alone
|
||||
med_29 = tabell(Eierrad.ZETA_LIK_EIERANDEL)
|
||||
assert med_29.kriterier[:2] == hoved.kriterier[:2]
|
||||
for j, navn in enumerate(former[2:], start=2):
|
||||
utfall = [
|
||||
eierskap.eierresultat(
|
||||
x, strom, dataclasses.replace(x.eierformer[navn], zeta=x.eierformer[navn].s)
|
||||
)
|
||||
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
|
||||
]
|
||||
assert med_29.kriterier[j] == eierskap.eierkriterier(navn, utfall, lcoc(navn))
|
||||
assert med_29.kriterier[j] != hoved.kriterier[j]
|
||||
|
||||
|
||||
def test_uten_eps_e_er_effektivitetsraden_hovedkjoringen(oppdiktet: LagInndata) -> None:
|
||||
trekninger = [
|
||||
dataclasses.replace(x, v={**x.v, "eps_e": 0.0}) for x in _eiertrekninger(oppdiktet)
|
||||
]
|
||||
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
|
||||
kall = {"scenario": NORM, "losninger": (Losning.C,)}
|
||||
assert kj.eierformer_paa_trinnet(
|
||||
trekninger,
|
||||
valg,
|
||||
EOS,
|
||||
rad=Eierrad.EFFEKTIVITET,
|
||||
**kall, # type: ignore[arg-type]
|
||||
) == kj.eierformer_paa_trinnet(trekninger, valg, EOS, **kall) # type: ignore[arg-type]
|
||||
|
||||
|
||||
def test_statens_kontantstrom_ved_siden_av_M6_over_trekningene(oppdiktet: LagInndata) -> None:
|
||||
"""Clarification 123: S30 for the wholly owned company in the stable year, over M6's base."""
|
||||
trekninger = [*_eiertrekninger(oppdiktet), oppdiktet(n_reaktor=40.0)]
|
||||
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
|
||||
t = kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,))[
|
||||
Losning.A
|
||||
]
|
||||
assert t is not None
|
||||
# with 40 MW of reactors a year the second facility of A does not start by 2060
|
||||
assert t.antall_byggbare == 3
|
||||
tall = []
|
||||
for x in trekninger[:3]:
|
||||
res, strom = _eier(x)
|
||||
heleid = eierskap.eierresultat(x, strom, x.eierformer["heleid_selskap"])
|
||||
tall.append(eierskap.statens_kontantstrom_ved_m6(x, res, heleid))
|
||||
assert all(v is not None for v in tall)
|
||||
assert t.statens_kontantstrom == kj.sidetall(tall)
|
||||
assert t.statens_kontantstrom is not None
|
||||
assert t.statens_kontantstrom.antall == 3
|
||||
613
tests/test_folsomheter_modell.py
Normal file
613
tests/test_folsomheter_modell.py
Normal file
|
|
@ -0,0 +1,613 @@
|
|||
"""The switches of the sensitivity list in the model code: lines 4, 7, 8, 10, 12, 13, 20 and 21.
|
||||
|
||||
Clarifications 118 a, 119, 120 and 121 of the specification. Every switch is
|
||||
checked three ways: off it gives the main run's figures exactly, on it changes
|
||||
the place the text names as a hand computation gives, and it is refused for the
|
||||
solutions its line does not apply to. Everything is computed on the made-up set
|
||||
in ``conftest.py``; the numbers say nothing about the hypothesis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
from dataclasses import replace
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import eierskap as ei
|
||||
from tokenfabrikker import kontantstrom as ks
|
||||
from tokenfabrikker import ligninger as lg
|
||||
from tokenfabrikker import nivaaisert as nv
|
||||
from tokenfabrikker import skala
|
||||
from tokenfabrikker.kontantstrom import Knapphet, Paaslagsform
|
||||
from tokenfabrikker.utbygging import Losning
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from conftest import LagInndata
|
||||
from tokenfabrikker.inndata import Inndata
|
||||
|
||||
NORM = Knapphet.NORMALISERING
|
||||
|
||||
STEG = {"A>=A*": 1.0, "0.99<=A<A*": 0.9, "0.95<=A<0.99": 0.7, "A<0.95": 0.0}
|
||||
"""The steps of clarification 119 c, as the text gives them."""
|
||||
|
||||
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
|
||||
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
|
||||
|
||||
|
||||
def _med(inn: Inndata, **verdier: float) -> Inndata:
|
||||
"""The set with quantities the made-up set does not have (P_dim0, tau_pi)."""
|
||||
return replace(inn, v={**inn.v, **verdier})
|
||||
|
||||
|
||||
def _crf(rho: float, levetid: float) -> float:
|
||||
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
|
||||
|
||||
|
||||
def _diskontering(res: ks.Programresultat, rho: float) -> np.ndarray:
|
||||
return np.array([(1.0 + rho) ** -(t - res.plan.T_0) for t in res.aar])
|
||||
|
||||
|
||||
def _regn(
|
||||
inn: Inndata,
|
||||
losning: Losning,
|
||||
*,
|
||||
N_anlegg: int = 2,
|
||||
knapphet: Knapphet = NORM,
|
||||
**dim_valg: object,
|
||||
) -> ks.Programresultat:
|
||||
dim = ks.dimensjoner(inn, losning, **dim_valg) # type: ignore[arg-type]
|
||||
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
|
||||
return ks.regn_program(inn, losning, plan, knapphet, dim=dim)
|
||||
|
||||
|
||||
def _samme_kontantstrom(a: ks.Programresultat, b: ks.Programresultat) -> None:
|
||||
"""The yearly cash flows and the effects outside them are the same to the last digit."""
|
||||
for felt in ("KS_D", "KS_N", "F_a", "Delta_W", "utslipp", "K_prog", "V"):
|
||||
assert getattr(a, felt).tobytes() == getattr(b, felt).tobytes(), felt
|
||||
assert a.kraftaar == b.kraftaar
|
||||
|
||||
|
||||
# ------------------------------------------------------------ which solutions
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("valg", "gjelder"),
|
||||
[
|
||||
({"minstelast": 0.2}, ks.SMAA_ENHETER),
|
||||
({"fritt_enhetsvalg": True}, ks.SMAA_ENHETER),
|
||||
({"gamma_trinn": True}, {Losning.A}),
|
||||
({"paaslag_kjernekraft": 0.02}, ks.KJERNEKRAFT_PAA_NETT),
|
||||
({"skaler_K_U": False}, ks.SMAA_ENHETER),
|
||||
({"bare_over_dimensjonerende_feil": True}, ks.KJERNEKRAFT_PAA_NETT),
|
||||
],
|
||||
)
|
||||
def test_en_bryter_gjelder_bare_losningene_linja_nevner(
|
||||
oppdiktet: LagInndata, valg: dict[str, object], gjelder: set[Losning]
|
||||
) -> None:
|
||||
"""Clarifications 117 to 121: a row is not computed for a solution its line does not name."""
|
||||
inn = replace(oppdiktet(), Gamma_trinn=STEG)
|
||||
for losning in Losning:
|
||||
if losning in gjelder:
|
||||
ks.dimensjoner(inn, losning, **valg) # type: ignore[arg-type]
|
||||
else:
|
||||
with pytest.raises(ValueError, match="applies to"):
|
||||
ks.dimensjoner(inn, losning, **valg) # type: ignore[arg-type]
|
||||
|
||||
|
||||
def test_minstelast_og_fritt_valg_er_to_rader(oppdiktet: LagInndata) -> None:
|
||||
with pytest.raises(ValueError, match="two rows"):
|
||||
ks.dimensjoner(oppdiktet(), Losning.A, minstelast=0.2, fritt_enhetsvalg=True)
|
||||
|
||||
|
||||
def test_valgene_staar_paa_dimensjoneringen(oppdiktet: LagInndata) -> None:
|
||||
hoved = ks.dimensjoner(oppdiktet(), Losning.B)
|
||||
assert (hoved.paaslag_kjernekraft, hoved.skaler_K_U, hoved.bare_over_dimensjonerende_feil) == (
|
||||
0.0,
|
||||
True,
|
||||
False,
|
||||
)
|
||||
med = ks.dimensjoner(
|
||||
oppdiktet(), Losning.B, paaslag_kjernekraft=0.02, bare_over_dimensjonerende_feil=True
|
||||
)
|
||||
assert med.paaslag_kjernekraft == 0.02
|
||||
assert med.bare_over_dimensjonerende_feil
|
||||
assert replace(med, paaslag_kjernekraft=0.0, bare_over_dimensjonerende_feil=False) == hoved
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- line 7
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.A, Losning.B_MERKET])
|
||||
def test_linje_7_minstelast_paa_plassen_til_lambda_i_s7(
|
||||
oppdiktet: LagInndata, losning: Losning
|
||||
) -> None:
|
||||
"""119 a: P_u = max{P <= chi 0.20 PUE P_IT} = max{P <= 24 MW} = 20 MW, m = ceil(1200 / 20)."""
|
||||
inn = oppdiktet()
|
||||
hoved = ks.dimensjoner(inn, losning)
|
||||
dim = ks.dimensjoner(inn, losning, minstelast=0.20)
|
||||
assert (hoved.P_u, hoved.m) == (50.0, 24)
|
||||
assert (dim.P_u, dim.m) == (20.0, 60)
|
||||
# S8 with the design values for a unit below 300 MW: o' = (1 - 0.1) 0.04
|
||||
r = lg.s8_reserveenheter(m=60, o_merket=0.9 * 0.04, A_krav=0.99)
|
||||
n_p = lg.s8_planlagt_ute(m=60, r=r, o_p=0.05)
|
||||
assert (dim.r, dim.n_p, dim.N_u) == (r, n_p, 60 + r + n_p)
|
||||
assert dim.P_G_N == dim.N_u * 20.0
|
||||
# lambda is unchanged everywhere else
|
||||
assert dim.E_D == hoved.E_D == pytest.approx(E_D)
|
||||
res = _regn(inn, losning, N_anlegg=1, minstelast=0.20)
|
||||
assert res.verk[0][0].effekt == dim.N_u * 20.0
|
||||
if losning is Losning.A:
|
||||
assert dim.Gamma == lg.s44_inntektsfaktor(m=60, r=r, o_f_A=0.04, beta_F=0.1)
|
||||
|
||||
|
||||
def test_linje_7_gir_b_merket_samme_enheter_som_a(oppdiktet: LagInndata) -> None:
|
||||
a = ks.dimensjoner(oppdiktet(), Losning.A, minstelast=0.20)
|
||||
b = ks.dimensjoner(oppdiktet(), Losning.B_MERKET, minstelast=0.20)
|
||||
assert (a.P_u, a.m, a.r, a.n_p, a.N_u) == (b.P_u, b.m, b.r, b.n_p, b.N_u)
|
||||
assert b.Gamma == 1.0
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- line 8
|
||||
|
||||
|
||||
def test_linje_8_billigste_storrelse_er_den_med_lavest_c_A(oppdiktet: LagInndata) -> None:
|
||||
"""119 b: c_A for every size; the chosen one has the lowest, and A's units follow it."""
|
||||
inn = oppdiktet()
|
||||
P_u, c_A = ks.billigste_enhetsstorrelse(inn, rho_A=0.08)
|
||||
assert sorted(c_A) == sorted(inn.P_u_sett)
|
||||
assert c_A[P_u] == min(c_A.values())
|
||||
dim = ks.dimensjoner(inn, Losning.A, fritt_enhetsvalg=True)
|
||||
assert dim.P_u == P_u
|
||||
assert dim.m == math.ceil(1200.0 / P_u - 1e-9)
|
||||
o_f = 0.04 if P_u < 300 else 0.02
|
||||
assert dim.Gamma == lg.s44_inntektsfaktor(m=dim.m, r=dim.r, o_f_A=o_f, beta_F=0.1)
|
||||
# with the size of the main run (50 MW, buffer 600 MW > 50 MW) c_A is the main run's S9
|
||||
hoved = _regn(inn, Losning.A, N_anlegg=1)
|
||||
assert hoved.dim.P_u == 50.0
|
||||
assert c_A[50.0] == pytest.approx(nv.kraftkostnad_dedikert(inn, hoved, 0, 0.08), rel=1e-14)
|
||||
|
||||
|
||||
def test_linje_8_bufferen_dekker_tapet_av_storste_enhet_i_c_A(oppdiktet: LagInndata) -> None:
|
||||
"""119 b: P_buf = max(delta_L PUE P_IT, P). With delta_L 0.1 the buffer is 120 MW."""
|
||||
inn = oppdiktet(delta_L=0.1)
|
||||
_, c_A = ks.billigste_enhetsstorrelse(inn, rho_A=0.08)
|
||||
hoved = ks.dimensjoner(inn, Losning.A)
|
||||
for P in (500.0, 1000.0):
|
||||
m = math.ceil(1200.0 / P)
|
||||
r, n_p, N_u = ks._reserve(inn, P, m) # noqa: SLF001 - S8 as dimensjoner computes it
|
||||
uten = replace(hoved, P_u=P, m=m, r=r, n_p=n_p, N_u=N_u, P_G_N=N_u * P)
|
||||
ekstra = (P - 120.0) * (10e6 * _crf(0.08, 20) + 0.4e6) / E_D
|
||||
assert c_A[P] == pytest.approx(ks.kraftkostnad_dedikert(inn, uten, 0, 0.08) + ekstra)
|
||||
|
||||
|
||||
def test_linje_8_minste_storrelse_ved_likhet(
|
||||
oppdiktet: LagInndata, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
monkeypatch.setattr(ks, "kraftkostnad_dedikert", lambda *_a, **_k: 1000.0)
|
||||
P_u, _ = ks.billigste_enhetsstorrelse(oppdiktet(), rho_A=0.08)
|
||||
assert P_u == 5.0
|
||||
|
||||
|
||||
def test_linje_8_bufferen_staar_alle_steder_p_buf_staar(oppdiktet: LagInndata) -> None:
|
||||
"""119 b: one buffer everywhere: the cash flow, S9, S31 and the business cash flow.
|
||||
|
||||
The same 50 MW units with delta_L 0.001 (a 1.2 MW buffer); with the free
|
||||
choice the buffer is the 50 MW unit, and every place moves by 48.8 MW of buffer.
|
||||
"""
|
||||
inn = oppdiktet(delta_L=0.001)
|
||||
dim = ks.dimensjoner(inn, Losning.A)
|
||||
plan = ks.lag_plan(inn, Losning.A, dim, N_anlegg=1)
|
||||
res = ks.regn_program(inn, Losning.A, plan, NORM, dim=dim)
|
||||
fri = ks.regn_program(inn, Losning.A, plan, NORM, dim=replace(dim, fritt_enhetsvalg=True))
|
||||
assert ks.bufferstorrelse(inn, dim) == pytest.approx(1.2)
|
||||
assert ks.bufferstorrelse(inn, fri.dim) == 50.0
|
||||
mer = 50.0 - 1.2
|
||||
# the cash flow: the buffer is bought the year before start, and costs f_buf per year
|
||||
start = plan.anlegg[0].start
|
||||
j = start - 1 - 2027
|
||||
assert fri.anlegg[0].buffer[j] - res.anlegg[0].buffer[j] == pytest.approx(mer * 10e6)
|
||||
assert fri.anlegg[0].buffer[j + 2] - res.anlegg[0].buffer[j + 2] == pytest.approx(mer * 0.4e6)
|
||||
# S9
|
||||
aarlig = mer * (10e6 * _crf(0.08, 20) + 0.4e6)
|
||||
assert nv.kraftkostnad_dedikert(inn, fri, 0, 0.08) - nv.kraftkostnad_dedikert(
|
||||
inn, res, 0, 0.08
|
||||
) == pytest.approx(aarlig / E_D)
|
||||
# S31, in an operating year
|
||||
B_res = skala.overskudd_utover_avkastning(inn, res)
|
||||
B_fri = skala.overskudd_utover_avkastning(inn, fri)
|
||||
assert B_res[j + 2] - B_fri[j + 2] == pytest.approx(aarlig)
|
||||
# the business cash flow: the fixed cost of the buffer in every operating year
|
||||
s_res, s_fri = ei.bedriftsstrom(inn, res), ei.bedriftsstrom(inn, fri)
|
||||
assert s_fri.drift[j + 2] - s_res.drift[j + 2] == pytest.approx(mer * 0.4e6)
|
||||
|
||||
|
||||
def test_linje_8_b_merket_faar_enhetene_til_a_og_ingen_buffer(oppdiktet: LagInndata) -> None:
|
||||
inn = oppdiktet()
|
||||
a = ks.dimensjoner(inn, Losning.A, fritt_enhetsvalg=True)
|
||||
b = ks.dimensjoner(inn, Losning.B_MERKET, fritt_enhetsvalg=True)
|
||||
assert (a.P_u, a.m, a.r, a.n_p, a.N_u) == (b.P_u, b.m, b.r, b.n_p, b.N_u)
|
||||
res = _regn(inn, Losning.B_MERKET, N_anlegg=1, fritt_enhetsvalg=True)
|
||||
assert not res.anlegg[0].buffer.any()
|
||||
assert res.verk[0][0].effekt == b.N_u * b.P_u
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ line 10
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("A", "A_krav", "Gamma"),
|
||||
[
|
||||
(0.995, 0.995, 1.0),
|
||||
(0.99499, 0.995, 0.9),
|
||||
(0.99, 0.995, 0.9),
|
||||
(0.98999, 0.995, 0.7),
|
||||
(0.95, 0.995, 0.7),
|
||||
(0.94999, 0.995, 0.0),
|
||||
(0.0, 0.995, 0.0),
|
||||
(0.99, 0.99, 1.0),
|
||||
(0.98999, 0.99, 0.7),
|
||||
(0.99995, 0.99995, 1.0),
|
||||
(0.99994, 0.99995, 0.9),
|
||||
],
|
||||
)
|
||||
def test_linje_10_trinnene_med_grensene(A: float, A_krav: float, Gamma: float) -> None:
|
||||
"""119 c: 1.0 from A*, 0.9 from 0.99, 0.7 from 0.95, zero below; empty second step at 0.99."""
|
||||
assert lg.s44_inntektsfaktor_trinn(tilgjengelighet=A, A_krav=A_krav, tabell=STEG) == Gamma
|
||||
|
||||
|
||||
def test_linje_10_tilgjengeligheten_for_haand() -> None:
|
||||
"""A = (1 - beta_F o_f) Pr[X >= m], X ~ Bin(m + r, 1 - o'), o' = (1 - beta_F) o_f.
|
||||
|
||||
m = 2, r = 1, o_f = 0.1, beta_F = 0.5: o' = 0.05, Pr[X >= 2] = 0.95^3 + 3 0.95^2 0.05.
|
||||
"""
|
||||
ventet = 0.95 * (0.95**3 + 3 * 0.95**2 * 0.05)
|
||||
assert lg.s44_tilgjengelighet(m=2, r=1, o_f_A=0.1, beta_F=0.5) == pytest.approx(ventet)
|
||||
assert ventet == pytest.approx(0.9431125)
|
||||
|
||||
|
||||
def test_linje_10_gamma_staar_alle_steder_gamma_staar(oppdiktet: LagInndata) -> None:
|
||||
"""119 c: A for the made-up plant is about 0.993; with A* = 0.995 Gamma is 0.9."""
|
||||
inn = replace(oppdiktet(A_krav=0.995), Gamma_trinn=STEG)
|
||||
dim = ks.dimensjoner(inn, Losning.A, gamma_trinn=True)
|
||||
hoved = ks.dimensjoner(inn, Losning.A)
|
||||
assert dim.tilgjengelighet == lg.s44_tilgjengelighet(m=dim.m, r=dim.r, o_f_A=0.04, beta_F=0.1)
|
||||
assert dim.tilgjengelighet is not None
|
||||
assert 0.99 <= dim.tilgjengelighet < 0.995
|
||||
assert dim.Gamma == 0.9
|
||||
assert (dim.P_u, dim.m, dim.N_u) == (hoved.P_u, hoved.m, hoved.N_u)
|
||||
assert hoved.tilgjengelighet is None
|
||||
plan = ks.lag_plan(inn, Losning.A, hoved, N_anlegg=1)
|
||||
res = ks.regn_program(inn, Losning.A, plan, NORM, dim=hoved)
|
||||
trinn = ks.regn_program(inn, Losning.A, plan, NORM, dim=dim)
|
||||
j = plan.anlegg[0].start - 2027
|
||||
assert trinn.anlegg[0].inntekt[j] == pytest.approx(res.anlegg[0].inntekt[j] * 0.9 / hoved.Gamma)
|
||||
aargang = nv.kraftkostnad(inn, trinn, bedrift=True).aarganger[0]
|
||||
assert aargang.inntekt == pytest.approx(0.9 * trinn.y(aargang.t_v))
|
||||
# with A* = 0.99 the plant is in the first step
|
||||
lav = replace(oppdiktet(), Gamma_trinn=STEG)
|
||||
assert ks.dimensjoner(lav, Losning.A, gamma_trinn=True).Gamma == 1.0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- lines 12, 13
|
||||
|
||||
|
||||
def _lcoc_v() -> float:
|
||||
"""S15 for the made-up competitor, per MW IT and year."""
|
||||
return 100e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 3e6 + 8760.0 * 0.75 * 1.2 * 800.0
|
||||
|
||||
|
||||
def test_linje_12_og_13_paaslaget_for_haand(oppdiktet: LagInndata) -> None:
|
||||
"""120: pi_0 for every vintage, and pi_0 exp(-(t_v - 2026) / tau_pi), without the cut."""
|
||||
inn = _med(oppdiktet(), tau_pi=2.5)
|
||||
pi_0 = 150e6 / _lcoc_v() - 1.0
|
||||
scenario = ks.regnekraftpris(inn, Knapphet.VARER, 2030)
|
||||
varig = ks.regnekraftpris(inn, Knapphet.VARER, 2030, form=Paaslagsform.VARIG)
|
||||
avtakende = ks.regnekraftpris(inn, Knapphet.VARER, 2030, form=Paaslagsform.AVTAKENDE)
|
||||
for t_v in (2030, 2039, 2040, 2055):
|
||||
assert varig.paaslag(t_v) == pytest.approx(pi_0)
|
||||
assert avtakende.paaslag(t_v) == pytest.approx(pi_0 * math.exp(-(t_v - 2026) / 2.5))
|
||||
assert varig(t_v) == pytest.approx(_lcoc_v() * (1.0 + pi_0))
|
||||
assert scenario.paaslag(2039) == varig.paaslag(2039)
|
||||
assert scenario.paaslag(2040) == 0.0
|
||||
assert lg.s43_avtakende_paaslag(pi_0=0.5, t_v=2026, tau_pi=2.0) == 0.5
|
||||
|
||||
|
||||
def test_linje_12_og_13_bare_naar_knappheten_varer(oppdiktet: LagInndata) -> None:
|
||||
inn = _med(oppdiktet(), tau_pi=2.5)
|
||||
for knapphet in (Knapphet.NORMALISERING, Knapphet.OVERKAPASITET):
|
||||
for form in (Paaslagsform.VARIG, Paaslagsform.AVTAKENDE):
|
||||
with pytest.raises(ValueError, match="knapphet varer"):
|
||||
ks.regnekraftpris(inn, knapphet, 2030, form=form)
|
||||
dim = ks.dimensjoner(inn, Losning.R)
|
||||
plan = ks.lag_plan(inn, Losning.R, dim, N_anlegg=1)
|
||||
with pytest.raises(ValueError, match="knapphet varer"):
|
||||
ks.regn_program(inn, Losning.R, plan, knapphet, dim=dim, paaslag=form)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
def test_linje_12_varig_paaslag_i_inntekten_og_marginen(
|
||||
oppdiktet: LagInndata, losning: Losning
|
||||
) -> None:
|
||||
"""The price in the result carries the form, so revenue and S19 follow (120)."""
|
||||
inn = _med(oppdiktet(tau_nett=6.0, g_fornybar=0.5e6), tau_pi=2.5)
|
||||
dim = ks.dimensjoner(inn, losning)
|
||||
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
|
||||
hoved = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim)
|
||||
varig = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, paaslag=Paaslagsform.VARIG)
|
||||
assert varig.y.form is Paaslagsform.VARIG
|
||||
pi_0 = 150e6 / _lcoc_v() - 1.0
|
||||
sene = [t_v for a in plan.anlegg for t_v in a.aarganger if t_v >= plan.t_1 + 10]
|
||||
assert sene
|
||||
for t_v in sene:
|
||||
assert hoved.y.paaslag(t_v) == 0.0
|
||||
assert varig.y(t_v) == pytest.approx(_lcoc_v() * (1.0 + pi_0))
|
||||
for a in nv.kraftkostnad(inn, varig).aarganger:
|
||||
assert a.margin is not None
|
||||
assert a.margin.knapphet == pytest.approx(pi_0 * _lcoc_v())
|
||||
assert varig.NNV > hoved.NNV
|
||||
assert skala.overskudd_utover_avkastning(inn, varig).sum() > (
|
||||
skala.overskudd_utover_avkastning(inn, hoved).sum()
|
||||
)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- line 20
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.A, Losning.B_MERKET])
|
||||
def test_linje_20_K_U_uten_skalering(oppdiktet: LagInndata, losning: Losning) -> None:
|
||||
"""121: q_N E = N_u phi_U [K_U - min(K_U, D_fors)] with K_U unscaled; 50 MW units, N_u = 30."""
|
||||
inn = oppdiktet()
|
||||
hoved = _regn(inn, losning, N_anlegg=1)
|
||||
uten = _regn(inn, losning, N_anlegg=1, skaler_K_U=False)
|
||||
assert uten.dim.N_u == hoved.dim.N_u == 30
|
||||
assert hoved.verk[0][0].ulykke == pytest.approx(30 * 1e-5 * (1e12 * 0.05 - 8e9))
|
||||
assert uten.verk[0][0].ulykke == pytest.approx(30 * 1e-5 * (1e12 - 8e9))
|
||||
j = hoved.plan.anlegg[0].start - 2027
|
||||
assert uten.anlegg[0].ulykke[j] == pytest.approx(30 * 1e-5 * (1e12 - 8e9))
|
||||
mer = 30 * 1e-5 * (1e12 - 8e9) - 30 * 1e-5 * (1e12 * 0.05 - 8e9)
|
||||
if losning is Losning.A:
|
||||
assert nv.kraftkostnad_dedikert(inn, uten, 0, 0.08) - nv.kraftkostnad_dedikert(
|
||||
inn, hoved, 0, 0.08
|
||||
) == pytest.approx(mer / E_D)
|
||||
else:
|
||||
E_N = hoved.verk[0][0].energi
|
||||
assert nv.ulykkeskostnad_per_mwh(inn, uten, N_u=30, E_N=E_N) - nv.ulykkeskostnad_per_mwh(
|
||||
inn, hoved, N_u=30, E_N=E_N
|
||||
) == pytest.approx(mer / E_N)
|
||||
# the other terms of S35 and the revenue are the same
|
||||
assert uten.KS_D.tobytes() == hoved.KS_D.tobytes()
|
||||
assert uten.KS_N - hoved.KS_N == pytest.approx(
|
||||
-(uten.anlegg[0].ulykke - hoved.anlegg[0].ulykke)
|
||||
)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- line 21
|
||||
|
||||
|
||||
def test_linje_21_s47_med_fradraget_for_haand() -> None:
|
||||
assert (
|
||||
lg.s47_utfall_ut_over_dimensjonerende_feil(
|
||||
Delta_R=500.0, storste_enhet=980.0, P_dim0=1450.0
|
||||
)
|
||||
== 500.0
|
||||
)
|
||||
assert lg.s47_utfall_ut_over_dimensjonerende_feil(
|
||||
Delta_R=500.0, storste_enhet=980.0, P_dim0=300.0
|
||||
) == pytest.approx(-180.0)
|
||||
|
||||
|
||||
def _snittpris(res: ks.Programresultat, t: int) -> float:
|
||||
priser = [
|
||||
res.mu_d(v) * res.y(v)
|
||||
for v in (res.plan.aargang(k, t) for k in range(len(res.plan.anlegg)))
|
||||
if v is not None
|
||||
]
|
||||
return math.fsum(priser) / len(priser) if priser else 0.0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("P_dim0", [0.0, 300.0, 1450.0])
|
||||
@pytest.mark.parametrize("losning", [Losning.B, Losning.T_K])
|
||||
def test_linje_21_bare_det_enheten_er_storre_enn_dimensjonerende_feil(
|
||||
oppdiktet: LagInndata, losning: Losning, P_dim0: float
|
||||
) -> None:
|
||||
"""121: Delta R^-1' = Delta R - max(0, 980 - P_dim0) in both arms; M4 keeps the whole unit."""
|
||||
inn = _med(oppdiktet(delta_V=0.0, tau_nett=6.0, g_fornybar=0.5e6), P_dim0=P_dim0)
|
||||
hoved = _regn(inn, losning)
|
||||
med = _regn(inn, losning, bare_over_dimensjonerende_feil=True)
|
||||
assert med.kraftaar == hoved.kraftaar
|
||||
assert max(rad.storste_enhet for rad in med.kraftaar) == pytest.approx(980.0)
|
||||
fradrag = max(0.0, 980.0 - P_dim0)
|
||||
F_bed = nv.effektkostnad_bedrift(inn, med)
|
||||
for j, rad in enumerate(med.kraftaar[1:], start=1):
|
||||
utfall = rad.Delta_R - (fradrag if rad.storste_enhet > 0 else 0.0)
|
||||
y = _snittpris(med, med.aar[j])
|
||||
assert med.F_a[j] == pytest.approx(
|
||||
lg.s47_effektkostnad(
|
||||
Delta_R=rad.Delta_R,
|
||||
Delta_R_utfall=utfall,
|
||||
c_fast=1.4e6,
|
||||
c_res=1.0e6,
|
||||
h_knapp=100.0,
|
||||
mu=1.0,
|
||||
y=y,
|
||||
PUE=1.2,
|
||||
),
|
||||
abs=1e-6,
|
||||
)
|
||||
if y > 0:
|
||||
assert F_bed[j] == pytest.approx(
|
||||
lg.s47_utkobling(Delta_R_utfall=utfall, h_knapp=100.0, mu=1.0, y=y, PUE=1.2),
|
||||
abs=1e-6,
|
||||
)
|
||||
if P_dim0 == 0.0:
|
||||
# the whole unit counts: S47 as in the main run, to the last digit
|
||||
assert med.F_a.tobytes() == hoved.F_a.tobytes()
|
||||
assert med.NNV == hoved.NNV
|
||||
else:
|
||||
assert med.F_a.sum() < hoved.F_a.sum()
|
||||
|
||||
|
||||
def test_linje_21_endrer_ikke_c_eller_r(oppdiktet: LagInndata) -> None:
|
||||
"""No nuclear power on the grid: the largest new unit is zero, and the line does not apply."""
|
||||
inn = _med(oppdiktet(delta_V=0.0), P_dim0=300.0)
|
||||
for losning in (Losning.C, Losning.R):
|
||||
assert all(rad.storste_enhet == 0.0 for rad in _regn(inn, losning).kraftaar)
|
||||
|
||||
|
||||
# -------------------------------------------------------------------- line 4
|
||||
|
||||
|
||||
def _kjernekraftens_egne(res: ks.Programresultat) -> np.ndarray:
|
||||
"""The nuclear plants' own terms of S35 (sales, investment, operation, decommissioning)."""
|
||||
v = res.varsigma.get(ks.KJERNEKRAFT, 1.0)
|
||||
ut = np.zeros(len(res.aar))
|
||||
for f in res.felles:
|
||||
ut += v * f.salg - f.investering - f.drift - f.avvikling
|
||||
for a in res.anlegg:
|
||||
if ks.KJERNEKRAFT in a.salg:
|
||||
i = ks.KJERNEKRAFT
|
||||
ut += v * a.salg[i] - a.investering[i] - a.kraftdrift[i] - a.avvikling[i]
|
||||
return ut
|
||||
|
||||
|
||||
def _sett_for_linje_4(oppdiktet: LagInndata, losning: Losning) -> Inndata:
|
||||
if losning is Losning.T_K:
|
||||
return oppdiktet(tau_nett=6.0, g_fornybar=0.5e6, L_N=30.0)
|
||||
return oppdiktet(L_N=30.0)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.B, Losning.B_MERKET, Losning.T_K])
|
||||
def test_linje_4_kjernekraftens_egne_ledd_med_egen_rente(
|
||||
oppdiktet: LagInndata, losning: Losning
|
||||
) -> None:
|
||||
"""118 a: rho_N + 0.02 = 0.08 for the nuclear plants' own terms in S26; the rest with 0.06.
|
||||
|
||||
The cash flows, the grid, q_N E, F_a and the other effects are unchanged.
|
||||
"""
|
||||
inn = _sett_for_linje_4(oppdiktet, losning)
|
||||
hoved = _regn(inn, losning)
|
||||
med = _regn(inn, losning, paaslag_kjernekraft=0.02)
|
||||
assert dict(med.varsigma) == dict(hoved.varsigma)
|
||||
_samme_kontantstrom(med, hoved)
|
||||
assert (med.NV_datasenter, med.NV_ovrige) == (hoved.NV_datasenter, hoved.NV_ovrige)
|
||||
egne = _kjernekraftens_egne(med)
|
||||
assert egne.any()
|
||||
resten = med.KS_N - egne
|
||||
ventet = math.fsum(_diskontering(med, 0.08) * egne) + math.fsum(
|
||||
_diskontering(med, 0.06) * resten
|
||||
)
|
||||
assert med.NV_kraft == pytest.approx(ventet, rel=1e-12)
|
||||
assert hoved.NV_kraft == pytest.approx(
|
||||
math.fsum(_diskontering(hoved, 0.06) * hoved.KS_N), rel=1e-12
|
||||
)
|
||||
# the decommissioning after the final year with 0.08 (S40): per group of the programme's
|
||||
# units, and in B' per facility, where the value part is the same as in the main run
|
||||
ventet_felles = math.fsum(
|
||||
-f.avvikling_etter * 1.08**-f.L_rest * 1.08**-33 for f in med.felles if f.L_rest > 0
|
||||
)
|
||||
assert med.RV_felles == pytest.approx(ventet_felles)
|
||||
if losning is Losning.B:
|
||||
assert ventet_felles < 0
|
||||
for a, rv_med, rv_hoved in zip(med.anlegg, med.RV_anlegg, hoved.RV_anlegg, strict=True):
|
||||
avvikling = math.fsum(a.avvikling_etter.values())
|
||||
endring = -avvikling * (1.08**-a.L_rest - 1.06**-a.L_rest) * 1.08**-33
|
||||
assert rv_med - rv_hoved == pytest.approx(endring, abs=1e-3)
|
||||
if losning is Losning.B_MERKET:
|
||||
assert avvikling > 0
|
||||
assert a.L_rest > 0
|
||||
assert med.SE == lg.s26_subsidieelement(
|
||||
naaverdi_prosjekt=med.NV_datasenter + med.NV_kraft + med.RV
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.B, Losning.B_MERKET, Losning.T_K])
|
||||
def test_linje_4_nivaaisert_og_skala_med_kjernekraftens_rente(
|
||||
oppdiktet: LagInndata, losning: Losning
|
||||
) -> None:
|
||||
"""118 a: S3 and S5 and the plant's part of ann_k with 0.08; H_a and renewables with 0.06.
|
||||
|
||||
The levelised cost with the markup is the main run's with the rate 0.08 passed for
|
||||
nuclear plants only, to the last digit.
|
||||
"""
|
||||
inn = _sett_for_linje_4(oppdiktet, losning)
|
||||
hoved = _regn(inn, losning)
|
||||
med = _regn(inn, losning, paaslag_kjernekraft=0.02)
|
||||
renter = nv.Renter(rho_D=0.08, rho_N=0.06, rho_A=0.08, rho_NK=0.08)
|
||||
assert nv.renter_i_hovedkjoringen(inn, med) == renter
|
||||
assert nv.renter_i_hovedkjoringen(inn, hoved).rho_kjernekraft == 0.06
|
||||
for bedrift in (False, True):
|
||||
a = nv.kraftkostnad(inn, med, bedrift=bedrift)
|
||||
b = nv.kraftkostnad(inn, hoved, bedrift=bedrift, renter=renter)
|
||||
assert a.c_a.tobytes() == b.c_a.tobytes()
|
||||
assert a.S42 == b.S42
|
||||
assert np.nansum(a.c_a) > np.nansum(nv.kraftkostnad(inn, hoved, bedrift=bedrift).c_a)
|
||||
assert (
|
||||
skala.overskudd_utover_avkastning(inn, med).tobytes()
|
||||
== skala.overskudd_utover_avkastning(inn, hoved, renter=renter).tobytes()
|
||||
)
|
||||
assert skala.overskudd_utover_avkastning(inn, med).sum() < (
|
||||
skala.overskudd_utover_avkastning(inn, hoved).sum()
|
||||
)
|
||||
|
||||
|
||||
def test_linje_4_renten_for_kjernekraft_alene(oppdiktet: LagInndata) -> None:
|
||||
"""118 a: with the markup only on nuclear plants, renewable plants in T-K keep rho_N."""
|
||||
inn = _sett_for_linje_4(oppdiktet, Losning.T_K)
|
||||
res = _regn(inn, Losning.T_K, paaslag_kjernekraft=0.02)
|
||||
r = nv.renter_i_hovedkjoringen(inn, res)
|
||||
fornybar = next(v for verk in res.verk for v in verk if v.teknologi == "vind")
|
||||
assert r.rho_N == 0.06
|
||||
assert nv.lcoe_fornybar(inn, fornybar.teknologi, r.rho_N) == nv.lcoe_fornybar(inn, "vind", 0.06)
|
||||
# the grid connection of every module with rho_N
|
||||
H_a = lg.s11_nettkostnad(
|
||||
I_nett=5e6, delta_V=0.5, PUE=1.2, P_IT=100.0, P_G_N=0.0, rho_N=0.06, L_nett=40
|
||||
)
|
||||
assert H_a == pytest.approx(5e6 * 0.5 * 1.2 * 100.0 * _crf(0.06, 40))
|
||||
|
||||
|
||||
def _nv_i(res: ks.Programresultat, varsigma: float, rho: float) -> float:
|
||||
"""NV_i of S45 for the programme's units by hand: present value with ``rho``, and S40."""
|
||||
D = _diskontering(res, rho)
|
||||
salg = math.fsum(math.fsum(D * f.salg) for f in res.felles)
|
||||
kost = math.fsum(math.fsum(D * (f.investering + f.drift + f.avvikling)) for f in res.felles)
|
||||
rest = math.fsum(
|
||||
lg.s40_restverdi(
|
||||
NK_snitt=varsigma * float(np.mean(f.salg[-5:]))
|
||||
- float(np.mean((f.investering + f.drift)[-5:])),
|
||||
L_rest=f.L_rest,
|
||||
rho_D=0.08,
|
||||
rho_avvikling=rho,
|
||||
avvikling=f.avvikling_etter,
|
||||
T_s=2060,
|
||||
T_0=2027,
|
||||
)
|
||||
for f in res.felles
|
||||
if f.L_rest > 0
|
||||
)
|
||||
return varsigma * salg - kost + rest
|
||||
|
||||
|
||||
def test_linje_4_tilleggsregelen_med_kjernekraftens_rente(oppdiktet: LagInndata) -> None:
|
||||
"""118 a: NV_i in S45 with 0.08 for nuclear power. Cheap units make the rule bind."""
|
||||
inn = oppdiktet(L_N=30.0, c_N_ref=10e6)
|
||||
hoved = _regn(inn, Losning.B)
|
||||
med = _regn(inn, Losning.B, paaslag_kjernekraft=0.02)
|
||||
v_hoved, v_med = hoved.varsigma[ks.KJERNEKRAFT], med.varsigma[ks.KJERNEKRAFT]
|
||||
assert v_hoved < v_med < 1.0
|
||||
skala_ = math.fsum(math.fsum(f.salg) for f in med.felles)
|
||||
assert _nv_i(med, v_med, 0.08) == pytest.approx(0.0, abs=1e-9 * skala_)
|
||||
assert _nv_i(hoved, v_hoved, 0.06) == pytest.approx(0.0, abs=1e-9 * skala_)
|
||||
assert _nv_i(med, v_hoved, 0.08) < 0.0
|
||||
|
||||
|
||||
def test_linje_4_restverdien_i_bedriftsokonomien(oppdiktet: LagInndata) -> None:
|
||||
"""The decommissioning after the final year in RV^bed with the nuclear plants' rate too."""
|
||||
inn = oppdiktet(L_N=30.0)
|
||||
med = _regn(inn, Losning.B, paaslag_kjernekraft=0.02)
|
||||
_, felles = ei.restverdi_bedrift(inn, med)
|
||||
assert felles == pytest.approx(
|
||||
math.fsum(-f.avvikling_etter * 1.08**-f.L_rest for f in med.felles if f.L_rest > 0)
|
||||
)
|
||||
446
tests/test_folsomheter_naaverdi.py
Normal file
446
tests/test_folsomheter_naaverdi.py
Normal file
|
|
@ -0,0 +1,446 @@
|
|||
"""The switches of the sensitivity list in S26 and the ownership forms: lines 16, 17, 18 and 28.
|
||||
|
||||
Clarifications 118 b to d, 122 and 123 of the specification, and that every
|
||||
switch at its default gives the main run's figures to the last digit.
|
||||
Everything is computed on the made-up set in ``conftest.py``; the numbers say
|
||||
nothing about the hypothesis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
from dataclasses import replace
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import eierskap as ei
|
||||
from tokenfabrikker import kontantstrom as ks
|
||||
from tokenfabrikker import ligninger as lg
|
||||
from tokenfabrikker import nivaaisert as nv
|
||||
from tokenfabrikker import skala
|
||||
from tokenfabrikker.kontantstrom import Diskontering, Knapphet, Paaslagsform, Skattekostnad
|
||||
from tokenfabrikker.utbygging import Losning
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from conftest import LagInndata
|
||||
from tokenfabrikker.inndata import Inndata
|
||||
|
||||
NORM = Knapphet.NORMALISERING
|
||||
|
||||
|
||||
def _crf(rho: float, levetid: float) -> float:
|
||||
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
|
||||
|
||||
|
||||
def _D(res: ks.Programresultat, rho: float) -> np.ndarray:
|
||||
return np.array([(1.0 + rho) ** -(t - res.plan.T_0) for t in res.aar])
|
||||
|
||||
|
||||
def _D_R(res: ks.Programresultat) -> np.ndarray:
|
||||
"""The circular's rate, by hand: 4 % for years 1 to 40, 3 % to 75, 2 % after (118 b)."""
|
||||
ut = []
|
||||
for t in res.aar:
|
||||
j = t - res.plan.T_0
|
||||
ut.append(1.04 ** -min(j, 40) * 1.03 ** -min(max(j - 40, 0), 35) * 1.02 ** -max(j - 75, 0))
|
||||
return np.array(ut)
|
||||
|
||||
|
||||
def _pv(D: np.ndarray, tabell: np.ndarray) -> float:
|
||||
return math.fsum(D * tabell)
|
||||
|
||||
|
||||
def _sett(
|
||||
oppdiktet: LagInndata,
|
||||
losning: Losning,
|
||||
*,
|
||||
L_N: float = 20.0,
|
||||
mu_rel: float = 1.0,
|
||||
T_slutt: float = 2060.0,
|
||||
) -> Inndata:
|
||||
"""The made-up set; solution T with a later grid and a slower pace, so T-K builds nuclear."""
|
||||
if losning.trinnvis:
|
||||
return oppdiktet(tau_nett=6.0, g_fornybar=0.5e6, L_N=L_N, mu_rel=mu_rel, T_slutt=T_slutt)
|
||||
return oppdiktet(L_N=L_N, mu_rel=mu_rel, T_slutt=T_slutt)
|
||||
|
||||
|
||||
def _regn(
|
||||
inn: Inndata,
|
||||
losning: Losning,
|
||||
*,
|
||||
N_anlegg: int = 2,
|
||||
knapphet: Knapphet = NORM,
|
||||
**program: object,
|
||||
) -> ks.Programresultat:
|
||||
dim = ks.dimensjoner(inn, losning)
|
||||
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
|
||||
return ks.regn_program(inn, losning, plan, knapphet, dim=dim, **program) # type: ignore[arg-type]
|
||||
|
||||
|
||||
def _alt(inn: Inndata, res: ks.Programresultat) -> dict[str, object]:
|
||||
"""Every figure the run reads from a path, as bytes or numbers, for an exact comparison."""
|
||||
ut: dict[str, object] = {
|
||||
felt: getattr(res, felt)
|
||||
for felt in ("NNV", "SE", "RV", "RV_anlegg", "RV_felles", "NV_kraft", "NV_datasenter")
|
||||
}
|
||||
for felt in ("KS_D", "KS_N", "F_a", "Delta_W", "V"):
|
||||
ut[felt] = getattr(res, felt).tobytes()
|
||||
ut["varsigma"] = dict(res.varsigma)
|
||||
for bedrift in (False, True):
|
||||
kost = nv.kraftkostnad(inn, res, bedrift=bedrift)
|
||||
ut[f"c_a{bedrift}"] = kost.c_a.tobytes()
|
||||
ut[f"S42{bedrift}"] = kost.S42
|
||||
ut["B_6"] = skala.skala(inn, res).B_6.tobytes()
|
||||
strom = ei.bedriftsstrom(inn, res, tilleggsregel=True)
|
||||
ut["NK"] = strom.NK.tobytes()
|
||||
for form in inn.eierformer.values():
|
||||
e = ei.eierresultat(inn, strom, form)
|
||||
ut[form.navn] = (e.NV_stat, e.KS_stat.tobytes())
|
||||
ut[f"LCOC {form.navn}"] = ei.lcoc_med_kapitalkostnad(inn, res, ei.krav_for_skatt(inn, form))
|
||||
return ut
|
||||
|
||||
|
||||
# ------------------------------------------------------ off is the main run
|
||||
|
||||
|
||||
@pytest.mark.parametrize("knapphet", list(Knapphet))
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
def test_alle_brytere_av_gir_hovedkjoringen(
|
||||
oppdiktet: LagInndata, losning: Losning, knapphet: Knapphet
|
||||
) -> None:
|
||||
"""Every switch given at its default value gives the main run to the last digit."""
|
||||
inn = _sett(oppdiktet, losning, L_N=30.0)
|
||||
hoved = _regn(inn, losning, knapphet=knapphet)
|
||||
dim = ks.dimensjoner(
|
||||
inn,
|
||||
losning,
|
||||
rho_A=None,
|
||||
minstelast=None,
|
||||
fritt_enhetsvalg=False,
|
||||
gamma_trinn=False,
|
||||
paaslag_kjernekraft=0.0,
|
||||
skaler_K_U=True,
|
||||
bare_over_dimensjonerende_feil=False,
|
||||
)
|
||||
assert dim == hoved.dim
|
||||
av = ks.regn_program(
|
||||
inn,
|
||||
losning,
|
||||
hoved.plan,
|
||||
knapphet,
|
||||
dim=dim,
|
||||
paaslag=Paaslagsform.SCENARIO,
|
||||
diskontering=Diskontering.MARKED,
|
||||
skattekostnad=Skattekostnad.SUBSIDIE,
|
||||
)
|
||||
assert _alt(inn, av) == _alt(inn, hoved)
|
||||
assert (av.K_inn, av.SE_stat, av.skattegrunnlag) == (None, None, av.SE)
|
||||
strom = ei.bedriftsstrom(inn, av, tilleggsregel=True)
|
||||
med_en = ei.bedriftsstrom(inn, av, tilleggsregel=True, kostnadsfaktor=1.0)
|
||||
assert med_en.NK.tobytes() == strom.NK.tobytes()
|
||||
assert med_en.avskrivning.tobytes() == strom.avskrivning.tobytes()
|
||||
|
||||
|
||||
# -------------------------------------------------------------------- line 16
|
||||
|
||||
|
||||
def test_linje_16_rundskrivets_rente_for_haand() -> None:
|
||||
"""118 b: D_R(j) = 1.04^-min(j,40) 1.03^-min(max(j-40,0),35) 1.02^-max(j-75,0)."""
|
||||
assert lg.s26_diskontering_rundskriv(j=0) == 1.0
|
||||
assert lg.s26_diskontering_rundskriv(j=1) == pytest.approx(1 / 1.04)
|
||||
assert lg.s26_diskontering_rundskriv(j=40) == pytest.approx(1.04**-40)
|
||||
assert lg.s26_diskontering_rundskriv(j=41) == pytest.approx(1.04**-40 / 1.03)
|
||||
assert lg.s26_diskontering_rundskriv(j=75) == pytest.approx(1.04**-40 * 1.03**-35)
|
||||
assert lg.s26_diskontering_rundskriv(j=76) == pytest.approx(1.04**-40 * 1.03**-35 / 1.02)
|
||||
assert lg.s26_diskontering_rundskriv(j=80) == pytest.approx(1.04**-40 * 1.03**-35 * 1.02**-5)
|
||||
|
||||
|
||||
def test_linje_16_restverdien_med_rundskrivets_rente_for_haand() -> None:
|
||||
"""118 b: every amount after the final year from the year it falls; T_s - T_0 = 73."""
|
||||
D = [lg.s26_diskontering_rundskriv(j=73 + x) for x in range(5)]
|
||||
assert lg.s40_restverdi_rundskriv(
|
||||
NK_snitt=10.0, L_rest=4, avvikling=5.0, T_s=2100, T_0=2027
|
||||
) == pytest.approx(10.0 * (D[1] + D[2] + D[3] + D[4]) - 5.0 * D[4])
|
||||
# a facility that loses money gets no value, but the decommissioning is deducted
|
||||
assert lg.s40_restverdi_rundskriv(
|
||||
NK_snitt=-10.0, L_rest=4, avvikling=5.0, T_s=2100, T_0=2027
|
||||
) == pytest.approx(-5.0 * D[4])
|
||||
assert (
|
||||
lg.s40_restverdi_rundskriv(NK_snitt=10.0, L_rest=0, avvikling=5.0, T_s=2100, T_0=2027) == 0
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
def test_linje_16_bare_naaverdien_i_s26_regnes_om(oppdiktet: LagInndata, losning: Losning) -> None:
|
||||
"""118 b: S26 with D_R everywhere, in A too; S45, S42, M3, M4 and M6 with the market's rates."""
|
||||
inn = _sett(oppdiktet, losning, T_slutt=2100.0)
|
||||
hoved = _regn(inn, losning)
|
||||
rund = _regn(inn, losning, diskontering=Diskontering.RUNDSKRIV)
|
||||
assert rund.diskontering is Diskontering.RUNDSKRIV
|
||||
assert dict(rund.varsigma) == dict(hoved.varsigma)
|
||||
for felt in ("KS_D", "KS_N", "F_a", "Delta_W", "V"):
|
||||
assert getattr(rund, felt).tobytes() == getattr(hoved, felt).tobytes()
|
||||
assert rund.kraftaar == hoved.kraftaar # M3 and M4
|
||||
a, b = nv.kraftkostnad(inn, rund, bedrift=True), nv.kraftkostnad(inn, hoved, bedrift=True)
|
||||
assert a.S42 == b.S42 # M2
|
||||
assert skala.skala(inn, rund).B_6.tobytes() == skala.skala(inn, hoved).B_6.tobytes() # M6
|
||||
D_R = _D_R(rund)
|
||||
assert rund.NV_datasenter == pytest.approx(_pv(D_R, rund.KS_D), rel=1e-12)
|
||||
assert rund.NV_kraft == pytest.approx(_pv(D_R, rund.KS_N), rel=1e-12, abs=1e-3)
|
||||
ovrige = rund.Delta_W - rund.utslipp - rund.K_prog - rund.V
|
||||
assert rund.NV_ovrige == pytest.approx(_pv(D_R, ovrige), rel=1e-12, abs=1e-3)
|
||||
assert rund.SE == lg.s26_subsidieelement(
|
||||
naaverdi_prosjekt=rund.NV_datasenter + rund.NV_kraft + rund.RV
|
||||
)
|
||||
assert rund.NNV == pytest.approx(
|
||||
rund.NV_datasenter + rund.NV_kraft + rund.NV_ovrige - 0.2 * rund.SE + rund.RV
|
||||
)
|
||||
assert rund.NNV != hoved.NNV
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.A, Losning.B])
|
||||
def test_linje_16_restverdien_i_s26(oppdiktet: LagInndata, losning: Losning) -> None:
|
||||
"""118 b: S40 with D_R. The average NK is found from the main run's S40 (positive here)."""
|
||||
inn = oppdiktet(L_N=30.0)
|
||||
hoved = _regn(inn, losning)
|
||||
rund = _regn(inn, losning, diskontering=Diskontering.RUNDSKRIV)
|
||||
rho_avv = 0.08 if losning is Losning.A else 0.06
|
||||
for a, rv_h, rv_r in zip(hoved.anlegg, hoved.RV_anlegg, rund.RV_anlegg, strict=True):
|
||||
assert a.L_rest > 0
|
||||
assert rv_h > 0
|
||||
avv = math.fsum(a.avvikling_etter.values())
|
||||
NK = (rv_h * 1.08**33 + avv * (1 + rho_avv) ** -a.L_rest) * _crf(0.08, a.L_rest)
|
||||
D = [lg.s26_diskontering_rundskriv(j=33 + x) for x in range(1, a.L_rest + 1)]
|
||||
assert rv_r == pytest.approx(max(0.0, NK * math.fsum(D)) - avv * D[-1], rel=1e-9)
|
||||
ventet = math.fsum(
|
||||
-f.avvikling_etter * lg.s26_diskontering_rundskriv(j=33 + f.L_rest)
|
||||
for f in rund.felles
|
||||
if f.L_rest > 0
|
||||
)
|
||||
assert rund.RV_felles == pytest.approx(ventet)
|
||||
if losning is Losning.B:
|
||||
assert ventet < 0
|
||||
|
||||
|
||||
# ------------------------------------------------------------- line 17, row 2
|
||||
|
||||
|
||||
def _investeringer(res: ks.Programresultat, inn: Inndata) -> tuple[np.ndarray, ...]:
|
||||
"""Every investment of S34 and S35 by hand: data centre, power (without nuclear), nuclear.
|
||||
|
||||
The buffer's table in the cash flow also holds f_buf P_buf in each operating year;
|
||||
that is operation and is taken out here.
|
||||
"""
|
||||
datasenter, kraft, kjerne = (np.zeros(len(res.aar)) for _ in range(3))
|
||||
for k, a in enumerate(res.anlegg):
|
||||
datasenter += a.I_bygg + a.I_H
|
||||
for i, investering in a.investering.items():
|
||||
if i == ks.KJERNEKRAFT:
|
||||
kjerne += investering
|
||||
else:
|
||||
kraft += investering
|
||||
kraft += a.I_nett + a.I_g
|
||||
if not res.losning.paa_nett:
|
||||
drift = np.array([1.0 if res.plan.i_drift(k, t) else 0.0 for t in res.aar])
|
||||
kraft += a.buffer - drift * inn["f_buf"] * ks.bufferstorrelse(inn, res.dim)
|
||||
for f in res.felles:
|
||||
kjerne += f.investering
|
||||
return datasenter, kraft, kjerne
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
def test_linje_17_all_innskutt_kapital(oppdiktet: LagInndata, losning: Losning) -> None:
|
||||
"""118 c: varphi K_inn in place of varphi SE; K_inn as each term is discounted in S26."""
|
||||
inn = _sett(oppdiktet, losning)
|
||||
hoved = _regn(inn, losning)
|
||||
alle = _regn(inn, losning, skattekostnad=Skattekostnad.ALL_KAPITAL)
|
||||
datasenter, kraft, kjerne = _investeringer(alle, inn)
|
||||
rho_kraft = 0.08 if losning is Losning.A else 0.06
|
||||
K_inn = (
|
||||
_pv(_D(alle, 0.08), datasenter)
|
||||
+ _pv(_D(alle, rho_kraft), kraft)
|
||||
+ _pv(_D(alle, rho_kraft), kjerne)
|
||||
)
|
||||
assert alle.K_inn is not None
|
||||
assert alle.K_inn == pytest.approx(K_inn, rel=1e-12)
|
||||
assert alle.K_inn > alle.SE > 0
|
||||
assert alle.skattegrunnlag == alle.K_inn
|
||||
assert alle.SE == hoved.SE
|
||||
assert alle.SE_stat is None
|
||||
assert alle.NNV == pytest.approx(hoved.NNV - 0.2 * (alle.K_inn - hoved.SE), rel=1e-12)
|
||||
if losning is Losning.A:
|
||||
assert kjerne.any()
|
||||
assert (alle.anlegg[0].buffer - kraft).any()
|
||||
|
||||
|
||||
# -------------------------------------------------------------------- line 18
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
def test_linje_18_subsidieelementet_med_statens_laanerente(
|
||||
oppdiktet: LagInndata, losning: Losning
|
||||
) -> None:
|
||||
"""118 d: SE = max(0, -[sum D_stat (KS_D + KS_N) + RV^stat]) with r_stat = 0.02 for S40 too.
|
||||
|
||||
With L_N = 30 the facilities and units run past 2060; the average NK of each facility is
|
||||
found from the main run's S40. A lower share sold in «overkapasitet» makes SE positive.
|
||||
"""
|
||||
inn = _sett(oppdiktet, losning, L_N=30.0, mu_rel=0.8)
|
||||
hoved = _regn(inn, losning, knapphet=Knapphet.OVERKAPASITET)
|
||||
stat = _regn(
|
||||
inn, losning, knapphet=Knapphet.OVERKAPASITET, skattekostnad=Skattekostnad.STATENS_RENTE
|
||||
)
|
||||
rho_avv = 0.08 if losning is Losning.A else 0.06
|
||||
RV_stat = []
|
||||
for a, rv in zip(hoved.anlegg, hoved.RV_anlegg, strict=True):
|
||||
avv = math.fsum(a.avvikling_etter.values())
|
||||
if a.L_rest == 0:
|
||||
RV_stat.append(0.0)
|
||||
continue
|
||||
# the value part of the main run's S40; zero when the facility loses money
|
||||
verdi = rv * 1.08**33 + avv * (1 + rho_avv) ** -a.L_rest
|
||||
NK = verdi * _crf(0.08, a.L_rest) if verdi > 1e-6 * max(1.0, avv) else 0.0
|
||||
RV_stat.append((NK / _crf(0.02, a.L_rest) - avv * 1.02**-a.L_rest) * 1.02**-33)
|
||||
if losning is not Losning.R:
|
||||
assert any(rv > 0 for rv in RV_stat), "a facility with value after the final year"
|
||||
RV_stat += [
|
||||
-f.avvikling_etter * 1.02**-f.L_rest * 1.02**-33 for f in stat.felles if f.L_rest > 0
|
||||
]
|
||||
D = _D(stat, 0.02)
|
||||
SE_stat = max(0.0, -(_pv(D, stat.KS_D) + _pv(D, stat.KS_N) + math.fsum(RV_stat)))
|
||||
assert stat.SE_stat is not None
|
||||
assert stat.SE_stat == pytest.approx(SE_stat, rel=1e-9)
|
||||
assert stat.SE_stat > 0
|
||||
assert stat.SE == hoved.SE
|
||||
assert stat.skattegrunnlag == stat.SE_stat
|
||||
assert stat.RV == hoved.RV
|
||||
assert stat.NNV == pytest.approx(hoved.NNV - 0.2 * (stat.SE_stat - hoved.SE), rel=1e-12)
|
||||
|
||||
|
||||
# -------------------------------------------------------------------- line 28
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.A, Losning.B, Losning.C, Losning.R, Losning.T_K])
|
||||
def test_linje_28_kostnadene_ganges_med_faktoren(oppdiktet: LagInndata, losning: Losning) -> None:
|
||||
"""122: investments (I^bud too) and operation times 1.1; the excepted items are not.
|
||||
|
||||
Excepted: power bought, electricity tax, grid tariff, q_N E and the capacity cost.
|
||||
Fuel, waste fee and decommissioning are multiplied; sales are not costs.
|
||||
"""
|
||||
inn = _sett(oppdiktet, losning, L_N=30.0)
|
||||
res = _regn(inn, losning)
|
||||
en = ei.bedriftsstrom(inn, res, tilleggsregel=True)
|
||||
med = ei.bedriftsstrom(inn, res, tilleggsregel=True, kostnadsfaktor=1.1)
|
||||
assert med.investering == pytest.approx(1.1 * en.investering)
|
||||
assert med.budsjett == pytest.approx(1.1 * en.budsjett)
|
||||
assert med.avskrivning == pytest.approx(1.1 * en.avskrivning)
|
||||
assert med.avskrivning_fast == pytest.approx(1.1 * en.avskrivning_fast)
|
||||
# zero at the end of the final year, up to the last digits of the sums
|
||||
assert med.kapital == pytest.approx(1.1 * en.kapital, abs=1e-2)
|
||||
assert med.inntekt.tobytes() == en.inntekt.tobytes()
|
||||
assert med.elavgift.tobytes() == en.elavgift.tobytes()
|
||||
ganges = np.zeros(len(res.aar))
|
||||
for k, a in enumerate(res.anlegg):
|
||||
ganges += a.drift + sum(a.kraftdrift.values(), np.zeros(len(res.aar)))
|
||||
ganges += sum(a.avvikling.values(), np.zeros(len(res.aar)))
|
||||
if not res.losning.paa_nett:
|
||||
drives = np.array([1.0 if res.plan.i_drift(k, t) else 0.0 for t in res.aar])
|
||||
ganges += drives * inn["f_buf"] * ks.bufferstorrelse(inn, res.dim)
|
||||
for f in res.felles:
|
||||
ganges += f.drift + f.avvikling
|
||||
assert ganges.any()
|
||||
assert med.drift - en.drift == pytest.approx(0.1 * ganges, abs=1e-3)
|
||||
# the residual value follows the cash flow with the factor, the decommissioning too
|
||||
RV_anlegg, RV_felles = ei.restverdi_bedrift(inn, res, tilleggsregel=True, kostnadsfaktor=1.1)
|
||||
assert med.restverdi_anlegg == RV_anlegg
|
||||
assert RV_felles == pytest.approx(1.1 * en.restverdi_felles)
|
||||
netto = ei.netto_per_anlegg(inn, res, tilleggsregel=True, kostnadsfaktor=1.1)
|
||||
assert (
|
||||
sum(netto, np.zeros(len(res.aar))).sum()
|
||||
< sum(ei.netto_per_anlegg(inn, res, tilleggsregel=True), np.zeros(len(res.aar))).sum()
|
||||
)
|
||||
|
||||
|
||||
def test_linje_28_kostnaden_for_regnekraft_med_faktoren(oppdiktet: LagInndata) -> None:
|
||||
"""122: LCOC^bed with the factor on building, IT hardware and operation.
|
||||
|
||||
R's power cost is the price, tax, tariff and the disconnection arm, which are not
|
||||
multiplied. gamma_H = 0, so every vintage moves by the same amount.
|
||||
"""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.R)
|
||||
r = 0.05
|
||||
en = ei.lcoc_med_kapitalkostnad(inn, res, r)
|
||||
med = ei.lcoc_med_kapitalkostnad(inn, res, r, kostnadsfaktor=1.1)
|
||||
endring = 0.1 * (100e6 * 1.1 * _crf(r, 15) + 200e6 * _crf(r, 5) + 2e6 + 0.5e6)
|
||||
assert med - en == pytest.approx(endring)
|
||||
with pytest.raises(ValueError, match="business version"):
|
||||
nv.kraftkostnad(inn, res, kostnadsfaktor=1.1)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.A, Losning.B_MERKET, Losning.C])
|
||||
def test_linje_28_kraftverkenes_kostnad_med_faktoren(
|
||||
oppdiktet: LagInndata, losning: Losning
|
||||
) -> None:
|
||||
"""122: in S9 and S5 every cost but q_N times the factor; in LCOE_i investment and operation."""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, losning, N_anlegg=1)
|
||||
if losning is Losning.A:
|
||||
en = ks.kraftkostnad_dedikert(inn, res.dim, 0, 0.08)
|
||||
med = ks.kraftkostnad_dedikert(inn, res.dim, 0, 0.08, kostnadsfaktor=1.1)
|
||||
q_N = lg.s6_ulykkeskostnad(
|
||||
N_u=30, phi_U=1e-5, K_U=1e12, D_fors=8e9, P_u=50.0, P_ref=1000.0, E=res.dim.E_D
|
||||
)
|
||||
assert med == pytest.approx(1.1 * (en - q_N) + q_N)
|
||||
elif losning is Losning.B_MERKET:
|
||||
numre = ks.enhetsnumre(res.dim, 1)
|
||||
E_N = res.verk[0][0].energi
|
||||
en = nv.lcoe_kjernekraft(inn, res, numre=numre, E_N=E_N, rho=0.06)
|
||||
med = nv.lcoe_kjernekraft(inn, res, numre=numre, E_N=E_N, rho=0.06, kostnadsfaktor=1.1)
|
||||
q_N = nv.ulykkeskostnad_per_mwh(inn, res, N_u=30, E_N=E_N)
|
||||
assert med == pytest.approx(1.1 * (en - q_N) + q_N)
|
||||
else:
|
||||
for teknologi in ("vann", "vind", "havvind"):
|
||||
en = nv.lcoe_fornybar(inn, teknologi, 0.06)
|
||||
assert nv.lcoe_fornybar(inn, teknologi, 0.06, kostnadsfaktor=1.1) == pytest.approx(
|
||||
1.1 * en
|
||||
)
|
||||
|
||||
|
||||
# ------------------------------------------------------------ clarification 123
|
||||
|
||||
|
||||
def test_123_statens_kontantstrom_ved_m6(oppdiktet: LagInndata) -> None:
|
||||
"""S30 for the wholly owned company in the first year of stable operation over SNKS_snitt."""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.R)
|
||||
strom = ei.bedriftsstrom(inn, res, tilleggsregel=True)
|
||||
heleid = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
|
||||
stabilt = skala.forste_aar_med_stabil_drift(res)
|
||||
assert stabilt is not None
|
||||
assert ei.statens_kontantstrom_ved_m6(inn, res, heleid) == pytest.approx(
|
||||
float(heleid.KS_stat[stabilt - 2027]) / 500e9
|
||||
)
|
||||
with pytest.raises(ValueError, match="heleid_selskap"):
|
||||
ei.statens_kontantstrom_ved_m6(
|
||||
inn, res, ei.eierresultat(inn, strom, inn.eierformer["direkte"])
|
||||
)
|
||||
|
||||
|
||||
def test_123_uten_aar_med_stabil_drift(oppdiktet: LagInndata) -> None:
|
||||
"""Facilities of three years that are never in operation together have no such year."""
|
||||
inn = oppdiktet(s_brikker=0.01, L_N=3.0)
|
||||
res = _regn(inn, Losning.R)
|
||||
strom = ei.bedriftsstrom(inn, res, tilleggsregel=True)
|
||||
heleid = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
|
||||
assert ei.statens_kontantstrom_ved_m6(inn, res, heleid) is None
|
||||
|
||||
|
||||
def test_gamma_trinn_tabellen_er_tom_i_det_oppdiktede_settet(oppdiktet: LagInndata) -> None:
|
||||
"""The table is only carried by a set used for line 10; without it the row cannot be run."""
|
||||
inn = oppdiktet()
|
||||
assert inn.Gamma_trinn == {}
|
||||
with pytest.raises(KeyError):
|
||||
ks.dimensjoner(inn, Losning.A, gamma_trinn=True)
|
||||
assert ks.dimensjoner(replace(inn, Gamma_trinn={"A>=A*": 1.0}), Losning.A, gamma_trinn=True)
|
||||
Loading…
Add table
Add a link
Reference in a new issue