tokenfabrikker/tests/test_folsomheter_modell.py
Kjell Tore Guttormsen 45aaffcb69
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>
2026-11-13 20:31:12 +01:00

613 lines
26 KiB
Python

"""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)
)