feat(folsomheter): the sensitivity list through the run over the draws, with eleven new switches in the model code

42 rows from the 37 lines: each row is the main run with one change, run
on the main run's step for the solutions it applies to and put in the
fixed table next to the main run. New switches in dimensjoner and
regn_program for lines 4, 7, 8, 10, 12, 13, 16, 17, 18, 20 and 21, the
cost factor of line 28 in the ownership pass, and the state's cash flow
next to M6. With the switches off every figure is unchanged to the last
digit. Made-up draws only; nothing is computed.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-13 20:31:12 +01:00
commit 45aaffcb69
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
12 changed files with 3275 additions and 220 deletions

View file

@ -46,7 +46,8 @@ import numpy as np
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import nivaaisert
from tokenfabrikker import nivaaisert, skala
from tokenfabrikker.inndata import HELEID_SELSKAP
from tokenfabrikker.nivaaisert import Renter
if TYPE_CHECKING:
@ -202,7 +203,7 @@ def _betalt(eiendeler: Sequence[Eiendel], res: Programresultat) -> Tabell:
def _investering_og_avskrivning(
res: Programresultat, iota: float
res: Programresultat, iota: float, kostnadsfaktor: float = 1.0
) -> tuple[Tabell, Tabell, Tabell, Tabell]:
"""Payments as made, the same at budget, tax depreciation and booked depreciation, per year.
@ -210,7 +211,8 @@ def _investering_og_avskrivning(
paid, so in constant kroner it shrinks with the price growth ``iota``. The
booked depreciation is the same straight line in constant kroner. An asset
in operation at the final year is written off in full there: the project
is valued as sold that year (clarification 62).
is valued as sold that year (clarification 62). ``kostnadsfaktor``
multiplies every payment, at budget too (line 28, clarification 122).
"""
T_0, T_s = res.plan.T_0, res.plan.T_s
investering, budsjett, skattemessig, bokfort = (
@ -218,13 +220,14 @@ def _investering_og_avskrivning(
)
for e in _eiendeler(res):
slutt = min(e.slutt, T_s)
kostnad = kostnadsfaktor * e.kostnad
for j, andel in enumerate(lg.byggeaar_andeler(tau=e.byggetid)):
betalt = e.start - 1 - j
investering[betalt - T_0] += e.kostnad * andel
budsjett[betalt - T_0] += e.budsjett * andel
investering[betalt - T_0] += kostnad * andel
budsjett[betalt - T_0] += kostnadsfaktor * e.budsjett * andel
for t in range(e.start, slutt + 1):
rett_linje = lg.s28_avskrivning(
kostnad=e.kostnad * andel,
kostnad=kostnad * andel,
levetid=e.levetid,
start=e.start,
slutt=slutt,
@ -238,7 +241,7 @@ def _investering_og_avskrivning(
def bedriftsstrom(
inn: Inndata, res: Programresultat, *, tilleggsregel: bool = False
inn: Inndata, res: Programresultat, *, tilleggsregel: bool = False, kostnadsfaktor: float = 1.0
) -> Bedriftsstrom:
"""Chapter 7: the cash flow of the path in ``res`` as a business pays it.
@ -252,7 +255,17 @@ def bedriftsstrom(
In solution T the tariff is paid per module, on PUE P_m (chapter 17.1). The
revenue and the disconnection arm carry the factor of S51 when the path is
computed with a loss of demand (chapter 17.3).
``kostnadsfaktor`` is 1 + eps_e, the efficiency of direct ownership and the
wholly owned company (line 28, clarifications 52 and 122). It multiplies
the investments, I^bud and renewals too, and all operation but power
bought, electricity tax, grid tariff, q_N E and the capacity cost: the
data centres' operation, the power plants' operation with fuel and waste
fee, their decommissioning and the fixed cost of the buffer. Sales are
not costs and are not multiplied. Tax and the residual value follow from
the cash flow with the factor. It is exactly one in every other computation.
"""
f = kostnadsfaktor
plan = res.plan
null = np.zeros(len(res.aar), dtype=np.float64)
med_last = np.array([plan.antall_med_last(t) for t in res.aar], dtype=np.float64)
@ -260,22 +273,24 @@ def bedriftsstrom(
pris = np.array([rad.pris for rad in res.kraftaar], dtype=np.float64)
brukt = med_last * res.dim.E_D
elavgift = inn["t_el"] * brukt
drift = sum((a.drift + a.ulykke for a in res.anlegg), null.copy()) + elavgift
drift = sum((f * a.drift + a.ulykke for a in res.anlegg), null.copy()) + elavgift
for a in res.anlegg:
for i in a.salg:
faktor = res.varsigma[i] if tilleggsregel else 1.0
drift += a.kraftdrift[i] + a.avvikling[i] - faktor * a.salg[i]
for f in res.felles:
drift += f * a.kraftdrift[i] + f * a.avvikling[i] - faktor * a.salg[i]
for g in res.felles:
faktor = res.varsigma[ks.KJERNEKRAFT] if tilleggsregel else 1.0
drift += f.drift + f.ulykke + f.avvikling - faktor * f.salg
drift += f * g.drift + g.ulykke + f * g.avvikling - faktor * g.salg
if res.losning.paa_nett:
tariff = i_drift * lg.s27_nettariff(t_nett=inn["t_nett"], PUE=inn["PUE"], P_IT=res.P_enhet)
drift += pris * brukt + tariff + nivaaisert.effektkostnad_bedrift(inn, res)
else:
P_buf = lg.s36_buffer(delta_L=inn["delta_L"], PUE=inn["PUE"], P_IT=inn["P_IT"])
drift += i_drift * inn["f_buf"] * P_buf
investering, budsjett, avskrivning, bokfort = _investering_og_avskrivning(res, inn["iota"])
RV_anlegg, RV_felles = restverdi_bedrift(inn, res, tilleggsregel=tilleggsregel)
P_buf = ks.bufferstorrelse(inn, res.dim)
drift += i_drift * (f * inn["f_buf"]) * P_buf
investering, budsjett, avskrivning, bokfort = _investering_og_avskrivning(res, inn["iota"], f)
RV_anlegg, RV_felles = restverdi_bedrift(
inn, res, tilleggsregel=tilleggsregel, kostnadsfaktor=f
)
restverdi = null.copy()
restverdi[-1] = math.fsum(RV_anlegg) + RV_felles
return Bedriftsstrom(
@ -295,7 +310,7 @@ def bedriftsstrom(
def netto_per_anlegg(
inn: Inndata, res: Programresultat, *, tilleggsregel: bool = False
inn: Inndata, res: Programresultat, *, tilleggsregel: bool = False, kostnadsfaktor: float = 1.0
) -> tuple[Tabell, ...]:
"""Clarification 62: each facility's part of the business net cash flow before tax, kr.
@ -305,8 +320,10 @@ def netto_per_anlegg(
programme's nuclear units is shared equally among the facilities operated
that year; in a year without any, it is not shared. In T-K it is shared
among the nuclear modules operated that year, and never on the renewable
modules (chapter 17.1, clarification 76).
modules (chapter 17.1, clarification 76). ``kostnadsfaktor`` multiplies the
costs as in ``bedriftsstrom`` (line 28, clarification 122).
"""
c = kostnadsfaktor
plan = res.plan
pris = np.array([rad.pris for rad in res.kraftaar], dtype=np.float64)
med_last = np.array([max(1, plan.antall_med_last(t)) for t in res.aar], dtype=np.float64)
@ -315,23 +332,25 @@ def netto_per_anlegg(
)
utkobling = nivaaisert.effektkostnad_bedrift(inn, res)
tariff = lg.s27_nettariff(t_nett=inn["t_nett"], PUE=inn["PUE"], P_IT=res.P_enhet)
buffer = inn["f_buf"] * lg.s36_buffer(delta_L=inn["delta_L"], PUE=inn["PUE"], P_IT=inn["P_IT"])
buffer = (c * inn["f_buf"]) * ks.bufferstorrelse(inn, res.dim)
def faktor(teknologi: str) -> float:
return res.varsigma[teknologi] if tilleggsregel else 1.0
felles = np.zeros(len(res.aar), dtype=np.float64)
for f in res.felles:
felles += faktor(ks.KJERNEKRAFT) * f.salg - f.drift - f.ulykke - f.avvikling
felles -= _betalt(f.eiendeler, res)
for g in res.felles:
felles += faktor(ks.KJERNEKRAFT) * g.salg - c * g.drift - g.ulykke - c * g.avvikling
felles -= c * _betalt(g.eiendeler, res)
netto = []
for k, a in enumerate(res.anlegg):
last = np.array([1.0 if plan.har_last(k, t) else 0.0 for t in res.aar], dtype=np.float64)
drives = np.array([1.0 if plan.i_drift(k, t) else 0.0 for t in res.aar], dtype=np.float64)
brukt = last * res.dim.E_D
strom = a.inntekt - a.drift - a.ulykke - inn["t_el"] * brukt - _betalt(a.eiendeler, res)
strom = (
a.inntekt - c * a.drift - a.ulykke - inn["t_el"] * brukt - c * _betalt(a.eiendeler, res)
)
for i in a.salg:
strom += faktor(i) * a.salg[i] - a.kraftdrift[i] - a.avvikling[i]
strom += faktor(i) * a.salg[i] - c * a.kraftdrift[i] - c * a.avvikling[i]
if res.losning.paa_nett:
strom -= pris * brukt + drives * tariff + utkobling * last / med_last
else:
@ -342,38 +361,44 @@ def netto_per_anlegg(
def restverdi_bedrift(
inn: Inndata, res: Programresultat, *, tilleggsregel: bool = False
inn: Inndata, res: Programresultat, *, tilleggsregel: bool = False, kostnadsfaktor: float = 1.0
) -> tuple[tuple[float, ...], float]:
"""Clarification 62: RV^bed per facility, and the decommissioning of the programme's units.
The rule of S40 on the business cash flow, in kr at the final year. A
facility that loses money gets no value, but the decommissioning that
falls after the final year is always deducted, discounted with rho_N
(rho_A in A).
(rho_A in A; the nuclear plants' own rate with line 4, clarification
118 a). ``kostnadsfaktor`` multiplies the costs, the decommissioning too
(line 28, clarification 122).
"""
c = kostnadsfaktor
vindu = min(res.plan.L_H, len(res.aar))
rho_avvikling = inn["rho_N"] if res.losning.paa_nett else res.dim.rho_A
rho_kjerne = ks.rente_kjernekraft(inn, res.dim)
rho_avvikling = rho_kjerne if res.losning.paa_nett else res.dim.rho_A
anlegg = tuple(
lg.s28_restverdi(
NK_snitt=float(np.mean(netto[-vindu:])),
L_rest=a.L_rest,
rho_D=inn["rho_D"],
rho_avvikling=rho_avvikling,
avvikling=math.fsum(a.avvikling_etter.values()),
avvikling=c * math.fsum(a.avvikling_etter.values()),
)
for a, netto in zip(
res.anlegg, netto_per_anlegg(inn, res, tilleggsregel=tilleggsregel), strict=True
res.anlegg,
netto_per_anlegg(inn, res, tilleggsregel=tilleggsregel, kostnadsfaktor=c),
strict=True,
)
)
felles = math.fsum(
lg.s28_restverdi(
NK_snitt=0.0,
L_rest=f.L_rest,
L_rest=g.L_rest,
rho_D=inn["rho_D"],
rho_avvikling=inn["rho_N"],
avvikling=f.avvikling_etter,
rho_avvikling=rho_kjerne,
avvikling=c * g.avvikling_etter,
)
for f in res.felles
for g in res.felles
)
return anlegg, felles
@ -400,16 +425,23 @@ def krav_for_skatt(inn: Inndata, eierform: Eierform) -> float:
return lg.s29_krav_for_skatt(r_e=r_e, tau_s=inn["tau_s"]) if eierform.skatt else r_e
def lcoc_med_kapitalkostnad(inn: Inndata, res: Programresultat, r_e: float) -> float:
def lcoc_med_kapitalkostnad(
inn: Inndata, res: Programresultat, r_e: float, *, kostnadsfaktor: float = 1.0
) -> float:
"""Chapter 8: what the cost of capital does to the cost of compute, kr per MW IT and year.
LCOC^bed with ``r_e`` as the required return for both compute and power,
averaged over the vintages of the path with the weights of S42. The
criterion of the pre-registration uses the requirement before tax,
``krav_for_skatt`` (clarification 66).
``krav_for_skatt`` (clarification 66). ``kostnadsfaktor`` multiplies the
costs as in ``bedriftsstrom`` (line 28, clarification 122).
"""
kost = nivaaisert.kraftkostnad(
inn, res, bedrift=True, renter=Renter(rho_D=r_e, rho_N=r_e, rho_A=r_e)
inn,
res,
bedrift=True,
renter=Renter(rho_D=r_e, rho_N=r_e, rho_A=r_e),
kostnadsfaktor=kostnadsfaktor,
)
vekter = [
lg.diskonteringsfaktor(rho=inn["rho_D"], t=a.t_v, T_0=res.plan.T_0) for a in kost.aarganger
@ -534,6 +566,22 @@ def eierresultat(
)
def statens_kontantstrom_ved_m6(
inn: Inndata, res: Programresultat, utfall_heleid: Eierresultat
) -> float | None:
"""Clarification 123: the state's net cash flow after investments, next to M6.
S30 for the wholly owned company (``utfall_heleid``, from ``eierresultat``
on the business cash flow of ``res`` with the factor of S45) in the first
year of stable operation, divided by the denominator of M6; None when the
path has no such year (clarification 53). It changes no verdict.
"""
if utfall_heleid.eierform.navn != HELEID_SELSKAP:
msg = f"the figure next to M6 is for {HELEID_SELSKAP}, not {utfall_heleid.eierform.navn}"
raise ValueError(msg)
return skala.statens_kontantstrom_mot_petroleum(inn, res, utfall_heleid.KS_stat)
def storste_innskutte_kapital(KS_stat: Tabell) -> float:
"""Chapter 8: the largest cumulative, undiscounted net payment from the state, kr."""
return max(0.0, float(-np.min(np.cumsum(KS_stat))))

View file

@ -0,0 +1,434 @@
"""The sensitivity list through the run over the draws.
Chapter 11 of the specification; chapter 16, clarifications 112, 113 and 116 to 124.
The list of the parameter file has 37 lines and gives 42 rows: five lines
have two values. A row is the main run with one change, over the same draws.
It is computed for the solutions it applies to, on the step the main run's
verdicts are read on and in the scenario it is read in; every other solution
keeps the main run's outcome. The verdicts per target, M7, part I and part II
are then put together from the row's outcomes as in the main run, without
thresholds. No verdict of a row counts.
Four rows concern only the comparison of the ownership forms and are computed
by ``kjoring.eierformer_paa_trinnet``; one row, M6 against the median of the
ten years, is no run of its own.
Nothing here reads the parameter file or the stored draws: the caller passes
the sets of values, and the low and the high path of the carbon price.
"""
from __future__ import annotations
import enum
from concurrent.futures import ProcessPoolExecutor
from dataclasses import dataclass, field, replace
from functools import partial
from typing import TYPE_CHECKING, Any, Final
from tokenfabrikker import dommer
from tokenfabrikker import kjoring as kj
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker.dommer import DOMSLOSNINGER, Dom, Trinnvalg
from tokenfabrikker.kjoring import Bane, Brytere, Eierrad, Kjoring, Scenario
from tokenfabrikker.kontantstrom import Diskontering, Knapphet, Paaslagsform, Skattekostnad
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Iterable, Mapping, Sequence
from tokenfabrikker.inndata import Inndata
from tokenfabrikker.kjoring import Losningsdommer, Maaldom, Sidetall, Utfall
ALLE: Final = tuple(Losning)
MED_KJERNEKRAFT: Final = (Losning.A, Losning.B, Losning.B_MERKET, Losning.T_K)
KJERNEKRAFT_PAA_NETT: Final = (Losning.B, Losning.B_MERKET, Losning.T_K)
SMAA_ENHETER: Final = (Losning.A, Losning.B_MERKET)
TRINNVIS: Final = (Losning.T_F, Losning.T_K)
BESLUTNINGSAAR: Final = 2030
"""Line 26: the year of decision (clarification 113)."""
NY_KRAFT_FRA: Final = 2031
"""Line 37: the first year with new renewable power beyond the reference (clarification 91)."""
HOVEDKJORINGEN: Final = "hovedkjøringen"
"""The name of the main run in the table."""
class Avlesning(enum.StrEnum):
"""Where a row is read (clarifications 112 and 116)."""
HOVED = "normalisering på hovedforløpet"
VARER = "knapphet varer"
MERKET = "de merkede scenarioene"
EIERFORMER = "tabellene for eierformene"
class Saerskilt(enum.StrEnum):
"""What a row changes that is neither a fixed value nor a switch of the model code."""
RHO_A = "rho_A lik trekningens rho_N"
HALV_TAU_N = "halv byggetid for enheter under 300 MW"
KARBON_LAV = "karbonprisens lave bane"
KARBON_HOY = "karbonprisens høye bane"
BESLUTNINGSAAR = "beslutningsår 2030"
C_I_MODULER = "C bygd i moduler"
M6_MOT_MEDIANEN = "M6 mot medianen av de ti årene"
@dataclass(frozen=True)
class Rad:
"""One row of the sensitivity list.
Attributes:
navn: the row, the number of the line in the list with a or b for a second value.
gjelder: the solutions the row changes; the others keep the main run's outcome.
avlesning: where the row is read.
verdier: quantities that get a fixed value in every draw.
brytere: the switches of the model code the row sets.
saerskilt: a change that depends on the draw, a table, or another path.
eierrad: the row of the ownership pass, for the four rows that are read there.
"""
navn: str
gjelder: tuple[Losning, ...]
avlesning: Avlesning = Avlesning.HOVED
verdier: Mapping[str, float] = field(default_factory=dict)
brytere: Brytere = kj.INGEN_BRYTERE
saerskilt: Saerskilt | None = None
eierrad: Eierrad | None = None
@property
def linje(self) -> int:
"""The line of the list in the parameter file, counted from one."""
return int(self.navn.rstrip("ab"))
@property
def er_kjoring(self) -> bool:
"""False for the rows that are not a run of the model over the draws here."""
return self.eierrad is None and self.saerskilt is not Saerskilt.M6_MOT_MEDIANEN
def _dim(**valg: Any) -> Brytere: # noqa: ANN401 - the keywords of the model code
return Brytere(dim=valg)
def _plan(**valg: Any) -> Brytere: # noqa: ANN401
return Brytere(plan=valg)
def _program(**valg: Any) -> Brytere: # noqa: ANN401
return Brytere(program=valg)
_RADER: Final = (
Rad("1", MED_KJERNEKRAFT, verdier={"w_xi": 0.0}),
Rad("2", MED_KJERNEKRAFT, verdier={"w_xi": 1.0}),
Rad("3", (Losning.A,), saerskilt=Saerskilt.RHO_A),
Rad("4", KJERNEKRAFT_PAA_NETT, brytere=_dim(paaslag_kjernekraft=0.02)),
Rad("5", SMAA_ENHETER, verdier={"nu": 0.6}),
Rad("6", MED_KJERNEKRAFT, verdier={"ell": -0.23}),
Rad("7", SMAA_ENHETER, brytere=_dim(minstelast=0.20)),
Rad("8", SMAA_ENHETER, brytere=_dim(fritt_enhetsvalg=True)),
Rad("9", SMAA_ENHETER, saerskilt=Saerskilt.HALV_TAU_N),
Rad("10", (Losning.A,), brytere=_dim(gamma_trinn=True)),
Rad("11a", ALLE, verdier={"mu_rel": 0.90}),
Rad("11b", ALLE, verdier={"mu_rel": 0.95}),
Rad("12", ALLE, Avlesning.VARER, brytere=_program(paaslag=Paaslagsform.VARIG)),
Rad("13", ALLE, Avlesning.VARER, brytere=_program(paaslag=Paaslagsform.AVTAKENDE)),
Rad("14", ALLE, verdier={"p_v": 1198.0}),
Rad("15", ALLE, verdier={"PUE_v": 1.45}),
Rad("16", ALLE, brytere=_program(diskontering=Diskontering.RUNDSKRIV)),
Rad("17a", ALLE, verdier={"varphi": 0.0}),
Rad("17b", ALLE, brytere=_program(skattekostnad=Skattekostnad.ALL_KAPITAL)),
Rad("18", ALLE, brytere=_program(skattekostnad=Skattekostnad.STATENS_RENTE)),
Rad("19a", ALLE, saerskilt=Saerskilt.KARBON_LAV),
Rad("19b", ALLE, saerskilt=Saerskilt.KARBON_HOY),
Rad("20", SMAA_ENHETER, brytere=_dim(skaler_K_U=False)),
Rad("21", KJERNEKRAFT_PAA_NETT, brytere=_dim(bare_over_dimensjonerende_feil=True)),
Rad(
"22",
(Losning.B, Losning.B_MERKET, Losning.C, Losning.T_F, Losning.T_K),
brytere=_program(tilleggsregel=False),
),
Rad("23", ALLE, brytere=_plan(eksportregel=False)),
Rad("24", DOMSLOSNINGER, Avlesning.EIERFORMER, eierrad=Eierrad.STATENS_RENTE),
Rad("25", DOMSLOSNINGER, Avlesning.EIERFORMER, eierrad=Eierrad.EGENKAPITALKRAV),
Rad("26", ALLE, saerskilt=Saerskilt.BESLUTNINGSAAR),
Rad("27", ALLE, verdier={"P_IT": 300.0}),
Rad("28", DOMSLOSNINGER, Avlesning.EIERFORMER, eierrad=Eierrad.EFFEKTIVITET),
Rad("29", DOMSLOSNINGER, Avlesning.EIERFORMER, eierrad=Eierrad.ZETA_LIK_EIERANDEL),
Rad("30", ALLE, saerskilt=Saerskilt.M6_MOT_MEDIANEN),
Rad("31a", ALLE, Avlesning.MERKET, verdier={"eps_d": 0.5}),
Rad("31b", ALLE, Avlesning.MERKET, verdier={"eps_d": 2.0}),
Rad("32a", TRINNVIS, verdier={"P_m": 50.0}),
Rad("32b", TRINNVIS, verdier={"P_m": 200.0}),
Rad("33", TRINNVIS, verdier={"n_1": 650.0}),
Rad("34", TRINNVIS, brytere=_program(full_fortrengning_i_forste_trinn=True)),
Rad("35", (Losning.C,), saerskilt=Saerskilt.C_I_MODULER),
Rad("36", (Losning.T_K,), brytere=_plan(uten_s49=True)),
Rad("37", (Losning.C, Losning.T_F, Losning.T_K), brytere=_plan(ny_kraft_fra=NY_KRAFT_FRA)),
)
RADER: Final[Mapping[str, Rad]] = {rad.navn: rad for rad in _RADER}
"""The 42 rows by name, in the order of the list (clarifications 116 to 122)."""
ANTALL_LINJER: Final = 37
"""The lines of the list in the parameter file."""
# ------------------------------------------------------------------ one draw
def regn_bane(
inn: Inndata,
losning: Losning,
trinn: int,
scenarioer: Sequence[Scenario],
*,
rad: Rad,
karbonbaner: Mapping[str, Mapping[int, float]] | None = None,
) -> Bane:
"""One solution on one step in one draw, with the change of one row (clarification 116).
A value that is replaced is set after the draw: the other quantities keep
their drawn values. ``karbonbaner`` holds the low and the high path of the
carbon price, ``lav`` and ``hoy``, for the two rows that use them. For
the row «C in modules» the path is T-F without its first stage, computed
in the place of C.
"""
if losning not in rad.gjelder or not rad.er_kjoring:
msg = f"row {rad.navn} is not computed for solution {losning.value}"
raise ValueError(msg)
brytere = rad.brytere
inn = inn.med(rad.verdier) if rad.verdier else inn
match rad.saerskilt:
case Saerskilt.RHO_A:
brytere = Brytere(dim={"rho_A": inn["rho_N"]})
case Saerskilt.HALV_TAU_N:
if ks.dimensjoner(inn, losning).P_u < lg.GRENSE_LITEN_ENHET_MW:
inn = inn.med({"tau_N": inn["tau_N"] / 2.0})
case Saerskilt.KARBON_LAV | Saerskilt.KARBON_HOY:
if karbonbaner is None:
msg = "the rows for the carbon price need its low and its high path"
raise ValueError(msg)
bane = "lav" if rad.saerskilt is Saerskilt.KARBON_LAV else "hoy"
inn = replace(inn, karbonpris=karbonbaner[bane])
case Saerskilt.BESLUTNINGSAAR:
inn = med_beslutningsaar(inn, BESLUTNINGSAAR)
case Saerskilt.C_I_MODULER:
losning = Losning.T_F
brytere = Brytere(plan={"uten_forste_trinn": True})
case _:
pass
return kj.regn_bane(inn, losning, trinn, scenarioer, brytere=brytere)
def med_beslutningsaar(inn: Inndata, T_0: int) -> Inndata:
"""The same set with a later year of decision (clarification 113).
The row of the export rule follows the calendar year: the number stored
for year t is used in year t, and the numbers for the years up to the
new year of decision are not used.
"""
senere = T_0 - inn.heltall("T0")
if senere < 0:
msg = f"the year of decision can be moved later, not earlier: {T_0}"
raise ValueError(msg)
return replace(inn.med({"T0": float(T_0)}), u_eksport=inn.u_eksport[senere:])
def scenarioer_for(rad: Rad, scenarioer: Iterable[Scenario]) -> tuple[Scenario, ...]:
"""The scenarios of a run that one row is read in (clarifications 112 and 116)."""
match rad.avlesning:
case Avlesning.HOVED:
return tuple(s for s in scenarioer if s.teller)
case Avlesning.VARER:
return tuple(
s for s in scenarioer if s.knapphet is Knapphet.VARER and s.bortfall is None
)
case Avlesning.MERKET:
return tuple(s for s in scenarioer if s.bortfall is not None)
case _:
return ()
def regn_trekning(
inn: Inndata,
*,
rad: Rad,
trinn: int,
scenarioer: Sequence[Scenario],
losninger: Sequence[Losning],
karbonbaner: Mapping[str, Mapping[int, float]] | None = None,
) -> kj.Trekningsutfall:
"""The solutions one row applies to, on the step, in one draw."""
return {
(a, trinn): regn_bane(inn, a, trinn, scenarioer, rad=rad, karbonbaner=karbonbaner)
for a in losninger
}
# ------------------------------------------------------------- over the draws
def kjor_rad(
trekninger: Iterable[Inndata],
rad: Rad,
valg: Trinnvalg,
*,
scenarioer: Sequence[Scenario] = kj.SCENARIOER,
losninger: Sequence[Losning] = ALLE,
karbonbaner: Mapping[str, Mapping[int, float]] | None = None,
prosesser: int = 1,
) -> Kjoring | None:
"""One row over the draws, on the step the main run's verdicts are read on.
``valg`` is the main run's step; the step is not chosen again
(clarification 112). The run holds the solutions the row applies to, among
``losninger``, in the scenarios the row is read in, among ``scenarioer``.
Returns None when the main run has no step, when the row is not a run of
its own (M6 against the median, and the rows of the ownership forms), and
when none of the solutions or scenarios of the row are in the run.
"""
egne = tuple(a for a in losninger if a in rad.gjelder)
leses = scenarioer_for(rad, scenarioer)
if valg.trinn is None or not rad.er_kjoring or not egne or not leses:
return None
en = partial(
regn_trekning,
rad=rad,
trinn=valg.trinn,
scenarioer=leses,
losninger=egne,
karbonbaner=karbonbaner,
)
if prosesser > 1:
with ProcessPoolExecutor(max_workers=prosesser) as utforer:
utfall = tuple(utforer.map(en, trekninger))
else:
utfall = tuple(en(inn) for inn in trekninger)
if not utfall:
msg = "the run needs at least one draw"
raise ValueError(msg)
return Kjoring(stige=(valg.trinn,), scenarioer=leses, losninger=egne, trekninger=utfall)
# ------------------------------------------------------------------ the table
@dataclass(frozen=True)
class Radtabell:
"""One row of the fixed table, in one scenario (clarifications 112 and 116).
Attributes:
rad: the name of the row, or ``HOVEDKJORINGEN``.
scenario: the name of the scenario the figures are read in.
gjelder: the solutions the row changes; the others have the main run's figures.
losninger: per solution the shares and verdicts for M1, M2, M3, M4 and M6, the
main run's M5, and the median net present value. In the row «C in modules»
the path stands in the place of C.
ved_siden_av: per solution the figures next to M6, among them M6 against the
median of the ten years.
M7: the share of the draws in which A is best, and the verdict; None without A.
del_I: part I as the row gives it, on the main run's step and without thresholds.
del_II: part II as the row gives it; None without A.
"""
rad: str
scenario: str
gjelder: tuple[Losning, ...]
losninger: Mapping[Losning, Losningsdommer]
ved_siden_av: Mapping[Losning, Mapping[str, Sidetall]]
M7: Maaldom | None
del_I: Dom
del_II: Dom | None
def _mot_medianen(utfall: Sequence[Utfall | None]) -> list[Utfall | None]:
return [None if u is None else replace(u, M6=u.M6_median) for u in utfall]
def _radtabell(
navn: str,
scenario: Scenario,
gjelder: tuple[Losning, ...],
*,
utfall: Mapping[Losning, Sequence[Utfall | None]],
for_dommene: Mapping[Losning, Sequence[Utfall | None]],
M5: Mapping[Losning, Dom],
valg: Trinnvalg,
) -> Radtabell:
per_losning = {a: kj.losningsdommer(u, M5[a]) for a, u in utfall.items()}
fem = [a for a in DOMSLOSNINGER if a in for_dommene]
dom = {a: kj.losningsdommer(for_dommene[a], M5[a]) for a in fem}
m7 = (
kj.maaldom_m7({a: [None if u is None else u.NNV for u in for_dommene[a]] for a in fem})
if Losning.A in fem
else None
)
return Radtabell(
rad=navn,
scenario=scenario.navn,
gjelder=gjelder,
losninger=per_losning,
ved_siden_av={a: kj.ved_siden_av_m6(u) for a, u in utfall.items()},
M7=m7,
del_I=dommer.del_I(
{a: dom[a].dommer for a in fem}, {a: dom[a].median_M1 for a in fem}, valg
),
del_II=None if m7 is None else dommer.del_II(m7.dom),
)
def hovedtabell(
hoved: Kjoring, M5: Mapping[Losning, Dom], valg: Trinnvalg, scenario: Scenario
) -> Radtabell:
"""The main run's figures in the format of the table, in one scenario."""
if valg.trinn is None:
msg = "without a step the sensitivity list has no table"
raise ValueError(msg)
utfall = {a: hoved.utfall(scenario, a, valg.trinn) for a in hoved.losninger}
return _radtabell(
HOVEDKJORINGEN, scenario, (), utfall=utfall, for_dommene=utfall, M5=M5, valg=valg
)
def tabell(
hoved: Kjoring,
rad: Rad,
radkjoring: Kjoring | None,
M5: Mapping[Losning, Dom],
valg: Trinnvalg,
) -> dict[str, Radtabell]:
"""One row of the table per scenario the row is read in, by the name of the scenario.
``hoved`` is the main run, ``radkjoring`` what ``kjor_rad`` gave for the
row and ``valg`` the main run's step. A solution the row does not apply
to has the main run's outcome. For the row «M6 against the median» the
verdict in M6 is set with that figure in every solution, and nothing is
run. For «C in modules» the path stands in the place of C, and M7, part I
and part II are the main run's. The rows of the ownership forms have no
table here.
"""
if valg.trinn is None or rad.eierrad is not None:
return {}
ut = {}
for scenario in scenarioer_for(rad, hoved.scenarioer):
utfall = {a: hoved.utfall(scenario, a, valg.trinn) for a in hoved.losninger}
for_dommene: dict[Losning, Sequence[Utfall | None]] = dict(utfall)
if rad.saerskilt is Saerskilt.M6_MOT_MEDIANEN:
utfall = {a: _mot_medianen(u) for a, u in utfall.items()}
for_dommene = dict(utfall)
elif radkjoring is not None:
for a in radkjoring.losninger:
utfall[a] = radkjoring.utfall(scenario, a, valg.trinn)
if rad.saerskilt is not Saerskilt.C_I_MODULER:
for_dommene[a] = utfall[a]
gjelder = tuple(a for a in hoved.losninger if a in rad.gjelder)
ut[scenario.navn] = _radtabell(
rad.navn, scenario, gjelder, utfall=utfall, for_dommene=for_dommene, M5=M5, valg=valg
)
return ut

View file

@ -120,6 +120,9 @@ class Inndata:
and ``null`` (17.4).
kjoletaarn: nuclear power with cooling towers, shown next to the main figure:
(low, median, high) m3 per MWh for ``forbruk`` and ``uttak`` (17.5).
Gamma_trinn: the revenue factor per step of the standard terms (a sensitivity only,
clarification 119 c), by the keys of ``ligninger.GAMMA_TRINN``. Empty in a set
that is not used for that sensitivity.
"""
v: Mapping[str, float]
@ -136,6 +139,7 @@ class Inndata:
bortfall: Mapping[str, tuple[float, float]] = field(default_factory=dict)
u_alt: Mapping[str, Mapping[int, float]] = field(default_factory=dict)
kjoletaarn: Mapping[str, tuple[float, float, float]] = field(default_factory=dict)
Gamma_trinn: Mapping[str, float] = field(default_factory=dict)
def __getitem__(self, navn: str) -> float:
"""The scalar quantity with this id, in the units of the equations."""
@ -320,4 +324,5 @@ def fra_trekning(
),
u_alt=tolk_u_alt(sett.tabell("u_alt")),
kjoletaarn=tolk_kjoletaarn(sett.tabell("w_N_taarn")),
Gamma_trinn=_ordbok_av_tall(sett.tabell("Gamma_trinn")),
)

View file

@ -29,11 +29,12 @@ that is the made-up set of the tests.
from __future__ import annotations
import enum
import math
from concurrent.futures import ProcessPoolExecutor
from dataclasses import dataclass
from dataclasses import dataclass, field, replace
from functools import partial
from typing import TYPE_CHECKING, Final
from typing import TYPE_CHECKING, Any, Final
from tokenfabrikker import dommer, eierskap, miljo, nivaaisert, skala, sobol, terskler
from tokenfabrikker import kontantstrom as ks
@ -196,23 +197,56 @@ def _utfall(inn: Inndata, res: ks.Programresultat) -> Utfall:
)
@dataclass(frozen=True)
class Brytere:
"""The switches of the model code one row of the sensitivity list sets (clarification 116).
Attributes:
dim: keywords to ``kontantstrom.dimensjoner``.
plan: keywords to ``kontantstrom.lag_plan``.
program: keywords to ``kontantstrom.regn_program``.
Empty, every figure is the main run's.
"""
dim: Mapping[str, Any] = field(default_factory=dict)
plan: Mapping[str, Any] = field(default_factory=dict)
program: Mapping[str, Any] = field(default_factory=dict)
INGEN_BRYTERE: Final = Brytere()
"""The main run."""
def regn_bane(
inn: Inndata, losning: Losning, trinn: int, scenarioer: Sequence[Scenario] = SCENARIOER
inn: Inndata,
losning: Losning,
trinn: int,
scenarioer: Sequence[Scenario] = SCENARIOER,
*,
brytere: Brytere = INGEN_BRYTERE,
) -> Bane:
"""One solution on one step in one draw: the build-out, the timeline and the outcomes.
The build-out is the same in every scenario (clarification 95). A set of
values the build-out rejects is an error and is not caught here: it is not
a path that cannot be built (clarification 96).
a path that cannot be built (clarification 96). ``brytere`` holds the
switches of a row of the sensitivity list; the main run has none.
"""
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=trinn)
dim = ks.dimensjoner(inn, losning, **brytere.dim)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=trinn, **brytere.plan)
linje = ub.tidslinje(losning, plan, P_IT=inn["P_IT"])
utfall: dict[str, Utfall] = {}
if plan.gjennomforbar:
for scenario in scenarioer:
res = ks.regn_program(
inn, losning, plan, scenario.knapphet, dim=dim, bortfall=_bortfall(inn, scenario)
inn,
losning,
plan,
scenario.knapphet,
dim=dim,
bortfall=_bortfall(inn, scenario),
**brytere.program,
)
utfall[scenario.navn] = _utfall(inn, res)
return Bane(
@ -642,7 +676,8 @@ def vilkaar_m7(nnv: Mapping[Losning, Sequence[float | None]]) -> list[bool | Non
return [None if a is None else b for a, b in zip(nnv[Losning.A], best, strict=True)]
def _m7(nnv: Mapping[Losning, Sequence[float | None]]) -> Maaldom:
def maaldom_m7(nnv: Mapping[Losning, Sequence[float | None]]) -> Maaldom:
"""M7 from the net present value per solution and draw, with the figures next to it."""
return _maaldom(dommer.dom_m7(nnv), vilkaar_m7(nnv))
@ -689,7 +724,9 @@ def sett_dommer(
utfall = {a: kjoring.utfall(scenario, a, trinn) for a in kjoring.losninger}
per_trinn[trinn] = {a: losningsdommer(utfall[a], M5[a]) for a in kjoring.losninger}
if Losning.A in fem:
m7[trinn] = _m7({a: [None if u is None else u.NNV for u in utfall[a]] for a in fem})
m7[trinn] = maaldom_m7(
{a: [None if u is None else u.NNV for u in utfall[a]] for a in fem}
)
paa_trinnet = {} if valg.trinn is None else per_trinn[valg.trinn]
betingelser: dict[Losning, Betingelser] | None = None
terskler_M7: tuple[Terskel, ...] = ()
@ -768,15 +805,17 @@ def ved_siden_av_m6(utfall: Sequence[Utfall | None]) -> dict[str, Sidetall]:
"2050": [u.M6_2050 for u in utfall if u is not None],
"toppaar": [u.M6_topp for u in utfall if u is not None],
}
ut = {}
for navn, rad in tall.items():
verdier = [x for x in rad if x is not None]
ut[navn] = Sidetall(
antall=len(verdier),
median=persentil(verdier, 0.5) if verdier else None,
persentiler=tuple(persentil(verdier, p) for p in PERSENTILER) if verdier else None,
)
return ut
return {navn: sidetall(rad) for navn, rad in tall.items()}
def sidetall(tall: Sequence[float | None]) -> Sidetall:
"""Median, percentiles and count over the draws that have a value (clarification 103 c)."""
verdier = [x for x in tall if x is not None]
return Sidetall(
antall=len(verdier),
median=persentil(verdier, 0.5) if verdier else None,
persentiler=tuple(persentil(verdier, p) for p in PERSENTILER) if verdier else None,
)
# ------------------------------------------------------------- the Sobol indices
@ -1080,6 +1119,8 @@ class Eierformtabell:
criteria (clarification 50).
kriterier: the first three criteria per ownership form, in the order of the set.
rangering: the rule of the pre-registration applied to them.
statens_kontantstrom: the state's net cash flow after investments next to M6, over
the draws that have a year of stable operation (clarification 123).
"""
losning: Losning
@ -1087,16 +1128,48 @@ class Eierformtabell:
antall_byggbare: int
kriterier: tuple[Eierkriterier, ...]
rangering: Rangering
statens_kontantstrom: Sidetall | None = None
class Eierrad(enum.StrEnum):
"""The rows of the sensitivity list that concern the ownership forms (clarification 122)."""
HOVED = "hovedkjøringen"
STATENS_RENTE = "24"
EGENKAPITALKRAV = "25"
EFFEKTIVITET = "28"
ZETA_LIK_EIERANDEL = "29"
MED_EFFEKTIVITET: Final = ("direkte", "heleid_selskap")
"""The forms whose costs carry the factor 1 + eps_e in row 28 (chapter 8)."""
HELEID: Final = "heleid_selskap"
"""The form the state's cash flow next to M6 is computed for (clarification 53)."""
def regn_eierformer(
inn: Inndata, losning: Losning, trinn: int, scenario: Scenario
) -> dict[str, tuple[Eierresultat, float]] | None:
inn: Inndata,
losning: Losning,
trinn: int,
scenario: Scenario,
*,
rad: Eierrad = Eierrad.HOVED,
) -> tuple[dict[str, tuple[Eierresultat, float]], float | None] | None:
"""S30 and the cost of compute per ownership form for one path in one draw.
Returns None when the path cannot be built. The cash flow carries the
factor of the additionality rule (S30), and the cost of compute is
computed with the form's required return before tax (clarification 66).
Next to them comes the state's net cash flow after investments in the
first year of stable operation over the denominator of M6, for the wholly
owned company; None when the path has no such year (clarification 123).
``rad`` is a row of the sensitivity list (clarification 122): the present
value of the state's cash flow with the state's borrowing rate (24), the
costs times 1 + eps_e for direct ownership and the wholly owned company
(28), or zeta equal to the state's share (29). Row 25 changes how the
criteria are put together and nothing here.
"""
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=trinn)
@ -1105,14 +1178,29 @@ def regn_eierformer(
res = ks.regn_program(
inn, losning, plan, scenario.knapphet, dim=dim, bortfall=_bortfall(inn, scenario)
)
strom = eierskap.bedriftsstrom(inn, res, tilleggsregel=True)
return {
navn: (
eierskap.eierresultat(inn, strom, form),
eierskap.lcoc_med_kapitalkostnad(inn, res, eierskap.krav_for_skatt(inn, form)),
)
for navn, form in inn.eierformer.items()
former = dict(inn.eierformer)
if rad is Eierrad.ZETA_LIK_EIERANDEL:
former = {navn: replace(form, zeta=form.s) for navn, form in former.items()}
rente = inn["r_stat"] if rad is Eierrad.STATENS_RENTE else None
strommer = {
faktor: eierskap.bedriftsstrom(inn, res, tilleggsregel=True, kostnadsfaktor=faktor)
for faktor in dict.fromkeys(_kostnadsfaktor(inn, navn, rad) for navn in former)
}
ut = {}
for navn, form in former.items():
faktor = _kostnadsfaktor(inn, navn, rad)
ut[navn] = (
eierskap.eierresultat(inn, strommer[faktor], form, rente=rente),
eierskap.lcoc_med_kapitalkostnad(
inn, res, eierskap.krav_for_skatt(inn, form), kostnadsfaktor=faktor
),
)
ved_m6 = eierskap.statens_kontantstrom_ved_m6(inn, res, ut[HELEID][0]) if HELEID in ut else None
return ut, ved_m6
def _kostnadsfaktor(inn: Inndata, navn: str, rad: Eierrad) -> float:
return 1.0 + inn["eps_e"] if rad is Eierrad.EFFEKTIVITET and navn in MED_EFFEKTIVITET else 1.0
def eierformer_paa_trinnet(
@ -1123,13 +1211,15 @@ def eierformer_paa_trinnet(
scenario: Scenario = SCENARIOER[1],
losninger: Sequence[Losning] = DOMSLOSNINGER,
prosesser: int = 1,
rad: Eierrad = Eierrad.HOVED,
) -> dict[Losning, Eierformtabell | None]:
"""The ownership forms for each solution on the step the verdicts are read on.
``eos`` holds the EEA assessment per form, decided outside the model.
The criteria are taken over the draws in which the solution's path can be
built. A solution has no table when its path cannot be built in any draw,
or when there is no step (clarification 98).
or when there is no step (clarification 98). ``rad`` is one of the rows of
the sensitivity list that concern the ownership forms (clarification 122).
"""
if not scenario.teller:
msg = "the ownership forms are compared in «normalisering» on the main path"
@ -1139,7 +1229,7 @@ def eierformer_paa_trinnet(
if valg.trinn is None:
tabeller[losning] = None
continue
en = partial(regn_eierformer, losning=losning, trinn=valg.trinn, scenario=scenario)
en = partial(regn_eierformer, losning=losning, trinn=valg.trinn, scenario=scenario, rad=rad)
if prosesser > 1:
with ProcessPoolExecutor(max_workers=prosesser) as utforer:
alle = list(utforer.map(en, trekninger))
@ -1151,9 +1241,12 @@ def eierformer_paa_trinnet(
continue
kriterier = tuple(
eierskap.eierkriterier(
navn, [u[navn][0] for u in byggbare], [u[navn][1] for u in byggbare]
navn,
[u[navn][0] for u, _ in byggbare],
[u[navn][1] for u, _ in byggbare],
egenkapitalkrav=rad is Eierrad.EGENKAPITALKRAV,
)
for navn in byggbare[0]
for navn in byggbare[0][0]
)
tabeller[losning] = Eierformtabell(
losning=losning,
@ -1161,5 +1254,6 @@ def eierformer_paa_trinnet(
antall_byggbare=len(byggbare),
kriterier=kriterier,
rangering=eierskap.ranger_eierformer(kriterier, eos),
statens_kontantstrom=sidetall([x for _, x in byggbare]),
)
return tabeller

View file

@ -29,7 +29,7 @@ from __future__ import annotations
import enum
import math
from dataclasses import dataclass
from dataclasses import dataclass, replace
from typing import TYPE_CHECKING, Final
import numpy as np
@ -74,10 +74,47 @@ class Knapphet(enum.StrEnum):
OVERKAPASITET = "overkapasitet"
class Paaslagsform(enum.StrEnum):
"""The first line of S43 in «knapphet varer» (lines 12 and 13 of the list, clarification 120).
SCENARIO is S43 as it stands; VARIG has pi_0 for every vintage, and
AVTAKENDE pi_0 exp(-(t_v - 2026) / tau_pi) for every vintage, without the
cut at t_1 + T_g.
"""
SCENARIO = "scenario"
VARIG = "varig knapphet"
AVTAKENDE = "avtakende knapphet"
class Diskontering(enum.StrEnum):
"""The rates the present values of S26 are taken with (line 16, clarification 118 b)."""
MARKED = "markedets renter"
RUNDSKRIV = "rundskrivets rente"
class Skattekostnad(enum.StrEnum):
"""What the tax cost varphi is charged on in S26 (lines 17 and 18, clarification 118 c, d).
SUBSIDIE is the subsidy element SE of the main run; ALL_KAPITAL the present
value of every investment, K_inn; STATENS_RENTE the subsidy element computed
with the state's borrowing rate.
"""
SUBSIDIE = "subsidieelementet"
ALL_KAPITAL = "all innskutt kapital"
STATENS_RENTE = "subsidieelementet med statens lånerente"
@dataclass(frozen=True)
class Dimensjonering:
"""What follows from the parameter values before anything is built.
The fields after ``rho_A`` are the sensitivities of the list that change the
dimensioning or are carried from here to every later computation
(clarifications 118 a, 119 and 121); their defaults are the main run.
Attributes:
E_D: yearly energy to one data centre, MWh (S10).
P_u: unit size of the nuclear plant, MW (S7 in A and B', P_ref in B, zero otherwise).
@ -89,6 +126,15 @@ class Dimensjonering:
P_G_N: reactor capacity one facility needs, MW (text under S22; zero in C and R).
xi_N: overrun factor (S46).
rho_A: required return for the power plant in A.
minstelast: the share in the place of lambda in S7 (line 7, 119 a); None in the main run.
fritt_enhetsvalg: True when P_u is the size with the lowest c_A and the buffer covers
the loss of the largest unit (line 8, 119 b).
gamma_trinn: True when Gamma is the step of the table Gamma_trinn (line 10, 119 c).
tilgjengelighet: the availability A of 119 c when ``gamma_trinn``; None otherwise.
paaslag_kjernekraft: added to rho_N for nuclear plants on the grid (line 4, 118 a).
skaler_K_U: False when K_U is not scaled with the unit size in S6 (line 20, 121).
bare_over_dimensjonerende_feil: True when S47 counts only what the largest new unit
is larger than P_dim,0 (line 21, 121).
"""
E_D: float
@ -101,6 +147,13 @@ class Dimensjonering:
P_G_N: float
xi_N: float
rho_A: float
minstelast: float | None = None
fritt_enhetsvalg: bool = False
gamma_trinn: bool = False
tilgjengelighet: float | None = None
paaslag_kjernekraft: float = 0.0
skaler_K_U: bool = True
bare_over_dimensjonerende_feil: bool = False
@dataclass(frozen=True)
@ -219,6 +272,14 @@ class Fellesstrom:
"""The units' part of S35: sales times ``varsigma`` minus every cost."""
return varsigma * self.salg - self.investering - self.drift - self.avvikling - self.ulykke
def egne(self, varsigma: float) -> Tabell:
"""The units' own terms of S35: sales, investment, operation and decommissioning.
Sales are multiplied by ``varsigma``. Without q_N E, which is discounted with
rho_N also when the nuclear plants have a markup (line 4, clarification 118 a).
"""
return varsigma * self.salg - self.investering - self.drift - self.avvikling
@dataclass(frozen=True)
class Anleggsstrom:
@ -272,14 +333,22 @@ class Anleggsstrom:
I_H=self.I_H,
)
def kraft(self, varsigma: Mapping[str, float], F_a: Tabell) -> Tabell:
"""S35 for this facility, with its share ``F_a`` of the capacity cost."""
def kraft(
self, varsigma: Mapping[str, float], F_a: Tabell, *, utenom: str | None = None
) -> Tabell:
"""S35 for this facility, with its share ``F_a`` of the capacity cost.
``utenom`` leaves one technology's own terms out (sales, investment,
operation, decommissioning), for the nuclear plants with a markup on
their rate (line 4, clarification 118 a); ``kraftverk`` gives them.
"""
null = np.zeros_like(self.inntekt)
med = [i for i in self.salg if i != utenom]
return lg.s35_kontantstrom_kraft(
salg=sum((varsigma[i] * s for i, s in self.salg.items()), null),
investering=sum(self.investering.values(), null),
drift=sum(self.kraftdrift.values(), null),
avvikling=sum(self.avvikling.values(), null),
salg=sum((varsigma[i] * self.salg[i] for i in med), null),
investering=sum((self.investering[i] for i in med), null),
drift=sum((self.kraftdrift[i] for i in med), null),
avvikling=sum((self.avvikling[i] for i in med), null),
ulykke=self.ulykke,
I_nett=self.I_nett,
buffer=self.buffer,
@ -287,6 +356,20 @@ class Anleggsstrom:
F_a=F_a,
)
def kraftverk(self, teknologi: str, varsigma: float) -> Tabell:
"""One technology's own terms of S35: sales, investment, operation and decommissioning.
Sales are multiplied by ``varsigma``; zero when the facility has no such plant.
"""
if teknologi not in self.salg:
return np.zeros_like(self.inntekt)
return (
varsigma * self.salg[teknologi]
- self.investering[teknologi]
- self.kraftdrift[teknologi]
- self.avvikling[teknologi]
)
@dataclass(frozen=True)
class Programresultat:
@ -314,19 +397,27 @@ class Programresultat:
K_prog: the fixed cost of becoming a nuclear country (S41).
V: the value of what the programme displaces in the grid queue.
NV_datasenter: present value of KS_D with rho_D.
NV_kraft: present value of KS_N with rho_N (rho_A in A).
NV_kraft: present value of KS_N with rho_N (rho_A in A); the nuclear plants' own
terms with rho_N plus the markup of line 4 when that is set.
NV_ovrige: present value with rho_N of Delta W - utslipp - K_prog - V.
RV_anlegg: residual value per facility (S40).
RV_felles: the decommissioning after the final year of the programme's units (B), as a
negative present value.
RV: their sum.
SE: the subsidy element.
SE: the subsidy element (S26, clarification 39). With the circular's rate (line 16)
the four figures above and this one are taken with D_R (clarification 118 b).
NNV: net present value for Norway (S26).
P_enhet: MW IT per facility: P_IT, and P_m per module in solution T.
mu_d: the factor of S51 per vintage (exactly one on the main path), times the price
factor of clarification 105 when that is set; ``mu_d.andel`` is S51 alone.
full_fortrengning: True in the sensitivity "full displacement in the first stage"
(chapter 17.8): delta_V is one for the modules of the first stage.
diskontering: the rates of the present values in S26 (line 16, clarification 118 b).
skattekostnad: what varphi is charged on in S26 (lines 17 and 18, 118 c and d).
K_inn: the present value of every investment of S34 and S35, each discounted as the
term it stands in (118 c); only with ``Skattekostnad.ALL_KAPITAL``, else None.
SE_stat: the subsidy element with the state's borrowing rate (118 d); only with
``Skattekostnad.STATENS_RENTE``, else None.
"""
losning: Losning
@ -358,6 +449,19 @@ class Programresultat:
P_enhet: float
mu_d: Etterspoersel
full_fortrengning: bool = False
diskontering: Diskontering = Diskontering.MARKED
skattekostnad: Skattekostnad = Skattekostnad.SUBSIDIE
K_inn: float | None = None
SE_stat: float | None = None
@property
def skattegrunnlag(self) -> float:
"""What the tax cost varphi is charged on in the net present value: SE, K_inn or SE_stat."""
if self.skattekostnad is Skattekostnad.ALL_KAPITAL and self.K_inn is not None:
return self.K_inn
if self.skattekostnad is Skattekostnad.STATENS_RENTE and self.SE_stat is not None:
return self.SE_stat
return self.SE
def paa_felles_kjernekraft(self, k: int) -> bool:
"""True when facility or module ``k`` (0 is the first) runs on the programme's units."""
@ -439,29 +543,231 @@ def investering_per_enhet(
]
def dimensjoner(inn: Inndata, losning: Losning, *, rho_A: float | None = None) -> Dimensjonering:
SMAA_ENHETER: Final = frozenset({Losning.A, Losning.B_MERKET})
"""The solutions whose unit size follows S7 (lines 7, 8 and 20 of the list apply to them)."""
KJERNEKRAFT_PAA_NETT: Final = frozenset({Losning.B, Losning.B_MERKET, Losning.T_K})
"""The solutions with nuclear plants on the grid (lines 4 and 21 of the list apply to them)."""
_BRYTERNE_GJELDER: Final = {
"minstelast": SMAA_ENHETER,
"fritt_enhetsvalg": SMAA_ENHETER,
"gamma_trinn": frozenset({Losning.A}),
"paaslag_kjernekraft": KJERNEKRAFT_PAA_NETT,
"skaler_K_U": SMAA_ENHETER,
"bare_over_dimensjonerende_feil": KJERNEKRAFT_PAA_NETT,
}
"""The solutions each switch of ``dimensjoner`` applies to (clarifications 117 to 121)."""
def _reserve(inn: Inndata, P_u: float, m: int) -> tuple[int, int, int]:
"""S8 with the design values (clarification 4): r, n_p and N_u for units of ``P_u``."""
design = inn.design["o_f_liten" if _liten(P_u) else "o_f_stor"]
r = lg.s8_reserveenheter(
m=m,
o_merket=lg.s8_uavhengig_utfallsrate(beta_F=inn.design["beta_F"], o_f_A=design),
A_krav=inn["A_krav"],
)
n_p = lg.s8_planlagt_ute(m=m, r=r, o_p=inn.design["o_p"])
return r, n_p, lg.s8_antall_enheter(m=m, r=r, n_p=n_p)
def bufferstorrelse(inn: Inndata, dim: Dimensjonering) -> float:
"""P_buf of S36, MW: delta_L PUE P_IT, and max(delta_L PUE P_IT, P_u) with line 8 (119 b).
Every place P_buf stands uses this (the cash flow, S9, S31 and the business
cash flow).
"""
P_buf = lg.s36_buffer(delta_L=inn["delta_L"], PUE=inn["PUE"], P_IT=inn["P_IT"])
return max(P_buf, dim.P_u) if dim.fritt_enhetsvalg else P_buf
def rente_kjernekraft(inn: Inndata, dim: Dimensjonering) -> float:
"""The required return for nuclear plants on the grid: rho_N, plus the markup of line 4 (118 a).
Exactly rho_N in the main run.
"""
return inn["rho_N"] + dim.paaslag_kjernekraft
def kraftkostnad_dedikert(
inn: Inndata, dim: Dimensjonering, k: int, rho_A: float, *, kostnadsfaktor: float = 1.0
) -> float:
"""S9 for facility ``k`` (0 is the first) in A, kr per MWh delivered to the data centre.
``kostnadsfaktor`` multiplies every cost but the accident cost: the
efficiency of an ownership form (line 28, clarification 122). It is
exactly one in every other computation.
"""
f = kostnadsfaktor
numre = enhetsnumre(dim, k + 1)
return lg.s9_kraftkostnad_dedikert(
I_N=[f * i for i in investering_per_enhet(inn, dim, P_u=dim.P_u, numre=numre, rho=rho_A)],
rho_A=rho_A,
L_N=inn["L_N"],
f_N_enhet=f
* lg.s5_fast_drift(f_N=inn["f_N"], P_u=dim.P_u, P_ref=inn["P_ref"], nu_f=inn["nu_f"]),
D_avv=f * inn["D_avv"],
P_u=dim.P_u,
P_buf=bufferstorrelse(inn, dim),
c_buf=f * inn["c_buf"],
f_buf=f * inn["f_buf"],
L_buf=inn["L_buf"],
I_g_aar=f
* lg.s36_ekstern_forsyning(
D_linje=inn["D_linje"],
c_linje=inn["c_linje"],
s_g=inn["s_g"],
N_u=dim.N_u,
P_u=dim.P_u,
c_gen=inn["c_gen"],
rho_A=rho_A,
L_nett=inn["L_nett"],
L_buf=inn["L_buf"],
),
E_D=dim.E_D,
v_N=f * inn["v_N"],
u_N_A=f * brenselkostnad(inn, dim.P_u),
d_N=f * inn["d_N"],
q_N=lg.s6_ulykkeskostnad(
N_u=dim.N_u,
phi_U=inn["phi_U"],
K_U=inn["K_U"],
D_fors=inn["D_fors"],
P_u=dim.P_u,
P_ref=inn["P_ref"],
E=dim.E_D,
skaler_med_enhet=dim.skaler_K_U,
),
)
def billigste_enhetsstorrelse(
inn: Inndata, *, rho_A: float, skaler_K_U: bool = True
) -> tuple[float, dict[float, float]]:
"""Clarification 119 b (line 8): the unit size in the set with the lowest c_A.
For every size P: m, r, n_p and N_u by S7 and S8 for that size, the buffer
max(delta_L PUE P_IT, P), I_g by S36, and c_A by S9 for the first facility
of the programme (units 1 .. N_u), with the draw's values and ``rho_A``.
Returns the size with the lowest c_A, the smallest on a tie, and c_A per size.
"""
E_D = lg.s10_energi_datasenter(lam=inn["lambda"], PUE=inn["PUE"], P_IT=inn["P_IT"])
xi_N = lg.s46_overskridelsesfaktor(u_xi=inn["u_xi"], w_xi=inn["w_xi"], o_xi=inn["o_xi"])
c_A: dict[float, float] = {}
for P in sorted(inn.P_u_sett):
m = lg.s7_enheter_som_maa_gaa(PUE=inn["PUE"], P_IT=inn["P_IT"], P_u=P)
r, n_p, N_u = _reserve(inn, P, m)
dim = Dimensjonering(
E_D=E_D,
P_u=P,
m=m,
r=r,
n_p=n_p,
N_u=N_u,
Gamma=1.0,
P_G_N=N_u * P,
xi_N=xi_N,
rho_A=rho_A,
fritt_enhetsvalg=True,
skaler_K_U=skaler_K_U,
)
c_A[P] = kraftkostnad_dedikert(inn, dim, 0, rho_A)
billigst = min(c_A, key=lambda P: (c_A[P], P))
return billigst, c_A
def _sjekk_brytere(losning: Losning, valgt: Mapping[str, bool]) -> None:
"""A switch of ``dimensjoner`` is only allowed for the solutions its line applies to."""
for navn, er_valgt in valgt.items():
if er_valgt and losning not in _BRYTERNE_GJELDER[navn]:
gjelder = ", ".join(sorted(a.value for a in _BRYTERNE_GJELDER[navn]))
msg = f"{navn} applies to {gjelder} only, not to {losning.value}"
raise ValueError(msg)
def dimensjoner(
inn: Inndata,
losning: Losning,
*,
rho_A: float | None = None,
minstelast: float | None = None,
fritt_enhetsvalg: bool = False,
gamma_trinn: bool = False,
paaslag_kjernekraft: float = 0.0,
skaler_K_U: bool = True,
bare_over_dimensjonerende_feil: bool = False,
) -> Dimensjonering:
"""S7, S8, S10, S44 and S46 for one set of values.
``rho_A`` is the required return for the power plant in A; the main run
uses rho_D (clarification 8), and rho_N is a sensitivity. In solution T
everything is per module, with P_m in place of P_IT (chapter 17.1).
The other keywords are lines of the sensitivity list; their defaults are
the main run, and each is only allowed for the solutions its line applies
to (ValueError otherwise):
- ``minstelast`` (line 7, clarification 119 a; A and B'): the share that
stands in the place of lambda in S7, 0.20 in the list. lambda is
unchanged everywhere else.
- ``fritt_enhetsvalg`` (line 8, 119 b; A and B'): P_u is the size with the
lowest c_A (``billigste_enhetsstorrelse``), and the buffer is
max(delta_L PUE P_IT, P_u) wherever P_buf stands. B' gets the same units
as A and no buffer.
- ``gamma_trinn`` (line 10, 119 c; A): Gamma is the step of the table
Gamma_trinn for the probability that at least m units run.
- ``paaslag_kjernekraft`` (line 4, 118 a; B, B' and T-K): the required
return for nuclear plants on the grid is rho_N plus this, at the places
118 a lists (``rente_kjernekraft``).
- ``skaler_K_U=False`` (line 20, 121; A and B'): K_U without the factor for
unit size in S6.
- ``bare_over_dimensjonerende_feil`` (line 21, 121; B, B' and T-K): S47
counts only what the largest new unit is larger than P_dim,0.
The choices are kept on the result, and every later computation reads them
from there.
"""
_sjekk_brytere(
losning,
{
"minstelast": minstelast is not None,
"fritt_enhetsvalg": fritt_enhetsvalg,
"gamma_trinn": gamma_trinn,
"paaslag_kjernekraft": paaslag_kjernekraft != 0.0,
"skaler_K_U": not skaler_K_U,
"bare_over_dimensjonerende_feil": bare_over_dimensjonerende_feil,
},
)
if minstelast is not None and fritt_enhetsvalg:
msg = "lines 7 and 8 are two rows: the minimum load and the free choice are not combined"
raise ValueError(msg)
rho_A = inn["rho_D"] if rho_A is None else rho_A
P_u, m, r, n_p, N_u, Gamma, P_G_N = 0.0, 0, 0, 0, 0, 1.0, 0.0
tilgjengelighet = None
P_IT = inn["P_m"] if losning.trinnvis else inn["P_IT"]
if losning in {Losning.A, Losning.B_MERKET}:
P_u, m = lg.s7_enhetsstorrelse(
P_sett=inn.P_u_sett, chi=inn["chi"], lam=inn["lambda"], PUE=inn["PUE"], P_IT=inn["P_IT"]
)
design = inn.design["o_f_liten" if _liten(P_u) else "o_f_stor"]
r = lg.s8_reserveenheter(
m=m,
o_merket=lg.s8_uavhengig_utfallsrate(beta_F=inn.design["beta_F"], o_f_A=design),
A_krav=inn["A_krav"],
)
n_p = lg.s8_planlagt_ute(m=m, r=r, o_p=inn.design["o_p"])
N_u = lg.s8_antall_enheter(m=m, r=r, n_p=n_p)
if losning in SMAA_ENHETER:
if fritt_enhetsvalg:
P_u, _ = billigste_enhetsstorrelse(inn, rho_A=rho_A, skaler_K_U=skaler_K_U)
m = lg.s7_enheter_som_maa_gaa(PUE=inn["PUE"], P_IT=inn["P_IT"], P_u=P_u)
else:
P_u, m = lg.s7_enhetsstorrelse(
P_sett=inn.P_u_sett,
chi=inn["chi"],
lam=inn["lambda"] if minstelast is None else minstelast,
PUE=inn["PUE"],
P_IT=inn["P_IT"],
)
r, n_p, N_u = _reserve(inn, P_u, m)
P_G_N = N_u * P_u
if losning is Losning.A:
if losning is Losning.A and gamma_trinn:
tilgjengelighet = lg.s44_tilgjengelighet(
m=m, r=r, o_f_A=_utfallsrate(inn, P_u), beta_F=inn["beta_F"]
)
Gamma = lg.s44_inntektsfaktor_trinn(
tilgjengelighet=tilgjengelighet, A_krav=inn["A_krav"], tabell=inn.Gamma_trinn
)
elif losning is Losning.A:
Gamma = lg.s44_inntektsfaktor(
m=m, r=r, o_f_A=_utfallsrate(inn, P_u), beta_F=inn["beta_F"]
)
@ -480,7 +786,14 @@ def dimensjoner(inn: Inndata, losning: Losning, *, rho_A: float | None = None) -
Gamma=Gamma,
P_G_N=P_G_N,
xi_N=lg.s46_overskridelsesfaktor(u_xi=inn["u_xi"], w_xi=inn["w_xi"], o_xi=inn["o_xi"]),
rho_A=inn["rho_D"] if rho_A is None else rho_A,
rho_A=rho_A,
minstelast=minstelast,
fritt_enhetsvalg=fritt_enhetsvalg,
gamma_trinn=gamma_trinn,
tilgjengelighet=tilgjengelighet,
paaslag_kjernekraft=paaslag_kjernekraft,
skaler_K_U=skaler_K_U,
bare_over_dimensjonerende_feil=bare_over_dimensjonerende_feil,
)
@ -721,6 +1034,7 @@ def _kjernekraftverk(
P_u=P_u,
P_ref=inn["P_ref"],
E=1.0,
skaler_med_enhet=dim.skaler_K_U,
)
return Kraftverk(
teknologi=KJERNEKRAFT,
@ -906,11 +1220,14 @@ class Regnekraftpris:
inn: the set of values.
paaslag_g: the scarcity markup of the price scenario while it lasts (S43).
siste: the first vintage year without the markup, t_1 + T_g.
form: the first line of S43 (clarification 120): as it stands, or the lasting or
the falling markup of lines 12 and 13, which have no cut at ``siste``.
"""
inn: Inndata
paaslag_g: float
siste: float
form: Paaslagsform = Paaslagsform.SCENARIO
def lcoc_v(self, t_v: int) -> float:
"""S15 for the competitor: LCOC^v(t_v), kr per MW IT and year."""
@ -930,7 +1247,15 @@ class Regnekraftpris:
)
def paaslag(self, t_v: int) -> float:
"""S43: pi_g(t_v), the markup for a vintage that enters operation in ``t_v``."""
"""S43: pi_g(t_v), the markup for a vintage that enters operation in ``t_v``.
With line 12 it is pi_0 for every vintage, with line 13
pi_0 exp(-(t_v - 2026) / tau_pi), with the draw's tau_pi (clarification 120).
"""
if self.form is Paaslagsform.VARIG:
return self.paaslag_g
if self.form is Paaslagsform.AVTAKENDE:
return lg.s43_avtakende_paaslag(pi_0=self.paaslag_g, t_v=t_v, tau_pi=self.inn["tau_pi"])
return self.paaslag_g if t_v < self.siste else 0.0
def __call__(self, t_v: int) -> float:
@ -938,8 +1263,34 @@ class Regnekraftpris:
return lg.s18_pris(LCOC_v=self.lcoc_v(t_v), pi_g=self.paaslag(t_v))
def regnekraftpris(inn: Inndata, knapphet: Knapphet, t_1: int) -> Regnekraftpris:
"""S18 with S15 for the competitor and S43: the price y(t_v) per MW IT and year, kr."""
def med_paaslagsform(
y: Regnekraftpris, knapphet: Knapphet, paaslag: Paaslagsform
) -> Regnekraftpris:
"""The same price with another first line of S43 (lines 12 and 13, clarification 120).
The lasting and the falling markup replace the first line of S43, so they
are only defined in «knapphet varer».
"""
if paaslag is not Paaslagsform.SCENARIO and knapphet is not Knapphet.VARER:
msg = f"the {paaslag.value} replaces the first line of S43 and needs «knapphet varer»"
raise ValueError(msg)
return replace(y, form=paaslag)
def regnekraftpris(
inn: Inndata,
knapphet: Knapphet,
t_1: int,
*,
form: Paaslagsform = Paaslagsform.SCENARIO,
) -> Regnekraftpris:
"""S18 with S15 for the competitor and S43: the price y(t_v) per MW IT and year, kr.
``form`` is the first line of S43 (lines 12 and 13 of the sensitivity
list, only with ``Knapphet.VARER``).
"""
if form is not Paaslagsform.SCENARIO:
return med_paaslagsform(regnekraftpris(inn, knapphet, t_1), knapphet, form)
uten = Regnekraftpris(inn=inn, paaslag_g=0.0, siste=t_1)
paaslag = {
Knapphet.VARER: lg.s43_knapphetspaaslag(
@ -1020,6 +1371,11 @@ class _Program:
T_s: int
full_fortrengning: bool = False
@property
def rho_K(self) -> float:
"""The required return for nuclear plants on the grid (exactly rho_N in the main run)."""
return rente_kjernekraft(self.inn, self.dim)
@property
def antall_aar(self) -> int:
return self.T_s - self.T_0 + 1
@ -1097,6 +1453,13 @@ class _Program:
dtype=np.float64,
)
def diskontering_rundskriv(self) -> Tabell:
"""D_R(t - T_0) for every year (line 16, clarification 118 b)."""
return np.array(
[lg.s26_diskontering_rundskriv(j=t - self.T_0) for t in self._aar()],
dtype=np.float64,
)
def _aar(self) -> range:
return range(self.T_0, self.T_s + 1)
@ -1185,6 +1548,18 @@ def _kraftsystem_per_aar(p: _Program) -> tuple[Kraftaar, ...]:
return tuple(rader)
def utfall_i_s47(inn: Inndata, dim: Dimensjonering, rad: Kraftaar) -> float:
"""Delta R^-1 as S47 uses it: S24, or with line 21 only what exceeds P_dim,0 (121).
M4 does not use this; it keeps the whole unit (presisering 4).
"""
if not dim.bare_over_dimensjonerende_feil:
return rad.Delta_R_utfall
return lg.s47_utfall_ut_over_dimensjonerende_feil(
Delta_R=rad.Delta_R, storste_enhet=rad.storste_enhet, P_dim0=inn["P_dim0"]
)
def _effektkostnad(p: _Program, kraftaar: Sequence[Kraftaar]) -> Tabell:
"""S47 per year for the programme (clarification 13). Zero in A.
@ -1200,7 +1575,7 @@ def _effektkostnad(p: _Program, kraftaar: Sequence[Kraftaar]) -> Tabell:
rad = kraftaar[t - p.T_0]
F_a[t - p.T_0] = lg.s47_effektkostnad(
Delta_R=rad.Delta_R,
Delta_R_utfall=rad.Delta_R_utfall,
Delta_R_utfall=utfall_i_s47(p.inn, p.dim, rad),
c_fast=p.inn["c_fast"],
c_res=p.inn["c_res"],
h_knapp=p.inn["h_knapp"],
@ -1365,7 +1740,7 @@ def _nett_buffer_og_forsyning(
uttak = (1.0 - p.delta_V(k)) * inn["PUE"] * p.P_enhet
betal(I_nett, NETT, inn["I_nett"] * (uttak + p.reaktoreffekt(k)), L_nett)
return I_nett, buffer, I_g
P_buf = lg.s36_buffer(delta_L=inn["delta_L"], PUE=inn["PUE"], P_IT=inn["P_IT"])
P_buf = bufferstorrelse(inn, dim)
betal(buffer, BUFFER, P_buf * inn["c_buf"], L_buf)
for t in p.driftsaar(k):
buffer[t - p.T_0] += inn["f_buf"] * P_buf
@ -1431,7 +1806,9 @@ def _tilleggsfaktor(
has operating years left, its own part of the residual value: per facility
for the facilities' own plants, per group of units for the programme's.
"""
D_N = p.diskontering(p.inn["rho_N"])
# nuclear plants on the grid have their own rate with line 4 (clarification 118 a)
rho = p.rho_K if teknologi == KJERNEKRAFT else p.inn["rho_N"]
D_N = p.diskontering(rho)
# per plant: sales, costs, decommissioning after the final year, operating years left
verk = [
(
@ -1459,7 +1836,7 @@ def _tilleggsfaktor(
NK_snitt=varsigma * snitt_salg - snitt_kostnad,
L_rest=L_rest,
rho_D=p.inn["rho_D"],
rho_avvikling=p.inn["rho_N"],
rho_avvikling=rho,
avvikling=avvikling,
T_s=p.T_s,
T_0=p.T_0,
@ -1499,14 +1876,29 @@ def _ovrige_virkninger(
return Delta_W, utslipp, K_prog, V
def _restverdier(
@dataclass(frozen=True)
class _Restgrunnlag:
"""What S40 is computed from, before any rate is chosen.
Attributes:
anlegg: per facility, the average net cash flow over the window, the operating years
left and the decommissioning after the final year.
felles: per group of the programme's units, the operating years left and the
decommissioning after the final year.
"""
anlegg: tuple[tuple[float, int, float], ...]
felles: tuple[tuple[int, float], ...]
def _restgrunnlag(
p: _Program,
anlegg: Sequence[Anleggsstrom],
felles: Sequence[Fellesstrom],
varsigma: Mapping[str, float],
F_a: Tabell,
) -> tuple[tuple[float, ...], float]:
"""S40: the residual value per facility, and the decommissioning of the programme's units.
) -> _Restgrunnlag:
"""The averages and the decommissioning S40 is computed from, per facility and group of units.
A facility's cash flow holds its share of the capacity cost, shared by
energy use (clarification 13): equally among the facilities that use power
@ -1529,35 +1921,207 @@ def _restverdier(
med_last = np.array([max(1, p.plan.antall_med_last(t)) for t in aar], dtype=np.float64)
i_drift = np.maximum(1.0, sum(paa_felles, p.null()))
kjernekraft = sum((f.netto(varsigma[KJERNEKRAFT]) for f in felles), p.null())
rho_avvikling = p.inn["rho_N"] if p.losning.paa_nett else p.dim.rho_A
verdier = []
per_anlegg = []
for k, a in enumerate(anlegg):
last = np.array([1.0 if p.plan.har_last(k, t) else 0.0 for t in aar], dtype=np.float64)
netto = a.datasenter() + a.kraft(varsigma, F_a * last / med_last)
verdier.append(
lg.s40_restverdi(
NK_snitt=p.vindu(netto + kjernekraft * paa_felles[k] / i_drift),
L_rest=a.L_rest,
rho_D=p.inn["rho_D"],
rho_avvikling=rho_avvikling,
avvikling=math.fsum(a.avvikling_etter.values()),
T_s=p.T_s,
T_0=p.T_0,
per_anlegg.append(
(
p.vindu(netto + kjernekraft * paa_felles[k] / i_drift),
a.L_rest,
math.fsum(a.avvikling_etter.values()),
)
)
avvikling_felles = math.fsum(
lg.s40_restverdi(
NK_snitt=0.0,
L_rest=f.L_rest,
rho_D=p.inn["rho_D"],
rho_avvikling=p.inn["rho_N"],
avvikling=f.avvikling_etter,
return _Restgrunnlag(
anlegg=tuple(per_anlegg), felles=tuple((f.L_rest, f.avvikling_etter) for f in felles)
)
def _restverdier(
p: _Program,
grunnlag: _Restgrunnlag,
*,
rho_D: float,
rho_avvikling: float,
rho_avvikling_felles: float,
rundskriv: bool = False,
) -> tuple[tuple[float, ...], float]:
"""S40: the residual value per facility, and the decommissioning of the programme's units.
``rho_D`` discounts the value and brings it back to T_0, ``rho_avvikling``
the decommissioning of a facility's own plants and ``rho_avvikling_felles``
that of the programme's units. ``rundskriv=True`` is S40 with the
circular's rate instead (line 16, clarification 118 b), and the rates are
then not used.
"""
def restverdi(NK_snitt: float, L_rest: int, avvikling: float, rho_avv: float) -> float:
if rundskriv:
return lg.s40_restverdi_rundskriv(
NK_snitt=NK_snitt, L_rest=L_rest, avvikling=avvikling, T_s=p.T_s, T_0=p.T_0
)
return lg.s40_restverdi(
NK_snitt=NK_snitt,
L_rest=L_rest,
rho_D=rho_D,
rho_avvikling=rho_avv,
avvikling=avvikling,
T_s=p.T_s,
T_0=p.T_0,
)
for f in felles
verdier = tuple(
restverdi(NK_snitt, L_rest, avvikling, rho_avvikling)
for NK_snitt, L_rest, avvikling in grunnlag.anlegg
)
avvikling_felles = math.fsum(
restverdi(0.0, L_rest, avvikling, rho_avvikling_felles)
for L_rest, avvikling in grunnlag.felles
)
return verdier, avvikling_felles
def _betalt_for(p: _Program, eiendeler: Sequence[Eiendel], slag: frozenset[str]) -> Tabell:
"""What is paid per year for the assets of the kinds in ``slag``, as the cash flow pays it."""
tabell = p.null()
for e in eiendeler:
if e.slag in slag:
_spre(p, tabell, forste_driftsaar=e.start, belop=e.kostnad, tau=e.byggetid)
return tabell
def _innskutt_kapital(
p: _Program,
anlegg: Sequence[Anleggsstrom],
felles: Sequence[Fellesstrom],
*,
D_D: Tabell,
D_kraft: Tabell,
D_K: Tabell,
) -> float:
"""Clarification 118 c: K_inn, the present value of every investment in S34 and S35.
I_bygg and I_H (S34) with ``D_D``; the power plants, grid connection,
buffer and external supply (S35) with ``D_kraft`` (D_N on the grid, rho_A
in A), the nuclear plants with ``D_K``: each as the term it stands in.
Renewals count; decommissioning is not an investment.
"""
datasenter = p.null()
kraft = p.null()
kjerne = sum((f.investering for f in felles), p.null())
for a in anlegg:
datasenter += a.I_bygg + a.I_H
for i, investering in a.investering.items():
if i == KJERNEKRAFT:
kjerne += investering
else:
kraft += investering
kraft += a.I_nett + _betalt_for(p, a.eiendeler, frozenset({BUFFER})) + a.I_g
return math.fsum(
(_naaverdi(D_D, datasenter), _naaverdi(D_kraft, kraft), _naaverdi(D_K, kjerne))
)
@dataclass(frozen=True)
class _Naaverdier:
"""The present values of S26 for one path, and what varphi is charged on."""
NV_datasenter: float
NV_kraft: float
NV_ovrige: float
RV_anlegg: tuple[float, ...]
RV_felles: float
RV: float
SE: float
K_inn: float | None
SE_stat: float | None
skattegrunnlag: float
def _s26(
p: _Program,
anlegg: Sequence[Anleggsstrom],
felles: Sequence[Fellesstrom],
varsigma: Mapping[str, float],
F_a: Tabell,
*,
KS_D: Tabell,
KS_N: Tabell,
ovrige: Tabell,
diskontering: Diskontering,
skattekostnad: Skattekostnad,
) -> _Naaverdier:
"""The present values, S40 and the subsidy element of S26 (clarifications 36, 39, 118).
KS_D with rho_D, KS_N with rho_N (rho_A in A) and the other effects with
rho_N. With the markup of line 4 the nuclear plants' own terms of S35 are
discounted with their own rate, and q_N E, the grid and F_a still with
rho_N. With the circular's rate every term is discounted with D_R.
"""
inn, losning, dim = p.inn, p.losning, p.dim
rundskriv = diskontering is Diskontering.RUNDSKRIV
rho_kraft = inn["rho_N"] if losning.paa_nett else dim.rho_A
if rundskriv:
D_D = D_kraft = D_K = D_ovrige = p.diskontering_rundskriv()
else:
D_D, D_kraft = p.diskontering(inn["rho_D"]), p.diskontering(rho_kraft)
D_ovrige = p.diskontering(inn["rho_N"])
markup = losning.paa_nett and dim.paaslag_kjernekraft != 0.0
D_K = p.diskontering(p.rho_K) if markup else D_kraft
NV_datasenter = _naaverdi(D_D, KS_D)
if D_K is D_kraft:
NV_kraft = _naaverdi(D_kraft, KS_N)
else:
# line 4: the nuclear plants' own terms with their own rate, the rest with rho_N (118 a)
kjerne = sum(
(a.kraftverk(KJERNEKRAFT, varsigma.get(KJERNEKRAFT, 1.0)) for a in anlegg), p.null()
)
kjerne += sum((f.egne(varsigma[KJERNEKRAFT]) for f in felles), p.null())
resten = sum((a.kraft(varsigma, p.null(), utenom=KJERNEKRAFT) for a in anlegg), p.null())
resten -= F_a + sum((f.ulykke for f in felles), p.null())
NV_kraft = _naaverdi(D_K, kjerne) + _naaverdi(D_kraft, resten)
NV_ovrige = _naaverdi(D_ovrige, ovrige)
grunnlag = _restgrunnlag(p, anlegg, felles, varsigma, F_a)
RV_anlegg, RV_felles = _restverdier(
p,
grunnlag,
rho_D=inn["rho_D"],
rho_avvikling=p.rho_K if losning.paa_nett else dim.rho_A,
rho_avvikling_felles=p.rho_K,
rundskriv=rundskriv,
)
RV = math.fsum(RV_anlegg) + RV_felles
SE = lg.s26_subsidieelement(naaverdi_prosjekt=NV_datasenter + NV_kraft + RV)
K_inn = SE_stat = None
skattegrunnlag = SE
if skattekostnad is Skattekostnad.ALL_KAPITAL:
K_inn = _innskutt_kapital(p, anlegg, felles, D_D=D_D, D_kraft=D_kraft, D_K=D_K)
skattegrunnlag = K_inn
elif skattekostnad is Skattekostnad.STATENS_RENTE:
r_stat = inn["r_stat"]
D_stat = p.diskontering(r_stat)
RV_stat_anlegg, RV_stat_felles = _restverdier(
p, grunnlag, rho_D=r_stat, rho_avvikling=r_stat, rho_avvikling_felles=r_stat
)
SE_stat = lg.s26_subsidieelement(
naaverdi_prosjekt=_naaverdi(D_stat, KS_D)
+ _naaverdi(D_stat, KS_N)
+ math.fsum(RV_stat_anlegg)
+ RV_stat_felles
)
skattegrunnlag = SE_stat
return _Naaverdier(
NV_datasenter=NV_datasenter,
NV_kraft=NV_kraft,
NV_ovrige=NV_ovrige,
RV_anlegg=RV_anlegg,
RV_felles=RV_felles,
RV=RV,
SE=SE,
K_inn=K_inn,
SE_stat=SE_stat,
skattegrunnlag=skattegrunnlag,
)
return tuple(verdier), avvikling_felles
def regn_program(
@ -1571,6 +2135,9 @@ def regn_program(
bortfall: Callable[[int], float] | None = None,
full_fortrengning_i_forste_trinn: bool = False,
prisfaktor: float = 1.0,
paaslag: Paaslagsform = Paaslagsform.SCENARIO,
diskontering: Diskontering = Diskontering.MARKED,
skattekostnad: Skattekostnad = Skattekostnad.SUBSIDIE,
) -> Programresultat:
"""S26 for one path: the yearly cash flows and the net present value for Norway.
@ -1594,6 +2161,22 @@ def regn_program(
the share of capacity sold stands together with the price (the price
threshold of chapter 3.2, clarification 105). The scarcity markup of S43,
the build-out and the costs are as without it.
Three lines of the sensitivity list are switches here; the defaults are the
main run:
- ``paaslag`` (lines 12 and 13, clarification 120): the lasting or the
falling scarcity markup in place of the first line of S43, only with
``Knapphet.VARER``. The price in the result carries it, so the levelised
cost, scale and ownership follow.
- ``diskontering=Diskontering.RUNDSKRIV`` (line 16, 118 b): every present
value in S26 with the circular's D_R, also inside SE and in S40, where the
amounts after the final year are discounted from the year they fall. S45
and everything outside S26 keep the market's rates.
- ``skattekostnad`` (lines 17 and 18, 118 c and d): varphi on K_inn, the
present value of every investment, or on SE computed with the state's
borrowing rate. ``SE`` in the result is the main run's either way, and
the figure varphi is charged on is ``skattegrunnlag``.
"""
if prisfaktor < 0:
msg = f"the price factor cannot be negative, got {prisfaktor}"
@ -1608,6 +2191,9 @@ def regn_program(
msg = "only solution T has a first stage, so only it has the sensitivity for it"
raise ValueError(msg)
dim = dimensjoner(inn, losning) if dim is None else dim
y = regnekraftpris(inn, knapphet, plan.t_1)
if paaslag is not Paaslagsform.SCENARIO:
y = med_paaslagsform(y, knapphet, paaslag)
p = _Program(
inn=inn,
losning=losning,
@ -1615,7 +2201,7 @@ def regn_program(
plan=plan,
verk=kraftverk_per_anlegg(inn, losning, dim, plan),
felles=enheter_i_B(inn, dim, plan, losning=losning),
y=regnekraftpris(inn, knapphet, plan.t_1),
y=y,
mu_d=Etterspoersel(eps_d=inn["eps_d"], d=bortfall, k=prisfaktor),
T_0=plan.T_0,
T_s=plan.T_s,
@ -1635,13 +2221,18 @@ def regn_program(
KS_N = sum((a.kraft(varsigma, p.null()) for a in anlegg), p.null()) - F_a
KS_N += sum((f.netto(varsigma[KJERNEKRAFT]) for f in felles), p.null())
Delta_W, utslipp, K_prog, V = _ovrige_virkninger(p, kraftaar, anlegg)
rho_kraft = inn["rho_N"] if losning.paa_nett else dim.rho_A
NV_datasenter = _naaverdi(p.diskontering(inn["rho_D"]), KS_D)
NV_kraft = _naaverdi(p.diskontering(rho_kraft), KS_N)
NV_ovrige = _naaverdi(p.diskontering(inn["rho_N"]), Delta_W - utslipp - K_prog - V)
RV_anlegg, RV_felles = _restverdier(p, anlegg, felles, varsigma, F_a)
RV = math.fsum(RV_anlegg) + RV_felles
SE = lg.s26_subsidieelement(naaverdi_prosjekt=NV_datasenter + NV_kraft + RV)
nv = _s26(
p,
anlegg,
felles,
varsigma,
F_a,
KS_D=KS_D,
KS_N=KS_N,
ovrige=Delta_W - utslipp - K_prog - V,
diskontering=diskontering,
skattekostnad=skattekostnad,
)
return Programresultat(
losning=losning,
knapphet=knapphet,
@ -1661,22 +2252,26 @@ def regn_program(
utslipp=utslipp,
K_prog=K_prog,
V=V,
NV_datasenter=NV_datasenter,
NV_kraft=NV_kraft,
NV_ovrige=NV_ovrige,
RV_anlegg=RV_anlegg,
RV_felles=RV_felles,
RV=RV,
SE=SE,
NV_datasenter=nv.NV_datasenter,
NV_kraft=nv.NV_kraft,
NV_ovrige=nv.NV_ovrige,
RV_anlegg=nv.RV_anlegg,
RV_felles=nv.RV_felles,
RV=nv.RV,
SE=nv.SE,
NNV=lg.s26_netto_naaverdi(
NV_datasenter=NV_datasenter,
NV_kraft=NV_kraft,
NV_ovrige=NV_ovrige,
NV_datasenter=nv.NV_datasenter,
NV_kraft=nv.NV_kraft,
NV_ovrige=nv.NV_ovrige,
varphi=inn["varphi"],
SE=SE,
RV=RV,
SE=nv.skattegrunnlag,
RV=nv.RV,
),
P_enhet=p.P_enhet,
mu_d=p.mu_d,
full_fortrengning=p.full_fortrengning,
diskontering=diskontering,
skattekostnad=skattekostnad,
K_inn=nv.K_inn,
SE_stat=nv.SE_stat,
)

View file

@ -32,6 +32,8 @@ class Kraftaar:
Delta_p: the price change for Norway in a normal year, kr/MWh.
Delta_R: the capacity balance in the scarcest hour against the zero alternative, MW (S24).
Delta_R_utfall: the same with the largest new unit out, MW.
storste_enhet: the largest new unit, max_i kappa_i P_u,i, MW (zero without nuclear power
on the grid); S47 needs it for line 21 of the sensitivity list (clarification 121).
"""
Delta_Q: float
@ -40,6 +42,7 @@ class Kraftaar:
Delta_p: float
Delta_R: float
Delta_R_utfall: float
storste_enhet: float = 0.0
def velferd(self, *, S_0: float) -> float:
"""S25: Delta W, the change in Norway's income from trade in power, kr per year."""
@ -87,6 +90,7 @@ def kraftaar(
Delta_p=Delta_p,
Delta_R=Delta_R,
Delta_R_utfall=Delta_R_utfall,
storste_enhet=storste_enhet,
)

View file

@ -64,6 +64,22 @@ HALVERINGSTOLERANSE = 1e-12
BORTFALL_AAR = (2025, 2030, 2035)
"""The loss of demand: zero in the first year, d_30 in the second, d_35 from the third (17.3)."""
AAR_AVTAKENDE_KNAPPHET = 2026
"""The year the falling scarcity markup counts from (chapter 3.2, clarification 120)."""
RUNDSKRIV_RENTER: tuple[tuple[int, float], tuple[int, float], tuple[None, float]] = (
(40, 0.04),
(35, 0.03),
(None, 0.02),
)
"""The circular's stepwise rate: years after T_0 at each rate, and the rate (118 b)."""
GAMMA_TRINN = ("A>=A*", "0.99<=A<A*", "0.95<=A<0.99", "A<0.95")
"""The keys of the table Gamma_trinn, from the highest availability to the lowest (119 c)."""
GAMMA_TRINN_GRENSER = (0.99, 0.95)
"""The two fixed limits of the steps in Gamma_trinn (clarification 119 c)."""
# --------------------------------------------------------------------------- S1
@ -281,7 +297,12 @@ def s7_enhetsstorrelse(
grense = chi * lam * PUE * P_IT * (1.0 + AVRUNDINGSTOLERANSE)
kandidater = [p for p in P_sett if p <= grense]
P_u = max(kandidater) if kandidater else min(P_sett)
return P_u, _tak(PUE * P_IT / P_u)
return P_u, s7_enheter_som_maa_gaa(PUE=PUE, P_IT=P_IT, P_u=P_u)
def s7_enheter_som_maa_gaa(*, PUE: float, P_IT: float, P_u: float) -> int:
"""S7: m = ceil(PUE * P_IT / P_u), the units that must run for a given unit size."""
return _tak(PUE * P_IT / P_u)
def s8_planlagt_ute(*, m: int, r: int, o_p: float) -> int:
@ -360,6 +381,38 @@ def s44_inntektsfaktor(*, m: int, r: int, o_f_A: float, beta_F: float) -> float:
return (1.0 - beta_F * o_f_A) * forventet / m
def s44_tilgjengelighet(*, m: int, r: int, o_f_A: float, beta_F: float) -> float:
"""Clarification 119 c: the probability that at least ``m`` units run, A.
A = (1 - beta_F o_f^A) Pr[X >= m], with X as in S44 and the drawn values:
in a common outage none runs.
"""
o_merket = s8_uavhengig_utfallsrate(beta_F=beta_F, o_f_A=o_f_A)
return (1.0 - beta_F * o_f_A) * s8_tilgjengelighet(m=m, r=r, o_merket=o_merket)
def s44_inntektsfaktor_trinn(
*, tilgjengelighet: float, A_krav: float, tabell: Mapping[str, float]
) -> float:
"""Clarification 119 c: Gamma as the step of the table Gamma_trinn for the availability A.
The first step when A >= A* (``A_krav``, the draw's value), the second when
0.99 <= A < A*, the third when 0.95 <= A < 0.99 and the last below 0.95.
With A* = 0.99 the second step is empty. The limits are compared as they
stand, without slack.
"""
hoy, lav = GAMMA_TRINN_GRENSER
if tilgjengelighet >= A_krav:
trinn = GAMMA_TRINN[0]
elif tilgjengelighet >= hoy:
trinn = GAMMA_TRINN[1]
elif tilgjengelighet >= lav:
trinn = GAMMA_TRINN[2]
else:
trinn = GAMMA_TRINN[3]
return tabell[trinn]
def s36_buffer(*, delta_L: float, PUE: float, P_IT: float) -> float:
"""S36: P_buf = delta_L * PUE * P_IT, the buffer that covers the largest load step, MW."""
return delta_L * PUE * P_IT
@ -589,6 +642,11 @@ def s43_knapphetspaaslag(*, y_obs: float, LCOC_v_2025: float) -> float:
return max(0.0, y_obs / LCOC_v_2025 - 1.0)
def s43_avtakende_paaslag(*, pi_0: float, t_v: int, tau_pi: float) -> float:
"""Clarification 120, line 13: pi(t_v) = pi_0 exp(-(t_v - 2026) / tau_pi), for every vintage."""
return pi_0 * math.exp(-(t_v - AAR_AVTAKENDE_KNAPPHET) / tau_pi)
@dataclass(frozen=True)
class Margin:
"""S19: Norway's margin per MW IT and year, split into its four terms (kr).
@ -713,6 +771,17 @@ def s47_utkobling(
return h_knapp * mu * y / (TIMER_PER_AAR * PUE) * max(0.0, -Delta_R_utfall)
def s47_utfall_ut_over_dimensjonerende_feil(
*, Delta_R: float, storste_enhet: float, P_dim0: float
) -> float:
"""Clarification 121, line 21: Delta R^-1' = Delta R - max(0, max_i kappa_i P_u,i - P_dim,0).
Only what the largest new unit is larger than today's dimensioning fault
counts. It stands in S47 in place of Delta R^-1; M4 keeps the whole unit.
"""
return Delta_R - max(0.0, storste_enhet - P_dim0)
# ------------------------------------------- whole calendar years (chapter 16, 21)
@ -1017,6 +1086,37 @@ def s40_restverdi(
return float(etter * (1.0 + rho_D) ** -(T_s - T_0))
def s26_diskontering_rundskriv(*, j: int) -> float:
"""Clarification 118 b: D_R(j), the circular's stepwise discount factor, j = t - T_0.
D_R(j) = 1.04^-min(j, 40) 1.03^-min(max(j - 40, 0), 35) 1.02^-max(j - 75, 0):
4 % for years 1 to 40 after T_0, 3 % for years 41 to 75 and 2 % after that.
"""
(forste, r_1), (andre, r_2), (_, r_3) = RUNDSKRIV_RENTER
return float(
(1.0 + r_1) ** -min(j, forste)
* (1.0 + r_2) ** -min(max(j - forste, 0), andre)
* (1.0 + r_3) ** -max(j - forste - andre, 0)
)
def s40_restverdi_rundskriv(
*, NK_snitt: float, L_rest: int, avvikling: float, T_s: int, T_0: int
) -> float:
"""Clarification 118 b: S40 with the circular's rate, kr in present value at T_0.
Every amount after the final year is discounted from the year it falls:
RV_k = max(0, sum_x NK_snitt D_R(T_s - T_0 + x)) - avvikling D_R(T_s - T_0 + L_rest),
for x = 1 .. L_rest. With no years left the value is zero, as in S40.
"""
if L_rest <= 0:
return 0.0
j_s = T_s - T_0
faktorer = (s26_diskontering_rundskriv(j=j_s + x) for x in range(1, L_rest + 1))
verdi = max(0.0, math.fsum(NK_snitt * d for d in faktorer))
return verdi - avvikling * s26_diskontering_rundskriv(j=j_s + L_rest)
def s26_subsidieelement(*, naaverdi_prosjekt: float) -> float:
"""S26: SE = max(0, -present value of the project's net cash flow), kr."""
return max(0.0, -naaverdi_prosjekt)

View file

@ -46,11 +46,19 @@ class Renter:
rho_D: compute (the data centre).
rho_N: power sold in the market.
rho_A: the power plant in A.
rho_NK: nuclear plants on the grid, when it differs from rho_N (line 4 of the
sensitivity list, clarification 118 a); None means rho_N.
"""
rho_D: float
rho_N: float
rho_A: float
rho_NK: float | None = None
@property
def rho_kjernekraft(self) -> float:
"""The rate for nuclear plants on the grid: in S3 and S5 for B, B' and T-K."""
return self.rho_N if self.rho_NK is None else self.rho_NK
@dataclass(frozen=True)
@ -104,14 +112,25 @@ class Kraftkostnad:
def renter_i_hovedkjoringen(inn: Inndata, res: Programresultat) -> Renter:
"""The required returns of the main run: rho_D, rho_N, and rho_A as the path was computed."""
return Renter(rho_D=inn["rho_D"], rho_N=inn["rho_N"], rho_A=res.dim.rho_A)
"""The required returns of the main run: rho_D, rho_N, and rho_A as the path was computed.
The nuclear plants on the grid carry the markup of line 4 when the path
was computed with it (clarification 118 a); otherwise their rate is rho_N.
"""
return Renter(
rho_D=inn["rho_D"],
rho_N=inn["rho_N"],
rho_A=res.dim.rho_A,
rho_NK=ks.rente_kjernekraft(inn, res.dim) if res.dim.paaslag_kjernekraft != 0.0 else None,
)
def effektkostnad_bedrift(inn: Inndata, res: Programresultat) -> Tabell:
"""Chapter 7: the disconnection arm of S47 per year for the programme, kr. Zero in A.
The price is the average of mu_d y over the vintages in operation (chapter 17.3).
With line 21 of the sensitivity list only what the largest new unit is larger
than P_dim,0 counts (clarification 121).
"""
plan = res.plan
F = np.zeros(len(res.aar), dtype=np.float64)
@ -122,7 +141,7 @@ def effektkostnad_bedrift(inn: Inndata, res: Programresultat) -> Tabell:
priser = [res.mu_d(v) * res.y(v) for v in aarganger if v is not None]
if priser:
F[j] = lg.s47_utkobling(
Delta_R_utfall=res.kraftaar[j].Delta_R_utfall,
Delta_R_utfall=ks.utfall_i_s47(inn, res.dim, res.kraftaar[j]),
h_knapp=inn["h_knapp"],
mu=inn["mu_rel"],
y=math.fsum(priser) / len(priser),
@ -132,7 +151,10 @@ def effektkostnad_bedrift(inn: Inndata, res: Programresultat) -> Tabell:
def ulykkeskostnad_per_mwh(inn: Inndata, res: Programresultat, *, N_u: int, E_N: float) -> float:
"""S6: the expected accident cost of ``N_u`` units producing ``E_N`` MWh a year, kr/MWh."""
"""S6: the expected accident cost of ``N_u`` units producing ``E_N`` MWh a year, kr/MWh.
Without the factor for unit size with line 20 of the sensitivity list (121).
"""
return lg.s6_ulykkeskostnad(
N_u=N_u,
phi_U=inn["phi_U"],
@ -141,35 +163,54 @@ def ulykkeskostnad_per_mwh(inn: Inndata, res: Programresultat, *, N_u: int, E_N:
P_u=res.dim.P_u,
P_ref=inn["P_ref"],
E=E_N,
skaler_med_enhet=res.dim.skaler_K_U,
)
def lcoe_kjernekraft(
inn: Inndata, res: Programresultat, *, numre: range | tuple[int, ...], E_N: float, rho: float
inn: Inndata,
res: Programresultat,
*,
numre: range | tuple[int, ...],
E_N: float,
rho: float,
kostnadsfaktor: float = 1.0,
) -> float:
"""S5 for the units with the numbers ``numre``, producing ``E_N`` MWh a year, kr/MWh."""
"""S5 for the units with the numbers ``numre``, producing ``E_N`` MWh a year, kr/MWh.
``kostnadsfaktor`` multiplies every cost but the accident cost (line 28,
clarification 122); it is exactly one in every other computation.
"""
f = kostnadsfaktor
P_u = res.dim.P_u
return lg.s5_lcoe_kjernekraft(
I_N=ks.investering_per_enhet(inn, res.dim, P_u=P_u, numre=numre, rho=rho),
I_N=[f * i for i in ks.investering_per_enhet(inn, res.dim, P_u=P_u, numre=numre, rho=rho)],
rho=rho,
L_N=inn["L_N"],
f_N_enhet=lg.s5_fast_drift(f_N=inn["f_N"], P_u=P_u, P_ref=inn["P_ref"], nu_f=inn["nu_f"]),
D_avv=inn["D_avv"],
f_N_enhet=f
* lg.s5_fast_drift(f_N=inn["f_N"], P_u=P_u, P_ref=inn["P_ref"], nu_f=inn["nu_f"]),
D_avv=f * inn["D_avv"],
P_u=P_u,
E_N=E_N,
v_N=inn["v_N"],
u_N=ks.brenselkostnad(inn, P_u),
d_N=inn["d_N"],
v_N=f * inn["v_N"],
u_N=f * ks.brenselkostnad(inn, P_u),
d_N=f * inn["d_N"],
q_N=ulykkeskostnad_per_mwh(inn, res, N_u=len(numre), E_N=E_N),
)
def lcoe_fornybar(inn: Inndata, teknologi: str, rho_N: float) -> float:
"""Clarification 10: LCOE_i for one renewable technology, kr/MWh."""
def lcoe_fornybar(
inn: Inndata, teknologi: str, rho_N: float, *, kostnadsfaktor: float = 1.0
) -> float:
"""Clarification 10: LCOE_i for one renewable technology, kr/MWh.
``kostnadsfaktor`` multiplies investment and operation (line 28, clarification 122).
"""
f = kostnadsfaktor
per_mw = teknologi in ks.DRIFT_PER_MW
drift = inn[f"{teknologi}.drift"]
drift = f * inn[f"{teknologi}.drift"]
return lg.lcoe_fornybar(
investering=inn[f"{teknologi}.investering"],
investering=f * inn[f"{teknologi}.investering"],
drift_per_mwh=0.0 if per_mw else drift,
drift_per_mw=drift if per_mw else 0.0,
fullasttimer=inn[f"{teknologi}.fullasttimer"],
@ -180,48 +221,15 @@ def lcoe_fornybar(inn: Inndata, teknologi: str, rho_N: float) -> float:
)
def kraftkostnad_dedikert(inn: Inndata, res: Programresultat, k: int, rho_A: float) -> float:
"""S9 for facility ``k`` (0 is the first) in A, kr per MWh delivered to the data centre."""
dim = res.dim
numre = ks.enhetsnumre(dim, k + 1)
return lg.s9_kraftkostnad_dedikert(
I_N=ks.investering_per_enhet(inn, dim, P_u=dim.P_u, numre=numre, rho=rho_A),
rho_A=rho_A,
L_N=inn["L_N"],
f_N_enhet=lg.s5_fast_drift(
f_N=inn["f_N"], P_u=dim.P_u, P_ref=inn["P_ref"], nu_f=inn["nu_f"]
),
D_avv=inn["D_avv"],
P_u=dim.P_u,
P_buf=lg.s36_buffer(delta_L=inn["delta_L"], PUE=inn["PUE"], P_IT=inn["P_IT"]),
c_buf=inn["c_buf"],
f_buf=inn["f_buf"],
L_buf=inn["L_buf"],
I_g_aar=lg.s36_ekstern_forsyning(
D_linje=inn["D_linje"],
c_linje=inn["c_linje"],
s_g=inn["s_g"],
N_u=dim.N_u,
P_u=dim.P_u,
c_gen=inn["c_gen"],
rho_A=rho_A,
L_nett=inn["L_nett"],
L_buf=inn["L_buf"],
),
E_D=dim.E_D,
v_N=inn["v_N"],
u_N_A=ks.brenselkostnad(inn, dim.P_u),
d_N=inn["d_N"],
q_N=lg.s6_ulykkeskostnad(
N_u=dim.N_u,
phi_U=inn["phi_U"],
K_U=inn["K_U"],
D_fors=inn["D_fors"],
P_u=dim.P_u,
P_ref=inn["P_ref"],
E=dim.E_D,
),
)
def kraftkostnad_dedikert(
inn: Inndata, res: Programresultat, k: int, rho_A: float, *, kostnadsfaktor: float = 1.0
) -> float:
"""S9 for facility ``k`` (0 is the first) in A, kr per MWh delivered to the data centre.
``kostnadsfaktor`` multiplies every cost but the accident cost (line 28,
clarification 122). The buffer is P_buf of ``kontantstrom.bufferstorrelse``.
"""
return ks.kraftkostnad_dedikert(inn, res.dim, k, rho_A, kostnadsfaktor=kostnadsfaktor)
@dataclass(frozen=True)
@ -233,7 +241,7 @@ class _Portefolje:
def _egen_portefolje(
inn: Inndata, res: Programresultat, k: int, r: Renter, *, bedrift: bool
inn: Inndata, res: Programresultat, k: int, r: Renter, *, bedrift: bool, faktor: float
) -> _Portefolje:
"""B' and C: the plants that belong to facility ``k``. Empty in R (and in B, see below).
@ -247,10 +255,12 @@ def _egen_portefolje(
q_N = 0.0
if v.teknologi == ks.KJERNEKRAFT:
numre = ks.enhetsnumre(res.dim, k + 1)
lcoe = lcoe_kjernekraft(inn, res, numre=numre, E_N=v.energi, rho=r.rho_N)
lcoe = lcoe_kjernekraft(
inn, res, numre=numre, E_N=v.energi, rho=r.rho_kjernekraft, kostnadsfaktor=faktor
)
q_N = ulykkeskostnad_per_mwh(inn, res, N_u=len(numre), E_N=v.energi)
else:
lcoe = lcoe_fornybar(inn, v.teknologi, r.rho_N)
lcoe = lcoe_fornybar(inn, v.teknologi, r.rho_N, kostnadsfaktor=faktor)
ledd.append(
lg.Portefoljeledd(
x=v.energi / E_G,
@ -264,7 +274,7 @@ def _egen_portefolje(
def _felles_portefolje(
inn: Inndata, res: Programresultat, t: int, r: Renter, *, bedrift: bool
inn: Inndata, res: Programresultat, t: int, r: Renter, *, bedrift: bool, faktor: float
) -> _Portefolje:
"""B and the nuclear modules of T-K: the programme's units in operation in year ``t``.
@ -277,7 +287,9 @@ def _felles_portefolje(
E_N = math.fsum(gruppe.verk.energi for gruppe in i_drift)
ledd = lg.Portefoljeledd(
x=1.0,
LCOE=lcoe_kjernekraft(inn, res, numre=numre, E_N=E_N, rho=r.rho_N),
LCOE=lcoe_kjernekraft(
inn, res, numre=numre, E_N=E_N, rho=r.rho_kjernekraft, kostnadsfaktor=faktor
),
psi=inn["psi_N"],
regelen_binder=not bedrift and res.varsigma[ks.KJERNEKRAFT] < 1.0,
q_N=ulykkeskostnad_per_mwh(inn, res, N_u=len(numre), E_N=E_N),
@ -285,12 +297,14 @@ def _felles_portefolje(
return _Portefolje(ledd=(ledd,), E_G=E_N)
def _dedikert_per_aar(inn: Inndata, res: Programresultat, r: Renter, *, bedrift: bool) -> Tabell:
def _dedikert_per_aar(
inn: Inndata, res: Programresultat, r: Renter, *, bedrift: bool, faktor: float
) -> Tabell:
"""A: S9 per facility, in the years the facility uses power; NaN otherwise."""
plan = res.plan
c_a = np.full((len(plan.anlegg), len(res.aar)), np.nan, dtype=np.float64)
for k in range(len(plan.anlegg)):
c_A = kraftkostnad_dedikert(inn, res, k, r.rho_A)
c_A = kraftkostnad_dedikert(inn, res, k, r.rho_A, kostnadsfaktor=faktor)
if bedrift:
c_A = lg.s27_kraftkostnad_bedrift_dedikert(c_A=c_A, t_el=inn["t_el"])
for j, t in enumerate(res.aar):
@ -300,7 +314,7 @@ def _dedikert_per_aar(inn: Inndata, res: Programresultat, r: Renter, *, bedrift:
def _kraftkostnad_per_aar(
inn: Inndata, res: Programresultat, r: Renter, F: Tabell, *, bedrift: bool
inn: Inndata, res: Programresultat, r: Renter, F: Tabell, *, bedrift: bool, faktor: float
) -> Tabell:
"""c_a per facility and year, kr/MWh; NaN where the facility uses no power.
@ -311,7 +325,7 @@ def _kraftkostnad_per_aar(
among all the modules that use power that year (clarification 76).
"""
if res.losning is Losning.A:
return _dedikert_per_aar(inn, res, r, bedrift=bedrift)
return _dedikert_per_aar(inn, res, r, bedrift=bedrift, faktor=faktor)
plan, dim = res.plan, res.dim
antall = range(len(plan.anlegg))
c_a = np.full((len(plan.anlegg), len(res.aar)), np.nan, dtype=np.float64)
@ -330,12 +344,12 @@ def _kraftkostnad_per_aar(
tariff = (
lg.s27_nettariff(t_nett=inn["t_nett"], PUE=inn["PUE"], P_IT=res.P_enhet) if bedrift else 0.0
)
egne = [_egen_portefolje(inn, res, k, r, bedrift=bedrift) for k in antall]
egne = [_egen_portefolje(inn, res, k, r, bedrift=bedrift, faktor=faktor) for k in antall]
for j, t in enumerate(res.aar):
med_last = plan.antall_med_last(t)
if med_last == 0:
continue
felles = _felles_portefolje(inn, res, t, r, bedrift=bedrift)
felles = _felles_portefolje(inn, res, t, r, bedrift=bedrift, faktor=faktor)
paa_felles = res.antall_paa_felles(t, med_last=True)
for k in antall:
if not plan.har_last(k, t):
@ -372,7 +386,7 @@ def _kraftkostnad_per_aar(
def _aarganger(
inn: Inndata, res: Programresultat, r: Renter, c_a: Tabell, *, bedrift: bool
inn: Inndata, res: Programresultat, r: Renter, c_a: Tabell, *, bedrift: bool, faktor: float
) -> tuple[Aargangskost, ...]:
"""S15 per vintage with the power cost of clarification 15, and S19 or S27 with it.
@ -390,14 +404,14 @@ def _aarganger(
w * float(c_a[k, t - plan.T_0]) for w, t in zip(vekter, aar, strict=True)
) / math.fsum(vekter)
LCOC = lg.s15_lcoc(
c_bygg=inn["c_bygg"],
c_bygg=faktor * 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),
c_H=faktor * lg.s13_it_kostnad(c_H0=inn["c_H0"], gamma_H=inn["gamma_H"], t_v=t_v),
rho_D=r.rho_D,
L_B=inn["L_B"],
L_H=inn["L_H"],
o_D=inn["o_D"],
d_o_D=inn["d_o_D"],
o_D=faktor * inn["o_D"],
d_o_D=faktor * inn["d_o_D"],
lam=inn["lambda"],
PUE=inn["PUE"],
c_a=kraft,
@ -444,6 +458,7 @@ def kraftkostnad(
*,
bedrift: bool = False,
renter: Renter | None = None,
kostnadsfaktor: float = 1.0,
) -> Kraftkostnad:
"""The levelised cost of power and compute for the path in ``res``.
@ -457,11 +472,20 @@ def kraftkostnad(
The path may be solution T, built in modules, and may be computed with a
loss of demand: the factor of S51 then stands in S19, S27 and S42 and in
the disconnection arm of S47.
``kostnadsfaktor`` is the efficiency of an ownership form (line 28,
clarification 122), only in the business version: it multiplies the
investments and all operation but power bought, electricity tax, grid
tariff, q_N and the capacity cost. Fuel, waste fee and decommissioning are
multiplied.
"""
if kostnadsfaktor != 1.0 and not bedrift:
msg = "the cost factor of an ownership form belongs to the business version only"
raise ValueError(msg)
r = renter_i_hovedkjoringen(inn, res) if renter is None else renter
F = effektkostnad_bedrift(inn, res) if bedrift else res.F_a
c_a = _kraftkostnad_per_aar(inn, res, r, F, bedrift=bedrift)
aarganger = _aarganger(inn, res, r, c_a, bedrift=bedrift)
c_a = _kraftkostnad_per_aar(inn, res, r, F, bedrift=bedrift, faktor=kostnadsfaktor)
aarganger = _aarganger(inn, res, r, c_a, bedrift=bedrift, faktor=kostnadsfaktor)
S42 = None
if bedrift:
S42 = lg.s42_naaverdivektet_margin(

View file

@ -119,7 +119,7 @@ def _faste_aarskostnader(inn: Inndata, res: Programresultat, r: Renter, k: int)
rho_N=r.rho_N,
L_nett=inn["L_nett"],
)
P_buf = lg.s36_buffer(delta_L=inn["delta_L"], PUE=inn["PUE"], P_IT=inn["P_IT"])
P_buf = ks.bufferstorrelse(inn, res.dim)
buffer = P_buf * (inn["c_buf"] * lg.s1_crf(rho=r.rho_A, L=inn["L_buf"]) + inn["f_buf"])
return buffer + lg.s36_ekstern_forsyning(
D_linje=inn["D_linje"],
@ -146,10 +146,14 @@ def overskudd_utover_avkastning(
units of T-K. In solution T the sum goes over the modules, each with P_m
(chapter 17.1). The revenue is the cash flow's, so it carries the factor of
S51 when the path is computed with a loss of demand, and so does F_a.
The nuclear plants on the grid are on levelised form with their own rate,
rho_N plus the markup of line 4 when that is set (clarification 118 a).
"""
r = nivaaisert.renter_i_hovedkjoringen(inn, res) if renter is None else renter
plan = res.plan
rho_kraft = r.rho_N if res.losning.paa_nett else r.rho_A
rho_kjerne = r.rho_kjernekraft if res.losning.paa_nett else r.rho_A
bygg = (
inn["c_bygg"] * (1.0 + inn["d_bygg"]) * res.P_enhet * lg.s1_crf(rho=r.rho_D, L=inn["L_B"])
)
@ -173,7 +177,7 @@ def overskudd_utover_avkastning(
ut[j] -= _kraftverk_netto(
inn,
verk,
rho=rho_kraft,
rho=rho_kjerne if verk.teknologi == ks.KJERNEKRAFT else rho_kraft,
pris=pris,
har_last=aargang is not None,
regelen_binder=res.varsigma[verk.teknologi] < 1.0,
@ -183,7 +187,7 @@ def overskudd_utover_avkastning(
ut[j] -= _kraftverk_netto(
inn,
f.gruppe.verk,
rho=rho_kraft,
rho=rho_kjerne,
pris=pris,
har_last=True,
regelen_binder=res.varsigma[ks.KJERNEKRAFT] < 1.0,

688
tests/test_folsomheter.py Normal file
View file

@ -0,0 +1,688 @@
"""The sensitivity list through the run (chapter 11; clarifications 112, 113, 116 to 123).
Made-up draws only: variants of the made-up set of ``conftest.py``, and invented outcomes per
draw for the table. Nothing here says anything about the hypothesis.
"""
from __future__ import annotations
import dataclasses
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import dommer, eierskap
from tokenfabrikker import folsomheter as fs
from tokenfabrikker import kjoring as kj
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag, Trinnvalg
from tokenfabrikker.folsomheter import RADER, Avlesning
from tokenfabrikker.kjoring import Bane, Brytere, Eierrad, Kjoring, Scenario, Utfall
from tokenfabrikker.kontantstrom import Diskontering, Knapphet, Paaslagsform, Skattekostnad
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
NORM = Scenario("normalisering", Knapphet.NORMALISERING)
VARER = Scenario("knapphet varer", Knapphet.VARER)
OVER = Scenario("overkapasitet", Knapphet.OVERKAPASITET)
LAVT = Scenario("lavt", Knapphet.NORMALISERING, "lavt")
HOYT = Scenario("hoyt", Knapphet.NORMALISERING, "hoyt")
SCENARIOER = (VARER, NORM, OVER, LAVT, HOYT)
"""The price scenarios and the two marked scenarios of the made-up set."""
EOS = {
"direkte": "består",
"heleid_selskap": "består",
"majoritet_boers": "usikker",
"petroleumsmodell": "består",
}
KARBONBANER = {"lav": {2026: 500.0, 2100: 500.0}, "hoy": {2026: 3000.0, 2100: 4000.0}}
"""Made-up low and high paths of the carbon price; the made-up set has 1 000 kr in every year."""
# ------------------------------------------------------------------ the list
def test_lista_har_42_rader_fra_37_linjer() -> None:
assert len(RADER) == 42
linjer = [rad.linje for rad in RADER.values()]
assert sorted(set(linjer)) == list(range(1, fs.ANTALL_LINJER + 1))
assert linjer == sorted(linjer)
assert sorted({n for n in linjer if linjer.count(n) == 2}) == [11, 17, 19, 31, 32]
assert [navn for navn, rad in RADER.items() if not rad.er_kjoring] == [
"24",
"25",
"28",
"29",
"30",
]
assert {navn: rad.eierrad for navn, rad in RADER.items() if rad.eierrad is not None} == {
"24": Eierrad.STATENS_RENTE,
"25": Eierrad.EGENKAPITALKRAV,
"28": Eierrad.EFFEKTIVITET,
"29": Eierrad.ZETA_LIK_EIERANDEL,
}
def test_radene_leses_av_der_avklaring_112_sier() -> None:
andre = {
navn: rad.avlesning for navn, rad in RADER.items() if rad.avlesning is not Avlesning.HOVED
}
assert andre == {
"12": Avlesning.VARER,
"13": Avlesning.VARER,
"24": Avlesning.EIERFORMER,
"25": Avlesning.EIERFORMER,
"28": Avlesning.EIERFORMER,
"29": Avlesning.EIERFORMER,
"31a": Avlesning.MERKET,
"31b": Avlesning.MERKET,
}
assert fs.scenarioer_for(RADER["14"], SCENARIOER) == (NORM,)
assert fs.scenarioer_for(RADER["12"], SCENARIOER) == (VARER,)
assert fs.scenarioer_for(RADER["31a"], SCENARIOER) == (LAVT, HOYT)
assert fs.scenarioer_for(RADER["24"], SCENARIOER) == ()
def test_hvilke_losninger_radene_gjelder() -> None:
"""Clarifications 117 to 122, row by row."""
A, B, Bm, C, R, TF, TK = (
Losning.A,
Losning.B,
Losning.B_MERKET,
Losning.C,
Losning.R,
Losning.T_F,
Losning.T_K,
)
alle = (A, B, Bm, C, R, TF, TK)
assert set(alle) == set(Losning)
ikke_alle = {
navn: set(rad.gjelder) for navn, rad in RADER.items() if set(rad.gjelder) != set(alle)
}
assert ikke_alle == {
"1": {A, B, Bm, TK},
"2": {A, B, Bm, TK},
"3": {A},
"4": {B, Bm, TK},
"5": {A, Bm},
"6": {A, B, Bm, TK},
"7": {A, Bm},
"8": {A, Bm},
"9": {A, Bm},
"10": {A},
"20": {A, Bm},
"21": {B, Bm, TK},
"22": {B, Bm, C, TF, TK},
"24": {A, B, C, TF, TK},
"25": {A, B, C, TF, TK},
"28": {A, B, C, TF, TK},
"29": {A, B, C, TF, TK},
"32a": {TF, TK},
"32b": {TF, TK},
"33": {TF, TK},
"34": {TF, TK},
"35": {C},
"36": {TK},
"37": {C, TF, TK},
}
# ------------------------------------------------------------------ one draw
@pytest.mark.parametrize(
("rad", "losning", "endring", "grunn"),
[
# the made-up set has u_xi = 0.9 and w_xi = 0.5: no overrun. With u_xi = 0.3 there is one.
("1", Losning.A, {"w_xi": 0.0}, {"u_xi": 0.3}),
("2", Losning.B, {"w_xi": 1.0}, {}),
("5", Losning.A, {"nu": 0.6}, {}),
("6", Losning.B, {"ell": -0.23}, {}),
("11a", Losning.C, {"mu_rel": 0.90}, {}),
("11b", Losning.R, {"mu_rel": 0.95}, {}),
("14", Losning.C, {"p_v": 1198.0}, {}),
("15", Losning.B, {"PUE_v": 1.45}, {}),
("17a", Losning.A, {"varphi": 0.0}, {}),
("27", Losning.C, {"P_IT": 300.0}, {}),
("27", Losning.T_F, {"P_IT": 300.0}, {}),
("27", Losning.A, {"P_IT": 300.0}, {}),
("32a", Losning.T_F, {"P_m": 50.0}, {}),
("32b", Losning.T_K, {"P_m": 200.0}, {}),
# the first stage of the made-up set takes 150 MW a year; the modules wait for grid
("33", Losning.T_F, {"n_1": 650.0}, {"tau_nett": 6.0}),
],
)
def test_en_rad_med_fast_verdi_er_hovedkjoringen_med_verdien_byttet(
oppdiktet: LagInndata,
rad: str,
losning: Losning,
endring: dict[str, float],
grunn: dict[str, float],
) -> None:
"""The value is set after the draw: every other quantity keeps its value."""
inn = oppdiktet().med(grunn)
med = fs.regn_bane(inn, losning, 2, (NORM, VARER), rad=RADER[rad])
assert med == kj.regn_bane(inn.med(endring), losning, 2, (NORM, VARER))
assert med != kj.regn_bane(inn, losning, 2, (NORM, VARER))
def test_bortfallets_utslag_virker_bare_i_de_merkede_scenarioene(oppdiktet: LagInndata) -> None:
"""Line 31: eps_d moves nothing on the main path."""
for navn, eps in (("31a", 0.5), ("31b", 2.0)):
med = fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM, LAVT), rad=RADER[navn])
hoved = kj.regn_bane(oppdiktet(), Losning.C, 2, (NORM, LAVT))
assert med == kj.regn_bane(oppdiktet(eps_d=eps), Losning.C, 2, (NORM, LAVT))
assert med.utfall[NORM.navn] == hoved.utfall[NORM.navn]
assert med.utfall[LAVT.navn] != hoved.utfall[LAVT.navn]
def test_rho_A_lik_rho_N_bruker_trekningens_rho_N(oppdiktet: LagInndata) -> None:
"""Line 3. The made-up set has rho_N = 0.06 and rho_D = 0.08."""
for rho_N in (0.06, 0.05):
inn = oppdiktet(rho_N=rho_N)
med = fs.regn_bane(inn, Losning.A, 2, (NORM,), rad=RADER["3"])
assert med == kj.regn_bane(
inn, Losning.A, 2, (NORM,), brytere=Brytere(dim={"rho_A": rho_N})
)
# a lower required return for the plant lowers the cost of power, and so helps M2; the
# plant's cash flow is costs only in A, so its present value falls
hoved = kj.regn_bane(inn, Losning.A, 2, (NORM,))
assert med.utfall[NORM.navn].S42 > hoved.utfall[NORM.navn].S42
assert med.utfall[NORM.navn].NNV < hoved.utfall[NORM.navn].NNV
def test_halv_byggetid_gjelder_enheter_under_300_MW(oppdiktet: LagInndata) -> None:
"""Line 9. The made-up set gives units of 50 MW in A; with chi = 0.5 they are 400 MW."""
for losning in (Losning.A, Losning.B_MERKET):
med = fs.regn_bane(oppdiktet(), losning, 2, (NORM,), rad=RADER["9"])
assert med == kj.regn_bane(oppdiktet(tau_N=2.0), losning, 2, (NORM,))
assert med != kj.regn_bane(oppdiktet(), losning, 2, (NORM,))
stor = oppdiktet(chi=0.5)
assert ks.dimensjoner(stor, Losning.A).P_u == 400.0
assert fs.regn_bane(stor, Losning.A, 2, (NORM,), rad=RADER["9"]) == kj.regn_bane(
stor, Losning.A, 2, (NORM,)
)
def test_karbonprisens_baner_gis_av_den_som_kjorer(oppdiktet: LagInndata) -> None:
"""Line 19: the run reads no file, so the two paths are passed in."""
inn = oppdiktet()
for navn, bane in (("19a", "lav"), ("19b", "hoy")):
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER[navn], karbonbaner=KARBONBANER)
byttet = dataclasses.replace(inn, karbonpris=KARBONBANER[bane])
assert med == kj.regn_bane(byttet, Losning.C, 2, (NORM,))
hoved = kj.regn_bane(inn, Losning.C, 2, (NORM,)).utfall[NORM.navn].NNV
lav = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["19a"], karbonbaner=KARBONBANER)
assert lav.utfall[NORM.navn].NNV > hoved > med.utfall[NORM.navn].NNV
with pytest.raises(ValueError, match="low and its high path"):
fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["19a"])
def test_beslutningsaar_2030_bruker_eksportradens_tall_for_samme_kalenderaar(
oppdiktet: LagInndata,
) -> None:
"""Line 26, clarification 113: the number stored for year t is used in year t.
The made-up set runs from 2027 to 2060, so the row has 33 numbers, for 2028 to 2060.
With a stop in 2034 only (the seventh number) the path built from 2030 meets it in
its fourth year, not in its seventh.
"""
u = tuple(0.0 if aar == 2034 else 0.9 for aar in range(2028, 2061))
inn = oppdiktet(u_eksport=u, phi_X=0.5)
senere = fs.med_beslutningsaar(inn, 2030)
assert (senere["T0"], len(senere.u_eksport)) == (2030.0, 30)
assert senere.u_eksport == u[3:]
assert senere.u_eksport.index(0.0) == 2034 - 2031
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["26"])
assert med == kj.regn_bane(
oppdiktet(u_eksport=u[3:], phi_X=0.5, T0=2030), Losning.C, 2, (NORM,)
)
assert med.forste_aar == 2031
assert med != kj.regn_bane(
oppdiktet(u_eksport=u[:30], phi_X=0.5, T0=2030), Losning.C, 2, (NORM,)
)
with pytest.raises(ValueError, match="later, not earlier"):
fs.med_beslutningsaar(inn, 2026)
def test_C_i_moduler_er_T_F_uten_forste_trinn_paa_plassen_til_C(oppdiktet: LagInndata) -> None:
"""Line 35, clarification 73."""
inn = oppdiktet()
med = fs.regn_bane(inn, Losning.C, 2, (NORM,), rad=RADER["35"])
assert med == kj.regn_bane(
inn, Losning.T_F, 2, (NORM,), brytere=Brytere(plan={"uten_forste_trinn": True})
)
assert med != kj.regn_bane(inn, Losning.C, 2, (NORM,))
def test_radene_som_er_brytere_gir_bryteren_til_modellkoden(oppdiktet: LagInndata) -> None:
"""Lines 22, 23, 34, 36 and 37 against the model code called directly."""
inn = oppdiktet(phi_X=0.5, u_eksport=(0.1,) * 4 + (0.9,) * 29)
def nnv(
losning: Losning, plan_valg: dict[str, object], program_valg: dict[str, object]
) -> float:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2, **plan_valg) # type: ignore[arg-type]
return ks.regn_program(
inn,
losning,
plan,
Knapphet.NORMALISERING,
dim=dim,
**program_valg, # type: ignore[arg-type]
).NNV
tilfeller: list[tuple[str, Losning, dict[str, object], dict[str, object]]] = [
("22", Losning.C, {}, {"tilleggsregel": False}),
("23", Losning.C, {"eksportregel": False}, {}),
("34", Losning.T_F, {}, {"full_fortrengning_i_forste_trinn": True}),
("36", Losning.T_K, {"uten_s49": True}, {}),
("37", Losning.C, {"ny_kraft_fra": 2031}, {}),
]
for navn, losning, plan_valg, program_valg in tilfeller:
med = fs.regn_bane(inn, losning, 2, (NORM,), rad=RADER[navn])
assert med.utfall[NORM.navn].NNV == nnv(losning, plan_valg, program_valg), navn
def test_radene_med_ny_modellkode_gir_bryteren_til_modellkoden(oppdiktet: LagInndata) -> None:
"""Lines 4, 7, 8, 10, 12, 13, 16, 17, 18, 20 and 21: the switch each row sets."""
assert {
navn: (dict(r.brytere.dim), dict(r.brytere.program))
for navn, r in RADER.items()
if r.linje in (4, 7, 8, 10, 12, 13, 16, 18, 20, 21) or navn == "17b"
} == {
"4": ({"paaslag_kjernekraft": 0.02}, {}),
"7": ({"minstelast": 0.20}, {}),
"8": ({"fritt_enhetsvalg": True}, {}),
"10": ({"gamma_trinn": True}, {}),
"12": ({}, {"paaslag": Paaslagsform.VARIG}),
"13": ({}, {"paaslag": Paaslagsform.AVTAKENDE}),
"16": ({}, {"diskontering": Diskontering.RUNDSKRIV}),
"17b": ({}, {"skattekostnad": Skattekostnad.ALL_KAPITAL}),
"18": ({}, {"skattekostnad": Skattekostnad.STATENS_RENTE}),
"20": ({"skaler_K_U": False}, {}),
"21": ({"bare_over_dimensjonerende_feil": True}, {}),
}
trinn = {"A>=A*": 1.0, "0.99<=A<A*": 0.9, "0.95<=A<0.99": 0.7, "A<0.95": 0.0}
grunn = oppdiktet()
# what only the rows read, with made-up values
v = {"tau_pi": 2.5, "P_dim0": 1450.0, **grunn.v}
inn = dataclasses.replace(grunn, v=v, Gamma_trinn=trinn)
tilfeller = [
("4", Losning.B, NORM),
("7", Losning.A, NORM),
("8", Losning.A, NORM),
("10", Losning.A, NORM),
("12", Losning.C, VARER),
("13", Losning.C, VARER),
("16", Losning.C, NORM),
("17b", Losning.C, NORM),
("18", Losning.A, NORM),
("20", Losning.A, NORM),
("21", Losning.B, NORM),
]
for navn, losning, scenario in tilfeller:
rad = RADER[navn]
med = fs.regn_bane(inn, losning, 2, (scenario,), rad=rad)
assert med == kj.regn_bane(inn, losning, 2, (scenario,), brytere=rad.brytere), navn
def test_en_rad_regnes_bare_for_losningene_den_gjelder(oppdiktet: LagInndata) -> None:
with pytest.raises(ValueError, match="row 3 is not computed for solution C"):
fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM,), rad=RADER["3"])
with pytest.raises(ValueError, match="row 30 is not computed"):
fs.regn_bane(oppdiktet(), Losning.C, 2, (NORM,), rad=RADER["30"])
with pytest.raises(ValueError, match="row 24 is not computed"):
fs.regn_bane(oppdiktet(), Losning.A, 2, (NORM,), rad=RADER["24"])
# ------------------------------------------------------------- over the draws
def test_en_rad_kjores_paa_hovedkjoringens_trinn_for_losningene_den_gjelder(
oppdiktet: LagInndata,
) -> None:
trekninger = [oppdiktet(), oppdiktet(p_v=3000.0), oppdiktet(n_reaktor=100.0)]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.TRINN_5)
k = fs.kjor_rad(
trekninger, RADER["1"], valg, scenarioer=SCENARIOER, losninger=(Losning.A, Losning.C)
)
assert k is not None
assert (k.stige, k.scenarioer, k.losninger, k.antall) == ((2,), (NORM,), (Losning.A,), 3)
assert k.trekninger[1][Losning.A, 2] == kj.regn_bane(
oppdiktet(p_v=3000.0, w_xi=0.0), Losning.A, 2, (NORM,)
)
# the same figures on several processes
assert (
fs.kjor_rad(
trekninger,
RADER["1"],
valg,
scenarioer=SCENARIOER,
losninger=(Losning.A, Losning.C),
prosesser=2,
)
== k
)
# the rows that are read in other scenarios
varig = fs.kjor_rad(
trekninger[:1], RADER["31a"], valg, scenarioer=SCENARIOER, losninger=(Losning.C,)
)
assert varig is not None
assert varig.scenarioer == (LAVT, HOYT)
def test_en_rad_uten_egen_kjoring_gir_ingen(oppdiktet: LagInndata) -> None:
trekninger = [oppdiktet()]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.TRINN_5)
uten = Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN)
assert fs.kjor_rad(trekninger, RADER["1"], uten, scenarioer=SCENARIOER) is None
assert fs.kjor_rad(trekninger, RADER["30"], valg, scenarioer=SCENARIOER) is None
assert fs.kjor_rad(trekninger, RADER["24"], valg, scenarioer=SCENARIOER) is None
# none of the row's solutions, or none of its scenarios, in the run
assert (
fs.kjor_rad(trekninger, RADER["3"], valg, scenarioer=SCENARIOER, losninger=(Losning.C,))
is None
)
assert fs.kjor_rad(trekninger, RADER["12"], valg, scenarioer=(NORM,)) is None
with pytest.raises(ValueError, match="at least one draw"):
fs.kjor_rad([], RADER["1"], valg, scenarioer=SCENARIOER)
# ----------------------------------------- the table, on invented outcomes per draw
def _u(NNV: float = 1.0, *, M6: float | None = 0.3, M6_median: float | None = None) -> Utfall:
return Utfall(
NNV=NNV,
S42=1.0,
M3=0.0,
M4=Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False),
M6=M6,
M6_snitt=M6,
M6_median=M6 if M6_median is None else M6_median,
M6_2050=None,
M6_topp=0.0 if M6 is None else M6,
stabilt_aar=None if M6 is None else 2040,
toppaar=2040,
)
def _kjoring(
per_trekning: list[dict[Losning, Utfall | None]],
scenarioer: tuple[Scenario, ...] = (NORM,),
trinn: int = 5,
) -> Kjoring:
"""A run on one step put together from invented outcomes, the same in every scenario."""
def bane(u: Utfall | None) -> Bane:
linje: dict[Kraft, tuple[float, ...]] = {}
utfall = {} if u is None else {s.navn: u for s in scenarioer}
return Bane(byggbar=u is not None, forste_aar=2028, tidslinje=linje, utfall=utfall)
return Kjoring(
stige=(trinn,),
scenarioer=scenarioer,
losninger=tuple(per_trekning[0]),
trekninger=tuple({(a, trinn): bane(u) for a, u in t.items()} for t in per_trekning),
)
VALG = Trinnvalg(trinn=5, grunnlag=Grunnlag.TRINN_25)
M5 = dict.fromkeys(Losning, Dom.HOLDER)
def test_hovedkjoringen_i_tabellen_er_dommene_paa_trinnet() -> None:
"""The main run in the format of the table gives what ``sett_dommer`` gives on the step."""
hoved = _kjoring(
[
{Losning.A: _u(1.0 if j < 7 else -1.0), Losning.C: _u(0.5), Losning.R: _u(2.0)}
for j in range(10)
]
)
d = kj.sett_dommer(hoved, M5)
t = fs.hovedtabell(hoved, M5, d.valg, NORM)
norm = d.scenarioer[NORM.navn]
assert (t.rad, t.scenario, t.gjelder) == (fs.HOVEDKJORINGEN, NORM.navn, ())
assert t.losninger == norm.per_trinn[5]
assert (t.M7, t.del_I, t.del_II) == (norm.M7[5], norm.del_I, norm.del_II)
assert t.ved_siden_av[Losning.A] == kj.ved_siden_av_m6(hoved.utfall(NORM, Losning.A, 5))
with pytest.raises(ValueError, match="no table"):
fs.hovedtabell(hoved, M5, Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN), NORM)
def test_en_rad_i_tabellen_har_radens_utfall_der_den_gjelder_og_hovedkjoringens_ellers() -> None:
"""Row 3 applies to A. A is best in 7 of 10 draws in the main run and in 2 of 10 in the row."""
hoved = _kjoring(
[{Losning.A: _u(1.0 if j < 7 else -1.0), Losning.C: _u(0.5)} for j in range(10)]
)
radkjoring = _kjoring([{Losning.A: _u(1.0 if j < 2 else 0.1)} for j in range(10)])
(t,) = fs.tabell(hoved, RADER["3"], radkjoring, M5, VALG).values()
assert (t.rad, t.scenario, t.gjelder) == ("3", NORM.navn, (Losning.A,))
assert t.losninger[Losning.C] == fs.hovedtabell(hoved, M5, VALG, NORM).losninger[Losning.C]
a = t.losninger[Losning.A]
assert (a.maal["M1"].andel_holder, a.maal["M1"].dom, a.median_M1) == (1.0, Dom.HOLDER, 0.1)
assert t.M7 is not None
assert (t.M7.andel_holder, t.M7.dom) == (0.2, Dom.BETINGELSER)
assert (t.del_I, t.del_II) == (Dom.HOLDER, Dom.BETINGELSER)
# the main run next to it: 7 of 10 positive, and A best in those 7
h = fs.hovedtabell(hoved, M5, VALG, NORM)
assert h.M7 is not None
assert (h.losninger[Losning.A].maal["M1"].andel_holder, h.M7.andel_holder) == (0.7, 0.7)
# without a run of the row every solution has the main run's figures
(uten,) = fs.tabell(hoved, RADER["3"], None, M5, VALG).values()
assert (uten.losninger, uten.M7, uten.del_I) == (h.losninger, h.M7, h.del_I)
def test_M6_mot_medianen_er_en_dom_og_ingen_kjoring() -> None:
"""Row 30: M6 is 30 % against the average and 10 % against the median in every draw."""
hoved = _kjoring(
[{Losning.A: _u(M6=0.3, M6_median=0.1), Losning.C: _u(M6=None)} for _ in range(10)]
)
(t,) = fs.tabell(hoved, RADER["30"], None, M5, VALG).values()
h = fs.hovedtabell(hoved, M5, VALG, NORM)
assert h.losninger[Losning.A].maal["M6"].dom is Dom.HOLDER
assert t.losninger[Losning.A].maal["M6"].dom is Dom.BETINGELSER
assert t.losninger[Losning.A].maal["M6"].andel_holder == 0.0
assert t.losninger[Losning.A].maal["M1"] == h.losninger[Losning.A].maal["M1"]
# a path without a year of stable operation has neither figure
assert t.losninger[Losning.C].maal["M6"] == h.losninger[Losning.C].maal["M6"]
assert (h.del_I, t.del_I) == (Dom.HOLDER, Dom.BETINGELSER)
assert t.gjelder == (Losning.A, Losning.C)
def test_C_i_moduler_staar_paa_plassen_til_C_og_endrer_ikke_M7_og_del_I() -> None:
"""Row 35: the path beats A in every draw, and is still not one of the five solutions."""
hoved = _kjoring([{Losning.A: _u(1.0), Losning.C: _u(0.5)} for _ in range(10)])
radkjoring = _kjoring([{Losning.C: _u(-2.0 if j < 9 else 3.0)} for j in range(10)])
(t,) = fs.tabell(hoved, RADER["35"], radkjoring, M5, VALG).values()
h = fs.hovedtabell(hoved, M5, VALG, NORM)
assert t.losninger[Losning.C].maal["M1"].andel_holder == 0.1
assert t.losninger[Losning.C].median_M1 == -2.0
assert (t.M7, t.del_I, t.del_II) == (h.M7, h.del_I, h.del_II)
assert h.M7 is not None
assert h.M7.andel_holder == 1.0
def test_tabellen_har_en_rad_per_scenario_raden_leses_av_i() -> None:
hoved = _kjoring([{Losning.C: _u(1.0)} for _ in range(4)], scenarioer=(NORM, VARER, LAVT, HOYT))
radkjoring = _kjoring([{Losning.C: _u(-1.0)} for _ in range(4)], scenarioer=(LAVT, HOYT))
t = fs.tabell(hoved, RADER["31a"], radkjoring, M5, VALG)
assert list(t) == [LAVT.navn, HOYT.navn]
assert all(rad.losninger[Losning.C].median_M1 == -1.0 for rad in t.values())
varig = fs.tabell(hoved, RADER["12"], None, M5, VALG)
assert list(varig) == [VARER.navn]
# the rows of the ownership forms have no table here, and nothing has one without a step
assert fs.tabell(hoved, RADER["24"], None, M5, VALG) == {}
assert fs.tabell(hoved, RADER["31a"], radkjoring, M5, Trinnvalg(None, Grunnlag.INGEN)) == {}
def test_tabellen_gjennom_modellen_paa_oppdiktede_trekninger(oppdiktet: LagInndata) -> None:
"""Row 14 through the model: the row's outcomes are the main run's with the value replaced."""
trekninger = [oppdiktet(), oppdiktet(c_H0=150e6), oppdiktet(n_reaktor=100.0)]
losninger = (Losning.A, Losning.C)
hoved = kj.kjor(trekninger, stige=(2,), scenarioer=(NORM,), losninger=losninger)
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
m5 = dict.fromkeys(losninger, Dom.HOLDER)
radkjoring = fs.kjor_rad(trekninger, RADER["14"], valg, scenarioer=(NORM,), losninger=losninger)
(t,) = fs.tabell(hoved, RADER["14"], radkjoring, m5, valg).values()
byttet = kj.kjor(
[x.med({"p_v": 1198.0}) for x in trekninger],
stige=(2,),
scenarioer=(NORM,),
losninger=losninger,
)
assert t.losninger == fs.hovedtabell(byttet, m5, valg, NORM).losninger
assert t.del_I == dommer.del_I(
{a: t.losninger[a].dommer for a in losninger},
{a: t.losninger[a].median_M1 for a in losninger},
valg,
)
# ------------------------------------------- the rows of the ownership forms
def _eiertrekninger(oppdiktet: LagInndata) -> list[Inndata]:
"""Three made-up draws with an overrun in A (u_xi below w_xi) and a made-up eps_e."""
return [
dataclasses.replace(x, v={**x.v, "eps_e": eps})
for x, eps in (
(oppdiktet(u_xi=0.3), 0.05),
(oppdiktet(u_xi=0.3, p_v=3000.0), -0.02),
(oppdiktet(u_xi=0.3, c_H0=150e6), 0.08),
)
]
def _eier(
inn: Inndata, losning: Losning = Losning.A
) -> tuple[ks.Programresultat, eierskap.Bedriftsstrom]:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
res = ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING, dim=dim)
return res, eierskap.bedriftsstrom(inn, res, tilleggsregel=True)
def test_eierformradene_gir_det_avklaring_122_sier(oppdiktet: LagInndata) -> None:
trekninger = _eiertrekninger(oppdiktet)
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
def tabell(rad: Eierrad) -> kj.Eierformtabell:
t = kj.eierformer_paa_trinnet(
trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,), rad=rad
)[Losning.A]
assert t is not None
return t
hoved = tabell(Eierrad.HOVED)
assert (
hoved
== kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,))[
Losning.A
]
)
former = list(EOS)
per_trekning = [_eier(x) for x in trekninger]
def lcoc(navn: str) -> list[float]:
return [
eierskap.lcoc_med_kapitalkostnad(x, res, eierskap.krav_for_skatt(x, x.eierformer[navn]))
for x, (res, _) in zip(trekninger, per_trekning, strict=True)
]
# line 24: the state's cash flow valued with the state's borrowing rate
med_24 = tabell(Eierrad.STATENS_RENTE)
for j, navn in enumerate(former):
utfall = [
eierskap.eierresultat(x, strom, x.eierformer[navn], rente=x["r_stat"])
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
]
assert med_24.kriterier[j] == eierskap.eierkriterier(navn, utfall, lcoc(navn))
assert med_24.kriterier != hoved.kriterier
# line 25: the settlement priced with the owners' required return on equity
med_25 = tabell(Eierrad.EGENKAPITALKRAV)
for j, navn in enumerate(former):
utfall = [
eierskap.eierresultat(x, strom, x.eierformer[navn])
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
]
assert med_25.kriterier[j] == eierskap.eierkriterier(
navn, utfall, lcoc(navn), egenkapitalkrav=True
)
# the two forms without private owners have no settlement and are unchanged
assert med_25.kriterier[:2] == hoved.kriterier[:2]
assert med_25.kriterier[2:] != hoved.kriterier[2:]
# line 28: the costs of direct ownership and the wholly owned company times 1 + eps_e
med_28 = tabell(Eierrad.EFFEKTIVITET)
assert med_28.kriterier[2:] == hoved.kriterier[2:]
for j, navn in enumerate(former[:2]):
utfall, kost = [], []
for x, (res, _) in zip(trekninger, per_trekning, strict=True):
faktor = 1.0 + x["eps_e"]
strom = eierskap.bedriftsstrom(x, res, tilleggsregel=True, kostnadsfaktor=faktor)
utfall.append(eierskap.eierresultat(x, strom, x.eierformer[navn]))
kost.append(
eierskap.lcoc_med_kapitalkostnad(
x, res, eierskap.krav_for_skatt(x, x.eierformer[navn]), kostnadsfaktor=faktor
)
)
assert med_28.kriterier[j] == eierskap.eierkriterier(navn, utfall, kost)
assert med_28.kriterier[j] != hoved.kriterier[j]
# line 29: zeta equal to the state's share; 1 already for the two forms the state owns alone
med_29 = tabell(Eierrad.ZETA_LIK_EIERANDEL)
assert med_29.kriterier[:2] == hoved.kriterier[:2]
for j, navn in enumerate(former[2:], start=2):
utfall = [
eierskap.eierresultat(
x, strom, dataclasses.replace(x.eierformer[navn], zeta=x.eierformer[navn].s)
)
for x, (_, strom) in zip(trekninger, per_trekning, strict=True)
]
assert med_29.kriterier[j] == eierskap.eierkriterier(navn, utfall, lcoc(navn))
assert med_29.kriterier[j] != hoved.kriterier[j]
def test_uten_eps_e_er_effektivitetsraden_hovedkjoringen(oppdiktet: LagInndata) -> None:
trekninger = [
dataclasses.replace(x, v={**x.v, "eps_e": 0.0}) for x in _eiertrekninger(oppdiktet)
]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
kall = {"scenario": NORM, "losninger": (Losning.C,)}
assert kj.eierformer_paa_trinnet(
trekninger,
valg,
EOS,
rad=Eierrad.EFFEKTIVITET,
**kall, # type: ignore[arg-type]
) == kj.eierformer_paa_trinnet(trekninger, valg, EOS, **kall) # type: ignore[arg-type]
def test_statens_kontantstrom_ved_siden_av_M6_over_trekningene(oppdiktet: LagInndata) -> None:
"""Clarification 123: S30 for the wholly owned company in the stable year, over M6's base."""
trekninger = [*_eiertrekninger(oppdiktet), oppdiktet(n_reaktor=40.0)]
valg = Trinnvalg(trinn=2, grunnlag=Grunnlag.HOYESTE)
t = kj.eierformer_paa_trinnet(trekninger, valg, EOS, scenario=NORM, losninger=(Losning.A,))[
Losning.A
]
assert t is not None
# with 40 MW of reactors a year the second facility of A does not start by 2060
assert t.antall_byggbare == 3
tall = []
for x in trekninger[:3]:
res, strom = _eier(x)
heleid = eierskap.eierresultat(x, strom, x.eierformer["heleid_selskap"])
tall.append(eierskap.statens_kontantstrom_ved_m6(x, res, heleid))
assert all(v is not None for v in tall)
assert t.statens_kontantstrom == kj.sidetall(tall)
assert t.statens_kontantstrom is not None
assert t.statens_kontantstrom.antall == 3

View file

@ -0,0 +1,613 @@
"""The switches of the sensitivity list in the model code: lines 4, 7, 8, 10, 12, 13, 20 and 21.
Clarifications 118 a, 119, 120 and 121 of the specification. Every switch is
checked three ways: off it gives the main run's figures exactly, on it changes
the place the text names as a hand computation gives, and it is refused for the
solutions its line does not apply to. Everything is computed on the made-up set
in ``conftest.py``; the numbers say nothing about the hypothesis.
"""
from __future__ import annotations
import math
from dataclasses import replace
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import eierskap as ei
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import nivaaisert as nv
from tokenfabrikker import skala
from tokenfabrikker.kontantstrom import Knapphet, Paaslagsform
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
NORM = Knapphet.NORMALISERING
STEG = {"A>=A*": 1.0, "0.99<=A<A*": 0.9, "0.95<=A<0.99": 0.7, "A<0.95": 0.0}
"""The steps of clarification 119 c, as the text gives them."""
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
def _med(inn: Inndata, **verdier: float) -> Inndata:
"""The set with quantities the made-up set does not have (P_dim0, tau_pi)."""
return replace(inn, v={**inn.v, **verdier})
def _crf(rho: float, levetid: float) -> float:
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
def _diskontering(res: ks.Programresultat, rho: float) -> np.ndarray:
return np.array([(1.0 + rho) ** -(t - res.plan.T_0) for t in res.aar])
def _regn(
inn: Inndata,
losning: Losning,
*,
N_anlegg: int = 2,
knapphet: Knapphet = NORM,
**dim_valg: object,
) -> ks.Programresultat:
dim = ks.dimensjoner(inn, losning, **dim_valg) # type: ignore[arg-type]
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
return ks.regn_program(inn, losning, plan, knapphet, dim=dim)
def _samme_kontantstrom(a: ks.Programresultat, b: ks.Programresultat) -> None:
"""The yearly cash flows and the effects outside them are the same to the last digit."""
for felt in ("KS_D", "KS_N", "F_a", "Delta_W", "utslipp", "K_prog", "V"):
assert getattr(a, felt).tobytes() == getattr(b, felt).tobytes(), felt
assert a.kraftaar == b.kraftaar
# ------------------------------------------------------------ which solutions
@pytest.mark.parametrize(
("valg", "gjelder"),
[
({"minstelast": 0.2}, ks.SMAA_ENHETER),
({"fritt_enhetsvalg": True}, ks.SMAA_ENHETER),
({"gamma_trinn": True}, {Losning.A}),
({"paaslag_kjernekraft": 0.02}, ks.KJERNEKRAFT_PAA_NETT),
({"skaler_K_U": False}, ks.SMAA_ENHETER),
({"bare_over_dimensjonerende_feil": True}, ks.KJERNEKRAFT_PAA_NETT),
],
)
def test_en_bryter_gjelder_bare_losningene_linja_nevner(
oppdiktet: LagInndata, valg: dict[str, object], gjelder: set[Losning]
) -> None:
"""Clarifications 117 to 121: a row is not computed for a solution its line does not name."""
inn = replace(oppdiktet(), Gamma_trinn=STEG)
for losning in Losning:
if losning in gjelder:
ks.dimensjoner(inn, losning, **valg) # type: ignore[arg-type]
else:
with pytest.raises(ValueError, match="applies to"):
ks.dimensjoner(inn, losning, **valg) # type: ignore[arg-type]
def test_minstelast_og_fritt_valg_er_to_rader(oppdiktet: LagInndata) -> None:
with pytest.raises(ValueError, match="two rows"):
ks.dimensjoner(oppdiktet(), Losning.A, minstelast=0.2, fritt_enhetsvalg=True)
def test_valgene_staar_paa_dimensjoneringen(oppdiktet: LagInndata) -> None:
hoved = ks.dimensjoner(oppdiktet(), Losning.B)
assert (hoved.paaslag_kjernekraft, hoved.skaler_K_U, hoved.bare_over_dimensjonerende_feil) == (
0.0,
True,
False,
)
med = ks.dimensjoner(
oppdiktet(), Losning.B, paaslag_kjernekraft=0.02, bare_over_dimensjonerende_feil=True
)
assert med.paaslag_kjernekraft == 0.02
assert med.bare_over_dimensjonerende_feil
assert replace(med, paaslag_kjernekraft=0.0, bare_over_dimensjonerende_feil=False) == hoved
# ------------------------------------------------------------------- line 7
@pytest.mark.parametrize("losning", [Losning.A, Losning.B_MERKET])
def test_linje_7_minstelast_paa_plassen_til_lambda_i_s7(
oppdiktet: LagInndata, losning: Losning
) -> None:
"""119 a: P_u = max{P <= chi 0.20 PUE P_IT} = max{P <= 24 MW} = 20 MW, m = ceil(1200 / 20)."""
inn = oppdiktet()
hoved = ks.dimensjoner(inn, losning)
dim = ks.dimensjoner(inn, losning, minstelast=0.20)
assert (hoved.P_u, hoved.m) == (50.0, 24)
assert (dim.P_u, dim.m) == (20.0, 60)
# S8 with the design values for a unit below 300 MW: o' = (1 - 0.1) 0.04
r = lg.s8_reserveenheter(m=60, o_merket=0.9 * 0.04, A_krav=0.99)
n_p = lg.s8_planlagt_ute(m=60, r=r, o_p=0.05)
assert (dim.r, dim.n_p, dim.N_u) == (r, n_p, 60 + r + n_p)
assert dim.P_G_N == dim.N_u * 20.0
# lambda is unchanged everywhere else
assert dim.E_D == hoved.E_D == pytest.approx(E_D)
res = _regn(inn, losning, N_anlegg=1, minstelast=0.20)
assert res.verk[0][0].effekt == dim.N_u * 20.0
if losning is Losning.A:
assert dim.Gamma == lg.s44_inntektsfaktor(m=60, r=r, o_f_A=0.04, beta_F=0.1)
def test_linje_7_gir_b_merket_samme_enheter_som_a(oppdiktet: LagInndata) -> None:
a = ks.dimensjoner(oppdiktet(), Losning.A, minstelast=0.20)
b = ks.dimensjoner(oppdiktet(), Losning.B_MERKET, minstelast=0.20)
assert (a.P_u, a.m, a.r, a.n_p, a.N_u) == (b.P_u, b.m, b.r, b.n_p, b.N_u)
assert b.Gamma == 1.0
# ------------------------------------------------------------------- line 8
def test_linje_8_billigste_storrelse_er_den_med_lavest_c_A(oppdiktet: LagInndata) -> None:
"""119 b: c_A for every size; the chosen one has the lowest, and A's units follow it."""
inn = oppdiktet()
P_u, c_A = ks.billigste_enhetsstorrelse(inn, rho_A=0.08)
assert sorted(c_A) == sorted(inn.P_u_sett)
assert c_A[P_u] == min(c_A.values())
dim = ks.dimensjoner(inn, Losning.A, fritt_enhetsvalg=True)
assert dim.P_u == P_u
assert dim.m == math.ceil(1200.0 / P_u - 1e-9)
o_f = 0.04 if P_u < 300 else 0.02
assert dim.Gamma == lg.s44_inntektsfaktor(m=dim.m, r=dim.r, o_f_A=o_f, beta_F=0.1)
# with the size of the main run (50 MW, buffer 600 MW > 50 MW) c_A is the main run's S9
hoved = _regn(inn, Losning.A, N_anlegg=1)
assert hoved.dim.P_u == 50.0
assert c_A[50.0] == pytest.approx(nv.kraftkostnad_dedikert(inn, hoved, 0, 0.08), rel=1e-14)
def test_linje_8_bufferen_dekker_tapet_av_storste_enhet_i_c_A(oppdiktet: LagInndata) -> None:
"""119 b: P_buf = max(delta_L PUE P_IT, P). With delta_L 0.1 the buffer is 120 MW."""
inn = oppdiktet(delta_L=0.1)
_, c_A = ks.billigste_enhetsstorrelse(inn, rho_A=0.08)
hoved = ks.dimensjoner(inn, Losning.A)
for P in (500.0, 1000.0):
m = math.ceil(1200.0 / P)
r, n_p, N_u = ks._reserve(inn, P, m) # noqa: SLF001 - S8 as dimensjoner computes it
uten = replace(hoved, P_u=P, m=m, r=r, n_p=n_p, N_u=N_u, P_G_N=N_u * P)
ekstra = (P - 120.0) * (10e6 * _crf(0.08, 20) + 0.4e6) / E_D
assert c_A[P] == pytest.approx(ks.kraftkostnad_dedikert(inn, uten, 0, 0.08) + ekstra)
def test_linje_8_minste_storrelse_ved_likhet(
oppdiktet: LagInndata, monkeypatch: pytest.MonkeyPatch
) -> None:
monkeypatch.setattr(ks, "kraftkostnad_dedikert", lambda *_a, **_k: 1000.0)
P_u, _ = ks.billigste_enhetsstorrelse(oppdiktet(), rho_A=0.08)
assert P_u == 5.0
def test_linje_8_bufferen_staar_alle_steder_p_buf_staar(oppdiktet: LagInndata) -> None:
"""119 b: one buffer everywhere: the cash flow, S9, S31 and the business cash flow.
The same 50 MW units with delta_L 0.001 (a 1.2 MW buffer); with the free
choice the buffer is the 50 MW unit, and every place moves by 48.8 MW of buffer.
"""
inn = oppdiktet(delta_L=0.001)
dim = ks.dimensjoner(inn, Losning.A)
plan = ks.lag_plan(inn, Losning.A, dim, N_anlegg=1)
res = ks.regn_program(inn, Losning.A, plan, NORM, dim=dim)
fri = ks.regn_program(inn, Losning.A, plan, NORM, dim=replace(dim, fritt_enhetsvalg=True))
assert ks.bufferstorrelse(inn, dim) == pytest.approx(1.2)
assert ks.bufferstorrelse(inn, fri.dim) == 50.0
mer = 50.0 - 1.2
# the cash flow: the buffer is bought the year before start, and costs f_buf per year
start = plan.anlegg[0].start
j = start - 1 - 2027
assert fri.anlegg[0].buffer[j] - res.anlegg[0].buffer[j] == pytest.approx(mer * 10e6)
assert fri.anlegg[0].buffer[j + 2] - res.anlegg[0].buffer[j + 2] == pytest.approx(mer * 0.4e6)
# S9
aarlig = mer * (10e6 * _crf(0.08, 20) + 0.4e6)
assert nv.kraftkostnad_dedikert(inn, fri, 0, 0.08) - nv.kraftkostnad_dedikert(
inn, res, 0, 0.08
) == pytest.approx(aarlig / E_D)
# S31, in an operating year
B_res = skala.overskudd_utover_avkastning(inn, res)
B_fri = skala.overskudd_utover_avkastning(inn, fri)
assert B_res[j + 2] - B_fri[j + 2] == pytest.approx(aarlig)
# the business cash flow: the fixed cost of the buffer in every operating year
s_res, s_fri = ei.bedriftsstrom(inn, res), ei.bedriftsstrom(inn, fri)
assert s_fri.drift[j + 2] - s_res.drift[j + 2] == pytest.approx(mer * 0.4e6)
def test_linje_8_b_merket_faar_enhetene_til_a_og_ingen_buffer(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
a = ks.dimensjoner(inn, Losning.A, fritt_enhetsvalg=True)
b = ks.dimensjoner(inn, Losning.B_MERKET, fritt_enhetsvalg=True)
assert (a.P_u, a.m, a.r, a.n_p, a.N_u) == (b.P_u, b.m, b.r, b.n_p, b.N_u)
res = _regn(inn, Losning.B_MERKET, N_anlegg=1, fritt_enhetsvalg=True)
assert not res.anlegg[0].buffer.any()
assert res.verk[0][0].effekt == b.N_u * b.P_u
# ------------------------------------------------------------------ line 10
@pytest.mark.parametrize(
("A", "A_krav", "Gamma"),
[
(0.995, 0.995, 1.0),
(0.99499, 0.995, 0.9),
(0.99, 0.995, 0.9),
(0.98999, 0.995, 0.7),
(0.95, 0.995, 0.7),
(0.94999, 0.995, 0.0),
(0.0, 0.995, 0.0),
(0.99, 0.99, 1.0),
(0.98999, 0.99, 0.7),
(0.99995, 0.99995, 1.0),
(0.99994, 0.99995, 0.9),
],
)
def test_linje_10_trinnene_med_grensene(A: float, A_krav: float, Gamma: float) -> None:
"""119 c: 1.0 from A*, 0.9 from 0.99, 0.7 from 0.95, zero below; empty second step at 0.99."""
assert lg.s44_inntektsfaktor_trinn(tilgjengelighet=A, A_krav=A_krav, tabell=STEG) == Gamma
def test_linje_10_tilgjengeligheten_for_haand() -> None:
"""A = (1 - beta_F o_f) Pr[X >= m], X ~ Bin(m + r, 1 - o'), o' = (1 - beta_F) o_f.
m = 2, r = 1, o_f = 0.1, beta_F = 0.5: o' = 0.05, Pr[X >= 2] = 0.95^3 + 3 0.95^2 0.05.
"""
ventet = 0.95 * (0.95**3 + 3 * 0.95**2 * 0.05)
assert lg.s44_tilgjengelighet(m=2, r=1, o_f_A=0.1, beta_F=0.5) == pytest.approx(ventet)
assert ventet == pytest.approx(0.9431125)
def test_linje_10_gamma_staar_alle_steder_gamma_staar(oppdiktet: LagInndata) -> None:
"""119 c: A for the made-up plant is about 0.993; with A* = 0.995 Gamma is 0.9."""
inn = replace(oppdiktet(A_krav=0.995), Gamma_trinn=STEG)
dim = ks.dimensjoner(inn, Losning.A, gamma_trinn=True)
hoved = ks.dimensjoner(inn, Losning.A)
assert dim.tilgjengelighet == lg.s44_tilgjengelighet(m=dim.m, r=dim.r, o_f_A=0.04, beta_F=0.1)
assert dim.tilgjengelighet is not None
assert 0.99 <= dim.tilgjengelighet < 0.995
assert dim.Gamma == 0.9
assert (dim.P_u, dim.m, dim.N_u) == (hoved.P_u, hoved.m, hoved.N_u)
assert hoved.tilgjengelighet is None
plan = ks.lag_plan(inn, Losning.A, hoved, N_anlegg=1)
res = ks.regn_program(inn, Losning.A, plan, NORM, dim=hoved)
trinn = ks.regn_program(inn, Losning.A, plan, NORM, dim=dim)
j = plan.anlegg[0].start - 2027
assert trinn.anlegg[0].inntekt[j] == pytest.approx(res.anlegg[0].inntekt[j] * 0.9 / hoved.Gamma)
aargang = nv.kraftkostnad(inn, trinn, bedrift=True).aarganger[0]
assert aargang.inntekt == pytest.approx(0.9 * trinn.y(aargang.t_v))
# with A* = 0.99 the plant is in the first step
lav = replace(oppdiktet(), Gamma_trinn=STEG)
assert ks.dimensjoner(lav, Losning.A, gamma_trinn=True).Gamma == 1.0
# ---------------------------------------------------------------- lines 12, 13
def _lcoc_v() -> float:
"""S15 for the made-up competitor, per MW IT and year."""
return 100e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 3e6 + 8760.0 * 0.75 * 1.2 * 800.0
def test_linje_12_og_13_paaslaget_for_haand(oppdiktet: LagInndata) -> None:
"""120: pi_0 for every vintage, and pi_0 exp(-(t_v - 2026) / tau_pi), without the cut."""
inn = _med(oppdiktet(), tau_pi=2.5)
pi_0 = 150e6 / _lcoc_v() - 1.0
scenario = ks.regnekraftpris(inn, Knapphet.VARER, 2030)
varig = ks.regnekraftpris(inn, Knapphet.VARER, 2030, form=Paaslagsform.VARIG)
avtakende = ks.regnekraftpris(inn, Knapphet.VARER, 2030, form=Paaslagsform.AVTAKENDE)
for t_v in (2030, 2039, 2040, 2055):
assert varig.paaslag(t_v) == pytest.approx(pi_0)
assert avtakende.paaslag(t_v) == pytest.approx(pi_0 * math.exp(-(t_v - 2026) / 2.5))
assert varig(t_v) == pytest.approx(_lcoc_v() * (1.0 + pi_0))
assert scenario.paaslag(2039) == varig.paaslag(2039)
assert scenario.paaslag(2040) == 0.0
assert lg.s43_avtakende_paaslag(pi_0=0.5, t_v=2026, tau_pi=2.0) == 0.5
def test_linje_12_og_13_bare_naar_knappheten_varer(oppdiktet: LagInndata) -> None:
inn = _med(oppdiktet(), tau_pi=2.5)
for knapphet in (Knapphet.NORMALISERING, Knapphet.OVERKAPASITET):
for form in (Paaslagsform.VARIG, Paaslagsform.AVTAKENDE):
with pytest.raises(ValueError, match="knapphet varer"):
ks.regnekraftpris(inn, knapphet, 2030, form=form)
dim = ks.dimensjoner(inn, Losning.R)
plan = ks.lag_plan(inn, Losning.R, dim, N_anlegg=1)
with pytest.raises(ValueError, match="knapphet varer"):
ks.regn_program(inn, Losning.R, plan, knapphet, dim=dim, paaslag=form)
@pytest.mark.parametrize("losning", list(Losning))
def test_linje_12_varig_paaslag_i_inntekten_og_marginen(
oppdiktet: LagInndata, losning: Losning
) -> None:
"""The price in the result carries the form, so revenue and S19 follow (120)."""
inn = _med(oppdiktet(tau_nett=6.0, g_fornybar=0.5e6), tau_pi=2.5)
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=2)
hoved = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim)
varig = ks.regn_program(inn, losning, plan, Knapphet.VARER, dim=dim, paaslag=Paaslagsform.VARIG)
assert varig.y.form is Paaslagsform.VARIG
pi_0 = 150e6 / _lcoc_v() - 1.0
sene = [t_v for a in plan.anlegg for t_v in a.aarganger if t_v >= plan.t_1 + 10]
assert sene
for t_v in sene:
assert hoved.y.paaslag(t_v) == 0.0
assert varig.y(t_v) == pytest.approx(_lcoc_v() * (1.0 + pi_0))
for a in nv.kraftkostnad(inn, varig).aarganger:
assert a.margin is not None
assert a.margin.knapphet == pytest.approx(pi_0 * _lcoc_v())
assert varig.NNV > hoved.NNV
assert skala.overskudd_utover_avkastning(inn, varig).sum() > (
skala.overskudd_utover_avkastning(inn, hoved).sum()
)
# ------------------------------------------------------------------- line 20
@pytest.mark.parametrize("losning", [Losning.A, Losning.B_MERKET])
def test_linje_20_K_U_uten_skalering(oppdiktet: LagInndata, losning: Losning) -> None:
"""121: q_N E = N_u phi_U [K_U - min(K_U, D_fors)] with K_U unscaled; 50 MW units, N_u = 30."""
inn = oppdiktet()
hoved = _regn(inn, losning, N_anlegg=1)
uten = _regn(inn, losning, N_anlegg=1, skaler_K_U=False)
assert uten.dim.N_u == hoved.dim.N_u == 30
assert hoved.verk[0][0].ulykke == pytest.approx(30 * 1e-5 * (1e12 * 0.05 - 8e9))
assert uten.verk[0][0].ulykke == pytest.approx(30 * 1e-5 * (1e12 - 8e9))
j = hoved.plan.anlegg[0].start - 2027
assert uten.anlegg[0].ulykke[j] == pytest.approx(30 * 1e-5 * (1e12 - 8e9))
mer = 30 * 1e-5 * (1e12 - 8e9) - 30 * 1e-5 * (1e12 * 0.05 - 8e9)
if losning is Losning.A:
assert nv.kraftkostnad_dedikert(inn, uten, 0, 0.08) - nv.kraftkostnad_dedikert(
inn, hoved, 0, 0.08
) == pytest.approx(mer / E_D)
else:
E_N = hoved.verk[0][0].energi
assert nv.ulykkeskostnad_per_mwh(inn, uten, N_u=30, E_N=E_N) - nv.ulykkeskostnad_per_mwh(
inn, hoved, N_u=30, E_N=E_N
) == pytest.approx(mer / E_N)
# the other terms of S35 and the revenue are the same
assert uten.KS_D.tobytes() == hoved.KS_D.tobytes()
assert uten.KS_N - hoved.KS_N == pytest.approx(
-(uten.anlegg[0].ulykke - hoved.anlegg[0].ulykke)
)
# ------------------------------------------------------------------- line 21
def test_linje_21_s47_med_fradraget_for_haand() -> None:
assert (
lg.s47_utfall_ut_over_dimensjonerende_feil(
Delta_R=500.0, storste_enhet=980.0, P_dim0=1450.0
)
== 500.0
)
assert lg.s47_utfall_ut_over_dimensjonerende_feil(
Delta_R=500.0, storste_enhet=980.0, P_dim0=300.0
) == pytest.approx(-180.0)
def _snittpris(res: ks.Programresultat, t: int) -> float:
priser = [
res.mu_d(v) * res.y(v)
for v in (res.plan.aargang(k, t) for k in range(len(res.plan.anlegg)))
if v is not None
]
return math.fsum(priser) / len(priser) if priser else 0.0
@pytest.mark.parametrize("P_dim0", [0.0, 300.0, 1450.0])
@pytest.mark.parametrize("losning", [Losning.B, Losning.T_K])
def test_linje_21_bare_det_enheten_er_storre_enn_dimensjonerende_feil(
oppdiktet: LagInndata, losning: Losning, P_dim0: float
) -> None:
"""121: Delta R^-1' = Delta R - max(0, 980 - P_dim0) in both arms; M4 keeps the whole unit."""
inn = _med(oppdiktet(delta_V=0.0, tau_nett=6.0, g_fornybar=0.5e6), P_dim0=P_dim0)
hoved = _regn(inn, losning)
med = _regn(inn, losning, bare_over_dimensjonerende_feil=True)
assert med.kraftaar == hoved.kraftaar
assert max(rad.storste_enhet for rad in med.kraftaar) == pytest.approx(980.0)
fradrag = max(0.0, 980.0 - P_dim0)
F_bed = nv.effektkostnad_bedrift(inn, med)
for j, rad in enumerate(med.kraftaar[1:], start=1):
utfall = rad.Delta_R - (fradrag if rad.storste_enhet > 0 else 0.0)
y = _snittpris(med, med.aar[j])
assert med.F_a[j] == pytest.approx(
lg.s47_effektkostnad(
Delta_R=rad.Delta_R,
Delta_R_utfall=utfall,
c_fast=1.4e6,
c_res=1.0e6,
h_knapp=100.0,
mu=1.0,
y=y,
PUE=1.2,
),
abs=1e-6,
)
if y > 0:
assert F_bed[j] == pytest.approx(
lg.s47_utkobling(Delta_R_utfall=utfall, h_knapp=100.0, mu=1.0, y=y, PUE=1.2),
abs=1e-6,
)
if P_dim0 == 0.0:
# the whole unit counts: S47 as in the main run, to the last digit
assert med.F_a.tobytes() == hoved.F_a.tobytes()
assert med.NNV == hoved.NNV
else:
assert med.F_a.sum() < hoved.F_a.sum()
def test_linje_21_endrer_ikke_c_eller_r(oppdiktet: LagInndata) -> None:
"""No nuclear power on the grid: the largest new unit is zero, and the line does not apply."""
inn = _med(oppdiktet(delta_V=0.0), P_dim0=300.0)
for losning in (Losning.C, Losning.R):
assert all(rad.storste_enhet == 0.0 for rad in _regn(inn, losning).kraftaar)
# -------------------------------------------------------------------- line 4
def _kjernekraftens_egne(res: ks.Programresultat) -> np.ndarray:
"""The nuclear plants' own terms of S35 (sales, investment, operation, decommissioning)."""
v = res.varsigma.get(ks.KJERNEKRAFT, 1.0)
ut = np.zeros(len(res.aar))
for f in res.felles:
ut += v * f.salg - f.investering - f.drift - f.avvikling
for a in res.anlegg:
if ks.KJERNEKRAFT in a.salg:
i = ks.KJERNEKRAFT
ut += v * a.salg[i] - a.investering[i] - a.kraftdrift[i] - a.avvikling[i]
return ut
def _sett_for_linje_4(oppdiktet: LagInndata, losning: Losning) -> Inndata:
if losning is Losning.T_K:
return oppdiktet(tau_nett=6.0, g_fornybar=0.5e6, L_N=30.0)
return oppdiktet(L_N=30.0)
@pytest.mark.parametrize("losning", [Losning.B, Losning.B_MERKET, Losning.T_K])
def test_linje_4_kjernekraftens_egne_ledd_med_egen_rente(
oppdiktet: LagInndata, losning: Losning
) -> None:
"""118 a: rho_N + 0.02 = 0.08 for the nuclear plants' own terms in S26; the rest with 0.06.
The cash flows, the grid, q_N E, F_a and the other effects are unchanged.
"""
inn = _sett_for_linje_4(oppdiktet, losning)
hoved = _regn(inn, losning)
med = _regn(inn, losning, paaslag_kjernekraft=0.02)
assert dict(med.varsigma) == dict(hoved.varsigma)
_samme_kontantstrom(med, hoved)
assert (med.NV_datasenter, med.NV_ovrige) == (hoved.NV_datasenter, hoved.NV_ovrige)
egne = _kjernekraftens_egne(med)
assert egne.any()
resten = med.KS_N - egne
ventet = math.fsum(_diskontering(med, 0.08) * egne) + math.fsum(
_diskontering(med, 0.06) * resten
)
assert med.NV_kraft == pytest.approx(ventet, rel=1e-12)
assert hoved.NV_kraft == pytest.approx(
math.fsum(_diskontering(hoved, 0.06) * hoved.KS_N), rel=1e-12
)
# the decommissioning after the final year with 0.08 (S40): per group of the programme's
# units, and in B' per facility, where the value part is the same as in the main run
ventet_felles = math.fsum(
-f.avvikling_etter * 1.08**-f.L_rest * 1.08**-33 for f in med.felles if f.L_rest > 0
)
assert med.RV_felles == pytest.approx(ventet_felles)
if losning is Losning.B:
assert ventet_felles < 0
for a, rv_med, rv_hoved in zip(med.anlegg, med.RV_anlegg, hoved.RV_anlegg, strict=True):
avvikling = math.fsum(a.avvikling_etter.values())
endring = -avvikling * (1.08**-a.L_rest - 1.06**-a.L_rest) * 1.08**-33
assert rv_med - rv_hoved == pytest.approx(endring, abs=1e-3)
if losning is Losning.B_MERKET:
assert avvikling > 0
assert a.L_rest > 0
assert med.SE == lg.s26_subsidieelement(
naaverdi_prosjekt=med.NV_datasenter + med.NV_kraft + med.RV
)
@pytest.mark.parametrize("losning", [Losning.B, Losning.B_MERKET, Losning.T_K])
def test_linje_4_nivaaisert_og_skala_med_kjernekraftens_rente(
oppdiktet: LagInndata, losning: Losning
) -> None:
"""118 a: S3 and S5 and the plant's part of ann_k with 0.08; H_a and renewables with 0.06.
The levelised cost with the markup is the main run's with the rate 0.08 passed for
nuclear plants only, to the last digit.
"""
inn = _sett_for_linje_4(oppdiktet, losning)
hoved = _regn(inn, losning)
med = _regn(inn, losning, paaslag_kjernekraft=0.02)
renter = nv.Renter(rho_D=0.08, rho_N=0.06, rho_A=0.08, rho_NK=0.08)
assert nv.renter_i_hovedkjoringen(inn, med) == renter
assert nv.renter_i_hovedkjoringen(inn, hoved).rho_kjernekraft == 0.06
for bedrift in (False, True):
a = nv.kraftkostnad(inn, med, bedrift=bedrift)
b = nv.kraftkostnad(inn, hoved, bedrift=bedrift, renter=renter)
assert a.c_a.tobytes() == b.c_a.tobytes()
assert a.S42 == b.S42
assert np.nansum(a.c_a) > np.nansum(nv.kraftkostnad(inn, hoved, bedrift=bedrift).c_a)
assert (
skala.overskudd_utover_avkastning(inn, med).tobytes()
== skala.overskudd_utover_avkastning(inn, hoved, renter=renter).tobytes()
)
assert skala.overskudd_utover_avkastning(inn, med).sum() < (
skala.overskudd_utover_avkastning(inn, hoved).sum()
)
def test_linje_4_renten_for_kjernekraft_alene(oppdiktet: LagInndata) -> None:
"""118 a: with the markup only on nuclear plants, renewable plants in T-K keep rho_N."""
inn = _sett_for_linje_4(oppdiktet, Losning.T_K)
res = _regn(inn, Losning.T_K, paaslag_kjernekraft=0.02)
r = nv.renter_i_hovedkjoringen(inn, res)
fornybar = next(v for verk in res.verk for v in verk if v.teknologi == "vind")
assert r.rho_N == 0.06
assert nv.lcoe_fornybar(inn, fornybar.teknologi, r.rho_N) == nv.lcoe_fornybar(inn, "vind", 0.06)
# the grid connection of every module with rho_N
H_a = lg.s11_nettkostnad(
I_nett=5e6, delta_V=0.5, PUE=1.2, P_IT=100.0, P_G_N=0.0, rho_N=0.06, L_nett=40
)
assert H_a == pytest.approx(5e6 * 0.5 * 1.2 * 100.0 * _crf(0.06, 40))
def _nv_i(res: ks.Programresultat, varsigma: float, rho: float) -> float:
"""NV_i of S45 for the programme's units by hand: present value with ``rho``, and S40."""
D = _diskontering(res, rho)
salg = math.fsum(math.fsum(D * f.salg) for f in res.felles)
kost = math.fsum(math.fsum(D * (f.investering + f.drift + f.avvikling)) for f in res.felles)
rest = math.fsum(
lg.s40_restverdi(
NK_snitt=varsigma * float(np.mean(f.salg[-5:]))
- float(np.mean((f.investering + f.drift)[-5:])),
L_rest=f.L_rest,
rho_D=0.08,
rho_avvikling=rho,
avvikling=f.avvikling_etter,
T_s=2060,
T_0=2027,
)
for f in res.felles
if f.L_rest > 0
)
return varsigma * salg - kost + rest
def test_linje_4_tilleggsregelen_med_kjernekraftens_rente(oppdiktet: LagInndata) -> None:
"""118 a: NV_i in S45 with 0.08 for nuclear power. Cheap units make the rule bind."""
inn = oppdiktet(L_N=30.0, c_N_ref=10e6)
hoved = _regn(inn, Losning.B)
med = _regn(inn, Losning.B, paaslag_kjernekraft=0.02)
v_hoved, v_med = hoved.varsigma[ks.KJERNEKRAFT], med.varsigma[ks.KJERNEKRAFT]
assert v_hoved < v_med < 1.0
skala_ = math.fsum(math.fsum(f.salg) for f in med.felles)
assert _nv_i(med, v_med, 0.08) == pytest.approx(0.0, abs=1e-9 * skala_)
assert _nv_i(hoved, v_hoved, 0.06) == pytest.approx(0.0, abs=1e-9 * skala_)
assert _nv_i(med, v_hoved, 0.08) < 0.0
def test_linje_4_restverdien_i_bedriftsokonomien(oppdiktet: LagInndata) -> None:
"""The decommissioning after the final year in RV^bed with the nuclear plants' rate too."""
inn = oppdiktet(L_N=30.0)
med = _regn(inn, Losning.B, paaslag_kjernekraft=0.02)
_, felles = ei.restverdi_bedrift(inn, med)
assert felles == pytest.approx(
math.fsum(-f.avvikling_etter * 1.08**-f.L_rest for f in med.felles if f.L_rest > 0)
)

View file

@ -0,0 +1,446 @@
"""The switches of the sensitivity list in S26 and the ownership forms: lines 16, 17, 18 and 28.
Clarifications 118 b to d, 122 and 123 of the specification, and that every
switch at its default gives the main run's figures to the last digit.
Everything is computed on the made-up set in ``conftest.py``; the numbers say
nothing about the hypothesis.
"""
from __future__ import annotations
import math
from dataclasses import replace
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import eierskap as ei
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import nivaaisert as nv
from tokenfabrikker import skala
from tokenfabrikker.kontantstrom import Diskontering, Knapphet, Paaslagsform, Skattekostnad
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
NORM = Knapphet.NORMALISERING
def _crf(rho: float, levetid: float) -> float:
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
def _D(res: ks.Programresultat, rho: float) -> np.ndarray:
return np.array([(1.0 + rho) ** -(t - res.plan.T_0) for t in res.aar])
def _D_R(res: ks.Programresultat) -> np.ndarray:
"""The circular's rate, by hand: 4 % for years 1 to 40, 3 % to 75, 2 % after (118 b)."""
ut = []
for t in res.aar:
j = t - res.plan.T_0
ut.append(1.04 ** -min(j, 40) * 1.03 ** -min(max(j - 40, 0), 35) * 1.02 ** -max(j - 75, 0))
return np.array(ut)
def _pv(D: np.ndarray, tabell: np.ndarray) -> float:
return math.fsum(D * tabell)
def _sett(
oppdiktet: LagInndata,
losning: Losning,
*,
L_N: float = 20.0,
mu_rel: float = 1.0,
T_slutt: float = 2060.0,
) -> Inndata:
"""The made-up set; solution T with a later grid and a slower pace, so T-K builds nuclear."""
if losning.trinnvis:
return oppdiktet(tau_nett=6.0, g_fornybar=0.5e6, L_N=L_N, mu_rel=mu_rel, T_slutt=T_slutt)
return oppdiktet(L_N=L_N, mu_rel=mu_rel, T_slutt=T_slutt)
def _regn(
inn: Inndata,
losning: Losning,
*,
N_anlegg: int = 2,
knapphet: Knapphet = NORM,
**program: object,
) -> 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, **program) # type: ignore[arg-type]
def _alt(inn: Inndata, res: ks.Programresultat) -> dict[str, object]:
"""Every figure the run reads from a path, as bytes or numbers, for an exact comparison."""
ut: dict[str, object] = {
felt: getattr(res, felt)
for felt in ("NNV", "SE", "RV", "RV_anlegg", "RV_felles", "NV_kraft", "NV_datasenter")
}
for felt in ("KS_D", "KS_N", "F_a", "Delta_W", "V"):
ut[felt] = getattr(res, felt).tobytes()
ut["varsigma"] = dict(res.varsigma)
for bedrift in (False, True):
kost = nv.kraftkostnad(inn, res, bedrift=bedrift)
ut[f"c_a{bedrift}"] = kost.c_a.tobytes()
ut[f"S42{bedrift}"] = kost.S42
ut["B_6"] = skala.skala(inn, res).B_6.tobytes()
strom = ei.bedriftsstrom(inn, res, tilleggsregel=True)
ut["NK"] = strom.NK.tobytes()
for form in inn.eierformer.values():
e = ei.eierresultat(inn, strom, form)
ut[form.navn] = (e.NV_stat, e.KS_stat.tobytes())
ut[f"LCOC {form.navn}"] = ei.lcoc_med_kapitalkostnad(inn, res, ei.krav_for_skatt(inn, form))
return ut
# ------------------------------------------------------ off is the main run
@pytest.mark.parametrize("knapphet", list(Knapphet))
@pytest.mark.parametrize("losning", list(Losning))
def test_alle_brytere_av_gir_hovedkjoringen(
oppdiktet: LagInndata, losning: Losning, knapphet: Knapphet
) -> None:
"""Every switch given at its default value gives the main run to the last digit."""
inn = _sett(oppdiktet, losning, L_N=30.0)
hoved = _regn(inn, losning, knapphet=knapphet)
dim = ks.dimensjoner(
inn,
losning,
rho_A=None,
minstelast=None,
fritt_enhetsvalg=False,
gamma_trinn=False,
paaslag_kjernekraft=0.0,
skaler_K_U=True,
bare_over_dimensjonerende_feil=False,
)
assert dim == hoved.dim
av = ks.regn_program(
inn,
losning,
hoved.plan,
knapphet,
dim=dim,
paaslag=Paaslagsform.SCENARIO,
diskontering=Diskontering.MARKED,
skattekostnad=Skattekostnad.SUBSIDIE,
)
assert _alt(inn, av) == _alt(inn, hoved)
assert (av.K_inn, av.SE_stat, av.skattegrunnlag) == (None, None, av.SE)
strom = ei.bedriftsstrom(inn, av, tilleggsregel=True)
med_en = ei.bedriftsstrom(inn, av, tilleggsregel=True, kostnadsfaktor=1.0)
assert med_en.NK.tobytes() == strom.NK.tobytes()
assert med_en.avskrivning.tobytes() == strom.avskrivning.tobytes()
# -------------------------------------------------------------------- line 16
def test_linje_16_rundskrivets_rente_for_haand() -> None:
"""118 b: D_R(j) = 1.04^-min(j,40) 1.03^-min(max(j-40,0),35) 1.02^-max(j-75,0)."""
assert lg.s26_diskontering_rundskriv(j=0) == 1.0
assert lg.s26_diskontering_rundskriv(j=1) == pytest.approx(1 / 1.04)
assert lg.s26_diskontering_rundskriv(j=40) == pytest.approx(1.04**-40)
assert lg.s26_diskontering_rundskriv(j=41) == pytest.approx(1.04**-40 / 1.03)
assert lg.s26_diskontering_rundskriv(j=75) == pytest.approx(1.04**-40 * 1.03**-35)
assert lg.s26_diskontering_rundskriv(j=76) == pytest.approx(1.04**-40 * 1.03**-35 / 1.02)
assert lg.s26_diskontering_rundskriv(j=80) == pytest.approx(1.04**-40 * 1.03**-35 * 1.02**-5)
def test_linje_16_restverdien_med_rundskrivets_rente_for_haand() -> None:
"""118 b: every amount after the final year from the year it falls; T_s - T_0 = 73."""
D = [lg.s26_diskontering_rundskriv(j=73 + x) for x in range(5)]
assert lg.s40_restverdi_rundskriv(
NK_snitt=10.0, L_rest=4, avvikling=5.0, T_s=2100, T_0=2027
) == pytest.approx(10.0 * (D[1] + D[2] + D[3] + D[4]) - 5.0 * D[4])
# a facility that loses money gets no value, but the decommissioning is deducted
assert lg.s40_restverdi_rundskriv(
NK_snitt=-10.0, L_rest=4, avvikling=5.0, T_s=2100, T_0=2027
) == pytest.approx(-5.0 * D[4])
assert (
lg.s40_restverdi_rundskriv(NK_snitt=10.0, L_rest=0, avvikling=5.0, T_s=2100, T_0=2027) == 0
)
@pytest.mark.parametrize("losning", list(Losning))
def test_linje_16_bare_naaverdien_i_s26_regnes_om(oppdiktet: LagInndata, losning: Losning) -> None:
"""118 b: S26 with D_R everywhere, in A too; S45, S42, M3, M4 and M6 with the market's rates."""
inn = _sett(oppdiktet, losning, T_slutt=2100.0)
hoved = _regn(inn, losning)
rund = _regn(inn, losning, diskontering=Diskontering.RUNDSKRIV)
assert rund.diskontering is Diskontering.RUNDSKRIV
assert dict(rund.varsigma) == dict(hoved.varsigma)
for felt in ("KS_D", "KS_N", "F_a", "Delta_W", "V"):
assert getattr(rund, felt).tobytes() == getattr(hoved, felt).tobytes()
assert rund.kraftaar == hoved.kraftaar # M3 and M4
a, b = nv.kraftkostnad(inn, rund, bedrift=True), nv.kraftkostnad(inn, hoved, bedrift=True)
assert a.S42 == b.S42 # M2
assert skala.skala(inn, rund).B_6.tobytes() == skala.skala(inn, hoved).B_6.tobytes() # M6
D_R = _D_R(rund)
assert rund.NV_datasenter == pytest.approx(_pv(D_R, rund.KS_D), rel=1e-12)
assert rund.NV_kraft == pytest.approx(_pv(D_R, rund.KS_N), rel=1e-12, abs=1e-3)
ovrige = rund.Delta_W - rund.utslipp - rund.K_prog - rund.V
assert rund.NV_ovrige == pytest.approx(_pv(D_R, ovrige), rel=1e-12, abs=1e-3)
assert rund.SE == lg.s26_subsidieelement(
naaverdi_prosjekt=rund.NV_datasenter + rund.NV_kraft + rund.RV
)
assert rund.NNV == pytest.approx(
rund.NV_datasenter + rund.NV_kraft + rund.NV_ovrige - 0.2 * rund.SE + rund.RV
)
assert rund.NNV != hoved.NNV
@pytest.mark.parametrize("losning", [Losning.A, Losning.B])
def test_linje_16_restverdien_i_s26(oppdiktet: LagInndata, losning: Losning) -> None:
"""118 b: S40 with D_R. The average NK is found from the main run's S40 (positive here)."""
inn = oppdiktet(L_N=30.0)
hoved = _regn(inn, losning)
rund = _regn(inn, losning, diskontering=Diskontering.RUNDSKRIV)
rho_avv = 0.08 if losning is Losning.A else 0.06
for a, rv_h, rv_r in zip(hoved.anlegg, hoved.RV_anlegg, rund.RV_anlegg, strict=True):
assert a.L_rest > 0
assert rv_h > 0
avv = math.fsum(a.avvikling_etter.values())
NK = (rv_h * 1.08**33 + avv * (1 + rho_avv) ** -a.L_rest) * _crf(0.08, a.L_rest)
D = [lg.s26_diskontering_rundskriv(j=33 + x) for x in range(1, a.L_rest + 1)]
assert rv_r == pytest.approx(max(0.0, NK * math.fsum(D)) - avv * D[-1], rel=1e-9)
ventet = math.fsum(
-f.avvikling_etter * lg.s26_diskontering_rundskriv(j=33 + f.L_rest)
for f in rund.felles
if f.L_rest > 0
)
assert rund.RV_felles == pytest.approx(ventet)
if losning is Losning.B:
assert ventet < 0
# ------------------------------------------------------------- line 17, row 2
def _investeringer(res: ks.Programresultat, inn: Inndata) -> tuple[np.ndarray, ...]:
"""Every investment of S34 and S35 by hand: data centre, power (without nuclear), nuclear.
The buffer's table in the cash flow also holds f_buf P_buf in each operating year;
that is operation and is taken out here.
"""
datasenter, kraft, kjerne = (np.zeros(len(res.aar)) for _ in range(3))
for k, a in enumerate(res.anlegg):
datasenter += a.I_bygg + a.I_H
for i, investering in a.investering.items():
if i == ks.KJERNEKRAFT:
kjerne += investering
else:
kraft += investering
kraft += a.I_nett + a.I_g
if not res.losning.paa_nett:
drift = np.array([1.0 if res.plan.i_drift(k, t) else 0.0 for t in res.aar])
kraft += a.buffer - drift * inn["f_buf"] * ks.bufferstorrelse(inn, res.dim)
for f in res.felles:
kjerne += f.investering
return datasenter, kraft, kjerne
@pytest.mark.parametrize("losning", list(Losning))
def test_linje_17_all_innskutt_kapital(oppdiktet: LagInndata, losning: Losning) -> None:
"""118 c: varphi K_inn in place of varphi SE; K_inn as each term is discounted in S26."""
inn = _sett(oppdiktet, losning)
hoved = _regn(inn, losning)
alle = _regn(inn, losning, skattekostnad=Skattekostnad.ALL_KAPITAL)
datasenter, kraft, kjerne = _investeringer(alle, inn)
rho_kraft = 0.08 if losning is Losning.A else 0.06
K_inn = (
_pv(_D(alle, 0.08), datasenter)
+ _pv(_D(alle, rho_kraft), kraft)
+ _pv(_D(alle, rho_kraft), kjerne)
)
assert alle.K_inn is not None
assert alle.K_inn == pytest.approx(K_inn, rel=1e-12)
assert alle.K_inn > alle.SE > 0
assert alle.skattegrunnlag == alle.K_inn
assert alle.SE == hoved.SE
assert alle.SE_stat is None
assert alle.NNV == pytest.approx(hoved.NNV - 0.2 * (alle.K_inn - hoved.SE), rel=1e-12)
if losning is Losning.A:
assert kjerne.any()
assert (alle.anlegg[0].buffer - kraft).any()
# -------------------------------------------------------------------- line 18
@pytest.mark.parametrize("losning", list(Losning))
def test_linje_18_subsidieelementet_med_statens_laanerente(
oppdiktet: LagInndata, losning: Losning
) -> None:
"""118 d: SE = max(0, -[sum D_stat (KS_D + KS_N) + RV^stat]) with r_stat = 0.02 for S40 too.
With L_N = 30 the facilities and units run past 2060; the average NK of each facility is
found from the main run's S40. A lower share sold in «overkapasitet» makes SE positive.
"""
inn = _sett(oppdiktet, losning, L_N=30.0, mu_rel=0.8)
hoved = _regn(inn, losning, knapphet=Knapphet.OVERKAPASITET)
stat = _regn(
inn, losning, knapphet=Knapphet.OVERKAPASITET, skattekostnad=Skattekostnad.STATENS_RENTE
)
rho_avv = 0.08 if losning is Losning.A else 0.06
RV_stat = []
for a, rv in zip(hoved.anlegg, hoved.RV_anlegg, strict=True):
avv = math.fsum(a.avvikling_etter.values())
if a.L_rest == 0:
RV_stat.append(0.0)
continue
# the value part of the main run's S40; zero when the facility loses money
verdi = rv * 1.08**33 + avv * (1 + rho_avv) ** -a.L_rest
NK = verdi * _crf(0.08, a.L_rest) if verdi > 1e-6 * max(1.0, avv) else 0.0
RV_stat.append((NK / _crf(0.02, a.L_rest) - avv * 1.02**-a.L_rest) * 1.02**-33)
if losning is not Losning.R:
assert any(rv > 0 for rv in RV_stat), "a facility with value after the final year"
RV_stat += [
-f.avvikling_etter * 1.02**-f.L_rest * 1.02**-33 for f in stat.felles if f.L_rest > 0
]
D = _D(stat, 0.02)
SE_stat = max(0.0, -(_pv(D, stat.KS_D) + _pv(D, stat.KS_N) + math.fsum(RV_stat)))
assert stat.SE_stat is not None
assert stat.SE_stat == pytest.approx(SE_stat, rel=1e-9)
assert stat.SE_stat > 0
assert stat.SE == hoved.SE
assert stat.skattegrunnlag == stat.SE_stat
assert stat.RV == hoved.RV
assert stat.NNV == pytest.approx(hoved.NNV - 0.2 * (stat.SE_stat - hoved.SE), rel=1e-12)
# -------------------------------------------------------------------- line 28
@pytest.mark.parametrize("losning", [Losning.A, Losning.B, Losning.C, Losning.R, Losning.T_K])
def test_linje_28_kostnadene_ganges_med_faktoren(oppdiktet: LagInndata, losning: Losning) -> None:
"""122: investments (I^bud too) and operation times 1.1; the excepted items are not.
Excepted: power bought, electricity tax, grid tariff, q_N E and the capacity cost.
Fuel, waste fee and decommissioning are multiplied; sales are not costs.
"""
inn = _sett(oppdiktet, losning, L_N=30.0)
res = _regn(inn, losning)
en = ei.bedriftsstrom(inn, res, tilleggsregel=True)
med = ei.bedriftsstrom(inn, res, tilleggsregel=True, kostnadsfaktor=1.1)
assert med.investering == pytest.approx(1.1 * en.investering)
assert med.budsjett == pytest.approx(1.1 * en.budsjett)
assert med.avskrivning == pytest.approx(1.1 * en.avskrivning)
assert med.avskrivning_fast == pytest.approx(1.1 * en.avskrivning_fast)
# zero at the end of the final year, up to the last digits of the sums
assert med.kapital == pytest.approx(1.1 * en.kapital, abs=1e-2)
assert med.inntekt.tobytes() == en.inntekt.tobytes()
assert med.elavgift.tobytes() == en.elavgift.tobytes()
ganges = np.zeros(len(res.aar))
for k, a in enumerate(res.anlegg):
ganges += a.drift + sum(a.kraftdrift.values(), np.zeros(len(res.aar)))
ganges += sum(a.avvikling.values(), np.zeros(len(res.aar)))
if not res.losning.paa_nett:
drives = np.array([1.0 if res.plan.i_drift(k, t) else 0.0 for t in res.aar])
ganges += drives * inn["f_buf"] * ks.bufferstorrelse(inn, res.dim)
for f in res.felles:
ganges += f.drift + f.avvikling
assert ganges.any()
assert med.drift - en.drift == pytest.approx(0.1 * ganges, abs=1e-3)
# the residual value follows the cash flow with the factor, the decommissioning too
RV_anlegg, RV_felles = ei.restverdi_bedrift(inn, res, tilleggsregel=True, kostnadsfaktor=1.1)
assert med.restverdi_anlegg == RV_anlegg
assert RV_felles == pytest.approx(1.1 * en.restverdi_felles)
netto = ei.netto_per_anlegg(inn, res, tilleggsregel=True, kostnadsfaktor=1.1)
assert (
sum(netto, np.zeros(len(res.aar))).sum()
< sum(ei.netto_per_anlegg(inn, res, tilleggsregel=True), np.zeros(len(res.aar))).sum()
)
def test_linje_28_kostnaden_for_regnekraft_med_faktoren(oppdiktet: LagInndata) -> None:
"""122: LCOC^bed with the factor on building, IT hardware and operation.
R's power cost is the price, tax, tariff and the disconnection arm, which are not
multiplied. gamma_H = 0, so every vintage moves by the same amount.
"""
inn = oppdiktet()
res = _regn(inn, Losning.R)
r = 0.05
en = ei.lcoc_med_kapitalkostnad(inn, res, r)
med = ei.lcoc_med_kapitalkostnad(inn, res, r, kostnadsfaktor=1.1)
endring = 0.1 * (100e6 * 1.1 * _crf(r, 15) + 200e6 * _crf(r, 5) + 2e6 + 0.5e6)
assert med - en == pytest.approx(endring)
with pytest.raises(ValueError, match="business version"):
nv.kraftkostnad(inn, res, kostnadsfaktor=1.1)
@pytest.mark.parametrize("losning", [Losning.A, Losning.B_MERKET, Losning.C])
def test_linje_28_kraftverkenes_kostnad_med_faktoren(
oppdiktet: LagInndata, losning: Losning
) -> None:
"""122: in S9 and S5 every cost but q_N times the factor; in LCOE_i investment and operation."""
inn = oppdiktet()
res = _regn(inn, losning, N_anlegg=1)
if losning is Losning.A:
en = ks.kraftkostnad_dedikert(inn, res.dim, 0, 0.08)
med = ks.kraftkostnad_dedikert(inn, res.dim, 0, 0.08, kostnadsfaktor=1.1)
q_N = lg.s6_ulykkeskostnad(
N_u=30, phi_U=1e-5, K_U=1e12, D_fors=8e9, P_u=50.0, P_ref=1000.0, E=res.dim.E_D
)
assert med == pytest.approx(1.1 * (en - q_N) + q_N)
elif losning is Losning.B_MERKET:
numre = ks.enhetsnumre(res.dim, 1)
E_N = res.verk[0][0].energi
en = nv.lcoe_kjernekraft(inn, res, numre=numre, E_N=E_N, rho=0.06)
med = nv.lcoe_kjernekraft(inn, res, numre=numre, E_N=E_N, rho=0.06, kostnadsfaktor=1.1)
q_N = nv.ulykkeskostnad_per_mwh(inn, res, N_u=30, E_N=E_N)
assert med == pytest.approx(1.1 * (en - q_N) + q_N)
else:
for teknologi in ("vann", "vind", "havvind"):
en = nv.lcoe_fornybar(inn, teknologi, 0.06)
assert nv.lcoe_fornybar(inn, teknologi, 0.06, kostnadsfaktor=1.1) == pytest.approx(
1.1 * en
)
# ------------------------------------------------------------ clarification 123
def test_123_statens_kontantstrom_ved_m6(oppdiktet: LagInndata) -> None:
"""S30 for the wholly owned company in the first year of stable operation over SNKS_snitt."""
inn = oppdiktet()
res = _regn(inn, Losning.R)
strom = ei.bedriftsstrom(inn, res, tilleggsregel=True)
heleid = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
stabilt = skala.forste_aar_med_stabil_drift(res)
assert stabilt is not None
assert ei.statens_kontantstrom_ved_m6(inn, res, heleid) == pytest.approx(
float(heleid.KS_stat[stabilt - 2027]) / 500e9
)
with pytest.raises(ValueError, match="heleid_selskap"):
ei.statens_kontantstrom_ved_m6(
inn, res, ei.eierresultat(inn, strom, inn.eierformer["direkte"])
)
def test_123_uten_aar_med_stabil_drift(oppdiktet: LagInndata) -> None:
"""Facilities of three years that are never in operation together have no such year."""
inn = oppdiktet(s_brikker=0.01, L_N=3.0)
res = _regn(inn, Losning.R)
strom = ei.bedriftsstrom(inn, res, tilleggsregel=True)
heleid = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
assert ei.statens_kontantstrom_ved_m6(inn, res, heleid) is None
def test_gamma_trinn_tabellen_er_tom_i_det_oppdiktede_settet(oppdiktet: LagInndata) -> None:
"""The table is only carried by a set used for line 10; without it the row cannot be run."""
inn = oppdiktet()
assert inn.Gamma_trinn == {}
with pytest.raises(KeyError):
ks.dimensjoner(inn, Losning.A, gamma_trinn=True)
assert ks.dimensjoner(replace(inn, Gamma_trinn={"A>=A*": 1.0}), Losning.A, gamma_trinn=True)