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