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>
536 lines
22 KiB
Python
536 lines
22 KiB
Python
"""The addition to the direction (chapter 17): solution T in modules, and S48 to S54.
|
|
|
|
Made-up round numbers only. The hand-computed build-outs follow chapter 17.1 line by line.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
from typing import TYPE_CHECKING
|
|
|
|
import pytest
|
|
|
|
from tokenfabrikker import inndata as idt
|
|
from tokenfabrikker import kontantstrom as ks
|
|
from tokenfabrikker import ligninger as lg
|
|
from tokenfabrikker import utbygging as ub
|
|
from tokenfabrikker.kontantstrom import Knapphet
|
|
from tokenfabrikker.utbygging import Kraft, Losning
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Callable
|
|
|
|
from conftest import LagInndata
|
|
|
|
# ------------------------------------------------------------------- S48 and S49
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("tau_1", "tau_nett", "tau_D", "tidspunkt"),
|
|
[
|
|
(3.0, 10.0, 2.5, 2030.5), # the module itself takes longest: one year plus tau_D
|
|
(5.0, 10.0, 2.5, 2032.0), # the connection within the grid that exists takes longest
|
|
(5.0, 4.0, 1.0, 2031.0), # new grid comes before the first-stage connection would
|
|
],
|
|
)
|
|
def test_s48_tidligste_tidspunkt(
|
|
tau_1: float, tau_nett: float, tau_D: float, tidspunkt: float
|
|
) -> None:
|
|
assert lg.s48_tidligste_tidspunkt_trinnvis(
|
|
T_0=2027.0, tau_1=tau_1, tau_nett=tau_nett, tau_D=tau_D
|
|
) == pytest.approx(tidspunkt)
|
|
|
|
|
|
def test_s48_saldoen_tar_med_rest_men_aldri_mer_enn_en_modul_trenger() -> None:
|
|
felles = {"n_1": 100.0, "PUE": 1.2, "P_m": 100.0}
|
|
assert lg.s48_nettsaldo(saldo_forrige=0.0, brukt_forrige=0.0, **felles) == 100.0
|
|
assert lg.s48_nettsaldo(saldo_forrige=200.0, brukt_forrige=120.0, **felles) == 180.0
|
|
# 300 would be carried on, but the balance stops at n_1 + PUE P_m = 220
|
|
assert lg.s48_nettsaldo(saldo_forrige=200.0, brukt_forrige=0.0, **felles) == 220.0
|
|
|
|
|
|
def test_s49_krever_en_hel_enhet_for_det_som_gjenstaar() -> None:
|
|
felles = {"lam": 0.75, "PUE": 1.2, "P_m": 100.0, "P_ref": 1000.0}
|
|
# seven modules left draw 630 MW on average, less than one unit gives (800 MW)
|
|
assert not lg.s49_kjernekraft_bygges(J=10, J_F=3, KF=0.8, **felles)
|
|
assert lg.s49_kjernekraft_bygges(J=20, J_F=3, KF=0.8, **felles)
|
|
assert lg.s49_kjernekraft_bygges(J=13, J_F=3, KF=0.9, **felles) # exactly one unit
|
|
assert not lg.s49_kjernekraft_bygges(J=10, J_F=10, KF=0.8, **felles)
|
|
with pytest.raises(ValueError, match="J_F must lie"):
|
|
lg.s49_kjernekraft_bygges(J=10, J_F=11, KF=0.8, **felles)
|
|
|
|
|
|
# ------------------------------------------------------ the build-out in modules
|
|
|
|
|
|
def _trinnvis(**endringer: object) -> ub.Trinnvisplan:
|
|
argumenter: dict[str, object] = {
|
|
"J": 4,
|
|
"T_0": 2027,
|
|
"T_s": 2045,
|
|
"t_forste": 2030,
|
|
"t_nett": 2034,
|
|
"P_m": 100.0,
|
|
"PUE": 1.2,
|
|
"n_1": 100.0,
|
|
"L_H": 20,
|
|
"L_N": 20,
|
|
"brikker_per_aar": 1000.0,
|
|
"kraftrom": ub.kraftrom_ubegrenset,
|
|
"forste_aar_kraft": lambda _j: 2028,
|
|
"stopp": (False,) * 18,
|
|
}
|
|
argumenter.update(endringer)
|
|
return ub.utbyggingsplan_trinnvis(**argumenter) # type: ignore[arg-type]
|
|
|
|
|
|
def _start(plan: ub.Plan) -> list[int]:
|
|
return [modul.start for modul in plan.anlegg]
|
|
|
|
|
|
def test_forste_trinn_folger_nettsaldoen() -> None:
|
|
"""Hand-computed: 100 MW of draw a year, a module draws 120, the balance stops at 220.
|
|
|
|
2030: 100, no module. 2031: 200, module 1 (80 left). 2032: 180, module 2 (60 left).
|
|
2033: 160, module 3. 2034: new grid can be in place, no limit, module 4.
|
|
"""
|
|
plan = _trinnvis()
|
|
assert _start(plan) == [2031, 2032, 2033, 2034]
|
|
assert [plan.i_forste_trinn(k) for k in range(4)] == [True, True, True, False]
|
|
assert plan.gjennomforbar
|
|
assert (plan.t_N, plan.J_F, plan.kjernekraft_bygges) == (None, None, False)
|
|
|
|
|
|
def test_saldoen_samles_ikke_opp_mens_krafta_holder_igjen() -> None:
|
|
"""No power before 2033. The balance is 100, 200, then 220 and 220: one module, not three."""
|
|
plan = _trinnvis(kraftrom=lambda t: math.inf if t >= 2033 else 0.0)
|
|
assert _start(plan) == [2033, 2034, 2034, 2034]
|
|
|
|
|
|
def test_flere_moduler_kan_starte_samme_aar() -> None:
|
|
"""250 MW a year: 2030 has room for two modules (240), 2031 has 10 + 250 = 260, two more."""
|
|
assert _start(_trinnvis(n_1=250.0)) == [2030, 2030, 2031, 2031]
|
|
|
|
|
|
def test_saldoen_vokser_ogsaa_i_et_aar_med_eksportstopp() -> None:
|
|
"""Stop in 2031: balance 100, 200 (nothing starts), 220 (module 1), 200 (module 2)."""
|
|
stopp = tuple(t == 2031 for t in range(2028, 2046))
|
|
assert _start(_trinnvis(stopp=stopp)) == [2032, 2033, 2034, 2034]
|
|
|
|
|
|
def test_ingen_modul_starter_for_kraftverkene_kan_betales() -> None:
|
|
plan = _trinnvis(n_1=1000.0, forste_aar_kraft=lambda j: 2030 if j == 1 else 2032)
|
|
assert _start(plan) == [2030, 2032, 2032, 2032]
|
|
|
|
|
|
def test_brikkene_telles_fra_forste_mulige_aar_for_modulene() -> None:
|
|
"""100 MW of chips a year from 2030 and no other limit: one module a year."""
|
|
plan = _trinnvis(n_1=1000.0, brikker_per_aar=100.0)
|
|
assert _start(plan) == [2030, 2031, 2032, 2033]
|
|
|
|
|
|
def test_uten_forste_trinn_starter_modulene_naar_nytt_nett_kan_komme() -> None:
|
|
assert _start(_trinnvis(t_forste=2034)) == [2034, 2034, 2034, 2034]
|
|
|
|
|
|
def _fase(t_N: int, *, per_aar: float = math.inf, bygges: bool = True) -> ub.Kjernekraftfase:
|
|
return ub.Kjernekraftfase(
|
|
t_N=t_N, rom=lambda t: per_aar * (t - t_N + 1), bygges=lambda _J_F: bygges
|
|
)
|
|
|
|
|
|
def test_tk_bygger_kjernekraftmoduler_i_reaktorenes_takt() -> None:
|
|
"""Power for two renewable modules only; from 2035 the reactors have room for two a year."""
|
|
plan = _trinnvis(
|
|
J=6, n_1=1000.0, t_nett=2031, kraftrom=lambda _t: 2.0, kjernekraft=_fase(2035, per_aar=2.0)
|
|
)
|
|
assert _start(plan) == [2030, 2030, 2035, 2035, 2036, 2036]
|
|
assert (plan.t_N, plan.J_F, plan.kjernekraft_bygges) == (2035, 2, True)
|
|
assert [plan.er_kjernekraftmodul(k) for k in range(6)] == [False, False, True, True, True, True]
|
|
uten_kjernekraft = _trinnvis(J=6, n_1=1000.0, t_nett=2031, kraftrom=lambda _t: 2.0)
|
|
assert _start(uten_kjernekraft) == [2030, 2030]
|
|
assert not uten_kjernekraft.gjennomforbar
|
|
|
|
|
|
def test_tk_kjernekraftmodulene_bruker_bare_brikker_levert_fra_t_N() -> None:
|
|
"""Hand-computed: 100 MW of chips a year, vintages of three years, one renewable module.
|
|
|
|
2030: module 1 (stock 0). 2031 and 2032: the stock grows to 200. 2033 = t_N: the 200
|
|
become the old stock; module 1's vintage is replaced from it (100 left) and the year's
|
|
delivery starts module 2. Had the old stock been open to nuclear modules, modules 2 and
|
|
3 would both have started in 2033. 2034: module 3. 2035: module 4. 2036: modules 1 and 2
|
|
expired the same year; module 1 takes the last of the old stock, module 2 the delivery.
|
|
2037: module 3. 2038: module 4. 2039: module 1 takes the delivery (no old stock left),
|
|
module 2 waits. 2040: module 2 before module 3, which waits.
|
|
"""
|
|
plan = _trinnvis(
|
|
T_s=2040,
|
|
stopp=(False,) * 13,
|
|
t_nett=2030,
|
|
L_H=3,
|
|
brikker_per_aar=100.0,
|
|
kraftrom=lambda _t: 1.0,
|
|
kjernekraft=_fase(2033),
|
|
)
|
|
assert [m.aarganger for m in plan.anlegg] == [
|
|
(2030, 2033, 2036, 2039),
|
|
(2033, 2036, 2040),
|
|
(2034, 2037),
|
|
(2035, 2038),
|
|
]
|
|
assert plan.J_F == 1
|
|
|
|
|
|
def test_tk_en_utskifting_som_maa_vente_holder_ikke_de_neste_i_koen_tilbake() -> None:
|
|
"""Hand-computed: the old stock is 400 at t_N = 2035, deliveries 100 a year, vintages 3 years.
|
|
|
|
Module 1 (renewable) starts in 2034, modules 2 to 4 (nuclear) in 2035, 2036 and 2037.
|
|
Replacements: 2037 module 1 (old stock 300), 2038 module 2, 2039 module 3, 2040 module 1
|
|
(old stock 200) and module 4. Export stop in 2041 and 2042. In 2043 four vintages wait,
|
|
in this order: module 2, 3, 1, 4. Module 2 takes the delivery. Module 3 has no chips it
|
|
may use and waits. Module 1, behind it in the queue, is replaced from the old stock.
|
|
Module 4 waits. 2044: module 3.
|
|
"""
|
|
plan = _trinnvis(
|
|
T_s=2044,
|
|
stopp=tuple(t in {2041, 2042} for t in range(2028, 2045)),
|
|
t_nett=2030,
|
|
L_H=3,
|
|
brikker_per_aar=100.0,
|
|
kraftrom=lambda t: 1.0 if t >= 2034 else 0.0,
|
|
kjernekraft=_fase(2035),
|
|
)
|
|
assert [m.aarganger for m in plan.anlegg] == [
|
|
(2034, 2037, 2040, 2043),
|
|
(2035, 2038, 2043),
|
|
(2036, 2039, 2044),
|
|
(2037, 2040),
|
|
]
|
|
|
|
|
|
def test_tk_er_tf_naar_s49_ikke_er_oppfylt() -> None:
|
|
felles: dict[str, object] = {"J": 6, "L_H": 3, "brikker_per_aar": 100.0}
|
|
tf = _trinnvis(**felles)
|
|
tk = _trinnvis(**felles, kjernekraft=_fase(2036, bygges=False))
|
|
assert tk.anlegg == tf.anlegg
|
|
assert (tk.J_F, tk.kjernekraft_bygges) == (4, False)
|
|
assert not any(tk.er_kjernekraftmodul(k) for k in range(len(tk.anlegg)))
|
|
|
|
|
|
def test_kjernekraft_for_nytt_nett_har_ingen_regel() -> None:
|
|
with pytest.raises(ValueError, match="no rule for that"):
|
|
_trinnvis(kjernekraft=_fase(2033))
|
|
|
|
|
|
def test_trinnvis_krever_ett_stoppflagg_per_aar() -> None:
|
|
with pytest.raises(ValueError, match="one export flag per year"):
|
|
_trinnvis(stopp=(False,) * 3)
|
|
|
|
|
|
# --------------------------------------------------------- the timeline, S50
|
|
|
|
|
|
def test_s50_summerer_per_krafttype() -> None:
|
|
felles: dict[str, object] = {
|
|
"P": [100.0, 100.0, 1000.0],
|
|
"har_aargang": [True, False, True],
|
|
"kraft": ["ny", "ny", "kjerne"],
|
|
}
|
|
assert lg.s50_regnekraft_i_drift(**felles, x="ny") == 100.0 # type: ignore[arg-type]
|
|
assert lg.s50_regnekraft_i_drift(**felles, x="kjerne") == 1000.0 # type: ignore[arg-type]
|
|
assert lg.s50_regnekraft_i_drift(**felles, x="annet") == 0.0 # type: ignore[arg-type]
|
|
with pytest.raises(ValueError, match="one size, one flag and one type"):
|
|
lg.s50_regnekraft_i_drift(P=[1.0], har_aargang=[], kraft=[], x="ny")
|
|
|
|
|
|
def test_tidslinjen_skiller_fornybar_kraft_og_kjernekraft_i_tk() -> None:
|
|
plan = _trinnvis(
|
|
J=6, n_1=1000.0, t_nett=2031, kraftrom=lambda _t: 2.0, kjernekraft=_fase(2035, per_aar=2.0)
|
|
)
|
|
linje = ub.tidslinje(Losning.T_K, plan, P_IT=1000.0)
|
|
aar = range(2028, 2046)
|
|
fornybar = dict(zip(aar, linje[Kraft.NY_FORNYBAR], strict=True))
|
|
kjernekraft = dict(zip(aar, linje[Kraft.KJERNEKRAFT_PAA_NETTET], strict=True))
|
|
assert (fornybar[2029], fornybar[2030], fornybar[2045]) == (0.0, 200.0, 200.0)
|
|
assert (kjernekraft[2034], kjernekraft[2035], kjernekraft[2036]) == (0.0, 200.0, 400.0)
|
|
assert not any(linje[Kraft.EGET_KJERNEKRAFTVERK])
|
|
assert not any(linje[Kraft.KJOP_FRA_NETTET])
|
|
|
|
|
|
def test_tidslinjen_teller_ikke_en_modul_uten_brikker() -> None:
|
|
"""One module, vintages of three years, and no chips after the first: 100 MW in 2030 to 2032."""
|
|
plan = _trinnvis(
|
|
J=1, n_1=1000.0, L_H=3, stopp=tuple(t > 2030 for t in range(2028, 2046)), t_nett=2030
|
|
)
|
|
linje = ub.tidslinje(Losning.T_F, plan, P_IT=1000.0)[Kraft.NY_FORNYBAR]
|
|
assert linje == (0.0, 0.0, 100.0, 100.0, 100.0) + (0.0,) * 13
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("losning", "kraft"),
|
|
[
|
|
(Losning.A, Kraft.EGET_KJERNEKRAFTVERK),
|
|
(Losning.B, Kraft.KJERNEKRAFT_PAA_NETTET),
|
|
(Losning.B_MERKET, Kraft.KJERNEKRAFT_PAA_NETTET),
|
|
(Losning.C, Kraft.NY_FORNYBAR),
|
|
(Losning.R, Kraft.KJOP_FRA_NETTET),
|
|
],
|
|
)
|
|
def test_tidslinjen_for_losningene_med_hele_anlegg(losning: Losning, kraft: Kraft) -> None:
|
|
plan = ub.utbyggingsplan(
|
|
N_anlegg=2,
|
|
T_0=2027,
|
|
T_s=2032,
|
|
t_min=2030,
|
|
P_IT=1000.0,
|
|
L_H=5,
|
|
L_N=20,
|
|
brikker_per_aar=1000.0,
|
|
kraftrom=ub.kraftrom_ubegrenset,
|
|
stopp=(False,) * 5,
|
|
)
|
|
linje = ub.tidslinje(losning, plan, P_IT=1000.0)
|
|
assert linje[kraft] == (0.0, 0.0, 1000.0, 2000.0, 2000.0)
|
|
assert all(not any(verdier) for x, verdier in linje.items() if x is not kraft)
|
|
|
|
|
|
def test_krafttype_i_t_krever_en_trinnvisplan(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
plan = ks.lag_plan(inn, Losning.C, ks.dimensjoner(inn, Losning.C), N_anlegg=1)
|
|
with pytest.raises(TypeError, match="utbyggingsplan_trinnvis"):
|
|
ub.krafttype(Losning.T_F, plan, 0)
|
|
|
|
|
|
# ------------------------------------------- the plan from a set of values
|
|
|
|
|
|
def _lag(inn: idt.Inndata, losning: Losning, N_anlegg: int, **brytere: bool) -> ub.Trinnvisplan:
|
|
plan = ks.lag_plan(inn, losning, ks.dimensjoner(inn, losning), N_anlegg=N_anlegg, **brytere)
|
|
assert isinstance(plan, ub.Trinnvisplan)
|
|
return plan
|
|
|
|
|
|
def test_dimensjoneringen_i_t_er_per_modul(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
tf, tk = ks.dimensjoner(inn, Losning.T_F), ks.dimensjoner(inn, Losning.T_K)
|
|
assert tf.E_D == pytest.approx(8760 * 0.75 * 1.2 * 100.0)
|
|
assert (tf.P_u, tf.P_G_N) == (0.0, 0.0)
|
|
assert tk.P_u == 1000.0
|
|
assert tk.P_G_N == pytest.approx(0.75 * 1.2 * 100.0 / 0.8)
|
|
assert ks.antall_moduler(inn, 3) == 30
|
|
with pytest.raises(ValueError, match="whole number of modules"):
|
|
ks.antall_moduler(oppdiktet(P_m=300.0), 1)
|
|
|
|
|
|
def test_tf_fra_det_oppdiktede_tallsettet(oppdiktet: LagInndata) -> None:
|
|
"""Hand-computed: new grid in 2033, first module in 2030 (S48: one year plus tau_D = 2).
|
|
|
|
150 MW of draw a year, a module draws 120: 2030 one module (30 left), 2031 180, one
|
|
module, 2032 210, one module. From 2033 no limit: chips and power have room for the
|
|
seven that remain.
|
|
"""
|
|
plan = _lag(oppdiktet(tau_nett=6.0), Losning.T_F, 1)
|
|
assert (plan.t_forste, plan.t_nett, plan.P_m, plan.N_anlegg) == (2030, 2033, 100.0, 10)
|
|
assert _start(plan) == [2030, 2031, 2032] + [2033] * 7
|
|
uten = _lag(oppdiktet(tau_nett=6.0), Losning.T_F, 1, uten_forste_trinn=True)
|
|
assert _start(uten) == [2033] * 10
|
|
|
|
|
|
def test_forste_aar_kraft_folger_byggetidene_i_portefoljen(oppdiktet: LagInndata) -> None:
|
|
"""Modules 1 and 2 get hydropower (paid the year before start), 3 to 5 wind (two years).
|
|
|
|
Module 6 is the first that needs offshore wind, with three years of construction.
|
|
"""
|
|
inn = oppdiktet()
|
|
forste = ks.forste_aar_kraft(inn, ks.dimensjoner(inn, Losning.T_F))
|
|
assert [forste(j) for j in (1, 2, 3, 5, 6)] == [2029, 2029, 2030, 2030, 2031]
|
|
|
|
|
|
def test_tk_fra_det_oppdiktede_tallsettet(oppdiktet: LagInndata) -> None:
|
|
"""Hand-computed, with renewable power for three modules before nuclear power in 2035.
|
|
|
|
0.5 TWh a year of new renewable power has room for 1 module in 2030, 2 in 2031 and 3 in
|
|
2033. S49 for two facilities: 17 modules left draw 1 530 MW on average, more than the
|
|
800 MW one unit gives, so nuclear power is built. 1 000 MW of chips a year from 2035:
|
|
ten modules in 2035 and seven in 2036; the replacements in the renewable modules take
|
|
from the old stock. For one facility 7 modules are left, 630 MW: no nuclear power.
|
|
"""
|
|
inn = oppdiktet(tau_nett=6.0, g_fornybar=0.5e6)
|
|
plan = _lag(inn, Losning.T_K, 2)
|
|
assert (plan.t_N, plan.J_F, plan.kjernekraft_bygges) == (2035, 3, True)
|
|
assert _start(plan) == [2030, 2031, 2033] + [2035] * 10 + [2036] * 7
|
|
assert plan.anlegg[0].aarganger[:2] == (2030, 2035)
|
|
assert plan.gjennomforbar
|
|
|
|
ett_anlegg = _lag(inn, Losning.T_K, 1)
|
|
assert (ett_anlegg.J_F, ett_anlegg.kjernekraft_bygges) == (3, False)
|
|
assert ett_anlegg.anlegg == _lag(inn, Losning.T_F, 1).anlegg
|
|
uten_vilkaaret = _lag(inn, Losning.T_K, 1, uten_s49=True)
|
|
assert uten_vilkaaret.kjernekraft_bygges
|
|
assert _start(uten_vilkaaret) == [2030, 2031, 2033] + [2035] * 7
|
|
|
|
|
|
def test_bryterne_for_t_gjelder_bare_t(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
dim = ks.dimensjoner(inn, Losning.C)
|
|
with pytest.raises(ValueError, match="only apply to solution T"):
|
|
ks.lag_plan(inn, Losning.C, dim, N_anlegg=1, uten_s49=True)
|
|
with pytest.raises(ValueError, match="not defined for T"):
|
|
ks.lag_plan(
|
|
inn, Losning.T_F, ks.dimensjoner(inn, Losning.T_F), N_anlegg=1, brikker_fra_T0=True
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize("losning", [Losning.T_F, Losning.T_K])
|
|
def test_t_gaar_ikke_gjennom_kontantstrommen_ennaa(oppdiktet: LagInndata, losning: Losning) -> None:
|
|
inn = oppdiktet(tau_nett=6.0)
|
|
plan = _lag(inn, losning, 1)
|
|
with pytest.raises(NotImplementedError, match="not taken through the cash flow yet"):
|
|
ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING)
|
|
|
|
|
|
# ----------------------------------------- AI use on the users' own machines, S51 and S52
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("t_v", "d"),
|
|
[(2020, 0.0), (2025, 0.0), (2028, 0.06), (2030, 0.1), (2033, 0.16), (2035, 0.2), (2060, 0.2)],
|
|
)
|
|
def test_bortfallet_er_lineaert_mellom_tre_punkter_og_fast_etterpaa(t_v: int, d: float) -> None:
|
|
assert lg.s51_bortfall(t_v=t_v, d_30=0.1, d_35=0.2) == pytest.approx(d)
|
|
|
|
|
|
def test_bortfallet_er_en_andel() -> None:
|
|
with pytest.raises(ValueError, match="d_35 is a share"):
|
|
lg.s51_bortfall(t_v=2030, d_30=0.1, d_35=1.2)
|
|
|
|
|
|
def test_s51_uten_bortfall_er_hovedforlopet() -> None:
|
|
assert lg.s51_etterspoerselsfaktor(eps_d=1.0, d=0.0) == 1.0
|
|
assert lg.s51_etterspoerselsfaktor(eps_d=2.0, d=0.0) == 1.0
|
|
|
|
|
|
def test_s51_faktoren() -> None:
|
|
assert lg.s51_etterspoerselsfaktor(eps_d=1.0, d=0.21) == pytest.approx(0.79)
|
|
assert lg.s51_etterspoerselsfaktor(eps_d=0.5, d=0.64) == pytest.approx(0.68)
|
|
assert lg.s51_etterspoerselsfaktor(eps_d=2.0, d=0.64) == 0.0 # never below zero
|
|
with pytest.raises(ValueError, match="share between 0 and 1"):
|
|
lg.s51_etterspoerselsfaktor(eps_d=1.0, d=1.5)
|
|
with pytest.raises(ValueError, match="cannot be negative"):
|
|
lg.s51_etterspoerselsfaktor(eps_d=-1.0, d=0.5)
|
|
|
|
|
|
def test_bortfallet_i_scenarioet_med_egne_maskiner() -> None:
|
|
assert lg.s51_bortfall_egne_maskiner(s_flytt=0.8, s_trening=0.5) == pytest.approx(0.4)
|
|
assert lg.s51_bortfall_egne_maskiner(s_flytt=0.8, s_trening=1.0) == 0.0
|
|
|
|
|
|
def test_s52_terskelen_er_pristerskelen_uttrykt_som_bortfall() -> None:
|
|
assert lg.s52_bortfallsterskel(k_a=0.7, eps_d=1.0) == pytest.approx(0.3)
|
|
assert lg.s52_bortfallsterskel(k_a=0.7, eps_d=2.0) == pytest.approx(0.15)
|
|
assert lg.s52_bortfallsterskel(k_a=0.3, eps_d=0.5) == 1.0 # never above one
|
|
assert lg.s52_bortfallsterskel(k_a=1.0, eps_d=1.0) == 0.0 # tolerates no loss
|
|
assert lg.s52_bortfallsterskel(k_a=1.4, eps_d=1.0) == 0.0
|
|
assert lg.s52_bortfallsterskel(k_a=None, eps_d=1.0) is None
|
|
with pytest.raises(ValueError, match="must be positive"):
|
|
lg.s52_bortfallsterskel(k_a=0.7, eps_d=0.0)
|
|
|
|
|
|
@pytest.mark.parametrize("eps_d", [0.5, 1.0, 2.0])
|
|
def test_s52_gir_samme_faktor_som_pristerskelen(eps_d: float) -> None:
|
|
"""A loss of d* for every vintage is the same as multiplying the price by k_a (17.3)."""
|
|
k_a = 0.6
|
|
d = lg.s52_bortfallsterskel(k_a=k_a, eps_d=eps_d)
|
|
assert d is not None
|
|
assert lg.s51_etterspoerselsfaktor(eps_d=eps_d, d=d) == pytest.approx(k_a)
|
|
|
|
|
|
# ------------------------------------------- emissions with deduction and water
|
|
|
|
|
|
def test_s53_unngaatte_utslipp_for_ett_anlegg() -> None:
|
|
"""1 000 MW IT at load 0.7 and PUE 1.14 uses 6 990 480 MWh; at 0.34 tonnes per MWh."""
|
|
felles = {"u_alt": 0.34, "Gamma": 1.0, "lam": 0.7, "PUE_v": 1.14, "P": 1000.0}
|
|
assert lg.s53_unngaatt_utslipp(mu=1.0, mu_d=1.0, **felles) == pytest.approx(2_376_763.2)
|
|
# only compute that is sold and delivered replaces compute elsewhere
|
|
assert lg.s53_unngaatt_utslipp(mu=0.9, mu_d=0.5, **felles) == pytest.approx(0.45 * 2_376_763.2)
|
|
assert lg.s53_unngaatt_utslipp(mu=1.0, mu_d=1.0, **{**felles, "u_alt": 0.0}) == 0.0
|
|
|
|
|
|
def test_s53_med_fradrag_kan_bli_negativt() -> None:
|
|
assert lg.s53_utslipp_med_fradrag(U_liv=100.0, U_unngaatt=30.0) == 70.0
|
|
assert lg.s53_utslipp_med_fradrag(U_liv=100.0, U_unngaatt=250.0) == -150.0
|
|
|
|
|
|
def test_s54_kjolevann() -> None:
|
|
E_IT = lg.s54_it_energi(lam=0.7, P=1000.0)
|
|
assert E_IT == pytest.approx(6_132_000.0)
|
|
E_N = 8760 * 0.84 * 1000.0
|
|
assert lg.s54_kjolevann(w_D=0.085, w_N=145.0, E_IT=E_IT, E_N=E_N) == pytest.approx(
|
|
521_220.0 + 1_066_968_000.0
|
|
)
|
|
# consumption of fresh water with sea-water cooling: only the data centre's
|
|
assert lg.s54_kjolevann(w_D=0.085, w_N=0.0, E_IT=E_IT, E_N=E_N) == pytest.approx(521_220.0)
|
|
|
|
|
|
# ------------------------------------------------------------------ the paths
|
|
|
|
|
|
def test_lineaer_bane() -> None:
|
|
bane = {2030: 10.0, 2040: 30.0, 2050: 0.0}
|
|
verdier = [lg.lineaer_bane(punkter=bane, t=t) for t in (2020, 2030, 2035, 2040, 2045, 2060)]
|
|
assert verdier == pytest.approx([10.0, 10.0, 20.0, 30.0, 15.0, 0.0])
|
|
assert lg.lineaer_bane(punkter={2024: 0.5}, t=2090) == 0.5
|
|
with pytest.raises(ValueError, match="at least one point"):
|
|
lg.lineaer_bane(punkter={}, t=2030)
|
|
|
|
|
|
def test_banene_i_det_oppdiktede_tallsettet(oppdiktet: LagInndata) -> None:
|
|
inn = oppdiktet()
|
|
assert inn.u_alt_i("hoved", 2030) == pytest.approx(0.3)
|
|
assert inn.u_alt_i("hoved", 2090) == pytest.approx(0.1)
|
|
assert inn.u_alt_i("fast", 2090) == 0.5
|
|
assert inn.bortfall_i("hoyt", 2032) == pytest.approx(0.3 + 0.4 * 0.3)
|
|
assert inn.karbonpris_i(2050) == 1000.0
|
|
|
|
|
|
def test_tabellene_for_bortfall_tolkes_som_i_17_3() -> None:
|
|
"""The table of 17.3, built from tables in the layout of the parameter file."""
|
|
bortfall = idt.tolk_bortfall(
|
|
d_kilde={"2030": 0.119, "2035": 0.21},
|
|
s_flytt={"2030": 0.4, "2035": 0.8},
|
|
s_trening={"hoy": 0.53, "lav": 0.2},
|
|
)
|
|
assert bortfall[idt.BORTFALL_KILDE] == (0.119, 0.21)
|
|
assert bortfall[idt.BORTFALL_EGNE_LAV] == pytest.approx((0.188, 0.376))
|
|
assert bortfall[idt.BORTFALL_EGNE_HOY] == pytest.approx((0.32, 0.64))
|
|
|
|
|
|
def test_tabellen_for_u_alt_regnes_om_til_tonn_per_mwh() -> None:
|
|
baner = idt.tolk_u_alt(
|
|
{
|
|
"hoved": {"2024": 400, "2030": 300},
|
|
"lav": {"2025": 200, "2030": 100},
|
|
"hoy": {"lav": 410, "hoy": 626},
|
|
"null": 0,
|
|
}
|
|
)
|
|
assert baner["hoved"] == pytest.approx({2024: 0.4, 2030: 0.3})
|
|
assert baner["lav"] == pytest.approx({2025: 0.2, 2030: 0.1})
|
|
assert baner["hoy_nedre"] == pytest.approx({2024: 0.41})
|
|
assert baner["hoy_ovre"] == pytest.approx({2024: 0.626})
|
|
assert baner["null"] == {2024: 0.0}
|
|
|
|
|
|
def test_tabellen_for_kjoletaarn() -> None:
|
|
taarn = idt.tolk_kjoletaarn({"forbruk": [2.2, 2.5, 3.2], "uttak": [3.0, 4.2, 9.8]})
|
|
assert taarn == {"forbruk": (2.2, 2.5, 3.2), "uttak": (3.0, 4.2, 9.8)}
|
|
|
|
|
|
def _alle(funksjon: Callable[[int], bool], antall: int) -> list[bool]:
|
|
return [funksjon(k) for k in range(antall)]
|
|
|
|
|
|
def test_modulene_i_forste_trinn_er_de_som_startet_for_nytt_nett(oppdiktet: LagInndata) -> None:
|
|
plan = _lag(oppdiktet(tau_nett=6.0), Losning.T_F, 1)
|
|
assert _alle(plan.i_forste_trinn, 10) == [True] * 3 + [False] * 7
|