feat(kode): first coding of business economics, ownership, scale, environment and verdicts
Chapters 7 to 11 of the specification, on the made-up set only: - nivaaisert: the power cost per facility, year and vintage on levelised form (S9, S11 with clarifications 2, 11, 13 and 15), S15, S19, S27, S42 - eierskap: the business cash flow with every asset booked, tax, S28, S29 and S30 for the four ownership forms, the criteria over the draws - skala: S31 year by year, the first year with stable operation, M6 - miljo: S32 year by year, the rules of M5 (i) and (ii) - dommer: S37, the verdict per target, the step of the ladder, the overall verdicts; tested on invented outcomes - kontantstrom: each asset is recorded as it is paid, and the price of compute exposes the competitor's cost and the markup This is an intermediate step. The readings are not settled: an independent reader is coding the same from the specification alone, a first comparison agrees on the levelised cost, S19, S42, the cash flows, M3 and M4 and differs on depreciation at the final year, tax, debt and two definitions. Chapter 16 gets the clarifications before any result is computed. Nothing is computed for the hypothesis; the parameter file is unchanged. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
parent
fb13b8fd75
commit
e216702d69
15 changed files with 3697 additions and 45 deletions
|
|
@ -11,13 +11,23 @@ from typing import TYPE_CHECKING, Protocol
|
|||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker.inndata import Inndata, Prislinje
|
||||
from tokenfabrikker.inndata import Eierform, Inndata, Prislinje
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Mapping
|
||||
|
||||
OMRAADER = ("NO1", "NO2", "NO3", "NO4", "NO5", "Norge")
|
||||
|
||||
EIERFORMER: Mapping[str, Eierform] = {
|
||||
"direkte": Eierform("direkte", 1.0, 0.0, 0.0, 1.0, 0.04, None, 1.0, skatt=False),
|
||||
"heleid_selskap": Eierform("heleid_selskap", 1.0, 0.0, 0.0, 0.5, 0.05, 0.10, 1.0, skatt=True),
|
||||
"majoritet_boers": Eierform("majoritet_boers", 0.6, 0.0, 0.0, 0.5, 0.05, 0.12, 1.0, skatt=True),
|
||||
"petroleumsmodell": Eierform(
|
||||
"petroleumsmodell", 0.6, 0.25, 0.5, 0.5, 0.05, 0.12, 1.0, skatt=True
|
||||
),
|
||||
}
|
||||
"""Made-up ownership forms with round numbers, in the layout of the parameter file."""
|
||||
|
||||
GRUNNVERDIER: Mapping[str, float] = {
|
||||
# time and size
|
||||
"T0": 2027,
|
||||
|
|
@ -132,6 +142,19 @@ GRUNNVERDIER: Mapping[str, float] = {
|
|||
"D_X": 2.0,
|
||||
"s_brikker": 0.04,
|
||||
"G_server": 25_000.0,
|
||||
# business economics and ownership
|
||||
"t_nett": 0.3e6,
|
||||
"tau_s": 0.2,
|
||||
"iota": 0.02,
|
||||
"r_stat": 0.02,
|
||||
# scale and environment (emissions in tonnes per MWh and per MW IT)
|
||||
"SNKS_snitt": 500e9,
|
||||
"u_kjerne": 0.012,
|
||||
"u_vind": 0.011,
|
||||
"u_havvind": 0.012,
|
||||
"u_vann": 0.004,
|
||||
"u_H": 1000.0,
|
||||
"eta_N": 3e-6,
|
||||
}
|
||||
"""Round, invented values in the units of the equations (kr, MW, MWh, kr/MWh, years)."""
|
||||
|
||||
|
|
@ -165,6 +188,9 @@ def lag_inndata(*, u_eksport: tuple[float, ...] | None = None, **endringer: floa
|
|||
linjer={omraade: Prislinje(alpha=700.0, b=-10e-6) for omraade in OMRAADER},
|
||||
karbonpris={2026: 1000.0, 2100: 1000.0},
|
||||
u_eksport=(0.5,) * antall_aar if u_eksport is None else u_eksport,
|
||||
eierformer=EIERFORMER,
|
||||
areal={"kjernekraft": 0.1e-6, "vind_direkte": 1.5e-6, "vind_plan": 30e-6, "tomt": 0.001},
|
||||
petroleum_median=250e9,
|
||||
)
|
||||
|
||||
|
||||
|
|
|
|||
275
tests/test_dommer.py
Normal file
275
tests/test_dommer.py
Normal file
|
|
@ -0,0 +1,275 @@
|
|||
"""The verdicts (chapter 11 and the pre-registration), tested on invented outcomes.
|
||||
|
||||
No array here comes from the model run on the frozen parameters: the outcomes per draw are
|
||||
made up, and the two conditions that are read from the power system are computed on the
|
||||
made-up set in ``conftest.py``. Nothing here says anything about the hypothesis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import dommer
|
||||
from tokenfabrikker import kontantstrom as ks
|
||||
from tokenfabrikker import ligninger as lg
|
||||
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag, Trinnvalg
|
||||
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."""
|
||||
|
||||
|
||||
_UENDRET = Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False)
|
||||
_EFFEKT_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=False)
|
||||
_ENERGI_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=True)
|
||||
|
||||
|
||||
def _utfall(*deler: tuple[float | None, int]) -> list[float | None]:
|
||||
"""Invented outcomes: each value repeated the given number of draws."""
|
||||
return [verdi for verdi, antall in deler for _ in range(antall)]
|
||||
|
||||
|
||||
def _regn(inn: Inndata, losning: Losning, *, N_anlegg: int = 1) -> 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.NORMALISERING, dim=dim)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- shares
|
||||
|
||||
|
||||
def test_s37_andel() -> None:
|
||||
assert lg.s37_andel([True, False, True, True]) == 0.75
|
||||
with pytest.raises(ValueError, match="at least one draw"):
|
||||
lg.s37_andel([])
|
||||
|
||||
|
||||
def test_trekning_uten_verdi_teller_i_nevneren() -> None:
|
||||
utfall = _utfall((1.0, 6), (-1.0, 2), (None, 2))
|
||||
assert dommer.andel_positiv(utfall) == 0.6
|
||||
assert dommer.andel(utfall, 0.0, minst=True) == 0.6
|
||||
assert dommer.andel(utfall, 0.0, minst=False) == 0.2
|
||||
assert dommer.median(utfall) == 1.0
|
||||
assert dommer.median(_utfall((1.0, 4), (None, 6))) == -math.inf
|
||||
|
||||
|
||||
# -------------------------------------------------------------- M1, M2, M7
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("positive", "negative", "uten", "dom"),
|
||||
[
|
||||
(80, 20, 0, Dom.HOLDER),
|
||||
(79, 21, 0, Dom.BETINGELSER),
|
||||
(20, 80, 0, Dom.BETINGELSER),
|
||||
(19, 81, 0, Dom.HOLDER_IKKE),
|
||||
(80, 0, 20, Dom.HOLDER),
|
||||
(79, 0, 21, Dom.BETINGELSER),
|
||||
(19, 0, 81, Dom.HOLDER_IKKE),
|
||||
],
|
||||
)
|
||||
def test_dom_m1(positive: int, negative: int, uten: int, dom: Dom) -> None:
|
||||
"""Positive in at least 80 % of all draws holds; in under 20 % it does not."""
|
||||
assert dommer.dom_m1(_utfall((5.0, positive), (-5.0, negative), (None, uten))) is dom
|
||||
|
||||
|
||||
def test_dom_m2_teller_null_som_oppfylt() -> None:
|
||||
"""S42 is an inequality with >=: a sum of exactly zero meets it."""
|
||||
assert dommer.dom_m2(_utfall((0.0, 80), (-1.0, 20))) is Dom.HOLDER
|
||||
assert dommer.dom_m2(_utfall((0.0, 50), (-1.0, 50))) is Dom.BETINGELSER
|
||||
assert dommer.dom_m2(_utfall((1.0, 10), (-1.0, 50), (None, 40))) is Dom.HOLDER_IKKE
|
||||
|
||||
|
||||
def test_dom_m7_a_mot_b_og_c() -> None:
|
||||
"""A is best in 5 of 10 draws: holds. A draw where A cannot be built is not one of them."""
|
||||
A = _utfall((10.0, 5), (1.0, 3), (None, 2))
|
||||
B = _utfall((5.0, 5), (2.0, 3), (-9.0, 2))
|
||||
C = _utfall((None, 5), (0.0, 5))
|
||||
assert dommer.a_er_best(A, B, C) == [True] * 5 + [False] * 5
|
||||
assert dommer.dom_m7(A, B, C) is Dom.HOLDER
|
||||
alltid_bedre = _utfall((5.0, 5), (2.0, 5))
|
||||
assert dommer.dom_m7(_utfall((10.0, 4), (1.0, 6)), alltid_bedre, C) is Dom.BETINGELSER
|
||||
assert dommer.dom_m7(_utfall((10.0, 1), (1.0, 9)), alltid_bedre, C) is Dom.HOLDER_IKKE
|
||||
# equal is not best
|
||||
assert dommer.a_er_best([1.0], [1.0], [0.0]) == [False]
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ M3 and M4
|
||||
|
||||
|
||||
def test_m3_verste_prisvirkning_i_R(oppdiktet: LagInndata) -> None:
|
||||
"""One facility in R takes 3.942 TWh from the balance: 39.42 kr/MWh on a price of 600.
|
||||
|
||||
In the dry year the effect is 1.2 times larger; the price level 1.5 is in both numerator
|
||||
and denominator. The made-up lines are the same in all areas.
|
||||
"""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.R)
|
||||
normal = 10e-6 * 0.5 * E_D / 600.0
|
||||
assert dommer.m3_verste_prisvirkning(inn, res) == pytest.approx(1.2 * normal)
|
||||
assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.A)) == 0.0
|
||||
# B produces more than the data centres use: the price falls
|
||||
assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.B)) < 0
|
||||
|
||||
|
||||
def test_dom_m3() -> None:
|
||||
assert dommer.dom_m3(_utfall((0.05, 80), (0.2, 20))) is Dom.HOLDER
|
||||
assert dommer.dom_m3(_utfall((0.051, 80), (0.2, 20))) is Dom.BETINGELSER
|
||||
assert dommer.dom_m3(_utfall((0.16, 80), (0.0, 20))) is Dom.HOLDER_IKKE
|
||||
assert dommer.dom_m3(_utfall((0.15, 80), (0.0, 20))) is Dom.BETINGELSER
|
||||
# a draw without a value meets neither condition
|
||||
assert dommer.dom_m3(_utfall((0.16, 79), (None, 21))) is Dom.BETINGELSER
|
||||
assert dommer.dom_m3(_utfall((0.0, 79), (None, 21))) is Dom.BETINGELSER
|
||||
|
||||
|
||||
def test_m4_forsyning_i_de_fem_losningene(oppdiktet: LagInndata) -> None:
|
||||
"""A changes nothing. R only takes power. B and one facility in C add more than they take.
|
||||
|
||||
With three facilities C has used up hydropower and wind on land; offshore wind counts
|
||||
nothing in the scarcest hour, so capacity is missing, but energy is not.
|
||||
"""
|
||||
inn = oppdiktet()
|
||||
assert dommer.m4_forsyning(inn, _regn(inn, Losning.A)) == _UENDRET
|
||||
assert dommer.m4_forsyning(inn, _regn(inn, Losning.R)) == _ENERGI_MANGLER
|
||||
assert dommer.m4_forsyning(inn, _regn(inn, Losning.B)) == _UENDRET
|
||||
assert dommer.m4_forsyning(inn, _regn(inn, Losning.C)) == _UENDRET
|
||||
tre = _regn(inn, Losning.C, N_anlegg=3)
|
||||
assert dommer.m4_forsyning(inn, tre) == _EFFEKT_MANGLER
|
||||
|
||||
|
||||
def test_m4_C_dekker_akkurat_forbruket_i_toerraaret(oppdiktet: LagInndata) -> None:
|
||||
"""With nothing displaced in the grid queue, C's dry-year balance is zero, not weaker."""
|
||||
inn = oppdiktet(delta_V=0.0, kappa_vind=1.0)
|
||||
res = _regn(inn, Losning.C)
|
||||
assert max(abs(rad.Delta_Q_tort) for rad in res.kraftaar) < 1.0
|
||||
assert not dommer.m4_forsyning(inn, res).svakere_ogsaa_med_tiltak
|
||||
|
||||
|
||||
def test_dom_m4() -> None:
|
||||
ok, effekt, energi = _UENDRET, _EFFEKT_MANGLER, _ENERGI_MANGLER
|
||||
assert dommer.dom_m4([ok] * 8 + [energi] * 2) is Dom.HOLDER
|
||||
assert dommer.dom_m4([ok] * 7 + [effekt] * 3) is Dom.BETINGELSER
|
||||
assert dommer.dom_m4([effekt] * 10) is Dom.BETINGELSER
|
||||
assert dommer.dom_m4([energi] * 8 + [ok] * 2) is Dom.HOLDER_IKKE
|
||||
assert dommer.dom_m4([energi] * 7 + [None] * 3) is Dom.BETINGELSER
|
||||
|
||||
|
||||
# -------------------------------------------------------- M6 and the ladder
|
||||
|
||||
|
||||
def test_dom_m6() -> None:
|
||||
assert dommer.dom_m6(_utfall((0.25, 80), (0.0, 20))) is Dom.HOLDER
|
||||
assert dommer.dom_m6(_utfall((0.24, 80), (0.0, 20))) is Dom.BETINGELSER
|
||||
assert dommer.dom_m6(_utfall((0.049, 80), (0.3, 20))) is Dom.HOLDER_IKKE
|
||||
assert dommer.dom_m6(_utfall((0.05, 80), (0.3, 20))) is Dom.BETINGELSER
|
||||
# a path that cannot be built does not reach 5 %
|
||||
assert dommer.dom_m6(_utfall((0.3, 20), (None, 80))) is Dom.HOLDER_IKKE
|
||||
|
||||
|
||||
def _stige(**andel_per_trinn: tuple[float, int]) -> dict[int, dict[Losning, list[float | None]]]:
|
||||
"""A made-up ladder: for A, M6 is the given value in the given number of 10 draws.
|
||||
|
||||
B can be built in the same draws and contributes nothing; R reaches 90 % everywhere.
|
||||
"""
|
||||
stige = {}
|
||||
for navn, (verdi, antall) in andel_per_trinn.items():
|
||||
trinn = int(navn.removeprefix("n"))
|
||||
stige[trinn] = {
|
||||
Losning.A: _utfall((verdi, antall), (None, 10 - antall)),
|
||||
Losning.B: _utfall((0.0, antall), (None, 10 - antall)),
|
||||
Losning.R: _utfall((0.9, 10)),
|
||||
}
|
||||
return stige
|
||||
|
||||
|
||||
def test_dommene_leses_paa_det_laveste_trinnet_som_gir_25_prosent() -> None:
|
||||
stige = _stige(n1=(0.03, 10), n5=(0.1, 10), n10=(0.3, 8), n20=(0.5, 10))
|
||||
assert dommer.trinn_for_dommene(stige) == Trinnvalg(10, Grunnlag.TRINN_25)
|
||||
|
||||
|
||||
def test_ellers_paa_trinnet_som_gir_5_prosent() -> None:
|
||||
"""25 % is reached in only 7 of 10 draws on the top step; 5 % in 8 of 10 from step 5."""
|
||||
stige = _stige(n1=(0.03, 10), n5=(0.1, 8), n10=(0.3, 7))
|
||||
assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.TRINN_5)
|
||||
|
||||
|
||||
def test_ellers_paa_hoyeste_trinn_som_lar_seg_bygge() -> None:
|
||||
"""No step reaches 5 %. Step 10 can be built in 7 of 10 draws, step 5 in 9."""
|
||||
stige = _stige(n1=(0.01, 10), n5=(0.03, 9), n10=(0.04, 7))
|
||||
assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.HOYESTE)
|
||||
|
||||
|
||||
def test_referansekjoringen_kan_ikke_gi_trinnet() -> None:
|
||||
"""R reaches 90 % on every step here, but only A, B and C decide the step."""
|
||||
stige = _stige(n1=(0.0, 10), n5=(0.0, 10))
|
||||
assert dommer.trinn_for_dommene(stige).grunnlag is Grunnlag.HOYESTE
|
||||
|
||||
|
||||
def test_ingen_trinn_lar_seg_bygge() -> None:
|
||||
stige = {
|
||||
1: {
|
||||
Losning.A: _utfall((None, 10)),
|
||||
Losning.B: _utfall((0.1, 7), (None, 3)),
|
||||
}
|
||||
}
|
||||
assert dommer.trinn_for_dommene(stige) == Trinnvalg(None, Grunnlag.INGEN)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- overall verdicts
|
||||
|
||||
|
||||
def _dommer(**endringer: Dom) -> dict[str, Dom]:
|
||||
alle = dict.fromkeys(dommer.MAAL_DEL_I, Dom.HOLDER)
|
||||
alle.update(endringer)
|
||||
return alle
|
||||
|
||||
|
||||
def test_del_I_holder_naar_en_losning_holder_paa_alle_maal() -> None:
|
||||
per_losning = {
|
||||
Losning.A: _dommer(M1=Dom.HOLDER_IKKE),
|
||||
Losning.B: _dommer(),
|
||||
Losning.C: _dommer(M3=Dom.BETINGELSER),
|
||||
}
|
||||
median = {Losning.A: -1.0, Losning.B: 5.0, Losning.C: 5.0}
|
||||
paa_25 = Trinnvalg(10, Grunnlag.TRINN_25)
|
||||
assert dommer.del_I(per_losning, median, paa_25) is Dom.HOLDER
|
||||
# on the 5 % step, or with a single facility, it can at most hold under conditions
|
||||
assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_5)) is Dom.BETINGELSER
|
||||
assert dommer.del_I(per_losning, median, Trinnvalg(1, Grunnlag.TRINN_25)) is Dom.BETINGELSER
|
||||
|
||||
|
||||
def test_del_I_holder_ikke_naar_hver_losning_er_felt() -> None:
|
||||
"""A fails M1, B has a negative median, C fails M4. M6 alone cannot fell a solution."""
|
||||
per_losning = {
|
||||
Losning.A: _dommer(M1=Dom.HOLDER_IKKE),
|
||||
Losning.B: _dommer(M1=Dom.BETINGELSER),
|
||||
Losning.C: _dommer(M4=Dom.HOLDER_IKKE),
|
||||
}
|
||||
median = {Losning.A: -1.0, Losning.B: -0.5, Losning.C: 5.0}
|
||||
valg = Trinnvalg(10, Grunnlag.TRINN_25)
|
||||
assert dommer.del_I(per_losning, median, valg) is Dom.HOLDER_IKKE
|
||||
per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE)
|
||||
assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER
|
||||
assert dommer.del_I(per_losning, median, Trinnvalg(None, Grunnlag.INGEN)) is Dom.HOLDER_IKKE
|
||||
|
||||
|
||||
def test_del_I_ser_bare_paa_A_B_og_C() -> None:
|
||||
"""The reference run R holds on everything here; it cannot give «holder»."""
|
||||
per_losning = {
|
||||
Losning.A: _dommer(M2=Dom.HOLDER_IKKE),
|
||||
Losning.R: _dommer(),
|
||||
}
|
||||
median = {Losning.A: 1.0, Losning.R: 9.0}
|
||||
assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_25)) is Dom.HOLDER_IKKE
|
||||
|
||||
|
||||
def test_del_II_folger_M7() -> None:
|
||||
assert dommer.del_II(Dom.BETINGELSER) is Dom.BETINGELSER
|
||||
455
tests/test_eierskap.py
Normal file
455
tests/test_eierskap.py
Normal file
|
|
@ -0,0 +1,455 @@
|
|||
"""Business cash flow, tax and ownership (chapters 7 and 8): S28, S29 and S30.
|
||||
|
||||
Made-up round numbers only; the ownership forms are those of ``conftest.py``, not the
|
||||
parameter file's. Nothing here says anything about the hypothesis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
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.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,
|
||||
) -> 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)
|
||||
|
||||
|
||||
def _lonnsom(inn: Inndata) -> ei.Bedriftsstrom:
|
||||
"""One facility in R with the scarcity markup: the made-up price is about twice the cost."""
|
||||
return ei.bedriftsstrom(inn, _regn(inn, Losning.R, knapphet=Knapphet.VARER))
|
||||
|
||||
|
||||
# ------------------------------------------------------- the equations one at a time
|
||||
|
||||
|
||||
def test_avskrivning_er_lineaer_over_levetiden() -> None:
|
||||
aar = [
|
||||
lg.s28_avskrivning(kostnad=100.0, levetid=4, start=2030, slutt=2033, t=t)
|
||||
for t in range(2029, 2035)
|
||||
]
|
||||
assert aar == pytest.approx([0.0, 25.0, 25.0, 25.0, 25.0, 0.0])
|
||||
|
||||
|
||||
def test_resten_skrives_av_naar_eiendelen_gaar_ut_for_tiden() -> None:
|
||||
"""A lifetime of ten years, but the facility goes out after three: 10, 10 and the last 80."""
|
||||
aar = [
|
||||
lg.s28_avskrivning(kostnad=100.0, levetid=10, start=2030, slutt=2032, t=t)
|
||||
for t in range(2030, 2034)
|
||||
]
|
||||
assert aar == pytest.approx([10.0, 10.0, 80.0, 0.0])
|
||||
assert math.fsum(aar) == pytest.approx(100.0)
|
||||
|
||||
|
||||
def test_underskudd_fores_fram_uten_rente() -> None:
|
||||
"""A loss of 100 is used against 60 and then against 40 of the next 80."""
|
||||
assert lg.s28_etter_framforing([-100.0, 60.0, 80.0, 50.0]) == (0.0, 0.0, 40.0, 50.0)
|
||||
assert lg.s28_etter_framforing([10.0, -5.0, -5.0, 30.0]) == (10.0, 0.0, 0.0, 20.0)
|
||||
|
||||
|
||||
def test_s28_naaverdi() -> None:
|
||||
assert lg.s28_naaverdi(netto=[-100.0, 0.0, 121.0], rente=0.1) == pytest.approx(0.0)
|
||||
|
||||
|
||||
def test_s29_kapitalkostnad() -> None:
|
||||
"""Half debt at 5 % (4 % after 20 % tax) and half equity at 10 %: 7 % nominal, 4.9 % real."""
|
||||
r_e = lg.s29_kapitalkostnad(h=0.5, r_d=0.05, r_q=0.10, tau_s=0.2, iota=0.02)
|
||||
assert r_e == pytest.approx(1.07 / 1.02 - 1.0)
|
||||
assert lg.realrente(nominell=0.071, iota=0.05) == pytest.approx(0.02)
|
||||
|
||||
|
||||
def test_s30_skatt_med_egen_framforing_for_saerskatten() -> None:
|
||||
"""Corporate tax 20 % on profit after the loss; special tax 50 % above 5 % of capital 200.
|
||||
|
||||
Profit above the return: -100, 50, 70, 40. The loss of 100 takes the 50 and half of the
|
||||
70, so the special tax base is 0, 0, 20, 40.
|
||||
"""
|
||||
selskap, saer = lg.s30_skatt(
|
||||
overskudd=[-100.0, 60.0, 80.0, 50.0],
|
||||
kapital_inn=[0.0, 200.0, 200.0, 200.0],
|
||||
tau_s=0.2,
|
||||
tau_g=0.5,
|
||||
r_e=0.05,
|
||||
)
|
||||
assert selskap == pytest.approx((0.0, 0.0, 8.0, 10.0))
|
||||
assert saer == pytest.approx((0.0, 0.0, 10.0, 20.0))
|
||||
|
||||
|
||||
def test_s30_statens_kontantstrom() -> None:
|
||||
"""State share 0.6, direct share 0.25, the state carries all overruns (zeta = 1)."""
|
||||
KS = lg.s30_statens_kontantstrom(
|
||||
skatt=30.0, FKE=100.0, NK=200.0, overskridelse=40.0, s=0.6, theta=0.25, zeta=1.0
|
||||
)
|
||||
assert KS == pytest.approx(30.0 + 0.6 * 0.75 * 100.0 + 0.25 * 200.0 - 0.4 * 0.75 * 40.0)
|
||||
# with zeta equal to the ownership share the state covers nothing beyond its share
|
||||
uten = lg.s30_statens_kontantstrom(
|
||||
skatt=30.0, FKE=100.0, NK=200.0, overskridelse=40.0, s=0.6, theta=0.25, zeta=0.6
|
||||
)
|
||||
assert uten == pytest.approx(30.0 + 45.0 + 50.0)
|
||||
|
||||
|
||||
# ------------------------------------------------------------ the business cash flow
|
||||
|
||||
|
||||
def test_R_bedriftsstrom_haandregnet(oppdiktet: LagInndata) -> None:
|
||||
"""One facility in R to 2040, as a business pays.
|
||||
|
||||
Building 110 mrd. kr and first vintage 200, paid in 2028 and 2029; vintages of 200 paid
|
||||
in 2034 and 2039; no grid investment. In operation it pays operation, power at the
|
||||
price, electricity tax, grid tariff on 1 200 MW and disconnection for 600 MW.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
res = _regn(inn, Losning.R)
|
||||
strom = ei.bedriftsstrom(inn, res)
|
||||
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
|
||||
pris = 700.0 - 10e-6 * (10e6 - 0.5 * E_D)
|
||||
utkobling = 100.0 * _lcoc_v() / (8760.0 * 1.2) * 600.0
|
||||
assert strom.inntekt[aar[2031]] == pytest.approx(1000.0 * _lcoc_v())
|
||||
assert strom.avgifter[aar[2031]] == pytest.approx(70.0 * E_D + 0.3e6 * 1200.0)
|
||||
assert strom.drift[aar[2031]] == pytest.approx(
|
||||
2.5e9 + pris * E_D + 70.0 * E_D + 0.3e6 * 1200.0 + utkobling
|
||||
)
|
||||
assert not strom.drift[: aar[2030]].any()
|
||||
investert = {2028: 155e9, 2029: 155e9, 2034: 200e9, 2039: 200e9}
|
||||
for t in res.aar:
|
||||
assert strom.investering[aar[t]] == pytest.approx(investert.get(t, 0.0))
|
||||
assert (strom.budsjett == strom.investering).all()
|
||||
# the building over 15 years and one vintage at a time over 5
|
||||
assert strom.avskrivning[aar[2030] :] == pytest.approx(110e9 / 15.0 + 40e9)
|
||||
assert not strom.avskrivning[: aar[2030]].any()
|
||||
assert strom.kapital[aar[2029]] == pytest.approx(310e9)
|
||||
assert strom.kapital[aar[2030]] == pytest.approx(310e9 - 110e9 / 15.0 - 40e9)
|
||||
assert strom.NK[aar[2034]] == pytest.approx(
|
||||
strom.inntekt[aar[2034]] - strom.drift[aar[2034]] - 200e9
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
@pytest.mark.parametrize(
|
||||
"endringer", [{}, {"T_slutt": 2045, "u_xi": 0.1}, {"L_N": 12.0, "L_B": 7.0}]
|
||||
)
|
||||
def test_eiendelene_gir_de_samme_investeringene_som_kontantstrommen(
|
||||
oppdiktet: LagInndata, losning: Losning, endringer: dict[str, float]
|
||||
) -> None:
|
||||
"""The booked assets, paid over their construction time, are the investments of S34 and S35.
|
||||
|
||||
All but the grid connection, which the tariff covers. In A the table for the buffer
|
||||
also holds its fixed operation, which is taken out here.
|
||||
"""
|
||||
inn = oppdiktet(u_eksport=None, **endringer)
|
||||
res = _regn(inn, losning, N_anlegg=2)
|
||||
strom = ei.bedriftsstrom(inn, res)
|
||||
ventet = np.zeros(len(res.aar))
|
||||
for k, a in enumerate(res.anlegg):
|
||||
ventet += a.I_bygg + a.I_H + a.I_g + a.buffer
|
||||
for tabell in a.investering.values():
|
||||
ventet += tabell
|
||||
if losning is Losning.A:
|
||||
i_drift = np.array([res.plan.i_drift(k, t) for t in res.aar], dtype=np.float64)
|
||||
ventet -= i_drift * 0.4e6 * 600.0
|
||||
for f in res.felles:
|
||||
ventet += f.investering
|
||||
assert strom.investering == pytest.approx(ventet)
|
||||
# the overrun factor is 1.5 in the second set, and only nuclear power carries it
|
||||
overskridelse = float((strom.investering - strom.budsjett).sum())
|
||||
if losning.kjernekraft and res.dim.xi_N > 1.0:
|
||||
eiendeler = [e for a in res.anlegg for e in a.eiendeler]
|
||||
eiendeler += [e for f in res.felles for e in f.eiendeler]
|
||||
kjernekraft = math.fsum(e.kostnad for e in eiendeler if e.slag == ks.KJERNEKRAFT)
|
||||
assert overskridelse == pytest.approx(kjernekraft / 3.0)
|
||||
else:
|
||||
assert overskridelse == 0.0
|
||||
|
||||
|
||||
def test_avskrivningene_summerer_seg_til_det_som_er_betalt(oppdiktet: LagInndata) -> None:
|
||||
"""Every asset is out of operation by 2060, so the booked capital ends at zero."""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.A)
|
||||
strom = ei.bedriftsstrom(inn, res)
|
||||
assert float(strom.avskrivning.sum()) == pytest.approx(float(strom.investering.sum()))
|
||||
assert strom.kapital[-1] == pytest.approx(0.0, abs=1.0)
|
||||
assert (strom.kapital > -1.0).all()
|
||||
|
||||
|
||||
def test_A_betaler_elavgift_men_ikke_nettariff(oppdiktet: LagInndata) -> None:
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.A)
|
||||
strom = ei.bedriftsstrom(inn, res)
|
||||
j = 2040 - 2027
|
||||
assert strom.avgifter[j] == pytest.approx(70.0 * E_D)
|
||||
anlegg = res.anlegg[0]
|
||||
assert strom.drift[j] == pytest.approx(
|
||||
2.5e9
|
||||
+ float(anlegg.kraftdrift[ks.KJERNEKRAFT][j])
|
||||
+ float(anlegg.ulykke[j])
|
||||
+ 0.4e6 * 600.0
|
||||
+ 70.0 * E_D
|
||||
)
|
||||
|
||||
|
||||
def test_kraftverk_paa_nettet_selger_uten_tilleggsregelen(oppdiktet: LagInndata) -> None:
|
||||
"""The business keeps the plant's whole sales, also when S45 binds in M1."""
|
||||
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6)
|
||||
res = _regn(inn, Losning.B_MERKET)
|
||||
assert res.varsigma[ks.KJERNEKRAFT] < 1.0
|
||||
strom = ei.bedriftsstrom(inn, res)
|
||||
j = 2040 - 2027
|
||||
anlegg = res.anlegg[0]
|
||||
uten_salg = (
|
||||
2.5e9
|
||||
+ float(anlegg.kraftdrift[ks.KJERNEKRAFT][j])
|
||||
+ float(anlegg.ulykke[j])
|
||||
+ res.kraftaar[j].pris * E_D
|
||||
+ float(strom.avgifter[j])
|
||||
)
|
||||
assert strom.drift[j] == pytest.approx(uten_salg - float(anlegg.salg[ks.KJERNEKRAFT][j]))
|
||||
# S30 is computed with the factor of S45 on the sales (chapter 1.4)
|
||||
med_regel = ei.bedriftsstrom(inn, res, tilleggsregel=True)
|
||||
assert med_regel.drift[j] == pytest.approx(
|
||||
uten_salg - res.varsigma[ks.KJERNEKRAFT] * float(anlegg.salg[ks.KJERNEKRAFT][j])
|
||||
)
|
||||
assert (med_regel.investering == strom.investering).all()
|
||||
|
||||
|
||||
# -------------------------------------------------------------- the ownership forms
|
||||
|
||||
|
||||
def test_kapitalkostnad_per_eierform(oppdiktet: LagInndata) -> None:
|
||||
inn = oppdiktet()
|
||||
assert ei.kapitalkostnad(inn, inn.eierformer["direkte"]) == 0.02
|
||||
assert ei.kapitalkostnad(inn, inn.eierformer["heleid_selskap"]) == pytest.approx(
|
||||
1.07 / 1.02 - 1.0
|
||||
)
|
||||
assert ei.kapitalkostnad(inn, inn.eierformer["majoritet_boers"]) == pytest.approx(
|
||||
1.08 / 1.02 - 1.0
|
||||
)
|
||||
|
||||
|
||||
def test_direkte_eierskap_gir_staten_hele_kontantstrommen(oppdiktet: LagInndata) -> None:
|
||||
"""No company and no corporate tax: FKE = NK, and the state also receives tax and tariff."""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
strom = ei.bedriftsstrom(inn, _regn(inn, Losning.R))
|
||||
ut = ei.eierresultat(inn, strom, inn.eierformer["direkte"])
|
||||
assert not ut.selskapsskatt.any()
|
||||
assert not ut.saerskatt.any()
|
||||
assert (ut.FKE == strom.NK).all()
|
||||
assert not ut.gjeld.any()
|
||||
assert ut.KS_stat == pytest.approx(strom.NK + strom.avgifter)
|
||||
NV = math.fsum(float(x) / 1.02**j for j, x in enumerate(strom.NK))
|
||||
assert ei.naaverdi_etter_skatt(inn, strom, inn.eierformer["direkte"]) == pytest.approx(NV)
|
||||
assert ut.NV_NK == pytest.approx(NV)
|
||||
# 310 mrd. kr is paid before the first revenue
|
||||
assert ut.storste_innskutte_kapital == pytest.approx(310e9)
|
||||
|
||||
|
||||
def test_heleid_selskap_skatt_gjeld_og_statens_kontantstrom(oppdiktet: LagInndata) -> None:
|
||||
"""One wholly owned company, half debt at 5 % nominal (1.05 / 1.02 - 1 real).
|
||||
|
||||
Tax is 20 % of revenue minus operation and depreciation; nothing is carried forward
|
||||
because the first operating year already has a profit. The state owns everything, so
|
||||
the tax cancels: what it gets is NK, tax and tariff, minus interest, plus new debt.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
strom = _lonnsom(inn)
|
||||
ut = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
|
||||
overskudd = strom.inntekt - strom.drift - strom.avskrivning
|
||||
assert (overskudd[3:] > 0).all()
|
||||
assert ut.selskapsskatt == pytest.approx(0.2 * overskudd)
|
||||
assert not ut.saerskatt.any()
|
||||
assert ut.gjeld[:-1] == pytest.approx(0.5 * strom.kapital[:-1])
|
||||
assert ut.gjeld[-1] == 0.0
|
||||
gjeld_inn = np.concatenate(([0.0], ut.gjeld[:-1]))
|
||||
rente = 1.05 / 1.02 - 1.0
|
||||
FKE = strom.NK - ut.selskapsskatt - rente * gjeld_inn + ut.gjeld - gjeld_inn
|
||||
assert ut.FKE == pytest.approx(FKE)
|
||||
assert ut.KS_stat == pytest.approx(
|
||||
strom.NK + strom.avgifter - rente * gjeld_inn + ut.gjeld - gjeld_inn
|
||||
)
|
||||
r_e = 1.07 / 1.02 - 1.0
|
||||
NV_e = ei.naaverdi_etter_skatt(inn, strom, inn.eierformer["heleid_selskap"])
|
||||
assert NV_e == pytest.approx(
|
||||
math.fsum(float(x) / (1.0 + r_e) ** j for j, x in enumerate(strom.NK - ut.selskapsskatt))
|
||||
)
|
||||
assert ut.NV_stat == pytest.approx(
|
||||
math.fsum(float(x) / 1.02**j for j, x in enumerate(ut.KS_stat))
|
||||
)
|
||||
andel = ut.andel_av_overskudd
|
||||
assert andel is not None
|
||||
assert andel == pytest.approx(ut.NV_stat / ut.NV_NK)
|
||||
# the owners put in half of what is built, and the interest in 2029 on what was borrowed
|
||||
# in 2028; the other half is borrowed
|
||||
assert ut.storste_innskutte_kapital == pytest.approx(155e9 + rente * 77.5e9)
|
||||
|
||||
|
||||
def test_privat_minoritet_og_direkte_andel(oppdiktet: LagInndata) -> None:
|
||||
"""The petroleum model: the state owns 60 % of the company and 25 % of the facilities directly.
|
||||
|
||||
The company's part, 75 %, pays corporate tax and special tax; the state's direct part
|
||||
does not. Electricity tax and grid tariff come from the whole project.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
strom = _lonnsom(inn)
|
||||
ut = ei.eierresultat(inn, strom, inn.eierformer["petroleumsmodell"])
|
||||
assert ut.saerskatt.sum() > 0
|
||||
skatt = ut.selskapsskatt + ut.saerskatt
|
||||
ventet = 0.75 * skatt + strom.avgifter + 0.6 * 0.75 * ut.FKE + 0.25 * strom.NK
|
||||
assert ut.KS_stat == pytest.approx(ventet)
|
||||
# the special tax is 50 % of the profit above r_e on the capital booked at the start of the
|
||||
# year; the return on what was booked during construction is carried forward and used in 2030
|
||||
r_e = 1.08 / 1.02 - 1.0
|
||||
overskudd = strom.inntekt - strom.drift - strom.avskrivning
|
||||
j = 2031 - 2027
|
||||
assert ut.saerskatt[j] == pytest.approx(0.5 * (overskudd[j] - r_e * strom.kapital[j - 1]))
|
||||
boers = ei.eierresultat(inn, strom, inn.eierformer["majoritet_boers"])
|
||||
assert boers.NV_stat < ut.NV_stat
|
||||
# the special tax lowers the project's value after tax (S28)
|
||||
assert ei.naaverdi_etter_skatt(
|
||||
inn, strom, inn.eierformer["majoritet_boers"]
|
||||
) > ei.naaverdi_etter_skatt(inn, strom, inn.eierformer["petroleumsmodell"])
|
||||
|
||||
|
||||
def test_staten_dekker_overskridelser_ut_over_eierandelen(oppdiktet: LagInndata) -> None:
|
||||
"""Overrun 50 % on nuclear power; the state owns 60 % but carries all of it (zeta = 1)."""
|
||||
inn = oppdiktet(u_xi=0.1)
|
||||
res = _regn(inn, Losning.A)
|
||||
assert res.dim.xi_N == 1.5
|
||||
strom = ei.bedriftsstrom(inn, res)
|
||||
overskridelse = strom.investering - strom.budsjett
|
||||
assert overskridelse.sum() > 0
|
||||
ut = ei.eierresultat(inn, strom, inn.eierformer["majoritet_boers"])
|
||||
skatt = ut.selskapsskatt + ut.saerskatt
|
||||
uten = skatt + strom.avgifter + 0.6 * ut.FKE
|
||||
assert ut.KS_stat == pytest.approx(uten - 0.4 * overskridelse)
|
||||
|
||||
|
||||
def test_underskudd_i_oppstarten_gir_ingen_skatt(oppdiktet: LagInndata) -> None:
|
||||
"""«Overkapasitet»: the price is 30 % under the competitor's cost, and nothing is taxable.
|
||||
|
||||
The last vintage, from 2040, is sold at cost and gives a small profit; the losses
|
||||
carried forward cover it.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
strom = ei.bedriftsstrom(inn, _regn(inn, Losning.R, knapphet=Knapphet.OVERKAPASITET))
|
||||
assert (strom.inntekt - strom.drift - strom.avskrivning)[-1] > 0
|
||||
ut = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
|
||||
assert not ut.selskapsskatt.any()
|
||||
assert ut.NV_stat < 0
|
||||
assert ut.andel_av_overskudd is None
|
||||
|
||||
|
||||
def test_kapitalkostnaden_flytter_kostnaden_for_regnekraft(oppdiktet: LagInndata) -> None:
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.B_MERKET)
|
||||
lav = ei.lcoc_med_kapitalkostnad(inn, res, 0.02)
|
||||
hoy = ei.lcoc_med_kapitalkostnad(inn, res, 0.06)
|
||||
assert lav < hoy
|
||||
|
||||
|
||||
# ------------------------------------------------------ the criteria over the draws
|
||||
|
||||
|
||||
def test_risikomaalene() -> None:
|
||||
utfall = [float(x) for x in range(-10, 30)] # 40 draws: -10 .. 29
|
||||
assert ei.sannsynlighet_for_tap(utfall) == pytest.approx(10 / 40)
|
||||
# 5 % of 40 draws is the two worst
|
||||
assert ei.snitt_av_de_daarligste(utfall) == pytest.approx(-9.5)
|
||||
assert ei.snitt_av_de_daarligste([3.0, 1.0, 2.0]) == 1.0
|
||||
|
||||
|
||||
def test_storste_innskutte_kapital() -> None:
|
||||
"""Paid in 100 and 50, then 30 back, then 40 more: 160 out at the most."""
|
||||
KS = np.array([-100.0, -50.0, 30.0, -40.0, 500.0])
|
||||
assert ei.storste_innskutte_kapital(KS) == pytest.approx(160.0)
|
||||
assert ei.storste_innskutte_kapital(np.array([10.0, 20.0])) == 0.0
|
||||
|
||||
|
||||
def _kriterier(navn: str, **endringer: float | None) -> ei.Eierkriterier:
|
||||
verdier: dict[str, float | None] = {
|
||||
"verdi": 100.0,
|
||||
"andel_av_overskudd": 0.9,
|
||||
"r_e": 0.05,
|
||||
"LCOC": 80.0,
|
||||
"tapssannsynlighet": 0.1,
|
||||
"daarligste": -50.0,
|
||||
"kapital_ute": 300.0,
|
||||
}
|
||||
verdier.update(endringer)
|
||||
return ei.Eierkriterier(navn=navn, **verdier) # type: ignore[arg-type]
|
||||
|
||||
|
||||
def test_eierkriterier_fra_utfallene(oppdiktet: LagInndata) -> None:
|
||||
"""Two draws with the same made-up path: the averages are those of the one outcome."""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
strom = _lonnsom(inn)
|
||||
ut = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
|
||||
k = ei.eierkriterier("heleid_selskap", [ut, ut], [80.0, 90.0])
|
||||
assert k.verdi == pytest.approx(ut.NV_stat)
|
||||
assert k.andel_av_overskudd == pytest.approx(ut.NV_stat / ut.NV_NK)
|
||||
assert k.r_e == pytest.approx(ut.r_e)
|
||||
assert k.LCOC == pytest.approx(85.0)
|
||||
assert k.tapssannsynlighet == 0.0
|
||||
assert k.daarligste == pytest.approx(ut.NV_stat)
|
||||
assert k.kapital_ute == pytest.approx(ut.storste_innskutte_kapital)
|
||||
|
||||
|
||||
def test_regelen_for_eierformer() -> None:
|
||||
"""One form fails the EEA test, one is worse on everything, one breaks the risk limit."""
|
||||
kriterier = [
|
||||
_kriterier("a", verdi=120.0),
|
||||
_kriterier("b", verdi=150.0, tapssannsynlighet=0.3),
|
||||
_kriterier(
|
||||
"c",
|
||||
verdi=90.0,
|
||||
andel_av_overskudd=0.8,
|
||||
r_e=0.06,
|
||||
LCOC=85.0,
|
||||
tapssannsynlighet=0.2,
|
||||
daarligste=-60.0,
|
||||
kapital_ute=310.0,
|
||||
),
|
||||
_kriterier("d", verdi=200.0),
|
||||
_kriterier("e", verdi=110.0, r_e=0.06, LCOC=85.0),
|
||||
]
|
||||
eos = {"a": "består", "b": "usikker", "c": "består", "d": "består ikke", "e": "består"}
|
||||
rangering = ei.ranger_eierformer(kriterier, eos)
|
||||
assert rangering.rangert == ("a", "e")
|
||||
assert rangering.over_risikogrensen == ("b",)
|
||||
assert set(rangering.ute) == {"c", "d"}
|
||||
assert rangering.ute["d"] == "består ikke EØS-vurderingen"
|
||||
assert "dårligere enn a" in rangering.ute["c"]
|
||||
# e is worse than a on value and capital cost, but not on risk, so it stays
|
||||
strengere = ei.ranger_eierformer(kriterier, eos, risikogrense=0.05)
|
||||
assert strengere.rangert == ()
|
||||
assert strengere.over_risikogrensen == ("b", "a", "e")
|
||||
150
tests/test_miljo.py
Normal file
150
tests/test_miljo.py
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
"""Environment (chapter 10): S32 year by year and the rules of M5.
|
||||
|
||||
Made-up round numbers only; the source values in the tests of M5 are invented. Nothing
|
||||
here says anything about the hypothesis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import pytest
|
||||
|
||||
from tokenfabrikker import kontantstrom as ks
|
||||
from tokenfabrikker import ligninger as lg
|
||||
from tokenfabrikker import miljo
|
||||
from tokenfabrikker.dommer import Dom
|
||||
from tokenfabrikker.kontantstrom import Knapphet
|
||||
from tokenfabrikker.miljo import Kildeverdier
|
||||
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."""
|
||||
|
||||
PORTEFOLJE = {"vann": 2e6, "vind": 3e6, "havvind": E_D - 1.6e6 - 3e6}
|
||||
"""The made-up portfolio of one facility in C: normal-year production per technology, MWh."""
|
||||
|
||||
U_FORNYBAR = (0.004 * 2e6 + 0.011 * 3e6 + 0.012 * PORTEFOLJE["havvind"]) / sum(PORTEFOLJE.values())
|
||||
"""Its emissions per MWh, weighted by production."""
|
||||
|
||||
|
||||
def _regn(inn: Inndata, losning: Losning, *, N_anlegg: int = 1) -> 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.NORMALISERING, dim=dim)
|
||||
|
||||
|
||||
def test_s32_er_summen_av_kraft_maskinvare_og_bygg() -> None:
|
||||
U = lg.s32_utslipp(kraft=500.0, u_H=1000.0, u_B=2000.0, P_IT=10.0, nye_aarganger=2, nye_bygg=1)
|
||||
assert U == pytest.approx(500.0 + 20_000.0 + 20_000.0)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.C, Losning.R])
|
||||
def test_utslipp_aar_for_aar_med_fornybar_kraft(oppdiktet: LagInndata, losning: Losning) -> None:
|
||||
"""One facility from 2030: building and first vintage in 2030, a vintage every five years.
|
||||
|
||||
The building lasts 15 years and is renewed in 2045. R uses the same figure for power
|
||||
as C: the portfolio the facility has in C.
|
||||
"""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, losning)
|
||||
U = miljo.utslipp_livslop(inn, res)
|
||||
kraft = U_FORNYBAR * E_D
|
||||
assert miljo.kraftutslipp_per_mwh(inn, res, 0) == pytest.approx(U_FORNYBAR)
|
||||
assert not U[:3].any()
|
||||
assert U[2030 - 2027] == pytest.approx(kraft + 1000.0 * 1000.0 + 2000.0 * 1000.0)
|
||||
assert U[2031 - 2027] == pytest.approx(kraft)
|
||||
assert U[2035 - 2027] == pytest.approx(kraft + 1000.0 * 1000.0)
|
||||
assert U[2045 - 2027] == pytest.approx(kraft + 1000.0 * 1000.0 + 2000.0 * 1000.0)
|
||||
assert not U[2050 - 2027 :].any()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.A, Losning.B, Losning.B_MERKET])
|
||||
def test_kjernekraftens_utslipp_regnes_paa_det_datasenteret_bruker(
|
||||
oppdiktet: LagInndata, losning: Losning
|
||||
) -> None:
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, losning)
|
||||
U = miljo.utslipp_livslop(inn, res)
|
||||
assert U[2036 - 2027] == pytest.approx(0.012 * E_D)
|
||||
|
||||
|
||||
def test_anlegg_uten_brikker_bruker_ikke_kraft(oppdiktet: LagInndata) -> None:
|
||||
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)
|
||||
U = miljo.utslipp_livslop(inn, _regn(inn, Losning.R))
|
||||
assert U[2036 - 2027] == 0.0
|
||||
assert U[2038 - 2027] > 1000.0 * 1000.0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", [Losning.C, Losning.R])
|
||||
def test_hvert_anlegg_bruker_sin_egen_portefolje(oppdiktet: LagInndata, losning: Losning) -> None:
|
||||
"""The first facility takes the hydropower and the wind; the second gets offshore wind only.
|
||||
|
||||
In R, facility k uses the figure of the portfolio facility k has in C.
|
||||
"""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, losning, N_anlegg=2)
|
||||
assert miljo.kraftutslipp_per_mwh(inn, res, 0) == pytest.approx(U_FORNYBAR)
|
||||
assert miljo.kraftutslipp_per_mwh(inn, res, 1) == pytest.approx(0.012)
|
||||
U = miljo.utslipp_livslop(inn, res)
|
||||
# 2034: both facilities are in operation in both solutions, and no vintage is new
|
||||
assert U[2034 - 2027] == pytest.approx((U_FORNYBAR + 0.012) * E_D)
|
||||
|
||||
|
||||
def test_brukt_brensel_og_areal(oppdiktet: LagInndata) -> None:
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.B_MERKET)
|
||||
tonn = miljo.brukt_brensel(inn, res)
|
||||
assert tonn[2036 - 2027] == pytest.approx(3e-6 * res.verk[0][0].energi)
|
||||
assert not miljo.brukt_brensel(inn, _regn(inn, Losning.R)).any()
|
||||
# A: only what the data centre uses is produced
|
||||
assert miljo.brukt_brensel(inn, _regn(inn, Losning.A))[2036 - 2027] == pytest.approx(3e-6 * E_D)
|
||||
# 0.1 km2 per TWh for nuclear power, 1.5 for wind, and 0.001 km2 per MW IT for the plot
|
||||
assert miljo.areal(inn, teknologi="kjernekraft", energi=E_D, P_IT=1000.0) == pytest.approx(
|
||||
0.7884 + 1.0
|
||||
)
|
||||
assert miljo.areal(inn, teknologi="vind_direkte", energi=E_D, P_IT=1000.0) == pytest.approx(
|
||||
11.826 + 1.0
|
||||
)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------ M5
|
||||
|
||||
|
||||
def test_m5_utslipp_kilde_for_kilde() -> None:
|
||||
"""Invented source values. Nuclear must not be above the lower of wind and hydro in any."""
|
||||
under = Kildeverdier("X", kjernekraft=5.0, vind=11.0, vann=6.0, vind_hoyeste=50.0)
|
||||
mellom = Kildeverdier("Y", kjernekraft=12.0, vind=11.0, vann=24.0, vind_hoyeste=56.0)
|
||||
over = Kildeverdier("Z", kjernekraft=60.0, vind=11.0, vann=24.0, vind_hoyeste=56.0)
|
||||
assert miljo.m5_utslipp(Losning.A, [under, under]) is Dom.HOLDER
|
||||
assert miljo.m5_utslipp(Losning.B, [under, mellom]) is Dom.BETINGELSER
|
||||
assert miljo.m5_utslipp(Losning.A, [under, mellom, over]) is Dom.HOLDER_IKKE
|
||||
lik = Kildeverdier("W", kjernekraft=6.0, vind=11.0, vann=6.0, vind_hoyeste=50.0)
|
||||
assert miljo.m5_utslipp(Losning.A, [lik]) is Dom.HOLDER
|
||||
# C and R meet (i) by definition
|
||||
assert miljo.m5_utslipp(Losning.C, [over]) is Dom.HOLDER
|
||||
assert miljo.m5_utslipp(Losning.R, []) is Dom.HOLDER
|
||||
with pytest.raises(ValueError, match="at least one source"):
|
||||
miljo.m5_utslipp(Losning.A, [])
|
||||
|
||||
|
||||
def test_m5_areal_mot_vind_paa_land() -> None:
|
||||
felles = {"vind_direkte": 1.5, "vind_plan": 35.0}
|
||||
assert miljo.m5_areal(Losning.A, kjernekraft=0.1, **felles) is Dom.HOLDER
|
||||
assert miljo.m5_areal(Losning.A, kjernekraft=1.5, **felles) is Dom.HOLDER
|
||||
assert miljo.m5_areal(Losning.B, kjernekraft=10.0, **felles) is Dom.BETINGELSER
|
||||
assert miljo.m5_areal(Losning.A, kjernekraft=40.0, **felles) is Dom.HOLDER_IKKE
|
||||
assert miljo.m5_areal(Losning.C, kjernekraft=40.0, **felles) is Dom.HOLDER
|
||||
|
||||
|
||||
def test_m5_samlet() -> None:
|
||||
assert miljo.m5(Dom.HOLDER, Dom.HOLDER) is Dom.HOLDER
|
||||
assert miljo.m5(Dom.BETINGELSER, Dom.HOLDER) is Dom.BETINGELSER
|
||||
assert miljo.m5(Dom.BETINGELSER, Dom.BETINGELSER) is Dom.BETINGELSER
|
||||
assert miljo.m5(Dom.HOLDER, Dom.HOLDER_IKKE) is Dom.HOLDER_IKKE
|
||||
assert miljo.m5(Dom.HOLDER, Dom.HOLDER, kostnadsfort=False) is Dom.HOLDER_IKKE
|
||||
405
tests/test_nivaaisert.py
Normal file
405
tests/test_nivaaisert.py
Normal file
|
|
@ -0,0 +1,405 @@
|
|||
"""The levelised cost of power and compute over a path: S9 and S11 per year, S15, S19, S27, S42.
|
||||
|
||||
Everything is computed on the made-up set in ``conftest.py``, and the expected numbers are
|
||||
built up here from the round values of that set. They 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 import nivaaisert as nv
|
||||
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."""
|
||||
|
||||
E_ENHET = 8760.0 * 0.8 * 1000.0
|
||||
"""Yearly production of one made-up reactor of 1 000 MW."""
|
||||
|
||||
|
||||
def _crf(rho: float, levetid: float) -> float:
|
||||
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
|
||||
|
||||
|
||||
def _sff(rho: float, levetid: float) -> float:
|
||||
return float(rho / ((1.0 + rho) ** levetid - 1.0))
|
||||
|
||||
|
||||
def _byggetid(rho: float, tau: float) -> float:
|
||||
"""S3: the factor for interest during construction."""
|
||||
return float(((1.0 + rho) ** tau - 1.0) / (tau * math.log1p(rho)))
|
||||
|
||||
|
||||
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 _lcoc(c_a: float) -> float:
|
||||
"""S15 for the made-up Norwegian facility with power at ``c_a`` kr/MWh."""
|
||||
return 110e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 2.5e6 + 8760.0 * 0.75 * 1.2 * c_a
|
||||
|
||||
|
||||
def _pris(antall_med_last: int, ny_kraft: float = 0.0) -> float:
|
||||
"""The made-up price line: 700 kr/MWh minus 10 kr per TWh of power balance."""
|
||||
return 700.0 - 10e-6 * (10e6 - 0.5 * antall_med_last * E_D + ny_kraft)
|
||||
|
||||
|
||||
def _utkobling(mw: float) -> float:
|
||||
"""S47, disconnection: 100 hours of the competitor-cost price for ``mw`` missing."""
|
||||
return 100.0 * _lcoc_v() / (8760.0 * 1.2) * mw
|
||||
|
||||
|
||||
def _regn(
|
||||
inn: Inndata,
|
||||
losning: Losning,
|
||||
*,
|
||||
N_anlegg: int = 1,
|
||||
knapphet: Knapphet = Knapphet.NORMALISERING,
|
||||
) -> 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)
|
||||
|
||||
|
||||
# ------------------------------------------------------- the equations one at a time
|
||||
|
||||
|
||||
def test_s47_utkobling_er_den_andre_armen() -> None:
|
||||
felles = {"h_knapp": 100.0, "mu": 1.0, "y": 105.12e6, "PUE": 1.2}
|
||||
assert lg.s47_utkobling(Delta_R_utfall=-600.0, **felles) == pytest.approx(600e6)
|
||||
assert lg.s47_utkobling(Delta_R_utfall=50.0, **felles) == 0.0
|
||||
# the full S47 takes the cheaper arm
|
||||
billig = lg.s47_effektkostnad(
|
||||
Delta_R=-600.0, Delta_R_utfall=-600.0, c_fast=0.5e6, c_res=1e6, **felles
|
||||
)
|
||||
assert billig == pytest.approx(300e6)
|
||||
|
||||
|
||||
def test_s27_kraftkostnad_slik_en_bedrift_betaler() -> None:
|
||||
"""Price 500, tax 70; a plant with LCOE 600 and value factor 1.1 covering twice the use."""
|
||||
ledd = lg.Portefoljeledd(x=1.0, LCOE=600.0, psi=1.1, regelen_binder=True)
|
||||
c = lg.s27_kraftkostnad_bedrift_nett(
|
||||
p_z=500.0, t_el=70.0, portefolje=[ledd], E_G=2e6, E_D=1e6, tariff=30e6, F_utkobling=10e6
|
||||
)
|
||||
# the additionality rule does not apply in M2: the plant's net term counts in full
|
||||
assert c == pytest.approx(500.0 + 70.0 + (600.0 - 550.0) * 2.0 + 40.0)
|
||||
assert lg.s27_nettariff(t_nett=0.3e6, PUE=1.2, P_IT=1000.0) == pytest.approx(360e6)
|
||||
assert lg.s27_kraftkostnad_bedrift_dedikert(c_A=900.0, t_el=70.0) == 970.0
|
||||
|
||||
|
||||
def test_s27_og_s42() -> None:
|
||||
assert lg.s27_margin_bedrift(mu=0.9, Gamma=1.0, y=100.0, LCOC_bed=80.0) == pytest.approx(10.0)
|
||||
sum_42 = lg.s42_naaverdivektet_margin(
|
||||
marginer=[10.0, -22.0], aarganger=[2027, 2029], rho_D=0.1, T_0=2027
|
||||
)
|
||||
assert sum_42 == pytest.approx(10.0 - 22.0 / 1.21)
|
||||
|
||||
|
||||
# ------------------------------------------------------------ R: bought from the grid
|
||||
|
||||
|
||||
def test_R_kraftkostnad_per_aar_og_aargang(oppdiktet: LagInndata) -> None:
|
||||
"""One facility in R to 2040: c_a = (1 + n_tap) p + (H_a + F_a) / E_D in every year.
|
||||
|
||||
H_a is the annuity of the grid connection for 600 MW (half the draw displaces private
|
||||
data centres), F_a the disconnection arm for the same 600 MW.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
res = _regn(inn, Losning.R)
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
H_a = 5e6 * 600.0 * _crf(0.06, 40)
|
||||
c_a = 1.05 * _pris(1) + (H_a + _utkobling(600.0)) / E_D
|
||||
assert np.isnan(kost.c_a[0, :3]).all()
|
||||
assert kost.c_a[0, 3:] == pytest.approx(c_a)
|
||||
assert not kost.bedrift
|
||||
assert kost.S42 is None
|
||||
assert kost.F is res.F_a
|
||||
|
||||
assert [(a.anlegg, a.t_v, a.aar) for a in kost.aarganger] == [
|
||||
(0, 2030, (2030, 2031, 2032, 2033, 2034)),
|
||||
(0, 2035, (2035, 2036, 2037, 2038, 2039)),
|
||||
(0, 2040, (2040,)),
|
||||
]
|
||||
for aargang in kost.aarganger:
|
||||
assert aargang.c_a == pytest.approx(c_a)
|
||||
assert aargang.LCOC == pytest.approx(_lcoc(c_a))
|
||||
assert aargang.inntekt == pytest.approx(_lcoc_v())
|
||||
margin = aargang.margin
|
||||
assert margin is not None
|
||||
assert margin.kraftfortrinn == pytest.approx(8760.0 * 0.75 * 1.2 * (800.0 - c_a))
|
||||
assert margin.knapphet == 0.0
|
||||
assert margin.drift_bygg_skatt == pytest.approx(3e6 - 2.5e6 - 10e6 * _crf(0.08, 15))
|
||||
assert margin.usolgt == 0.0
|
||||
assert margin.sum == pytest.approx(aargang.overskudd)
|
||||
|
||||
|
||||
def test_kraftkostnaden_vektes_med_naaverdi_over_aargangens_aar(oppdiktet: LagInndata) -> None:
|
||||
"""Two facilities in R that start in 2030 and 2031 (clarification 15).
|
||||
|
||||
The second facility weakens the power balance, so the price is higher from 2031. The
|
||||
first vintage of facility 1 has one year at the low cost and four at the high, each
|
||||
discounted with rho_D to the vintage's first year.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
res = _regn(inn, Losning.R, N_anlegg=2)
|
||||
assert [a.start for a in res.plan.anlegg] == [2030, 2031]
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
faste = (5e6 * 600.0 * _crf(0.06, 40) + _utkobling(600.0)) / E_D
|
||||
lav, hoy = 1.05 * _pris(1) + faste, 1.05 * _pris(2) + faste
|
||||
assert kost.c_a[0, 3] == pytest.approx(lav)
|
||||
assert kost.c_a[0, 4] == pytest.approx(hoy)
|
||||
assert kost.c_a[1, 4] == pytest.approx(hoy)
|
||||
assert np.isnan(kost.c_a[1, 3])
|
||||
vekter = [1.08**-x for x in range(5)]
|
||||
ventet = (lav * vekter[0] + hoy * math.fsum(vekter[1:])) / math.fsum(vekter)
|
||||
forste = next(a for a in kost.aarganger if (a.anlegg, a.t_v) == (0, 2030))
|
||||
assert forste.c_a == pytest.approx(ventet)
|
||||
assert lav < forste.c_a < hoy
|
||||
|
||||
|
||||
def test_anlegg_uten_brikker_har_ingen_kraftkostnad(oppdiktet: LagInndata) -> None:
|
||||
"""An export stop from 2035 to 2037: the vintage from 2030 is replaced in 2038."""
|
||||
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)
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
assert np.isnan(kost.c_a[0, 2035 - 2027 : 2038 - 2027]).all()
|
||||
assert not np.isnan(kost.c_a[0, 2038 - 2027])
|
||||
assert [a.aar[0] for a in kost.aarganger][:2] == [2030, 2038]
|
||||
assert kost.aarganger[0].aar == (2030, 2031, 2032, 2033, 2034)
|
||||
|
||||
|
||||
# ------------------------------------------------------------- A: the dedicated plant
|
||||
|
||||
|
||||
def test_A_kraftkostnaden_er_S9(oppdiktet: LagInndata) -> None:
|
||||
"""One facility in A: units of 50 MW at 100 mill. kr/MW, four years to build, 8 % return."""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.A)
|
||||
N_u = res.dim.N_u
|
||||
enhet = (
|
||||
100e6 * 50.0 * _byggetid(0.08, 4.0) * _crf(0.08, 20)
|
||||
+ 1e6 * 50.0
|
||||
+ 5e6 * 50.0 * _sff(0.08, 20)
|
||||
)
|
||||
buffer = 600.0 * (10e6 * _crf(0.08, 20) + 0.4e6)
|
||||
forsyning = 2.0 * 50.0 * 10e6 * _crf(0.08, 40) + 0.02 * N_u * 50.0 * 10e6 * _crf(0.08, 20)
|
||||
ulykke = N_u * 1e-5 * (1e12 * 50.0 / 1000.0 - 8e9)
|
||||
c_A = (N_u * enhet + buffer + forsyning + ulykke) / E_D + 50.0 + 100.0 + 30.0
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
i_drift = [j for j, t in enumerate(res.aar) if res.plan.har_last(0, t)]
|
||||
assert kost.c_a[0, i_drift] == pytest.approx(c_A)
|
||||
assert nv.kraftkostnad_dedikert(inn, res, 0, 0.08) == pytest.approx(c_A)
|
||||
assert not kost.F.any()
|
||||
# as a business: the electricity tax also applies behind the meter, and there is no tariff
|
||||
bedrift = nv.kraftkostnad(inn, res, bedrift=True)
|
||||
assert bedrift.c_a[0, i_drift] == pytest.approx(c_A + 70.0)
|
||||
# the revenue carries the revenue factor of S44
|
||||
assert kost.aarganger[0].inntekt == pytest.approx(res.dim.Gamma * _lcoc_v())
|
||||
margin = kost.aarganger[0].margin
|
||||
assert margin is not None
|
||||
assert margin.usolgt == pytest.approx((1.0 - res.dim.Gamma) * _lcoc_v())
|
||||
|
||||
|
||||
def test_A_enhetene_nummereres_paa_tvers_av_anleggene(oppdiktet: LagInndata) -> None:
|
||||
"""With learning the second facility's units are cheaper than the first's."""
|
||||
inn = oppdiktet(ell=0.1, s_brikker=0.12)
|
||||
res = _regn(inn, Losning.A, N_anlegg=2)
|
||||
forste = nv.kraftkostnad_dedikert(inn, res, 0, 0.08)
|
||||
andre = nv.kraftkostnad_dedikert(inn, res, 1, 0.08)
|
||||
assert andre < forste
|
||||
|
||||
|
||||
# ------------------------------------------------------ B and B': nuclear on the grid
|
||||
|
||||
|
||||
def _lcoe_stor_enhet() -> float:
|
||||
"""S5 for made-up units of 1 000 MW on the grid, without the accident cost, kr/MWh."""
|
||||
aarlig = (
|
||||
100e6 * 1000.0 * _byggetid(0.06, 4.0) * _crf(0.06, 20)
|
||||
+ 1e6 * 1000.0
|
||||
+ 5e6 * 1000.0 * _sff(0.06, 20)
|
||||
)
|
||||
return aarlig / E_ENHET + 50.0 + 70.0 + 30.0
|
||||
|
||||
|
||||
def test_B_kraftkostnaden_bruker_programmets_enheter(oppdiktet: LagInndata) -> None:
|
||||
"""Three facilities that start together in 2035 and four units of 1 000 MW (clarification 2).
|
||||
|
||||
The four units produce 28.0 TWh and the facilities use 23.7: the price falls. Each
|
||||
MWh used carries the units' net cost times production over use for the programme.
|
||||
"""
|
||||
inn = oppdiktet(s_brikker=0.12)
|
||||
res = _regn(inn, Losning.B, N_anlegg=3)
|
||||
assert res.varsigma == {ks.KJERNEKRAFT: 1.0}
|
||||
j = 2040 - 2027
|
||||
pris = _pris(3, ny_kraft=4 * E_ENHET)
|
||||
assert res.kraftaar[j].pris == pytest.approx(pris)
|
||||
ulykke = 4 * 1e-5 * (1e12 - 8e9) / (4 * E_ENHET)
|
||||
netto = (_lcoe_stor_enhet() + ulykke - pris) * 4 * E_ENHET / (3 * E_D)
|
||||
H_a = 5e6 * (600.0 + 0.75 * 1.2 * 1000.0 / 0.8) * _crf(0.06, 40)
|
||||
c_a = 1.05 * pris + netto + (H_a + float(res.F_a[j]) / 3.0) / E_D
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
assert kost.c_a[:, j] == pytest.approx(c_a)
|
||||
|
||||
|
||||
def test_bindende_tilleggsregel_gir_nettoledd_null(oppdiktet: LagInndata) -> None:
|
||||
"""A cheap reactor that pays its way on the grid neither adds nor takes (clarification 11)."""
|
||||
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 res.varsigma[ks.KJERNEKRAFT] < 1.0
|
||||
j = 2040 - 2027
|
||||
H_a = 5e6 * (600.0 + res.dim.P_G_N) * _crf(0.06, 40)
|
||||
c_a = 1.05 * res.kraftaar[j].pris + (H_a + float(res.F_a[j]) / 2.0) / E_D
|
||||
assert nv.kraftkostnad(inn, res).c_a[:, j] == pytest.approx(c_a)
|
||||
# a business is credited the plant's surplus: S45 does not apply in M2
|
||||
bedrift = nv.kraftkostnad(inn, res, bedrift=True)
|
||||
uten_verk = res.kraftaar[j].pris + 70.0 + (0.3e6 * 1200.0 + float(bedrift.F[j]) / 2.0) / E_D
|
||||
assert (bedrift.c_a[:, j] < uten_verk).all()
|
||||
|
||||
|
||||
def test_B_merket_bruker_anleggets_eget_verk(oppdiktet: LagInndata) -> None:
|
||||
"""B': the plant of A on the grid. Small units: fuel 100 kr/MWh and a lower capacity factor."""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.B_MERKET)
|
||||
N_u = res.dim.N_u
|
||||
verk = res.verk[0][0]
|
||||
assert verk.energi == pytest.approx(8760.0 * 0.8 * 0.96 / 0.98 * N_u * 50.0)
|
||||
aarlig = N_u * (
|
||||
100e6 * 50.0 * _byggetid(0.06, 4.0) * _crf(0.06, 20)
|
||||
+ 1e6 * 50.0
|
||||
+ 5e6 * 50.0 * _sff(0.06, 20)
|
||||
)
|
||||
ulykke = N_u * 1e-5 * (1e12 * 50.0 / 1000.0 - 8e9)
|
||||
lcoe = (aarlig + ulykke) / verk.energi + 50.0 + 100.0 + 30.0
|
||||
assert nv.lcoe_kjernekraft(
|
||||
inn, res, numre=range(1, N_u + 1), E_N=verk.energi, rho=0.06
|
||||
) == pytest.approx(lcoe)
|
||||
j = 2040 - 2027
|
||||
pris = res.kraftaar[j].pris
|
||||
H_a = 5e6 * (600.0 + N_u * 50.0) * _crf(0.06, 40)
|
||||
c_a = 1.05 * pris + (lcoe - pris) * verk.energi / E_D + (H_a + float(res.F_a[j])) / E_D
|
||||
assert nv.kraftkostnad(inn, res).c_a[0, j] == pytest.approx(c_a)
|
||||
|
||||
|
||||
# ----------------------------------------------------------------- C: renewable power
|
||||
|
||||
|
||||
def test_C_bruker_anleggets_egen_portefolje(oppdiktet: LagInndata) -> None:
|
||||
"""One facility in C: hydropower 2 TWh, wind 3 and offshore wind 3.284 (clarification 10).
|
||||
|
||||
Hydropower has interest during construction in its investment figure already; the two
|
||||
others get the factor of S3. A technology the additionality rule binds for counts zero.
|
||||
"""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.C)
|
||||
lcoe = {
|
||||
"vann": 20e6 * _crf(0.06, 40) / 3000.0 + 70.0,
|
||||
"vind": 14e6 * _byggetid(0.06, 2.0) * _crf(0.06, 30) / 3000.0 + 120.0,
|
||||
"havvind": (50e6 * _byggetid(0.06, 3.0) * _crf(0.06, 30) + 0.9e6) / 4500.0,
|
||||
}
|
||||
for teknologi, ventet in lcoe.items():
|
||||
assert nv.lcoe_fornybar(inn, teknologi, 0.06) == pytest.approx(ventet)
|
||||
energi = {"vann": 2e6, "vind": 3e6, "havvind": E_D - 1.6e6 - 3e6}
|
||||
psi = {"vann": 1.2, "vind": 0.9, "havvind": 1.0}
|
||||
assert res.varsigma["vann"] < 1.0
|
||||
j = 2035 - 2027
|
||||
pris = res.kraftaar[j].pris
|
||||
netto = math.fsum(
|
||||
energi[i] * (lcoe[i] - psi[i] * pris) for i in energi if res.varsigma[i] >= 1.0
|
||||
)
|
||||
H_a = 5e6 * 600.0 * _crf(0.06, 40)
|
||||
c_a = 1.05 * pris + (netto + H_a + float(res.F_a[j])) / E_D
|
||||
assert nv.kraftkostnad(inn, res).c_a[0, j] == pytest.approx(c_a)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- M2: S27 and S42
|
||||
|
||||
|
||||
def test_R_bedriftsokonomi_haandregnet(oppdiktet: LagInndata) -> None:
|
||||
"""One facility in R to 2040 as a business pays for it.
|
||||
|
||||
Price plus electricity tax (70 kr/MWh), the grid tariff on 1 200 MW at 0.3 mill. kr per
|
||||
MW, and disconnection for the 600 MW that is missing; no grid investment and no losses.
|
||||
S42 sums the three vintages with rho_D to their first year.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
res = _regn(inn, Losning.R)
|
||||
kost = nv.kraftkostnad(inn, res, bedrift=True)
|
||||
c_bed = _pris(1) + 70.0 + (0.3e6 * 1200.0 + _utkobling(600.0)) / E_D
|
||||
assert kost.c_a[0, 3:] == pytest.approx(c_bed)
|
||||
assert kost.F[3:] == pytest.approx(_utkobling(600.0))
|
||||
assert not kost.F[:3].any()
|
||||
margin = _lcoc_v() - _lcoc(c_bed)
|
||||
for aargang in kost.aarganger:
|
||||
assert aargang.LCOC == pytest.approx(_lcoc(c_bed))
|
||||
assert aargang.overskudd == pytest.approx(margin)
|
||||
assert aargang.margin is None
|
||||
ventet = margin * (1.08**-3 + 1.08**-8 + 1.08**-13)
|
||||
assert kost.S42 == pytest.approx(ventet)
|
||||
|
||||
|
||||
def test_M2_bruker_bare_utkoblingsarmen(oppdiktet: LagInndata) -> None:
|
||||
"""With cheap firm capacity S47 picks that arm in M1; a business still pays disconnection."""
|
||||
inn = oppdiktet(T_slutt=2040, c_fast=0.1e6)
|
||||
res = _regn(inn, Losning.R)
|
||||
j = 2035 - 2027
|
||||
assert res.F_a[j] == pytest.approx(0.1e6 * 600.0)
|
||||
assert nv.effektkostnad_bedrift(inn, res)[j] == pytest.approx(_utkobling(600.0))
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
@pytest.mark.parametrize("knapphet", list(Knapphet))
|
||||
def test_s19_er_en_regnskapsidentitet(
|
||||
oppdiktet: LagInndata, losning: Losning, knapphet: Knapphet
|
||||
) -> None:
|
||||
"""The four parts of S19 sum to mu Gamma y - LCOC_a for every vintage in every solution."""
|
||||
inn = oppdiktet(mu_rel=0.95, s_brikker=0.08)
|
||||
res = _regn(inn, losning, N_anlegg=2, knapphet=knapphet)
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
assert len(kost.aarganger) == sum(len(a.aarganger) for a in res.plan.anlegg)
|
||||
for aargang in kost.aarganger:
|
||||
assert aargang.margin is not None
|
||||
assert aargang.margin.sum == pytest.approx(aargang.overskudd)
|
||||
assert aargang.inntekt == pytest.approx(0.95 * res.dim.Gamma * res.y(aargang.t_v))
|
||||
|
||||
|
||||
def test_knapphetspaaslaget_staar_i_marginen_i_ti_aar(oppdiktet: LagInndata) -> None:
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.R, knapphet=Knapphet.VARER)
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
paaslag = 150e6 / _lcoc_v() - 1.0
|
||||
for aargang in kost.aarganger:
|
||||
assert aargang.margin is not None
|
||||
ventet = paaslag * _lcoc_v() if aargang.t_v < 2040 else 0.0
|
||||
assert aargang.margin.knapphet == pytest.approx(ventet)
|
||||
|
||||
|
||||
def test_andre_avkastningskrav_kan_settes_inn(oppdiktet: LagInndata) -> None:
|
||||
"""The cost of capital of an ownership form replaces the three required returns."""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.B_MERKET)
|
||||
som_for = nv.Renter(rho_D=0.08, rho_N=0.06, rho_A=0.08)
|
||||
assert nv.renter_i_hovedkjoringen(inn, res) == som_for
|
||||
hoved = nv.kraftkostnad(inn, res, bedrift=True)
|
||||
samme = nv.kraftkostnad(inn, res, bedrift=True, renter=som_for)
|
||||
assert samme.aarganger == hoved.aarganger
|
||||
billig = nv.kraftkostnad(
|
||||
inn, res, bedrift=True, renter=nv.Renter(rho_D=0.02, rho_N=0.02, rho_A=0.02)
|
||||
)
|
||||
assert billig.aarganger[0].LCOC < hoved.aarganger[0].LCOC
|
||||
assert billig.aarganger[0].c_a < hoved.aarganger[0].c_a
|
||||
254
tests/test_skala.py
Normal file
254
tests/test_skala.py
Normal file
|
|
@ -0,0 +1,254 @@
|
|||
"""Scale (chapter 9): S31 year by year, the first year with stable operation and M6.
|
||||
|
||||
Made-up round numbers only. Nothing here says anything about the hypothesis.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
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 import nivaaisert as nv
|
||||
from tokenfabrikker import skala
|
||||
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
|
||||
|
||||
|
||||
BYGG = 110e9 * _crf(0.08, 15)
|
||||
"""The yearly cost of the made-up building for 1 000 MW IT."""
|
||||
|
||||
MASKINVARE = 200e9 * _crf(0.08, 5)
|
||||
"""The yearly cost of one made-up vintage of IT hardware for 1 000 MW IT."""
|
||||
|
||||
NETT = 5e6 * 600.0 * _crf(0.06, 40)
|
||||
"""The yearly cost of the grid connection of one made-up facility without power plant."""
|
||||
|
||||
|
||||
def _regn(
|
||||
inn: Inndata,
|
||||
losning: Losning,
|
||||
*,
|
||||
N_anlegg: int = 1,
|
||||
knapphet: Knapphet = Knapphet.NORMALISERING,
|
||||
) -> 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)
|
||||
|
||||
|
||||
def test_s31_er_summen_av_leddene() -> None:
|
||||
B_6 = lg.s31_nettobidrag(
|
||||
u_e=0.25,
|
||||
overskudd_utover_avkastning=100.0,
|
||||
Delta_W=20.0,
|
||||
K_prog=5.0,
|
||||
V=3.0,
|
||||
utslipp=2.0,
|
||||
)
|
||||
assert B_6 == pytest.approx(75.0 + 20.0 - 5.0 - 3.0 - 2.0)
|
||||
|
||||
|
||||
def test_R_bidraget_aar_for_aar_og_M6(oppdiktet: LagInndata) -> None:
|
||||
"""One facility in R to 2040, every term by hand.
|
||||
|
||||
Revenue minus operation, power with losses, the yearly cost of building, hardware and
|
||||
grid connection, and disconnection; plus the gain for Norway of a higher power price,
|
||||
minus what is displaced in the grid queue; and in 2030 the emissions from the building.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2040)
|
||||
res = _regn(inn, Losning.R)
|
||||
ut = skala.skala(inn, res)
|
||||
pris = 700.0 - 10e-6 * (10e6 - 0.5 * E_D)
|
||||
utkobling = 100.0 * _lcoc_v() / (8760.0 * 1.2) * 600.0
|
||||
overskudd = (
|
||||
1000.0 * _lcoc_v() - 2.5e9 - 1.05 * pris * E_D - BYGG - MASKINVARE - NETT - utkobling
|
||||
)
|
||||
i_drift = overskudd + (pris - 600.0) * 10e6 - 0.5 * E_D * 70.0
|
||||
assert not ut.B_6[:3].any()
|
||||
assert ut.B_6[3] == pytest.approx(i_drift - 1e9)
|
||||
assert ut.B_6[4:] == pytest.approx(i_drift)
|
||||
assert ut.stabilt_aar == 2030
|
||||
assert ut.M6 == pytest.approx((i_drift - 1e9) / 500e9)
|
||||
assert ut.M6_snitt == pytest.approx((i_drift - 1e9 / 5.0) / 500e9)
|
||||
assert ut.M6_median == pytest.approx((i_drift - 1e9) / 250e9)
|
||||
assert ut.M6_2050 is None
|
||||
# at the made-up cost-based price the contribution is negative, so no year beats 2027
|
||||
assert i_drift < 0
|
||||
assert (ut.M6_topp, ut.toppaar) == (0.0, 2027)
|
||||
# with 40 % owned outside Norway only 60 % of the surplus above normal return counts
|
||||
utenlandsk = skala.skala(inn, res, u_e=0.4)
|
||||
assert utenlandsk.B_6[4] == pytest.approx(
|
||||
0.6 * overskudd + (pris - 600.0) * 10e6 - 0.5 * E_D * 70.0
|
||||
)
|
||||
|
||||
|
||||
def test_toppaaret_ligger_i_aarene_med_knapphetspaaslag(oppdiktet: LagInndata) -> None:
|
||||
"""«Knapphet varer»: vintages from before 2040 get the markup, so the best year is 2031-2039.
|
||||
|
||||
2030 carries the emissions from the building; from 2031 every year to 2039 is the same.
|
||||
"""
|
||||
inn = oppdiktet(T_slutt=2045)
|
||||
ut = skala.skala(inn, _regn(inn, Losning.R, knapphet=Knapphet.VARER))
|
||||
assert ut.toppaar == 2031
|
||||
assert ut.M6_topp == pytest.approx(float(ut.B_6[2031 - 2027]) / 500e9)
|
||||
assert ut.M6_topp > 0
|
||||
assert ut.B_6[2039 - 2027] == pytest.approx(ut.B_6[2031 - 2027])
|
||||
assert ut.B_6[2040 - 2027] < ut.B_6[2039 - 2027]
|
||||
|
||||
|
||||
def test_maalet_i_2050_er_null_naar_anlegget_er_gaatt_ut(oppdiktet: LagInndata) -> None:
|
||||
"""The made-up facility starts in 2030 and lives 20 years: nothing is left in 2050."""
|
||||
inn = oppdiktet()
|
||||
ut = skala.skala(inn, _regn(inn, Losning.R))
|
||||
assert ut.M6_2050 == 0.0
|
||||
assert ut.B_6[2049 - 2027] != 0.0
|
||||
|
||||
|
||||
def test_stabil_drift_er_forste_aar_alle_anleggene_er_i_drift(oppdiktet: LagInndata) -> None:
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.R, N_anlegg=3)
|
||||
assert [a.start for a in res.plan.anlegg] == [2030, 2031, 2032]
|
||||
assert skala.forste_aar_med_stabil_drift(res) == 2032
|
||||
ut = skala.skala(inn, res)
|
||||
assert ut.M6 == pytest.approx(float(ut.B_6[2032 - 2027]) / 500e9)
|
||||
assert ut.M6_snitt == pytest.approx(float(ut.B_6[5:10].mean()) / 500e9)
|
||||
|
||||
|
||||
def test_uten_aar_med_alle_i_drift_finnes_ikke_M6(oppdiktet: LagInndata) -> None:
|
||||
"""250 MW of chips a year and facilities that live three years: 2033-2035 and 2037-2039.
|
||||
|
||||
Both facilities start, so the path is built, but they are never in operation together.
|
||||
"""
|
||||
inn = oppdiktet(s_brikker=0.01, L_N=3.0)
|
||||
res = _regn(inn, Losning.R, N_anlegg=2)
|
||||
assert [(a.start, a.siste_driftsaar) for a in res.plan.anlegg] == [(2033, 2035), (2037, 2039)]
|
||||
ut = skala.skala(inn, res)
|
||||
assert ut.stabilt_aar is None
|
||||
assert ut.M6 is None
|
||||
assert ut.M6_snitt is None
|
||||
assert ut.M6_median is None
|
||||
assert ut.B_6[2033 - 2027] != 0.0
|
||||
|
||||
|
||||
def test_anlegg_uten_brikker_baerer_bygg_og_nett_men_ikke_maskinvare(
|
||||
oppdiktet: LagInndata,
|
||||
) -> None:
|
||||
"""An export stop from 2035 to 2037: no revenue, no power and no vintage in operation."""
|
||||
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)
|
||||
ut = skala.skala(inn, res)
|
||||
assert ut.B_6[2036 - 2027] == pytest.approx(-2.5e9 - BYGG - NETT)
|
||||
assert ut.B_6[2036 - 2027] < ut.B_6[2034 - 2027]
|
||||
|
||||
|
||||
def test_A_uten_brikker_betaler_ikke_variable_kostnader(oppdiktet: LagInndata) -> None:
|
||||
"""In A the plant's capital and fixed costs run on; fuel, waste fee and variable 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)
|
||||
assert not res.plan.har_last(0, 2041)
|
||||
c_A = nv.kraftkostnad_dedikert(inn, res, 0, 0.08)
|
||||
ut = skala.overskudd_utover_avkastning(inn, res)
|
||||
assert ut[2041 - 2027] == pytest.approx(-2.5e9 - BYGG - (c_A - 180.0) * E_D)
|
||||
med_last = 1000.0 * res.dim.Gamma * _lcoc_v() - 2.5e9 - BYGG - MASKINVARE - c_A * E_D
|
||||
assert ut[2039 - 2027] == pytest.approx(med_last)
|
||||
|
||||
|
||||
def test_kraftverk_som_tilleggsregelen_binder_for_teller_null(oppdiktet: LagInndata) -> None:
|
||||
"""Two facilities in B with a cheap reactor: the units neither add nor take in S31."""
|
||||
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6, s_brikker=0.12)
|
||||
res = _regn(inn, Losning.B, N_anlegg=2)
|
||||
assert res.varsigma[ks.KJERNEKRAFT] < 1.0
|
||||
j = 2040 - 2027
|
||||
nett = 5e6 * (600.0 + res.dim.P_G_N) * _crf(0.06, 40)
|
||||
per_anlegg = (
|
||||
1000.0 * _lcoc_v() - 2.5e9 - 1.05 * res.kraftaar[j].pris * E_D - BYGG - MASKINVARE - nett
|
||||
)
|
||||
ut = skala.overskudd_utover_avkastning(inn, res)
|
||||
assert ut[j] == pytest.approx(2.0 * per_anlegg - float(res.F_a[j]))
|
||||
# without the rule the surplus of the units is credited
|
||||
dim = ks.dimensjoner(inn, Losning.B)
|
||||
uten = ks.regn_program(
|
||||
inn, Losning.B, res.plan, Knapphet.NORMALISERING, dim=dim, tilleggsregel=False
|
||||
)
|
||||
assert skala.overskudd_utover_avkastning(inn, uten)[j] > ut[j]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("losning", list(Losning))
|
||||
@pytest.mark.parametrize(
|
||||
"endringer",
|
||||
[{}, {"c_N_ref": 10e6, "f_N": 0.3e6}, {"T_slutt": 2045, "L_B": 7.0, "mu_rel": 0.9}],
|
||||
)
|
||||
def test_bidraget_er_inntekt_minus_nivaaisert_kostnad(
|
||||
oppdiktet: LagInndata, losning: Losning, endringer: dict[str, float]
|
||||
) -> None:
|
||||
"""Two ways to the same number.
|
||||
|
||||
S31 is built from the yearly amounts of the cash flow and the annuity of each asset.
|
||||
The price side (S15 with S9 or S11) is built per MWh. In every year all the operated
|
||||
facilities use power, P_IT (mu Gamma y - LCOC_a) summed over them is the same amount.
|
||||
"""
|
||||
inn = oppdiktet(u_eksport=None, **endringer)
|
||||
res = _regn(inn, losning, N_anlegg=3, knapphet=Knapphet.VARER)
|
||||
kost = nv.kraftkostnad(inn, res)
|
||||
ut = skala.overskudd_utover_avkastning(inn, res)
|
||||
sjekket = 0
|
||||
for j, t in enumerate(res.aar):
|
||||
i_drift = [k for k in range(3) if res.plan.i_drift(k, t)]
|
||||
if not i_drift or not all(res.plan.har_last(k, t) for k in i_drift):
|
||||
continue
|
||||
sum_margin = 0.0
|
||||
for k in i_drift:
|
||||
t_v = res.plan.aargang(k, t)
|
||||
assert t_v is not None
|
||||
LCOC = lg.s15_lcoc(
|
||||
c_bygg=inn["c_bygg"],
|
||||
d_bygg=inn["d_bygg"],
|
||||
c_H=lg.s13_it_kostnad(c_H0=inn["c_H0"], gamma_H=inn["gamma_H"], t_v=t_v),
|
||||
rho_D=inn["rho_D"],
|
||||
L_B=inn["L_B"],
|
||||
L_H=inn["L_H"],
|
||||
o_D=inn["o_D"],
|
||||
d_o_D=inn["d_o_D"],
|
||||
lam=inn["lambda"],
|
||||
PUE=inn["PUE"],
|
||||
c_a=float(kost.c_a[k, j]),
|
||||
)
|
||||
sum_margin += inn["P_IT"] * (inn["mu_rel"] * res.dim.Gamma * res.y(t_v) - LCOC)
|
||||
assert ut[j] == pytest.approx(sum_margin, rel=1e-9, abs=1.0)
|
||||
sjekket += 1
|
||||
assert sjekket >= 10
|
||||
|
||||
|
||||
def test_programmets_enheter_i_B_teller_ogsaa_etter_at_anleggene_er_gaatt_ut(
|
||||
oppdiktet: LagInndata,
|
||||
) -> None:
|
||||
"""Staggered starts: a unit from 2055 still runs in 2058, after the last facility is out."""
|
||||
inn = oppdiktet()
|
||||
res = _regn(inn, Losning.B, N_anlegg=2)
|
||||
assert [(f.gruppe.start, f.gruppe.siste_driftsaar) for f in res.felles][-1] == (2055, 2074)
|
||||
assert res.plan.antall_i_drift(2058) == 0
|
||||
ut = skala.overskudd_utover_avkastning(inn, res)
|
||||
assert ut[2058 - 2027] < 0
|
||||
assert np.count_nonzero(ut[2056 - 2027 :]) == 5
|
||||
Loading…
Add table
Add a link
Reference in a new issue