tokenfabrikker/tests/test_kontantstrom.py
Kjell Tore Guttormsen bca6496c0a
feat(utbygging): build out solution T in modules and add S48-S54
utbyggingsplan_trinnvis follows chapter 17.1: the grid balance of the
first stage, the payment condition for a module's power plants, S49,
and in T-K the two stocks of chips and the queue for replacements.
tidslinje gives MW IT in operation per type of power (S50). S48-S54
are pure functions in ligninger.py, and Inndata carries the new
quantities, the scenarios for the loss of demand and the paths of
u_alt. lag_plan returns a Trinnvisplan for T-F and T-K; regn_program
refuses T until it is taken through the cash flow.

Tested on made-up numbers only (59 new tests, hand-computed build-outs).
Nothing is computed for the hypothesis.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 23:55:57 +01:00

801 lines
36 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
I_KONTANTSTROMMEN = tuple(a for a in Losning if not a.trinnvis)
"""The solutions the cash flow is coded for. Solution T only has its build-out so far."""
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 I_KONTANTSTROMMEN:
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])