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>
613 lines
26 KiB
Python
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)
|
|
)
|