The project owner answered the three questions from part 5b on 2026-11-12
("Ja til dine anbefalinger"), before any result is computed:
- chips are a stock from the solution's first possible operating year, not
from the decision year (clarification 25 rewritten; the old reading stays
as a switch that is not part of the verdicts)
- renewable power in C enters operation the same year as the facility
(clarification 24 stands)
- the other choices in clarifications 21-40 are approved
The default in the code is flipped, seven tests that assumed a stock from
2027 are redone, and the comparison with the independent reader's code is
rerun with its switch set the same way: same numbers in all 9 471 paths
that can be built. The parameter file is unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
798 lines
35 KiB
Python
798 lines
35 KiB
Python
"""The cash flow and the net present value (chapters 0 and 6): S26, S34, S35, S40 and S45.
|
|
|
|
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 typing import TYPE_CHECKING
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
from tokenfabrikker import kontantstrom as ks
|
|
from tokenfabrikker import ligninger as lg
|
|
from tokenfabrikker.kontantstrom import Knapphet
|
|
from tokenfabrikker.utbygging import Losning
|
|
|
|
if TYPE_CHECKING:
|
|
from conftest import LagInndata
|
|
from tokenfabrikker.inndata import Inndata
|
|
|
|
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
|
|
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
|
|
|
|
|
|
def _crf(rho: float, levetid: float) -> float:
|
|
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
|
|
|
|
|
|
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 _regn(
|
|
inn: Inndata,
|
|
losning: Losning,
|
|
*,
|
|
N_anlegg: int = 1,
|
|
knapphet: Knapphet = Knapphet.NORMALISERING,
|
|
tilleggsregel: bool = True,
|
|
) -> 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, tilleggsregel=tilleggsregel)
|
|
|
|
|
|
# ----------------------------------------------------- the equations one at a time
|
|
|
|
|
|
def test_s34_og_s35_er_summer_av_leddene() -> None:
|
|
assert lg.s34_kontantstrom_datasenter(
|
|
inntekt=100.0, drift=10.0, kraftkjop=20.0, I_bygg=5.0, I_H=30.0
|
|
) == pytest.approx(35.0)
|
|
assert lg.s35_kontantstrom_kraft(
|
|
salg=50.0,
|
|
investering=10.0,
|
|
drift=5.0,
|
|
avvikling=1.0,
|
|
ulykke=2.0,
|
|
I_nett=3.0,
|
|
buffer=4.0,
|
|
I_g=6.0,
|
|
F_a=7.0,
|
|
) == pytest.approx(12.0)
|
|
|
|
|
|
def test_s40_haandregnet() -> None:
|
|
"""100 a year for 3 years at 10 % is 248.685; less 50 / 1.05^3; discounted 10 years."""
|
|
verdi = lg.s40_restverdi(
|
|
NK_snitt=100.0,
|
|
L_rest=3,
|
|
rho_D=0.10,
|
|
rho_avvikling=0.05,
|
|
avvikling=50.0,
|
|
T_s=2037,
|
|
T_0=2027,
|
|
)
|
|
assert verdi == pytest.approx((248.6852 - 43.1919) / 1.1**10, rel=1e-6)
|
|
|
|
|
|
def test_s40_tap_gir_ingen_verdi_men_avviklingen_trekkes_alltid() -> None:
|
|
verdi = lg.s40_restverdi(
|
|
NK_snitt=-100.0,
|
|
L_rest=3,
|
|
rho_D=0.10,
|
|
rho_avvikling=0.05,
|
|
avvikling=50.0,
|
|
T_s=2027,
|
|
T_0=2027,
|
|
)
|
|
assert verdi == pytest.approx(-50.0 / 1.05**3)
|
|
|
|
|
|
def test_s40_ingen_restverdi_uten_driftstid_igjen() -> None:
|
|
assert (
|
|
lg.s40_restverdi(
|
|
NK_snitt=100.0,
|
|
L_rest=0,
|
|
rho_D=0.10,
|
|
rho_avvikling=0.05,
|
|
avvikling=50.0,
|
|
T_s=2037,
|
|
T_0=2027,
|
|
)
|
|
== 0.0
|
|
)
|
|
|
|
|
|
def test_s26_subsidieelement_og_sum() -> None:
|
|
assert lg.s26_subsidieelement(naaverdi_prosjekt=-40.0) == 40.0
|
|
assert lg.s26_subsidieelement(naaverdi_prosjekt=40.0) == 0.0
|
|
assert lg.s26_netto_naaverdi(
|
|
NV_datasenter=100.0, NV_kraft=-150.0, NV_ovrige=5.0, varphi=0.2, SE=40.0, RV=10.0
|
|
) == pytest.approx(-43.0)
|
|
|
|
|
|
def test_s45_iterasjonen_finner_nullpunktet() -> None:
|
|
assert lg.s45_los_tilleggsfaktor(naaverdi=lambda s: 200.0 * s - 150.0) == pytest.approx(0.75)
|
|
assert lg.s45_los_tilleggsfaktor(naaverdi=lambda s: 200.0 * s - 250.0) == 1.0
|
|
# with a kink, as the residual value gives
|
|
assert lg.s45_los_tilleggsfaktor(
|
|
naaverdi=lambda s: 100.0 * s - 60.0 + max(0.0, 100.0 * s - 50.0)
|
|
) == pytest.approx(0.55)
|
|
|
|
|
|
# --------------------------------------------- one facility in R, computed by hand
|
|
|
|
|
|
def test_R_ett_anlegg_aar_for_aar(oppdiktet: LagInndata) -> None:
|
|
"""One facility that buys from the grid, 2027-2040, every term computed here by hand.
|
|
|
|
Start 2030 (grid lead time 3 years). Vintages 2030, 2035 and 2040. Building and first
|
|
vintage are paid in 2028 and 2029, later vintages the year before they start, the grid
|
|
connection in 2029.
|
|
"""
|
|
inn = oppdiktet(T_slutt=2040)
|
|
res = _regn(inn, Losning.R)
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
y = _lcoc_v()
|
|
|
|
assert [(a.start, a.siste_driftsaar, a.aarganger) for a in res.plan.anlegg] == [
|
|
(2030, 2049, (2030, 2035, 2040))
|
|
]
|
|
pris = 700.0 - 10e-6 * (10e6 - 0.5 * E_D)
|
|
assert res.kraftaar[aar[2035]].pris == pytest.approx(pris)
|
|
assert res.kraftaar[aar[2029]].pris == pytest.approx(600.0)
|
|
|
|
anlegg = res.anlegg[0]
|
|
assert anlegg.inntekt[aar[2030]] == pytest.approx(1000.0 * y)
|
|
assert anlegg.inntekt[aar[2029]] == 0.0
|
|
assert anlegg.drift[aar[2040]] == pytest.approx(2.5e9)
|
|
assert anlegg.kraftkjop[aar[2033]] == pytest.approx(1.05 * pris * E_D)
|
|
assert anlegg.I_bygg[aar[2028]] == pytest.approx(55e9)
|
|
assert anlegg.I_bygg[aar[2029]] == pytest.approx(55e9)
|
|
assert float(anlegg.I_bygg.sum()) == pytest.approx(110e9)
|
|
assert [float(anlegg.I_H[aar[t]]) for t in (2028, 2029, 2034, 2039)] == pytest.approx(
|
|
[100e9, 100e9, 200e9, 200e9]
|
|
)
|
|
assert float(anlegg.I_H.sum()) == pytest.approx(600e9)
|
|
assert anlegg.I_nett[aar[2029]] == pytest.approx(5e6 * 0.5 * 1.2 * 1000.0)
|
|
assert float(anlegg.I_nett.sum()) == pytest.approx(3e9)
|
|
|
|
# S47: 600 MW is missing; disconnection (100 hours) is cheaper than new firm capacity
|
|
F_a = min(1.4e6 * 600.0, 100.0 * y / (8760.0 * 1.2) * 600.0)
|
|
assert res.F_a[aar[2031]] == pytest.approx(F_a)
|
|
assert res.F_a[aar[2029]] == 0.0
|
|
|
|
assert res.Delta_W[aar[2031]] == pytest.approx((pris - 600.0) * 10e6)
|
|
assert res.V[aar[2031]] == pytest.approx(0.5 * E_D * 70.0)
|
|
assert res.utslipp[aar[2030]] == pytest.approx(1000.0 * 0.5 * 2000.0 * 1000.0)
|
|
assert float(res.utslipp.sum()) == pytest.approx(1e9)
|
|
assert not res.K_prog.any()
|
|
|
|
# the sums of S26, built up again from the yearly amounts above
|
|
KS_D, KS_N, ovrige = {}, {}, {}
|
|
for t in range(2027, 2041):
|
|
i_drift = t >= 2030
|
|
KS_D[t] = (1000.0 * y - 2.5e9 - 1.05 * pris * E_D) if i_drift else 0.0
|
|
KS_D[t] -= {2028: 155e9, 2029: 155e9, 2034: 200e9, 2039: 200e9}.get(t, 0.0)
|
|
KS_N[t] = -(F_a if i_drift else 0.0) - (3e9 if t == 2029 else 0.0)
|
|
ovrige[t] = ((pris - 600.0) * 10e6 - 0.5 * E_D * 70.0) if i_drift else 0.0
|
|
ovrige[t] -= 1e9 if t == 2030 else 0.0
|
|
NV_D = math.fsum(v / 1.08 ** (t - 2027) for t, v in KS_D.items())
|
|
NV_N = math.fsum(v / 1.06 ** (t - 2027) for t, v in KS_N.items())
|
|
NV_ovrige = math.fsum(v / 1.06 ** (t - 2027) for t, v in ovrige.items())
|
|
assert res.NV_datasenter == pytest.approx(NV_D)
|
|
assert res.NV_kraft == pytest.approx(NV_N)
|
|
assert res.NV_ovrige == pytest.approx(NV_ovrige)
|
|
|
|
# S40: nine operating years left; the average of 2036-2040 holds the vintage paid in 2039
|
|
snitt = math.fsum(KS_D[t] + KS_N[t] for t in range(2036, 2041)) / 5.0
|
|
RV = max(0.0, snitt * (1.0 - 1.08**-9) / 0.08) / 1.08**13
|
|
assert res.RV == pytest.approx(RV)
|
|
assert res.RV > 0
|
|
SE = max(0.0, -(NV_D + NV_N + RV))
|
|
assert res.SE == pytest.approx(SE)
|
|
assert res.NNV == pytest.approx(NV_D + NV_N + NV_ovrige - 0.2 * SE + RV)
|
|
|
|
|
|
def test_nnv_er_summen_av_delene_i_alle_losninger(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
for losning in Losning:
|
|
for knapphet in Knapphet:
|
|
res = _regn(inn, losning, N_anlegg=2, knapphet=knapphet)
|
|
D_D = np.array([1.08 ** -(t - 2027) for t in res.aar])
|
|
D_N = np.array([1.06 ** -(t - 2027) for t in res.aar])
|
|
D_kraft = D_D if losning is Losning.A else D_N
|
|
assert res.NV_datasenter == pytest.approx(float(D_D @ res.KS_D))
|
|
assert res.NV_kraft == pytest.approx(float(D_kraft @ res.KS_N))
|
|
assert res.NV_ovrige == pytest.approx(
|
|
float(D_N @ (res.Delta_W - res.utslipp - res.K_prog - res.V))
|
|
)
|
|
assert res.SE == pytest.approx(max(0.0, -(res.NV_datasenter + res.NV_kraft + res.RV)))
|
|
assert res.NNV == pytest.approx(
|
|
res.NV_datasenter + res.NV_kraft + res.NV_ovrige - 0.2 * res.SE + res.RV
|
|
)
|
|
assert res.KS_D == pytest.approx(sum(a.datasenter() for a in res.anlegg))
|
|
|
|
|
|
def test_prisscenarioene_skiller_seg_bare_i_knapphetens_ti_aar(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
y = _lcoc_v()
|
|
paaslag = 150e6 / y - 1.0
|
|
pris = {k: ks.regnekraftpris(inn, k, t_1=2030) for k in Knapphet}
|
|
assert pris[Knapphet.NORMALISERING](2030) == pytest.approx(y)
|
|
assert pris[Knapphet.VARER](2030) == pytest.approx(150e6)
|
|
assert pris[Knapphet.VARER](2039) == pytest.approx(y * (1.0 + paaslag))
|
|
assert pris[Knapphet.VARER](2040) == pytest.approx(y)
|
|
assert pris[Knapphet.OVERKAPASITET](2035) == pytest.approx(0.7 * y)
|
|
assert pris[Knapphet.OVERKAPASITET](2040) == pytest.approx(y)
|
|
|
|
|
|
def test_negativt_paaslag_settes_til_null(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet(y_obs=10e6)
|
|
assert ks.regnekraftpris(inn, Knapphet.VARER, t_1=2030)(2030) == pytest.approx(_lcoc_v())
|
|
|
|
|
|
# ------------------------------------------------------------------------ timing
|
|
|
|
|
|
def test_byggetid_som_ikke_er_hele_aar_fordeles_etter_andel(oppdiktet: LagInndata) -> None:
|
|
res = _regn(oppdiktet(tau_D=2.5, T_slutt=2040), Losning.R)
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
bygg = res.anlegg[0].I_bygg
|
|
assert [float(bygg[aar[t]]) for t in (2027, 2028, 2029)] == pytest.approx([22e9, 44e9, 44e9])
|
|
|
|
|
|
def test_levetid_for_bygg_rundes_og_bygget_fornyes(oppdiktet: LagInndata) -> None:
|
|
"""L_B = 4.4 is four years in the cash flow: buildings enter operation in 2030, 2034, 2038."""
|
|
res = _regn(oppdiktet(L_B=4.4, T_slutt=2040), Losning.R)
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
assert res.anlegg[0].bygg_i_drift == (2030, 2034, 2038)
|
|
assert res.anlegg[0].I_bygg[aar[2033]] == pytest.approx(55e9)
|
|
assert float(res.anlegg[0].I_bygg.sum()) == pytest.approx(330e9)
|
|
# emissions from building in Norway each time a building enters operation
|
|
assert [float(res.utslipp[aar[t]]) for t in (2030, 2034, 2038)] == pytest.approx([1e9] * 3)
|
|
|
|
|
|
def test_betaling_for_beslutningsaaret_er_en_feil(oppdiktet: LagInndata) -> None:
|
|
with pytest.raises(ValueError, match="before the decision year"):
|
|
_regn(oppdiktet(tau_D=3.5, tau_nett=2.0), Losning.R)
|
|
|
|
|
|
def test_bane_som_ikke_lar_seg_bygge_har_ingen_naaverdi(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet(s_brikker=0.001) # 25 MW of chips a year: 825 MW by 2060
|
|
dim = ks.dimensjoner(inn, Losning.R)
|
|
plan = ks.lag_plan(inn, Losning.R, dim, N_anlegg=1)
|
|
assert not plan.gjennomforbar
|
|
with pytest.raises(ValueError, match="cannot be built"):
|
|
ks.regn_program(inn, Losning.R, plan, Knapphet.NORMALISERING)
|
|
|
|
|
|
def test_anlegg_uten_brikker_har_verken_inntekt_eller_kraftbruk(oppdiktet: LagInndata) -> None:
|
|
"""Chips for one facility a year from 2030, but a three-year export stop from 2035.
|
|
|
|
The vintage from 2030 has expired in 2035 and is replaced in 2038. In between the
|
|
facility earns nothing and uses no power, but its fixed operation is still paid.
|
|
"""
|
|
u = tuple(0.0 if aar == 2035 else 0.5 for aar in range(2028, 2061))
|
|
inn = oppdiktet(u_eksport=u, phi_X=0.1, D_X=3.0)
|
|
res = _regn(inn, Losning.R)
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
assert res.plan.stopp[2035 - 2028 : 2039 - 2028] == (True, True, True, False)
|
|
assert res.plan.anlegg[0].aarganger[:2] == (2030, 2038)
|
|
anlegg = res.anlegg[0]
|
|
for t in (2035, 2036, 2037):
|
|
assert anlegg.inntekt[aar[t]] == 0.0
|
|
assert anlegg.kraftkjop[aar[t]] == 0.0
|
|
assert anlegg.drift[aar[t]] == pytest.approx(2.5e9)
|
|
assert res.kraftaar[aar[t]].Delta_Q == 0.0
|
|
assert res.kraftaar[aar[t]].Delta_R == 0.0
|
|
assert res.F_a[aar[t]] == 0.0
|
|
assert res.V[aar[t]] == 0.0
|
|
assert res.Delta_W[aar[t]] == 0.0
|
|
assert anlegg.inntekt[aar[2038]] > 0
|
|
assert anlegg.kraftkjop[aar[2038]] > 0
|
|
assert res.V[aar[2038]] > 0
|
|
|
|
|
|
def test_A_uten_brikker_betaler_fast_men_ikke_variabel_drift(oppdiktet: LagInndata) -> None:
|
|
"""A stop from 2040 to 2042: the plant's fixed operation runs on, fuel and waste fee do not."""
|
|
u = tuple(0.0 if aar == 2040 else 0.5 for aar in range(2028, 2061))
|
|
inn = oppdiktet(u_eksport=u, phi_X=0.1, D_X=3.0)
|
|
res = _regn(inn, Losning.A)
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
assert res.plan.anlegg[0].aarganger[:2] == (2035, 2043)
|
|
drift = res.anlegg[0].kraftdrift[ks.KJERNEKRAFT]
|
|
fast = 1e6 * res.dim.N_u * 50.0
|
|
assert drift[aar[2039]] == pytest.approx(fast + 180.0 * E_D)
|
|
assert drift[aar[2041]] == pytest.approx(fast)
|
|
assert res.anlegg[0].ulykke[aar[2041]] > 0
|
|
|
|
|
|
def test_kraftverk_paa_nettet_selger_ogsaa_naar_anlegget_staar(oppdiktet: LagInndata) -> None:
|
|
u = tuple(0.0 if aar == 2040 else 0.5 for aar in range(2028, 2061))
|
|
inn = oppdiktet(u_eksport=u, phi_X=0.1, D_X=3.0)
|
|
res = _regn(inn, Losning.B)
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
anlegg = res.anlegg[0]
|
|
assert anlegg.kraftkjop[aar[2041]] == 0.0
|
|
assert res.felles[0].salg[aar[2041]] > 0
|
|
# all the new production is surplus that year
|
|
assert res.kraftaar[aar[2041]].Delta_Q == pytest.approx(-2 * 8760.0 * 0.8 * 1000.0)
|
|
|
|
|
|
def test_brikker_telles_fra_forste_mulige_aar(oppdiktet: LagInndata) -> None:
|
|
"""1 000 MW of chips a year, counted from the first possible year (2030): one facility a year.
|
|
|
|
Saved up from the decision year instead (the switch), three facilities start in 2030.
|
|
"""
|
|
inn = oppdiktet(L_H=7)
|
|
dim = ks.dimensjoner(inn, Losning.R)
|
|
fra_start = ks.lag_plan(inn, Losning.R, dim, N_anlegg=3)
|
|
assert [a.start for a in fra_start.anlegg] == [2030, 2031, 2032]
|
|
fra_beslutning = ks.lag_plan(inn, Losning.R, dim, N_anlegg=3, brikker_fra_T0=True)
|
|
assert [a.start for a in fra_beslutning.anlegg] == [2030, 2030, 2030]
|
|
|
|
|
|
def test_uten_eksportregel_brukes_ikke_strommen(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet(u_eksport=(0.0,) * 33, phi_X=0.2)
|
|
dim = ks.dimensjoner(inn, Losning.R)
|
|
assert all(ks.lag_plan(inn, Losning.R, dim, N_anlegg=1).stopp)
|
|
assert not any(ks.lag_plan(inn, Losning.R, dim, N_anlegg=1, eksportregel=False).stopp)
|
|
|
|
|
|
# ----------------------------------------------------- the dedicated plant (A)
|
|
|
|
|
|
def test_A_dimensjonering_og_kraftverk(oppdiktet: LagInndata) -> None:
|
|
"""Average load 900 MW and chi = 0.1 give 50 MW units; 1 200 MW peak needs 24 of them."""
|
|
inn = oppdiktet()
|
|
dim = ks.dimensjoner(inn, Losning.A)
|
|
assert (dim.P_u, dim.m) == (50.0, 24)
|
|
assert dim.N_u == dim.m + dim.r + dim.n_p
|
|
assert 0.99 < dim.Gamma < 1.0
|
|
assert dim.xi_N == 1.0
|
|
assert dim.rho_A == 0.08
|
|
(verk,) = ks.kraftverk_for_anlegg(inn, Losning.A, dim, 2)
|
|
assert verk.effekt == dim.N_u * 50.0
|
|
assert not verk.selges
|
|
assert verk.energi == pytest.approx(E_D)
|
|
# nu = 1 and no learning: every unit costs the reference 100 mill. kr per MW
|
|
assert verk.investering == pytest.approx(100e6 * dim.N_u * 50.0)
|
|
# fixed operation per MW, and variable operation, small-unit fuel and waste fee per MWh used
|
|
assert verk.fast_drift == pytest.approx(1e6 * dim.N_u * 50.0)
|
|
assert verk.variabel_drift == pytest.approx((50.0 + 100.0 + 30.0) * E_D)
|
|
assert verk.avvikling == pytest.approx(5e6 * dim.N_u * 50.0)
|
|
# K_U scaled to 50 MW is 50 mrd. kr; 8 mrd. kr of it is insured
|
|
assert verk.ulykke == pytest.approx(dim.N_u * 1e-5 * (50e9 - 8e9))
|
|
assert verk.effektbidrag == 0.0
|
|
|
|
|
|
def test_A_har_ingen_kraftkjop_og_ingen_virkning_paa_kraftsystemet(
|
|
oppdiktet: LagInndata,
|
|
) -> None:
|
|
res = _regn(oppdiktet(), Losning.A)
|
|
assert not res.anlegg[0].kraftkjop.any()
|
|
assert not res.anlegg[0].salg[ks.KJERNEKRAFT].any()
|
|
assert not res.F_a.any()
|
|
assert not res.Delta_W.any()
|
|
assert not res.V.any()
|
|
assert all(rad.Delta_Q == 0.0 and rad.Delta_R == 0.0 for rad in res.kraftaar)
|
|
assert res.varsigma == {ks.KJERNEKRAFT: 1.0}
|
|
|
|
|
|
def test_A_bygging_buffer_ekstern_forsyning_og_avvikling(oppdiktet: LagInndata) -> None:
|
|
"""Start 2035 (2027 + max(8, 2 + 4)); four construction years; last operating year 2054."""
|
|
inn = oppdiktet()
|
|
res = _regn(inn, Losning.A)
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
anlegg, dim = res.anlegg[0], res.dim
|
|
effekt = dim.N_u * 50.0
|
|
investering = anlegg.investering[ks.KJERNEKRAFT]
|
|
assert [float(investering[aar[t]]) for t in (2030, 2031, 2034, 2035)] == pytest.approx(
|
|
[0.0, 25e6 * effekt, 25e6 * effekt, 0.0]
|
|
)
|
|
assert anlegg.avvikling[ks.KJERNEKRAFT][aar[2054]] == pytest.approx(5e6 * effekt)
|
|
assert float(anlegg.avvikling[ks.KJERNEKRAFT].sum()) == pytest.approx(5e6 * effekt)
|
|
assert not anlegg.inntekt[aar[2055] :].any()
|
|
# buffer: 600 MW at 10 mill. kr per MW the year before start, 0.4 mill. kr per MW a year
|
|
assert anlegg.buffer[aar[2034]] == pytest.approx(600.0 * 10e6)
|
|
assert anlegg.buffer[aar[2040]] == pytest.approx(600.0 * 0.4e6)
|
|
# two lines of 50 km at 10 mill. kr per km, and gensets for 2 % of the plant
|
|
assert anlegg.I_g[aar[2034]] == pytest.approx(2 * 50 * 10e6 + 0.02 * effekt * 10e6)
|
|
assert float(anlegg.I_g.sum()) == pytest.approx(2 * 50 * 10e6 + 0.02 * effekt * 10e6)
|
|
assert not anlegg.I_nett.any()
|
|
# S41: 200 mill. kr spread on the eight years to the first facility
|
|
assert res.K_prog[aar[2028]] == pytest.approx(25e6)
|
|
assert res.K_prog[aar[2035]] == pytest.approx(25e6)
|
|
assert float(res.K_prog.sum()) == pytest.approx(200e6)
|
|
# revenue is reduced by the availability of a plant without a grid
|
|
assert anlegg.inntekt[aar[2035]] == pytest.approx(dim.Gamma * 1000.0 * _lcoc_v())
|
|
|
|
|
|
def test_A_enhetsnumrene_loper_paa_tvers_av_anleggene(oppdiktet: LagInndata) -> None:
|
|
"""With 10 % learning the second facility's units are cheaper than the first's."""
|
|
inn = oppdiktet(ell=0.1)
|
|
dim = ks.dimensjoner(inn, Losning.A)
|
|
forste, andre = (ks.kraftverk_for_anlegg(inn, Losning.A, dim, k)[0] for k in (1, 2))
|
|
assert andre.investering < forste.investering
|
|
haand = math.fsum(
|
|
100e6 * ((5 + n) / 6) ** math.log2(0.9) * 50.0 for n in range(dim.N_u + 1, 2 * dim.N_u + 1)
|
|
)
|
|
assert andre.investering == pytest.approx(haand)
|
|
|
|
|
|
def test_overskridelsen_slaar_inn_i_budsjettlesningen(oppdiktet: LagInndata) -> None:
|
|
"""u_xi below w_xi is the budget reading: the investment is multiplied by 1 + o_xi."""
|
|
investering = {}
|
|
for u_xi in (0.1, 0.9):
|
|
inn = oppdiktet(u_xi=u_xi)
|
|
dim = ks.dimensjoner(inn, Losning.A)
|
|
investering[dim.xi_N] = ks.kraftverk_for_anlegg(inn, Losning.A, dim, 1)[0].investering
|
|
assert set(investering) == {1.0, 1.5}
|
|
assert investering[1.5] == pytest.approx(1.5 * investering[1.0])
|
|
|
|
|
|
def test_rho_A_kan_settes_for_seg(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
dim = ks.dimensjoner(inn, Losning.A, rho_A=0.06)
|
|
plan = ks.lag_plan(inn, Losning.A, dim, N_anlegg=1)
|
|
lav = ks.regn_program(inn, Losning.A, plan, Knapphet.NORMALISERING, dim=dim)
|
|
hoy = _regn(inn, Losning.A)
|
|
assert lav.KS_N == pytest.approx(hoy.KS_N)
|
|
assert lav.NV_kraft < hoy.NV_kraft # the costs weigh more at a lower rate
|
|
|
|
|
|
# ------------------------------------------------ nuclear power on the grid (B, B')
|
|
|
|
|
|
def _enheter(inn: Inndata, N_anlegg: int) -> tuple[ks.Enhetsgruppe, ...]:
|
|
dim = ks.dimensjoner(inn, Losning.B)
|
|
return ks.enheter_i_B(inn, dim, ks.lag_plan(inn, Losning.B, dim, N_anlegg=N_anlegg))
|
|
|
|
|
|
def test_B_enhetene_hoerer_til_programmet(oppdiktet: LagInndata) -> None:
|
|
"""Three facilities that start together and need 1.125 unit each: four units of 1 000 MW."""
|
|
inn = oppdiktet(s_brikker=0.12)
|
|
dim = ks.dimensjoner(inn, Losning.B)
|
|
assert dim.P_G_N == pytest.approx(0.75 * 1.2 * 1000.0 / 0.8)
|
|
assert all(ks.kraftverk_for_anlegg(inn, Losning.B, dim, k) == () for k in (1, 2, 3))
|
|
(gruppe,) = _enheter(inn, 3)
|
|
assert (gruppe.start, gruppe.siste_driftsaar, gruppe.numre) == (2035, 2054, (1, 2, 3, 4))
|
|
verk = gruppe.verk
|
|
assert verk.effekt == 4000.0
|
|
assert verk.energi == pytest.approx(4 * 8760.0 * 0.8 * 1000.0)
|
|
assert verk.effektbidrag == pytest.approx(0.98 * 4000.0)
|
|
assert verk.storste_enhet == pytest.approx(980.0)
|
|
# large units: fuel 70 kr/MWh
|
|
assert verk.fast_drift == pytest.approx(1e6 * 4000.0)
|
|
assert verk.variabel_drift == pytest.approx((50.0 + 70.0 + 30.0) * verk.energi)
|
|
assert verk.avvikling == pytest.approx(5e6 * 4000.0)
|
|
# one facility alone needs two units
|
|
assert _enheter(inn, 1)[0].numre == (1, 2)
|
|
|
|
|
|
def test_B_enheter_settes_i_drift_naar_S39_krever_flere(oppdiktet: LagInndata) -> None:
|
|
"""Staggered starts, 0.8 unit per facility (lam 0.6, KF 0.9), plant life 20 years.
|
|
|
|
200 MW of reactors a year and 800 MW per facility give starts in 2035 (two), 2039, 2043,
|
|
2047 and 2051. S39 requires 2, 3, 4, 4 and 5 units as the facilities come: units 1 and 2
|
|
in 2035, unit 3 in 2039, unit 4 in 2043, none in 2047, unit 5 in 2051. Units 1 and 2 go
|
|
out in 2054 together with the first two facilities; the four facilities left require
|
|
four units, and three are in operation, so unit 6 enters operation in 2055. After that
|
|
the units go out as fast as the facilities.
|
|
"""
|
|
inn = oppdiktet(lam=0.6, KF=0.9, n_reaktor=200.0, T_slutt=2075, L_H=7, s_brikker=1.0)
|
|
dim = ks.dimensjoner(inn, Losning.B)
|
|
plan = ks.lag_plan(inn, Losning.B, dim, N_anlegg=6)
|
|
assert [a.start for a in plan.anlegg] == [2035, 2035, 2039, 2043, 2047, 2051]
|
|
grupper = ks.enheter_i_B(inn, dim, plan)
|
|
assert [(g.start, g.siste_driftsaar, g.numre) for g in grupper] == [
|
|
(2035, 2054, (1, 2)),
|
|
(2039, 2058, (3,)),
|
|
(2043, 2062, (4,)),
|
|
(2051, 2070, (5,)),
|
|
(2055, 2074, (6,)),
|
|
]
|
|
|
|
|
|
def test_B_kraftbalansen_svekkes_ikke_naar_anlegg_gaar_ut(oppdiktet: LagInndata) -> None:
|
|
"""The same programme year by year: never fewer units than S39 requires.
|
|
|
|
The capacity balance shows the units in operation: 0.98 * 1 000 MW per unit, less
|
|
0.5 * 1.2 * 1 000 MW per facility. Units in operation: 2 (2035-38), 3 (2039-42),
|
|
4 (2043-50), 5 (2051-54), 4 (2055-58), 3 (2059-62), 2 (2063-70) and 1 (2071-74). In
|
|
2067-70 one facility is left and two units run, and in 2071-74 unit 6 runs alone: a
|
|
unit that is no longer required runs and sells until its lifetime is out.
|
|
"""
|
|
inn = oppdiktet(lam=0.6, KF=0.9, n_reaktor=200.0, T_slutt=2075, L_H=7, s_brikker=1.0)
|
|
res = _regn(inn, Losning.B, N_anlegg=6)
|
|
enheter = {}
|
|
for t in range(2035, 2076):
|
|
anlegg = res.plan.antall_i_drift(t)
|
|
rad = res.kraftaar[t - 2027]
|
|
enheter[t] = round((rad.Delta_R + 0.5 * 1.2 * 1000.0 * anlegg) / 980.0)
|
|
assert enheter[t] >= math.ceil(0.8 * anlegg - 1e-9), t
|
|
assert rad.Delta_Q <= 0, t
|
|
assert [enheter[t] for t in (2035, 2039, 2043, 2051, 2055, 2059, 2063, 2067, 2071, 2075)] == [
|
|
2, 3, 4, 5, 4, 3, 2, 2, 1, 0,
|
|
] # fmt: skip
|
|
# six units are built, and all six are decommissioned within 2075
|
|
assert sum(len(f.gruppe.numre) for f in res.felles) == 6
|
|
assert sum(float(f.avvikling.sum()) for f in res.felles) == pytest.approx(6 * 5e6 * 1000.0)
|
|
siste = res.felles[-1]
|
|
assert siste.avvikling[2074 - 2027] == pytest.approx(5e6 * 1000.0)
|
|
assert siste.salg[2072 - 2027] > 0 # it sells after the last facility has gone out
|
|
assert siste.investering[2054 - 2027] > 0
|
|
assert res.RV_felles == 0.0
|
|
assert all(a.salg == {} for a in res.anlegg)
|
|
|
|
|
|
def test_B_avvikling_etter_sluttaaret_regnes_per_enhet(oppdiktet: LagInndata) -> None:
|
|
"""Final year 2060 in the same programme: units 3 to 6 go out after it, each in its own year.
|
|
|
|
The decommissioning of a unit is discounted with rho_N over its own years left (2, 10
|
|
and 14 years for the units that go out in 2062, 2070 and 2074), then to 2027 with rho_D.
|
|
Unit 3 goes out in 2058, within the final year.
|
|
"""
|
|
inn = oppdiktet(lam=0.6, KF=0.9, n_reaktor=200.0, T_slutt=2060, L_H=7, s_brikker=1.0)
|
|
res = _regn(inn, Losning.B, N_anlegg=6)
|
|
assert [f.L_rest for f in res.felles] == [0, 0, 2, 10, 14]
|
|
avvikling = 5e6 * 1000.0
|
|
haand = -avvikling * (1.06**-2 + 1.06**-10 + 1.06**-14) / 1.08**33
|
|
assert res.RV_felles == pytest.approx(haand)
|
|
assert res.RV == pytest.approx(math.fsum(res.RV_anlegg) + res.RV_felles)
|
|
assert all(a.avvikling_etter == {} for a in res.anlegg)
|
|
|
|
|
|
def test_B_anlegget_baerer_sin_del_av_programmets_kjernekraft_i_restverdien(
|
|
oppdiktet: LagInndata,
|
|
) -> None:
|
|
"""One facility in B with final year 2045: the two units are all its own in S40."""
|
|
inn = oppdiktet(T_slutt=2045)
|
|
res = _regn(inn, Losning.B, knapphet=Knapphet.VARER)
|
|
(felles,) = res.felles
|
|
assert felles.L_rest == 9
|
|
netto = res.anlegg[0].datasenter() + res.anlegg[0].kraft(res.varsigma, res.F_a)
|
|
netto = netto + felles.netto(res.varsigma[ks.KJERNEKRAFT])
|
|
verdi = max(0.0, float(netto[-5:].mean()) * (1 - 1.08**-9) / 0.08) / 1.08**18
|
|
assert list(res.RV_anlegg) == pytest.approx([verdi])
|
|
assert res.RV_felles == pytest.approx(-5e6 * 2000.0 / 1.06**9 / 1.08**18)
|
|
|
|
|
|
def test_B_merket_selger_alt_og_bruker_smaa_enheters_tall(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
dim = ks.dimensjoner(inn, Losning.B_MERKET)
|
|
assert dim.Gamma == 1.0
|
|
(verk,) = ks.kraftverk_for_anlegg(inn, Losning.B_MERKET, dim, 1)
|
|
effekt = dim.N_u * 50.0
|
|
kapasitetsfaktor = 0.8 * (1 - 0.04) / (1 - 0.02)
|
|
assert verk.energi == pytest.approx(8760.0 * kapasitetsfaktor * effekt)
|
|
assert verk.selges
|
|
assert verk.effektbidrag == pytest.approx(0.96 * effekt)
|
|
assert verk.storste_enhet == pytest.approx(0.96 * 50.0)
|
|
assert verk.fast_drift + verk.variabel_drift == pytest.approx(
|
|
1e6 * effekt + (50.0 + 100.0 + 30.0) * verk.energi
|
|
)
|
|
assert dim.P_G_N == effekt
|
|
|
|
|
|
def test_B_nettinvesteringen_bruker_behovet_ikke_hele_enheter(oppdiktet: LagInndata) -> None:
|
|
res = _regn(oppdiktet(), Losning.B)
|
|
assert float(res.anlegg[0].I_nett.sum()) == pytest.approx(5e6 * (0.5 * 1.2 * 1000.0 + 1125.0))
|
|
|
|
|
|
def test_B_kraftsystemet_i_driftsaarene(oppdiktet: LagInndata) -> None:
|
|
res = _regn(oppdiktet(), Losning.B)
|
|
rad = res.kraftaar[2040 - 2027]
|
|
E_N = 2 * 8760.0 * 0.8 * 1000.0
|
|
assert rad.Delta_Q == pytest.approx(0.5 * E_D - E_N)
|
|
assert rad.Delta_Q_tort == pytest.approx(rad.Delta_Q)
|
|
assert rad.pris == pytest.approx(700.0 - 10e-6 * (10e6 - rad.Delta_Q))
|
|
assert rad.Delta_R == pytest.approx(0.98 * 2000.0 - 0.5 * 1.2 * 1000.0)
|
|
assert rad.Delta_R_utfall == pytest.approx(rad.Delta_R - 980.0)
|
|
assert not res.F_a.any() # the balance holds also with the largest unit out
|
|
|
|
|
|
# ------------------------------------------------------- the additionality rule (S45)
|
|
|
|
|
|
def _naaverdi_kraftverk(res: ks.Programresultat, teknologi: str, rho_N: float) -> float:
|
|
"""NV_i of S45, built up again from the yearly amounts (no residual value: L_rest = 0)."""
|
|
D_N = np.array([(1.0 + rho_N) ** -(t - res.aar[0]) for t in res.aar])
|
|
egne = math.fsum(
|
|
float(
|
|
D_N
|
|
@ (
|
|
res.varsigma[teknologi] * a.salg[teknologi]
|
|
- a.investering[teknologi]
|
|
- a.kraftdrift[teknologi]
|
|
- a.avvikling[teknologi]
|
|
)
|
|
)
|
|
for a in res.anlegg
|
|
if teknologi in a.salg
|
|
)
|
|
if teknologi != ks.KJERNEKRAFT:
|
|
return egne
|
|
# in B the units belong to the programme; the accident cost is not part of NV_i
|
|
return egne + math.fsum(
|
|
float(D_N @ (f.netto(res.varsigma[teknologi]) + f.ulykke)) for f in res.felles
|
|
)
|
|
|
|
|
|
def test_s45_binder_ikke_for_et_kraftverk_som_taper(oppdiktet: LagInndata) -> None:
|
|
res = _regn(oppdiktet(), Losning.B_MERKET)
|
|
assert res.varsigma == {ks.KJERNEKRAFT: 1.0}
|
|
assert _naaverdi_kraftverk(res, ks.KJERNEKRAFT, 0.06) < 0
|
|
|
|
|
|
def test_s45_gir_naaverdi_null_naar_den_binder(oppdiktet: LagInndata) -> None:
|
|
"""A cheap reactor that earns money on the grid is credited nothing.
|
|
|
|
Chips for three facilities a year, so the two start together and every unit goes out
|
|
before the final year; the helper below has no residual value.
|
|
"""
|
|
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6, s_brikker=0.12)
|
|
for losning in (Losning.B, Losning.B_MERKET):
|
|
res = _regn(inn, losning, N_anlegg=2)
|
|
assert 0.0 < res.varsigma[ks.KJERNEKRAFT] < 1.0
|
|
kostnader = -_naaverdi_kraftverk(
|
|
ks.regn_program(inn, losning, res.plan, Knapphet.NORMALISERING, tilleggsregel=False),
|
|
ks.KJERNEKRAFT,
|
|
0.06,
|
|
)
|
|
assert kostnader < 0 # without the rule the plant has a surplus
|
|
assert _naaverdi_kraftverk(res, ks.KJERNEKRAFT, 0.06) == pytest.approx(
|
|
0.0, abs=1e-3 * abs(kostnader)
|
|
)
|
|
|
|
|
|
def test_s45_regnes_for_hver_teknologi_i_C(oppdiktet: LagInndata) -> None:
|
|
"""Hydropower (value factor 1.2) earns money, offshore wind does not."""
|
|
res = _regn(oppdiktet(), Losning.C)
|
|
assert set(res.varsigma) == {"vann", "vind", "havvind"}
|
|
assert res.varsigma["vann"] < 1.0
|
|
assert res.varsigma["havvind"] == 1.0
|
|
assert _naaverdi_kraftverk(res, "vann", 0.06) == pytest.approx(0.0, abs=1.0)
|
|
assert _naaverdi_kraftverk(res, "havvind", 0.06) < 0
|
|
|
|
|
|
def test_uten_tilleggsregelen_krediteres_overskuddet(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6)
|
|
med = _regn(inn, Losning.B_MERKET)
|
|
uten = _regn(inn, Losning.B_MERKET, tilleggsregel=False)
|
|
assert uten.varsigma == {ks.KJERNEKRAFT: 1.0}
|
|
assert uten.NV_kraft > med.NV_kraft
|
|
|
|
|
|
def test_s45_med_restverdi_gir_naaverdi_null_med_kraftverkets_del(
|
|
oppdiktet: LagInndata,
|
|
) -> None:
|
|
"""Final year 2045: nine operating years are left, so the plant's own residual value counts.
|
|
|
|
NV_i is built up again here: the cash flow to 2045, plus the plant's own part of the
|
|
residual value (clarification 22) with the decommissioning that falls after 2045.
|
|
"""
|
|
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6, T_slutt=2045)
|
|
res = _regn(inn, Losning.B_MERKET)
|
|
anlegg, varsigma = res.anlegg[0], res.varsigma[ks.KJERNEKRAFT]
|
|
assert anlegg.L_rest == 9
|
|
assert 0.0 < varsigma < 1.0
|
|
assert not anlegg.avvikling[ks.KJERNEKRAFT].any()
|
|
netto = (
|
|
varsigma * anlegg.salg[ks.KJERNEKRAFT]
|
|
- anlegg.investering[ks.KJERNEKRAFT]
|
|
- anlegg.kraftdrift[ks.KJERNEKRAFT]
|
|
)
|
|
D_N = np.array([1.06 ** -(t - 2027) for t in res.aar])
|
|
snitt = float(netto[-5:].mean())
|
|
egen_restverdi = (
|
|
max(0.0, snitt * (1 - 1.08**-9) / 0.08) - anlegg.avvikling_etter[ks.KJERNEKRAFT] / 1.06**9
|
|
) / 1.08**18
|
|
assert float(D_N @ netto) + egen_restverdi == pytest.approx(0.0, abs=1e3)
|
|
assert anlegg.avvikling_etter[ks.KJERNEKRAFT] == pytest.approx(5e6 * res.dim.N_u * 50.0)
|
|
|
|
|
|
# ------------------------------------------------------------ renewable power (C)
|
|
|
|
|
|
def test_C_portefoljen_per_anlegg_og_toerraaret(oppdiktet: LagInndata) -> None:
|
|
"""Dry-year need 7.884 TWh per facility: hydropower 2 (1.6 dry), wind 3, offshore 3.284."""
|
|
inn = oppdiktet()
|
|
dim = ks.dimensjoner(inn, Losning.C)
|
|
forste = {v.teknologi: v for v in ks.kraftverk_for_anlegg(inn, Losning.C, dim, 1)}
|
|
assert forste["vann"].energi == pytest.approx(2e6)
|
|
assert forste["vind"].energi == pytest.approx(3e6)
|
|
assert forste["havvind"].energi == pytest.approx(E_D - 1.6e6 - 3e6)
|
|
# the potentials are used up: the second facility gets offshore wind only
|
|
andre = ks.kraftverk_for_anlegg(inn, Losning.C, dim, 2)
|
|
assert [v.teknologi for v in andre] == ["havvind"]
|
|
assert andre[0].energi == pytest.approx(E_D)
|
|
|
|
vann, havvind = forste["vann"], forste["havvind"]
|
|
assert vann.effekt == pytest.approx(2e6 / 3000.0)
|
|
assert vann.investering == pytest.approx(20e6 * 2e6 / 3000.0)
|
|
assert vann.byggetid == 1.0 # NVE's figure holds the interest: booked the year before start
|
|
assert [vann.fast_drift, vann.variabel_drift] == pytest.approx([0.0, 70.0 * 2e6])
|
|
assert vann.effektbidrag == pytest.approx(0.9 * 2e6 / 3000.0)
|
|
# offshore wind: per MW and year
|
|
assert [havvind.fast_drift, havvind.variabel_drift] == pytest.approx(
|
|
[0.9e6 * havvind.effekt, 0.0]
|
|
)
|
|
assert havvind.effektbidrag == 0.0
|
|
assert forste["vind"].effektbidrag == pytest.approx(0.05 * 1000.0)
|
|
|
|
|
|
def test_C_dekker_forbruket_i_toerraar_og_selger_overskudd_i_normalaar(
|
|
oppdiktet: LagInndata,
|
|
) -> None:
|
|
res = _regn(oppdiktet(), Losning.C)
|
|
rad = res.kraftaar[2035 - 2027]
|
|
E_G = 2e6 + 3e6 + (E_D - 4.6e6)
|
|
assert rad.Delta_Q == pytest.approx(0.5 * E_D - E_G)
|
|
assert rad.Delta_Q_tort == pytest.approx(0.5 * E_D - E_D)
|
|
assert rad.Delta_Q < rad.Delta_Q_tort <= 0
|
|
assert rad.Delta_R == pytest.approx(0.9 * 2e6 / 3000.0 + 0.05 * 1000.0 - 600.0)
|
|
assert rad.Delta_R_utfall == rad.Delta_R # no largest unit without nuclear power
|
|
|
|
|
|
def test_C_fornybare_kraftverk_fornyes_naar_levetiden_er_ute(oppdiktet: LagInndata) -> None:
|
|
"""Wind lasts 30 years: with 45 operating years it is built twice, hydropower (40) twice."""
|
|
inn = oppdiktet(L_N=45.0, T_slutt=2080, vind__levetid=30, u_eksport=(0.5,) * 53)
|
|
res = _regn(inn, Losning.C)
|
|
anlegg = res.anlegg[0]
|
|
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
|
en_gang = 14e6 * 1000.0
|
|
assert float(anlegg.investering["vind"].sum()) == pytest.approx(2 * en_gang)
|
|
assert [float(anlegg.investering["vind"][aar[t]]) for t in (2028, 2029, 2058, 2059)] == (
|
|
pytest.approx([en_gang / 2] * 4)
|
|
)
|
|
assert anlegg.investering["vann"][aar[2029]] == pytest.approx(20e6 * 2e6 / 3000.0)
|
|
assert anlegg.investering["vann"][aar[2069]] == pytest.approx(20e6 * 2e6 / 3000.0)
|
|
|
|
|
|
# ----------------------------------------------------------------- residual value
|
|
|
|
|
|
def test_restverdi_per_anlegg_og_avvikling_etter_sluttaaret(oppdiktet: LagInndata) -> None:
|
|
"""A with final year 2045: nine years left, and the decommissioning falls after 2045."""
|
|
inn = oppdiktet(T_slutt=2045)
|
|
res = _regn(inn, Losning.A, knapphet=Knapphet.VARER)
|
|
anlegg = res.anlegg[0]
|
|
assert anlegg.L_rest == 9
|
|
assert not anlegg.avvikling[ks.KJERNEKRAFT].any()
|
|
avvikling = 5e6 * res.dim.N_u * 50.0
|
|
assert anlegg.avvikling_etter == {ks.KJERNEKRAFT: pytest.approx(avvikling)}
|
|
netto = anlegg.datasenter() + anlegg.kraft(res.varsigma, np.zeros(len(res.aar)))
|
|
snitt = float(netto[-5:].mean())
|
|
# in A the decommissioning is discounted with rho_A = rho_D
|
|
haand = (max(0.0, snitt * (1 - 1.08**-9) / 0.08) - avvikling / 1.08**9) / 1.08**18
|
|
assert list(res.RV_anlegg) == pytest.approx([haand])
|
|
assert res.RV == pytest.approx(haand)
|
|
|
|
|
|
def test_anlegg_som_taper_faar_bare_avviklingen_i_restverdien(oppdiktet: LagInndata) -> None:
|
|
"""A price 90 % below cost in every vintage to 2045: the facility loses money each year."""
|
|
inn = oppdiktet(T_slutt=2045, pi_neg=-0.9, T_knapp=20)
|
|
res = _regn(inn, Losning.B_MERKET, knapphet=Knapphet.OVERKAPASITET)
|
|
netto = res.anlegg[0].datasenter() + res.anlegg[0].kraft(res.varsigma, res.F_a)
|
|
assert float(netto[-5:].mean()) < 0
|
|
avvikling = 5e6 * res.dim.N_u * 50.0
|
|
assert res.RV == pytest.approx(-avvikling / 1.06**9 / 1.08**18)
|
|
|
|
|
|
def test_effektkostnaden_deles_paa_anleggene_i_drift(oppdiktet: LagInndata) -> None:
|
|
"""Three facilities in R that start the same year carry a third each of F_a."""
|
|
inn = oppdiktet(T_slutt=2040, s_brikker=0.12)
|
|
en = _regn(inn, Losning.R, N_anlegg=1)
|
|
tre = _regn(inn, Losning.R, N_anlegg=3)
|
|
assert [a.start for a in tre.plan.anlegg] == [2030, 2030, 2030]
|
|
assert tre.F_a[-1] == pytest.approx(3 * en.F_a[-1])
|
|
assert len(set(tre.RV_anlegg)) == 1
|
|
assert tre.RV == pytest.approx(3 * tre.RV_anlegg[0])
|