feat(kode): first coding of business economics, ownership, scale, environment and verdicts

Chapters 7 to 11 of the specification, on the made-up set only:

- nivaaisert: the power cost per facility, year and vintage on levelised
  form (S9, S11 with clarifications 2, 11, 13 and 15), S15, S19, S27, S42
- eierskap: the business cash flow with every asset booked, tax, S28, S29
  and S30 for the four ownership forms, the criteria over the draws
- skala: S31 year by year, the first year with stable operation, M6
- miljo: S32 year by year, the rules of M5 (i) and (ii)
- dommer: S37, the verdict per target, the step of the ladder, the overall
  verdicts; tested on invented outcomes
- kontantstrom: each asset is recorded as it is paid, and the price of
  compute exposes the competitor's cost and the markup

This is an intermediate step. The readings are not settled: an independent
reader is coding the same from the specification alone, a first comparison
agrees on the levelised cost, S19, S42, the cash flows, M3 and M4 and
differs on depreciation at the final year, tax, debt and two definitions.
Chapter 16 gets the clarifications before any result is computed.
Nothing is computed for the hypothesis; the parameter file is unchanged.

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

View file

@ -30,13 +30,19 @@ carousel, Python code, and a Claude plugin (own repo, later).
`inndata.py` holds one set of values in the equations' units (`Inndata`; `fra_trekning` builds it for a draw). `inndata.py` holds one set of values in the equations' units (`Inndata`; `fra_trekning` builds it for a draw).
`utbygging.py` (S22: start years, IT vintages, export stops), `kraftsystem.py` (S23 to S25, S38) and `utbygging.py` (S22: start years, IT vintages, export stops), `kraftsystem.py` (S23 to S25, S38) and
`kontantstrom.py` (S26, S34, S35, S40, S45: `lag_plan`, `regn_program`) put the equations together over the `kontantstrom.py` (S26, S34, S35, S40, S45: `lag_plan`, `regn_program`) put the equations together over the
years. So far: chapters 1 to 6; business economics, ownership, scale, environment and verdicts are not coded yet. years. `nivaaisert.py` (the power cost per facility, year and vintage on levelised form; S15, S19, S27, S42),
`eierskap.py` (S28 to S30: business cash flow, tax, ownership forms, the criteria over the draws), `skala.py`
(S31, M6), `miljo.py` (S32, the rules of M5) and `dommer.py` (S37, the verdict per target, the step of the
ladder, the overall verdicts) cover chapters 7 to 11. They are a first coding: the readings in them are being
held against an independent reader's code and are not yet settled in chapter 16. The run over the draws, the
sensitivities and the tools of chapter 12 are not coded yet.
- `data/trekninger.npy` and `data/trekninger.json`: the 10 000 draws of the 87 drawn quantities, in the parameter - `data/trekninger.npy` and `data/trekninger.json`: the 10 000 draws of the 87 drawn quantities, in the parameter
file's units. `data/aarshendelser.npy` and `.json`: one uniform number per draw and year 2028–2100 for the file's units. `data/aarshendelser.npy` and `.json`: one uniform number per draw and year 2028–2100 for the
export rule (own seed). Committed; every later computation reads them. export rule (own seed). Committed; every later computation reads them.
- `tests/`: unit tests per equation, the loader, the draws, and `test_fasit.py` (known answers from Argonne, - `tests/`: unit tests per equation, the loader, the draws, and `test_fasit.py` (known answers from Argonne,
NOU 2026: 4, Epoch and NVE with the sources' own assumptions). Build-out, power system and cash flow are tested NOU 2026: 4, Epoch and NVE with the sources' own assumptions). Build-out, power system and cash flow are tested
on the made-up set of values in `tests/conftest.py`. on the made-up set of values in `tests/conftest.py`, and so are the levelised cost, ownership, scale and
environment. The verdicts are tested on invented outcomes per draw.
- `requirements.txt` (numpy, scipy) and `requirements-dev.txt` (pytest, ruff, mypy) pin exact versions; - `requirements.txt` (numpy, scipy) and `requirements-dev.txt` (pytest, ruff, mypy) pin exact versions;
`pyproject.toml` only configures the tools (ruff `ALL`, mypy strict). `pyproject.toml` only configures the tools (ruff `ALL`, mypy strict).

View file

@ -0,0 +1,322 @@
"""The verdicts (chapter 11 of the specification and the pre-registration).
A verdict is read from the share of the draws in which a condition is met
(S37). This module holds the condition per draw for each target, the verdict
from the shares (the table in chapter 11), the step of the ladder the verdicts
are read on (pre-registration, clarification 1) and the overall verdicts.
A draw in which the path cannot be built has no values; it is passed in as
None. It counts in the denominator and never meets the condition for «holder».
In M1, M2, M6 and M7, where «holder ikke» is that too few draws reach the
target, it counts as a draw that does not reach it. In M3 and M4, where
«holder ikke» is a harm that occurs, it meets neither condition. That reading,
and which step counts as one that can be built, are NOT settled yet: they go
to chapter 16 of the specification and to the project owner before any result
is computed.
The thresholds are those of the pre-registration. Nothing here is computed
from the parameter file: the functions take outcomes per draw.
"""
from __future__ import annotations
import enum
import math
import statistics
from dataclasses import dataclass
from typing import TYPE_CHECKING, Final
from tokenfabrikker import kraftsystem
from tokenfabrikker import ligninger as lg
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Mapping, Sequence
from tokenfabrikker.inndata import Inndata
from tokenfabrikker.kontantstrom import Programresultat
Utfall = Sequence[float | None]
ANDEL_HOLDER: Final = 0.8
"""«Holder» needs the condition met in at least this share of the draws."""
ANDEL_HOLDER_IKKE: Final = 0.2
"""M1, M2 and M7: «holder ikke» when the target is reached in less than this share."""
ANDEL_M7: Final = 0.5
"""M7: «holder» when A is best in at least half of the draws."""
M3_HOYST: Final = 0.05
M3_OVER: Final = 0.15
"""M3: at most 5 % increase holds; more than 15 % in one price area does not."""
M6_MINST: Final = 0.25
M6_UNDER: Final = 0.05
"""M6: at least 25 % of the petroleum cash flow holds; under 5 % does not."""
DOMSLOSNINGER: Final = (Losning.A, Losning.B, Losning.C)
"""The solutions the verdict for part I is about (pre-registration, clarification 3)."""
MAAL_DEL_I: Final = ("M1", "M2", "M3", "M4", "M5", "M6")
MAAL_SOM_FELLER: Final = ("M1", "M2", "M3", "M4", "M5")
class Dom(enum.StrEnum):
"""The three verdicts of the pre-registration."""
HOLDER = "holder"
BETINGELSER = "holder under betingelser"
HOLDER_IKKE = "holder ikke"
class Grunnlag(enum.StrEnum):
"""Which step of the ladder the verdicts are read on (clarification 1)."""
TRINN_25 = "25 %-trinnet"
TRINN_5 = "5 %-trinnet"
HOYESTE = "høyeste trinn (skalaen nås ikke)"
INGEN = "ingen trinn lar seg bygge"
# -------------------------------------------------------------- the shares of S37
def andel(utfall: Utfall, vilkaar: float, *, minst: bool) -> float:
"""S37 for a threshold: the share of all draws with a value at least / below ``vilkaar``.
``minst=True`` counts values >= the threshold; a draw without a value does
not count. ``minst=False`` counts values strictly below it.
"""
if minst:
return lg.s37_andel([x is not None and x >= vilkaar for x in utfall])
return lg.s37_andel([x is not None and x < vilkaar for x in utfall])
def andel_positiv(utfall: Utfall) -> float:
"""The share of all draws with a strictly positive value."""
return lg.s37_andel([x is not None and x > 0 for x in utfall])
def median(utfall: Utfall) -> float:
"""The median over all draws, with a draw without a value ranked below every value."""
return statistics.median(-math.inf if x is None else x for x in utfall)
def dom_av_andeler(andel_holder: float, andel_holder_ikke: float) -> Dom:
"""M3, M4 and M6: the verdict from the shares of the two conditions (clarification 2)."""
if andel_holder >= ANDEL_HOLDER:
return Dom.HOLDER
if andel_holder_ikke >= ANDEL_HOLDER:
return Dom.HOLDER_IKKE
return Dom.BETINGELSER
def dom_av_andel_som_naar(andel_naar: float, *, holder_fra: float = ANDEL_HOLDER) -> Dom:
"""M1, M2 and M7: the verdict from the share of the draws that reach the target."""
if andel_naar >= holder_fra:
return Dom.HOLDER
if andel_naar < ANDEL_HOLDER_IKKE:
return Dom.HOLDER_IKKE
return Dom.BETINGELSER
# ----------------------------------------------------------------- the targets
def dom_m1(nnv: Utfall) -> Dom:
"""M1: net present value positive in at least 80 % of the draws and a positive median."""
dom = dom_av_andel_som_naar(andel_positiv(nnv))
if dom is Dom.HOLDER and not median(nnv) > 0:
return Dom.BETINGELSER
return dom
def dom_m2(s42: Utfall) -> Dom:
"""M2: S42 not negative in at least 80 % of the draws; «holder ikke» under 20 %."""
return dom_av_andel_som_naar(andel(s42, 0.0, minst=True))
def m3_verste_prisvirkning(inn: Inndata, res: Programresultat) -> float:
"""M3 in one draw: the largest Delta p_z / p_z^0 over price areas, weather and operating years.
A negative number is a price fall. Years in which no facility of the path
is operated do not count.
"""
verst = -math.inf
sett: dict[tuple[float, bool], float] = {}
for j, t in enumerate(res.aar):
if res.plan.antall_i_drift(t) == 0:
continue
rad = res.kraftaar[j]
for Delta_Q, tort in ((rad.Delta_Q, False), (rad.Delta_Q_tort, True)):
if (Delta_Q, tort) not in sett:
andeler = kraftsystem.relativ_prisvirkning(inn, Delta_Q=Delta_Q, tort=tort)
sett[Delta_Q, tort] = max(andeler.values())
verst = max(verst, sett[Delta_Q, tort])
return verst
def dom_m3(verste: Utfall) -> Dom:
"""M3: at most 5 % in every area in 80 % of the draws; over 15 % in one area in 80 %."""
holder = lg.s37_andel([x is not None and x <= M3_HOYST for x in verste])
holder_ikke = lg.s37_andel([x is not None and x > M3_OVER for x in verste])
return dom_av_andeler(holder, holder_ikke)
@dataclass(frozen=True)
class Forsyning:
"""M4 in one draw, over the operating years (pre-registration, clarification 4).
Attributes:
ikke_svakere_uten_tiltak: the power balance for the rest of the country is not weaker
in a normal or in the dry year (Delta Q <= 0), and the capacity balance with the
largest new unit out is not weaker (Delta R^-1 >= 0), in every operating year.
svakere_ogsaa_med_tiltak: the power balance is weaker in at least one operating year.
The measures of S47 cover missing capacity, without an upper limit, but not energy.
"""
ikke_svakere_uten_tiltak: bool
svakere_ogsaa_med_tiltak: bool
def m4_forsyning(inn: Inndata, res: Programresultat) -> Forsyning:
"""M4 in one draw from the power system year by year (S23, S24)."""
slakk_energi = lg.AVRUNDINGSTOLERANSE * res.plan.N_anlegg * res.dim.E_D
slakk_effekt = lg.AVRUNDINGSTOLERANSE * res.plan.N_anlegg * inn["PUE"] * inn["P_IT"]
energi_svakere = effekt_svakere = False
for j, t in enumerate(res.aar):
if res.plan.antall_i_drift(t) == 0:
continue
rad = res.kraftaar[j]
energi_svakere |= max(rad.Delta_Q, rad.Delta_Q_tort) > slakk_energi
effekt_svakere |= rad.Delta_R_utfall < -slakk_effekt
return Forsyning(
ikke_svakere_uten_tiltak=not (energi_svakere or effekt_svakere),
svakere_ogsaa_med_tiltak=energi_svakere,
)
def dom_m4(forsyning: Sequence[Forsyning | None]) -> Dom:
"""M4: not weaker without measures in 80 % of the draws; weaker also with measures in 80 %."""
holder = lg.s37_andel([f is not None and f.ikke_svakere_uten_tiltak for f in forsyning])
holder_ikke = lg.s37_andel([f is not None and f.svakere_ogsaa_med_tiltak for f in forsyning])
return dom_av_andeler(holder, holder_ikke)
def dom_m6(m6: Utfall) -> Dom:
"""M6: at least 25 % in 80 % of the draws holds; under 5 % in 80 % does not.
A draw in which the path cannot be built, or never has every facility in
operation at once, does not reach 5 %.
"""
holder = andel(m6, M6_MINST, minst=True)
under = lg.s37_andel([x is None or x < M6_UNDER for x in m6])
return dom_av_andeler(holder, under)
def a_er_best(nnv_A: Utfall, nnv_B: Utfall, nnv_C: Utfall) -> list[bool]:
"""M7 per draw: NNV_A > max(NNV_B, NNV_C), among the solutions that can be built.
A draw in which A cannot be built is not one where A is best.
"""
best = []
for a, b, c in zip(nnv_A, nnv_B, nnv_C, strict=True):
andre = [x for x in (b, c) if x is not None]
best.append(a is not None and all(a > x for x in andre))
return best
def dom_m7(nnv_A: Utfall, nnv_B: Utfall, nnv_C: Utfall) -> Dom:
"""M7: A has the highest net present value in at least half of the draws; under 20 % not."""
return dom_av_andel_som_naar(lg.s37_andel(a_er_best(nnv_A, nnv_B, nnv_C)), holder_fra=ANDEL_M7)
# ------------------------------------------------- the step of the ladder
@dataclass(frozen=True)
class Trinnvalg:
"""The step the verdicts are read on.
Attributes:
trinn: the number of facilities; None when no step can be built.
grunnlag: why that step.
"""
trinn: int | None
grunnlag: Grunnlag
def _laveste_trinn(m6: Mapping[int, Mapping[Losning, Utfall]], minst: float) -> int | None:
for trinn in sorted(m6):
if any(
andel(m6[trinn][a], minst, minst=True) >= ANDEL_HOLDER
for a in DOMSLOSNINGER
if a in m6[trinn]
):
return trinn
return None
def trinn_for_dommene(m6: Mapping[int, Mapping[Losning, Utfall]]) -> Trinnvalg:
"""Pre-registration, clarification 1: which step of the ladder the verdicts are read on.
``m6[trinn][losning]`` holds M6 per draw in «normalisering» (None where the
path cannot be built or has no year of stable operation). The 25 % step is
the lowest step where at least 80 % of the draws reach 25 % for one of A, B
and C; the 5 % step likewise. Without either, the verdicts are read on the
highest step that can be built: the highest where one of A, B and C has a
value in at least 80 % of the draws (a reading that is not settled yet).
"""
for minst, grunnlag in ((M6_MINST, Grunnlag.TRINN_25), (M6_UNDER, Grunnlag.TRINN_5)):
trinn = _laveste_trinn(m6, minst)
if trinn is not None:
return Trinnvalg(trinn=trinn, grunnlag=grunnlag)
for trinn in sorted(m6, reverse=True):
byggbar = [
lg.s37_andel([x is not None for x in m6[trinn][a]])
for a in DOMSLOSNINGER
if a in m6[trinn]
]
if any(b >= ANDEL_HOLDER for b in byggbar):
return Trinnvalg(trinn=trinn, grunnlag=Grunnlag.HOYESTE)
return Trinnvalg(trinn=None, grunnlag=Grunnlag.INGEN)
# ------------------------------------------------------------ the overall verdicts
def del_I(
dommer: Mapping[Losning, Mapping[str, Dom]],
median_m1: Mapping[Losning, float],
valg: Trinnvalg,
) -> Dom:
"""The verdict for part I (the programme), as far as it follows from the targets.
``dommer[losning]`` holds the verdicts for M1 to M6 on the step in ``valg``,
``median_m1`` the median net present value. «Holder»: one of A, B and C has
M1 to M6 all holding, on the 25 % step, with more than one facility.
«Holder ikke»: each of them has at least one of M1 to M5 not holding, or a
median in M1 that is not positive. Otherwise it holds under conditions;
whether the conditions can be named within the range of the sources
(clarification 5) is decided where the thresholds are computed.
"""
if valg.trinn is None:
return Dom.HOLDER_IKKE
losninger = [a for a in DOMSLOSNINGER if a in dommer]
felt = [
any(dommer[a][m] is Dom.HOLDER_IKKE for m in MAAL_SOM_FELLER) or not median_m1[a] > 0
for a in losninger
]
if all(felt):
return Dom.HOLDER_IKKE
alle_holder = any(all(dommer[a][m] is Dom.HOLDER for m in MAAL_DEL_I) for a in losninger)
if alle_holder and valg.grunnlag is Grunnlag.TRINN_25 and valg.trinn > 1:
return Dom.HOLDER
return Dom.BETINGELSER
def del_II(m7: Dom) -> Dom:
"""The verdict for part II (the power solution) follows M7."""
return m7

View file

@ -0,0 +1,426 @@
"""Business cash flow, tax and ownership (chapters 7 and 8): S28, S29 and S30.
``bedriftsstrom`` gives the project's cash flow as a business sees it: what is
actually paid (grid tariff and electricity tax instead of marginal grid
losses, no grid investment, the disconnection arm of S47), with every asset
booked and depreciated. The power plants' sales come without the
additionality rule for M2 and S28, and with the factor of S45 for S30
(chapter 1.4 of the specification). ``naaverdi_etter_skatt`` is S28 for one
ownership form, and ``eierresultat`` S30: the cost of capital (S29), the tax,
the company's free cash flow to its owners and the state's net cash flow. The
functions at the end turn the outcomes of many draws into the criteria of the
pre-registration.
How the text is read here: the project is one taxpayer; the booked capital is
what is paid minus straight-line depreciation; the debt is the share h_e of the
booked capital, with the real borrowing rate, and is repaid at the final year;
tax is computed as if the project had no debt. These readings are NOT settled
yet: they are being held against an independent reader's coding, and what is
chosen will stand in chapter 16 of the specification before any result is
computed.
Nothing here reads the parameter file or draws random numbers.
"""
from __future__ import annotations
import math
from dataclasses import dataclass
from typing import TYPE_CHECKING, Final
import numpy as np
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import nivaaisert
from tokenfabrikker.nivaaisert import Renter
if TYPE_CHECKING:
from collections.abc import Mapping, Sequence
import numpy.typing as npt
from tokenfabrikker.inndata import Eierform, Inndata
from tokenfabrikker.kontantstrom import Eiendel, Programresultat
Tabell = npt.NDArray[np.float64]
ANDEL_DAARLIGSTE: Final = 0.05
"""The share of the draws the average of the worst outcomes is taken over (chapter 8)."""
RISIKOGRENSE: Final = 0.25
"""Pre-registration: the probability that the state loses money shall be below this."""
EOS_BESTAAR_IKKE: Final = "består ikke"
"""The assessment that takes an ownership form out; the others are «består» and «usikker»."""
@dataclass(frozen=True)
class Bedriftsstrom:
"""The project's cash flow as a business pays it, kr per year (index t - T_0).
Attributes:
inntekt: Y, the revenue from compute.
drift: K^drift: operation, power bought, electricity tax, grid tariff, the power
plants' operation and accident cost, the disconnection arm of S47 and the
decommissioning when it is paid, minus the power plants' sales.
avgifter: the electricity tax and grid tariff that are part of ``drift``; the state's
income in S30.
investering: I, every investment but the grid connection (the tariff covers it).
budsjett: I^bud, the same with the overrun factor xi_N = 1.
avskrivning: straight-line depreciation over each asset's lifetime.
kapital: the booked capital at the end of each year.
"""
inntekt: Tabell
drift: Tabell
avgifter: Tabell
investering: Tabell
budsjett: Tabell
avskrivning: Tabell
kapital: Tabell
@property
def NK(self) -> Tabell:
"""The project's net cash flow before tax and financing."""
return self.inntekt - self.drift - self.investering
@dataclass(frozen=True)
class Eierresultat:
"""One ownership form for one path in one draw.
Attributes:
eierform: the ownership form.
r_e: its cost of capital, real (S29; the state's borrowing rate with direct ownership).
selskapsskatt: corporate tax per year for the whole project, kr.
saerskatt: special tax per year for the whole project, kr.
gjeld: the company's debt at the end of each year, for the whole project, kr.
FKE: the free cash flow to the owners after tax and debt service, whole project, kr.
KS_stat: the state's net cash flow per year (S30), kr.
NV_stat: its present value with the state's borrowing rate, kr.
NV_NK: the present value of the project's net cash flow with the same rate, kr.
storste_innskutte_kapital: the largest cumulative, undiscounted net payment from the
state over time, kr.
"""
eierform: Eierform
r_e: float
selskapsskatt: Tabell
saerskatt: Tabell
gjeld: Tabell
FKE: Tabell
KS_stat: Tabell
NV_stat: float
NV_NK: float
storste_innskutte_kapital: float
@property
def andel_av_overskudd(self) -> float | None:
"""The state's share of the surplus: NV_stat / NV_NK when the latter is positive."""
return self.NV_stat / self.NV_NK if self.NV_NK > 0 else None
# ------------------------------------------------------------ the business cash flow
def _eiendeler(res: Programresultat) -> list[Eiendel]:
"""Every asset the business owns: all but the grid connection."""
alle = [e for a in res.anlegg for e in a.eiendeler]
alle += [e for f in res.felles for e in f.eiendeler]
return [e for e in alle if e.slag != ks.NETT]
def _investering_og_avskrivning(
res: Programresultat,
) -> tuple[Tabell, Tabell, Tabell]:
"""Payments as made, the same at budget, and depreciation, per year."""
T_0, T_s = res.plan.T_0, res.plan.T_s
investering, budsjett, avskrivning = (
np.zeros(len(res.aar), dtype=np.float64) for _ in range(3)
)
for e in _eiendeler(res):
for j, andel in enumerate(lg.byggeaar_andeler(tau=e.byggetid)):
investering[e.start - 1 - j - T_0] += e.kostnad * andel
budsjett[e.start - 1 - j - T_0] += e.budsjett * andel
for t in range(e.start, min(e.slutt, T_s) + 1):
avskrivning[t - T_0] += lg.s28_avskrivning(
kostnad=e.kostnad, levetid=e.levetid, start=e.start, slutt=e.slutt, t=t
)
return investering, budsjett, avskrivning
def bedriftsstrom(
inn: Inndata, res: Programresultat, *, tilleggsregel: bool = False
) -> Bedriftsstrom:
"""Chapter 7: the cash flow of the path in ``res`` as a business pays it.
The same years, prices, plants and build-out as the cash flow of S26, with
the swaps of chapter 7. The grid tariff is paid for every facility that is
operated, the electricity tax on the power the data centres use, also in A.
``tilleggsregel=True`` multiplies the power plants' sales by the factor of
S45; that is the cash flow S30 is computed on, while M2 and S28 use the
sales as they are.
"""
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)
i_drift = np.array([plan.antall_i_drift(t) for t in res.aar], dtype=np.float64)
pris = np.array([rad.pris for rad in res.kraftaar], dtype=np.float64)
brukt = med_last * res.dim.E_D
avgifter = inn["t_el"] * brukt
drift = sum((a.drift + a.ulykke for a in res.anlegg), null.copy()) + avgifter
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:
faktor = res.varsigma[ks.KJERNEKRAFT] if tilleggsregel else 1.0
drift += f.drift + f.ulykke + f.avvikling - faktor * f.salg
if res.losning.paa_nett:
tariff = i_drift * lg.s27_nettariff(t_nett=inn["t_nett"], PUE=inn["PUE"], P_IT=inn["P_IT"])
avgifter = avgifter + tariff
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 = _investering_og_avskrivning(res)
return Bedriftsstrom(
inntekt=sum((a.inntekt for a in res.anlegg), null.copy()),
drift=drift,
avgifter=avgifter,
investering=investering,
budsjett=budsjett,
avskrivning=avskrivning,
kapital=np.cumsum(investering - avskrivning),
)
# ------------------------------------------------------------- one ownership form
def kapitalkostnad(inn: Inndata, eierform: Eierform) -> float:
"""S29: r_e, real. With direct ownership it is the state's borrowing rate as drawn."""
if eierform.r_q is None:
return inn["r_stat"]
return lg.s29_kapitalkostnad(
h=eierform.h, r_d=eierform.r_d, r_q=eierform.r_q, tau_s=inn["tau_s"], iota=inn["iota"]
)
def lcoc_med_kapitalkostnad(inn: Inndata, res: Programresultat, r_e: float) -> 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.
"""
kost = nivaaisert.kraftkostnad(
inn, res, bedrift=True, renter=Renter(rho_D=r_e, rho_N=r_e, rho_A=r_e)
)
vekter = [
lg.diskonteringsfaktor(rho=inn["rho_D"], t=a.t_v, T_0=res.plan.T_0) for a in kost.aarganger
]
return math.fsum(w * a.LCOC for w, a in zip(vekter, kost.aarganger, strict=True)) / math.fsum(
vekter
)
def _skatt(
inn: Inndata, strom: Bedriftsstrom, eierform: Eierform, r_e: float
) -> tuple[Tabell, Tabell]:
"""Corporate tax and special tax per year for the whole project, as if it had no debt."""
kapital_inn = np.concatenate(([0.0], strom.kapital[:-1]))
selskap, saer = lg.s30_skatt(
overskudd=[float(x) for x in strom.inntekt - strom.drift - strom.avskrivning],
kapital_inn=[float(x) for x in kapital_inn],
tau_s=inn["tau_s"] if eierform.skatt else 0.0,
tau_g=eierform.tau_g,
r_e=r_e,
)
return np.array(selskap, dtype=np.float64), np.array(saer, dtype=np.float64)
def naaverdi_etter_skatt(inn: Inndata, strom: Bedriftsstrom, eierform: Eierform) -> float:
"""S28: NV_e, the project's present value after tax with the cost of capital r_e, kr.
``strom`` is the business cash flow without the additionality rule. The
whole project is taxed as one company; nothing is counted after the final
year.
"""
r_e = kapitalkostnad(inn, eierform)
selskapsskatt, saerskatt = _skatt(inn, strom, eierform, r_e)
netto = strom.NK - selskapsskatt - saerskatt
return lg.s28_naaverdi(netto=[float(x) for x in netto], rente=r_e)
def eierresultat(inn: Inndata, strom: Bedriftsstrom, eierform: Eierform) -> Eierresultat:
"""S29 and S30 for one ownership form.
``strom`` is the business cash flow with the factor of the additionality
rule on the power plants' sales. Tax is computed for the project as one
taxpayer, as if it had no debt. The state receives the tax of the
company's part, 1 - theta_e, and the electricity tax and grid tariff of
the whole project. The debt is h_e of the booked capital, carries the real
borrowing rate and is repaid at the final year. With direct ownership the
free cash flow to the owner is the project's net cash flow.
"""
e = eierform
r_e = kapitalkostnad(inn, e)
NK = strom.NK
selskapsskatt, saerskatt = _skatt(inn, strom, e, r_e)
skatt = selskapsskatt + saerskatt
if e.r_q is None:
gjeld = np.zeros_like(NK)
FKE = NK.copy()
else:
gjeld = e.h * strom.kapital
gjeld[-1] = 0.0
gjeld_inn = np.concatenate(([0.0], gjeld[:-1]))
rente = lg.realrente(nominell=e.r_d, iota=inn["iota"])
FKE = NK - skatt - rente * gjeld_inn + gjeld - gjeld_inn
KS_stat = lg.s30_statens_kontantstrom(
skatt=(1.0 - e.theta) * skatt + strom.avgifter,
FKE=FKE,
NK=NK,
overskridelse=np.maximum(0.0, strom.investering - strom.budsjett),
s=e.s,
theta=e.theta,
zeta=e.zeta,
)
return Eierresultat(
eierform=e,
r_e=r_e,
selskapsskatt=selskapsskatt,
saerskatt=saerskatt,
gjeld=gjeld,
FKE=FKE,
KS_stat=KS_stat,
NV_stat=lg.s28_naaverdi(netto=[float(x) for x in KS_stat], rente=inn["r_stat"]),
NV_NK=lg.s28_naaverdi(netto=[float(x) for x in NK], rente=inn["r_stat"]),
storste_innskutte_kapital=storste_innskutte_kapital(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))))
# ------------------------------------------------- the criteria over the draws
def sannsynlighet_for_tap(NV_stat: Sequence[float]) -> float:
"""Chapter 8: the share of the draws in which the present value of S30 is negative."""
return lg.s37_andel([x < 0 for x in NV_stat])
def snitt_av_de_daarligste(NV_stat: Sequence[float], andel: float = ANDEL_DAARLIGSTE) -> float:
"""Chapter 8: the average of the worst 5 % of the outcomes (rounded up to whole draws)."""
antall = max(1, math.ceil(andel * len(NV_stat) * (1.0 - lg.AVRUNDINGSTOLERANSE)))
return math.fsum(sorted(NV_stat)[:antall]) / antall
@dataclass(frozen=True)
class Eierkriterier:
"""The first three criteria of the pre-registration for one ownership form, over the draws.
Attributes:
navn: the ownership form.
verdi: the expected present value of the state's net cash flow, kr.
andel_av_overskudd: the expected present value of S30 over that of the project's net
cash flow, when the latter is positive; otherwise None.
r_e: the cost of capital (the average over the draws).
LCOC: the cost of compute with that cost of capital (the average over the draws).
tapssannsynlighet: the probability of a negative present value of S30.
daarligste: the average of the worst 5 % of the outcomes, kr.
kapital_ute: the largest capital the state has out (the average over the draws), kr.
"""
navn: str
verdi: float
andel_av_overskudd: float | None
r_e: float
LCOC: float
tapssannsynlighet: float
daarligste: float
kapital_ute: float
def eierkriterier(
navn: str, utfall: Sequence[Eierresultat], LCOC: Sequence[float]
) -> Eierkriterier:
"""The criteria for one ownership form from its outcome in every draw that can be built."""
NV_stat = [u.NV_stat for u in utfall]
NV_NK = math.fsum(u.NV_NK for u in utfall)
return Eierkriterier(
navn=navn,
verdi=math.fsum(NV_stat) / len(NV_stat),
andel_av_overskudd=math.fsum(NV_stat) / NV_NK if NV_NK > 0 else None,
r_e=math.fsum(u.r_e for u in utfall) / len(utfall),
LCOC=math.fsum(LCOC) / len(LCOC),
tapssannsynlighet=sannsynlighet_for_tap(NV_stat),
daarligste=snitt_av_de_daarligste(NV_stat),
kapital_ute=math.fsum(u.storste_innskutte_kapital for u in utfall) / len(utfall),
)
def _daarligere_paa_alt(a: Eierkriterier, b: Eierkriterier) -> bool:
"""True when ``a`` is worse than ``b`` on every measure of value, capital cost and risk."""
verdi = a.verdi < b.verdi and (
a.andel_av_overskudd is None
or b.andel_av_overskudd is None
or a.andel_av_overskudd < b.andel_av_overskudd
)
kapitalkostnad_ = a.r_e > b.r_e and a.LCOC > b.LCOC
risiko = (
a.tapssannsynlighet > b.tapssannsynlighet
and a.daarligste < b.daarligste
and a.kapital_ute > b.kapital_ute
)
return verdi and kapitalkostnad_ and risiko
@dataclass(frozen=True)
class Rangering:
"""The rule of the pre-registration applied to the ownership forms.
Attributes:
rangert: the forms that pass, best first by value for the public, among those within
the limit for the state's risk.
over_risikogrensen: forms that pass the first two tests but break the risk limit.
ute: forms that go out, with the reason.
"""
rangert: tuple[str, ...]
over_risikogrensen: tuple[str, ...]
ute: Mapping[str, str]
def ranger_eierformer(
kriterier: Sequence[Eierkriterier],
eos: Mapping[str, str],
*,
risikogrense: float = RISIKOGRENSE,
) -> Rangering:
"""Chapter 8, the rule: who goes out, and the ranking of the rest.
A form goes out when it does not pass the EEA assessment (``eos`` holds
«består», «usikker» or «består ikke» per form, decided outside the model),
or when another form is better on every measure of all the first three
criteria. The rest are ranked by value for the public, given the limit for
the state's risk.
"""
ute: dict[str, str] = {}
for a in kriterier:
if eos[a.navn] == EOS_BESTAAR_IKKE:
ute[a.navn] = "består ikke EØS-vurderingen"
continue
bedre = [b.navn for b in kriterier if b is not a and _daarligere_paa_alt(a, b)]
if bedre:
ute[a.navn] = f"dårligere enn {bedre[0]} på alle de tre første kriteriene"
igjen = sorted((a for a in kriterier if a.navn not in ute), key=lambda a: -a.verdi)
return Rangering(
rangert=tuple(a.navn for a in igjen if a.tapssannsynlighet < risikogrense),
over_risikogrensen=tuple(a.navn for a in igjen if a.tapssannsynlighet >= risikogrense),
ute=ute,
)

View file

@ -12,7 +12,8 @@ nothing is computed with them here.
from __future__ import annotations from __future__ import annotations
from dataclasses import dataclass import statistics
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Final, cast from typing import TYPE_CHECKING, Final, cast
from tokenfabrikker import ligninger as lg from tokenfabrikker import ligninger as lg
@ -35,6 +36,15 @@ SENTRAL_KARBONBANE: Final = "sentral"
HELE_NORGE: Final = "Norge" HELE_NORGE: Final = "Norge"
"""The column of NVE's table with the price for Norway as a whole.""" """The column of NVE's table with the price for Norway as a whole."""
HELEID_SELSKAP: Final = "heleid_selskap"
"""The ownership form the verdicts are computed with (pre-registration, clarification 3)."""
KM2_PER_TWH_TIL_PER_MWH: Final = 1e-6
"""The area table is in km2 per TWh per year; the equations use MWh."""
TOMT: Final = "tomt"
"""The entry of the area table that is per MW IT, not per TWh."""
@dataclass(frozen=True) @dataclass(frozen=True)
class Prislinje: class Prislinje:
@ -49,6 +59,33 @@ class Prislinje:
b: float b: float
@dataclass(frozen=True)
class Eierform:
"""One ownership form (chapter 8), as it stands in the parameter file.
Attributes:
navn: the id in the parameter file.
s: the state's share of the company.
theta: the state's direct share in the facilities outside the company.
tau_g: special tax on profit above the return r_e on booked capital.
h: share of the capital financed with debt.
r_d: borrowing rate, nominal.
r_q: required return on equity, nominal after tax; None with direct ownership.
zeta: the state's share of overruns.
skatt: False with direct ownership, where the state pays no corporate tax.
"""
navn: str
s: float
theta: float
tau_g: float
h: float
r_d: float
r_q: float | None
zeta: float
skatt: bool
@dataclass(frozen=True) @dataclass(frozen=True)
class Inndata: class Inndata:
"""One set of parameter values, in the units of the equations. """One set of parameter values, in the units of the equations.
@ -62,6 +99,10 @@ class Inndata:
linjer: the fitted price line per price area and for Norway (S38). linjer: the fitted price line per price area and for Norway (S38).
karbonpris: the carbon price at the years of the table, kr per tonne. karbonpris: the carbon price at the years of the table, kr per tonne.
u_eksport: one uniform number per year T_0 + 1 .. T_s for the export rule. u_eksport: one uniform number per year T_0 + 1 .. T_s for the export rule.
eierformer: the ownership forms by id (S29, S30).
areal: km2 per MWh per year for nuclear power and wind, and km2 per MW IT for the plot.
petroleum_median: the median of the state's net cash flow from petroleum over the ten
years, kr in current prices (shown next to M6).
""" """
v: Mapping[str, float] v: Mapping[str, float]
@ -72,6 +113,9 @@ class Inndata:
linjer: Mapping[str, Prislinje] linjer: Mapping[str, Prislinje]
karbonpris: Mapping[int, float] karbonpris: Mapping[int, float]
u_eksport: tuple[float, ...] u_eksport: tuple[float, ...]
eierformer: Mapping[str, Eierform] = field(default_factory=dict)
areal: Mapping[str, float] = field(default_factory=dict)
petroleum_median: float = 0.0
def __getitem__(self, navn: str) -> float: def __getitem__(self, navn: str) -> float:
"""The scalar quantity with this id, in the units of the equations.""" """The scalar quantity with this id, in the units of the equations."""
@ -112,6 +156,33 @@ def _ordbok_av_tall(verdi: object) -> dict[str, float]:
return {str(n): float(x) for n, x in cast("dict[str, float]", verdi).items()} return {str(n): float(x) for n, x in cast("dict[str, float]", verdi).items()}
def tolk_eierformer(tabell: object) -> dict[str, Eierform]:
"""The ownership forms of the parameter file's table, by id."""
former = {}
for navn, felt in cast("dict[str, dict[str, object]]", tabell).items():
r_q = felt["r_q"]
former[navn] = Eierform(
navn=navn,
s=float(cast("float", felt["s"])),
theta=float(cast("float", felt["theta"])),
tau_g=float(cast("float", felt["tau_g"])),
h=float(cast("float", felt["h"])),
r_d=float(cast("float", felt["r_d"])),
r_q=None if r_q is None else float(cast("float", r_q)),
zeta=float(cast("float", felt["zeta"])),
skatt=bool(felt["skatt"]),
)
return former
def tolk_areal(tabell: object) -> dict[str, float]:
"""The area table in the units of the equations: km2 per MWh per year, plot per MW IT."""
return {
navn: verdi if navn == TOMT else verdi * KM2_PER_TWH_TIL_PER_MWH
for navn, verdi in _ordbok_av_tall(tabell).items()
}
def fra_trekning( def fra_trekning(
sett: Parametersett, sett: Parametersett,
trekninger: Trekninger, trekninger: Trekninger,
@ -147,4 +218,7 @@ def fra_trekning(
linjer=tilpass_prislinjer(sett.pris_balanse()), linjer=tilpass_prislinjer(sett.pris_balanse()),
karbonpris=sett.karbonpris()[SENTRAL_KARBONBANE], karbonpris=sett.karbonpris()[SENTRAL_KARBONBANE],
u_eksport=tuple(float(u) for u in u_eksport), u_eksport=tuple(float(u) for u in u_eksport),
eierformer=tolk_eierformer(sett.tabell("eierformer")),
areal=tolk_areal(sett.tabell("alpha")),
petroleum_median=statistics.median(sett.petroleumsinntekt().values()),
) )

View file

@ -42,6 +42,12 @@ if TYPE_CHECKING:
KJERNEKRAFT: Final = "kjernekraft" KJERNEKRAFT: Final = "kjernekraft"
VANN: Final = "vann" VANN: Final = "vann"
BYGG: Final = "bygg"
IT: Final = "it"
NETT: Final = "nett"
BUFFER: Final = "buffer"
AGGREGAT: Final = "aggregat"
LINJE: Final = "linje"
DRIFT_PER_MW: Final = frozenset({"havvind"}) DRIFT_PER_MW: Final = frozenset({"havvind"})
"""Technologies whose operating cost in the parameter file is per MW and year, not per MWh.""" """Technologies whose operating cost in the parameter file is per MW and year, not per MWh."""
@ -98,6 +104,8 @@ class Kraftverk:
selges: False in A, where power that is not used cannot be sold. selges: False in A, where power that is not used cannot be sold.
investering: kr each time the plant is built. investering: kr each time the plant is built.
byggetid: years the investment is spread over before the first operating year. byggetid: years the investment is spread over before the first operating year.
renter_i_investeringen: True when the source's investment figure already holds interest
during construction (hydropower, clarification 10), so S3 is not applied on top.
levetid: whole years before the plant is renewed; None for nuclear power (not renewed). levetid: whole years before the plant is renewed; None for nuclear power (not renewed).
fast_drift: operation that does not depend on production, kr per year. fast_drift: operation that does not depend on production, kr per year.
variabel_drift: variable operation, fuel and waste fee at ``energi``, kr per year. In A variabel_drift: variable operation, fuel and waste fee at ``energi``, kr per year. In A
@ -116,6 +124,7 @@ class Kraftverk:
selges: bool selges: bool
investering: float investering: float
byggetid: float byggetid: float
renter_i_investeringen: bool
levetid: int | None levetid: int | None
fast_drift: float fast_drift: float
variabel_drift: float variabel_drift: float
@ -127,6 +136,30 @@ class Kraftverk:
w_tort: float w_tort: float
@dataclass(frozen=True)
class Eiendel:
"""One asset as it is paid for: what the tax rules and the levelised form need (chapter 7).
Attributes:
slag: bygg, it, kjernekraft, vann, vind, havvind, nett, buffer, aggregat or linje.
kostnad: kr as paid, with the overrun of S46 for nuclear power.
budsjett: kr with xi_N = 1 (I^bud in S30); equal to ``kostnad`` outside nuclear power.
start: first operating year.
byggetid: years the payment is spread over before ``start`` (clarification 21).
levetid: whole years the asset lasts (clarification 21).
slutt: last year the asset is in operation: its lifetime, or the last operating year
of the facility when that comes first. May lie after the final year.
"""
slag: str
kostnad: float
budsjett: float
start: int
byggetid: float
levetid: int
slutt: int
@dataclass(frozen=True) @dataclass(frozen=True)
class Enhetsgruppe: class Enhetsgruppe:
"""The nuclear units of B that enter operation the same year (clarification 29). """The nuclear units of B that enter operation the same year (clarification 29).
@ -159,6 +192,7 @@ class Fellesstrom:
ulykke: q_N E. ulykke: q_N E.
avvikling_etter: decommissioning that falls after the final year, kr. avvikling_etter: decommissioning that falls after the final year, kr.
L_rest: the units' operating years left after the final year. L_rest: the units' operating years left after the final year.
eiendeler: the units as one asset.
""" """
gruppe: Enhetsgruppe gruppe: Enhetsgruppe
@ -169,6 +203,7 @@ class Fellesstrom:
ulykke: Tabell ulykke: Tabell
avvikling_etter: float avvikling_etter: float
L_rest: int L_rest: int
eiendeler: tuple[Eiendel, ...]
def netto(self, varsigma: float) -> Tabell: def netto(self, varsigma: float) -> Tabell:
"""The units' part of S35: sales times ``varsigma`` minus every cost.""" """The units' part of S35: sales times ``varsigma`` minus every cost."""
@ -196,6 +231,7 @@ class Anleggsstrom:
bygg_i_drift: the years a building, first or renewed, enters operation. bygg_i_drift: the years a building, first or renewed, enters operation.
avvikling_etter: decommissioning per technology that falls after the final year, kr. avvikling_etter: decommissioning per technology that falls after the final year, kr.
L_rest: operating years left after the final year. L_rest: operating years left after the final year.
eiendeler: every asset of the facility, first and renewed, as it is paid for.
""" """
inntekt: Tabell inntekt: Tabell
@ -214,6 +250,7 @@ class Anleggsstrom:
bygg_i_drift: tuple[int, ...] bygg_i_drift: tuple[int, ...]
avvikling_etter: Mapping[str, float] avvikling_etter: Mapping[str, float]
L_rest: int L_rest: int
eiendeler: tuple[Eiendel, ...]
def datasenter(self) -> Tabell: def datasenter(self) -> Tabell:
"""S34 for this facility.""" """S34 for this facility."""
@ -252,6 +289,8 @@ class Programresultat:
knapphet: the price scenario for compute. knapphet: the price scenario for compute.
plan: the build-out. plan: the build-out.
dim: the dimensioning. dim: the dimensioning.
verk: the power plants that belong to each facility.
y: the price of compute per vintage (S18).
aar: the calendar years T_0 .. T_s. aar: the calendar years T_0 .. T_s.
kraftaar: the power system year by year (S23, S24). kraftaar: the power system year by year (S23, S24).
anlegg: the yearly amounts per facility. anlegg: the yearly amounts per facility.
@ -279,6 +318,8 @@ class Programresultat:
knapphet: Knapphet knapphet: Knapphet
plan: Plan plan: Plan
dim: Dimensjonering dim: Dimensjonering
verk: tuple[tuple[Kraftverk, ...], ...]
y: Regnekraftpris
aar: tuple[int, ...] aar: tuple[int, ...]
kraftaar: tuple[Kraftaar, ...] kraftaar: tuple[Kraftaar, ...]
anlegg: tuple[Anleggsstrom, ...] anlegg: tuple[Anleggsstrom, ...]
@ -313,6 +354,46 @@ def _utfallsrate(inn: Inndata, P_u: float) -> float:
return inn["o_f_liten"] if _liten(P_u) else inn["o_f_stor"] return inn["o_f_liten"] if _liten(P_u) else inn["o_f_stor"]
def brenselkostnad(inn: Inndata, P_u: float) -> float:
"""Chapter 1.2: fuel per MWh, u_N^A for units below 300 MW and u_N otherwise (kr/MWh)."""
return inn["u_N_liten"] if _liten(P_u) else inn["u_N"]
def enhetsnumre(dim: Dimensjonering, k: int) -> range:
"""Clarification 1: the numbers in the Norwegian series of the units of facility ``k``.
``k`` is 1 for the first facility (A and B').
"""
return range((k - 1) * dim.N_u + 1, k * dim.N_u + 1)
def investering_per_enhet(
inn: Inndata, dim: Dimensjonering, *, P_u: float, numre: Sequence[int], rho: float
) -> list[float]:
"""S2 and S3: the levelised-form investment of each unit, with interest during construction.
kr per unit, with the overrun factor of S46. ``rho`` is rho_N on the grid and rho_A in A.
"""
return [
lg.s3_investering_med_renter(
xi_N=dim.xi_N,
c_N=lg.s2_investering_per_mw(
c_N_ref=inn["c_N_ref"],
P_u=P_u,
P_ref=inn["P_ref"],
nu=inn["nu"],
ell=inn["ell"],
n_0=inn["n_0"],
n=n,
),
P_u=P_u,
rho=rho,
tau_N=inn["tau_N"],
)
for n in numre
]
def dimensjoner(inn: Inndata, losning: Losning, *, rho_A: float | None = None) -> Dimensjonering: def dimensjoner(inn: Inndata, losning: Losning, *, rho_A: float | None = None) -> Dimensjonering:
"""S7, S8, S10, S44 and S46 for one set of values. """S7, S8, S10, S44 and S46 for one set of values.
@ -442,7 +523,7 @@ def _kjernekraftverk(
"""The nuclear units with the numbers ``numre`` in the Norwegian series (S2, S5, S6).""" """The nuclear units with the numbers ``numre`` in the Norwegian series (S2, S5, S6)."""
antall = len(numre) antall = len(numre)
o_f = _utfallsrate(inn, P_u) o_f = _utfallsrate(inn, P_u)
brensel = inn["u_N_liten"] if _liten(P_u) else inn["u_N"] brensel = brenselkostnad(inn, P_u)
per_mw = math.fsum( per_mw = math.fsum(
lg.s2_investering_per_mw( lg.s2_investering_per_mw(
c_N_ref=inn["c_N_ref"], c_N_ref=inn["c_N_ref"],
@ -472,6 +553,7 @@ def _kjernekraftverk(
selges=selges, selges=selges,
investering=dim.xi_N * per_mw * P_u, investering=dim.xi_N * per_mw * P_u,
byggetid=inn["tau_N"], byggetid=inn["tau_N"],
renter_i_investeringen=False,
levetid=None, levetid=None,
fast_drift=antall * fast * P_u, fast_drift=antall * fast * P_u,
variabel_drift=(inn["v_N"] + brensel + inn["d_N"]) * energi, variabel_drift=(inn["v_N"] + brensel + inn["d_N"]) * energi,
@ -495,6 +577,7 @@ def _fornybart_kraftverk(inn: Inndata, teknologi: str, energi: float) -> Kraftve
selges=True, selges=True,
investering=inn[f"{teknologi}.investering"] * effekt, investering=inn[f"{teknologi}.investering"] * effekt,
byggetid=UTEN_BYGGETID if teknologi == VANN else inn[f"{teknologi}.byggetid"], byggetid=UTEN_BYGGETID if teknologi == VANN else inn[f"{teknologi}.byggetid"],
renter_i_investeringen=teknologi == VANN,
levetid=inn.heltall(f"{teknologi}.levetid"), levetid=inn.heltall(f"{teknologi}.levetid"),
fast_drift=inn[f"{teknologi}.drift"] * effekt if per_mw else 0.0, fast_drift=inn[f"{teknologi}.drift"] * effekt if per_mw else 0.0,
variabel_drift=0.0 if per_mw else inn[f"{teknologi}.drift"] * energi, variabel_drift=0.0 if per_mw else inn[f"{teknologi}.drift"] * energi,
@ -554,7 +637,7 @@ def kraftverk_for_anlegg(
B and R: nothing. In B the units belong to the programme (``enheter_i_B``). B and R: nothing. In B the units belong to the programme (``enheter_i_B``).
""" """
if losning in {Losning.A, Losning.B_MERKET}: if losning in {Losning.A, Losning.B_MERKET}:
numre = range((k - 1) * dim.N_u + 1, k * dim.N_u + 1) numre = enhetsnumre(dim, k)
if losning is Losning.A: if losning is Losning.A:
return ( return (
_kjernekraftverk(inn, dim, P_u=dim.P_u, numre=numre, energi=dim.E_D, selges=False), _kjernekraftverk(inn, dim, P_u=dim.P_u, numre=numre, energi=dim.E_D, selges=False),
@ -576,10 +659,23 @@ def kraftverk_for_anlegg(
# --------------------------------------------------------------- the price of compute # --------------------------------------------------------------- the price of compute
def regnekraftpris(inn: Inndata, knapphet: Knapphet, t_1: int) -> Callable[[int], float]: @dataclass(frozen=True)
"""S18 with S15 for the competitor and S43: the price y(t_v) per MW IT and year, kr.""" class Regnekraftpris:
"""S18 with S15 for the competitor and S43: the price of compute per vintage.
def lcoc_v(t_v: int) -> float: Attributes:
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.
"""
inn: Inndata
paaslag_g: float
siste: float
def lcoc_v(self, t_v: int) -> float:
"""S15 for the competitor: LCOC^v(t_v), kr per MW IT and year."""
inn = self.inn
return lg.s15_lcoc( return lg.s15_lcoc(
c_bygg=inn["c_bygg"], c_bygg=inn["c_bygg"],
d_bygg=0.0, d_bygg=0.0,
@ -594,19 +690,26 @@ def regnekraftpris(inn: Inndata, knapphet: Knapphet, t_1: int) -> Callable[[int]
c_a=inn["p_v"], c_a=inn["p_v"],
) )
def paaslag(self, t_v: int) -> float:
"""S43: pi_g(t_v), the markup for a vintage that enters operation in ``t_v``."""
return self.paaslag_g if t_v < self.siste else 0.0
def __call__(self, t_v: int) -> float:
"""S18: the price y(t_v) per MW IT and year, kr."""
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."""
uten = Regnekraftpris(inn=inn, paaslag_g=0.0, siste=t_1)
paaslag = { paaslag = {
Knapphet.VARER: lg.s43_knapphetspaaslag( Knapphet.VARER: lg.s43_knapphetspaaslag(
y_obs=inn["y_obs"], LCOC_v_2025=lcoc_v(lg.BASISAAR_IT_PRIS) y_obs=inn["y_obs"], LCOC_v_2025=uten.lcoc_v(lg.BASISAAR_IT_PRIS)
), ),
Knapphet.NORMALISERING: 0.0, Knapphet.NORMALISERING: 0.0,
Knapphet.OVERKAPASITET: inn["pi_neg"], Knapphet.OVERKAPASITET: inn["pi_neg"],
}[knapphet] }[knapphet]
siste = t_1 + inn["T_knapp"] return Regnekraftpris(inn=inn, paaslag_g=paaslag, siste=t_1 + inn["T_knapp"])
def pris(t_v: int) -> float:
return lg.s18_pris(LCOC_v=lcoc_v(t_v), pi_g=paaslag if t_v < siste else 0.0)
return pris
# ------------------------------------------------------------- the yearly amounts # ------------------------------------------------------------- the yearly amounts
@ -622,7 +725,7 @@ class _Program:
plan: Plan plan: Plan
verk: tuple[tuple[Kraftverk, ...], ...] verk: tuple[tuple[Kraftverk, ...], ...]
felles: tuple[Enhetsgruppe, ...] felles: tuple[Enhetsgruppe, ...]
y: Callable[[int], float] y: Regnekraftpris
T_0: int T_0: int
T_s: int T_s: int
@ -675,6 +778,38 @@ def _spre(p: _Program, tabell: Tabell, *, forste_driftsaar: int, belop: float, t
tabell[indeks] += belop * andel tabell[indeks] += belop * andel
def _betal(
p: _Program,
tabell: Tabell,
eiendeler: list[Eiendel],
*,
slag: str,
kostnad: float,
start: int,
byggetid: float,
levetid: int,
siste_driftsaar: int,
budsjett: float | None = None,
) -> None:
"""Pay for one asset over its construction time, and record it.
``siste_driftsaar`` is that of the facility, or of the units when they belong to the
programme: the asset leaves operation then, also when its own lifetime is longer.
"""
_spre(p, tabell, forste_driftsaar=start, belop=kostnad, tau=byggetid)
eiendeler.append(
Eiendel(
slag=slag,
kostnad=kostnad,
budsjett=kostnad if budsjett is None else budsjett,
start=start,
byggetid=byggetid,
levetid=levetid,
slutt=min(start + levetid - 1, siste_driftsaar),
)
)
def _fornyet(p: _Program, k: int, levetid: int | None) -> range: def _fornyet(p: _Program, k: int, levetid: int | None) -> range:
"""First operating year of an asset of facility ``k`` and of each renewal of it.""" """First operating year of an asset of facility ``k`` and of each renewal of it."""
start = p.plan.anlegg[k].start start = p.plan.anlegg[k].start
@ -725,9 +860,12 @@ def _effektkostnad(p: _Program, kraftaar: Sequence[Kraftaar]) -> Tabell:
return F_a return F_a
def _datasenter(p: _Program, k: int, pris: Tabell) -> tuple[Tabell, Tabell, Tabell, Tabell, Tabell]: def _datasenter(
p: _Program, k: int, pris: Tabell, eiendeler: list[Eiendel]
) -> tuple[Tabell, Tabell, Tabell, Tabell, Tabell]:
"""The terms of S34 for facility ``k``: revenue, operation, power, building, IT hardware.""" """The terms of S34 for facility ``k``: revenue, operation, power, building, IT hardware."""
inn, anlegg = p.inn, p.plan.anlegg[k] inn, anlegg = p.inn, p.plan.anlegg[k]
siste = anlegg.siste_driftsaar
inntekt, drift, kraftkjop, I_bygg, I_H = (p.null() for _ in range(5)) inntekt, drift, kraftkjop, I_bygg, I_H = (p.null() for _ in range(5))
for t in p.driftsaar(k): for t in p.driftsaar(k):
j = t - p.T_0 j = t - p.T_0
@ -740,27 +878,61 @@ def _datasenter(p: _Program, k: int, pris: Tabell) -> tuple[Tabell, Tabell, Tabe
if p.losning.paa_nett and aargang is not None: if p.losning.paa_nett and aargang is not None:
kraftkjop[j] = (1.0 + inn["n_tap"]) * pris[j] * p.dim.E_D kraftkjop[j] = (1.0 + inn["n_tap"]) * pris[j] * p.dim.E_D
bygg = inn["c_bygg"] * (1.0 + inn["d_bygg"]) * inn["P_IT"] bygg = inn["c_bygg"] * (1.0 + inn["d_bygg"]) * inn["P_IT"]
for t in _fornyet(p, k, lg.avrundet_varighet(varighet=inn["L_B"])): L_B = lg.avrundet_varighet(varighet=inn["L_B"])
_spre(p, I_bygg, forste_driftsaar=t, belop=bygg, tau=inn["tau_D"]) for t in _fornyet(p, k, L_B):
for t_v in anlegg.aarganger: _betal(
p,
I_bygg,
eiendeler,
slag=BYGG,
kostnad=bygg,
start=t,
byggetid=inn["tau_D"],
levetid=L_B,
siste_driftsaar=siste,
)
for nr, t_v in enumerate(anlegg.aarganger):
maskinvare = inn["P_IT"] * lg.s13_it_kostnad( maskinvare = inn["P_IT"] * lg.s13_it_kostnad(
c_H0=inn["c_H0"], gamma_H=inn["gamma_H"], t_v=t_v c_H0=inn["c_H0"], gamma_H=inn["gamma_H"], t_v=t_v
) )
tau = inn["tau_D"] if t_v == anlegg.start else UTEN_BYGGETID # a vintage is in operation until the next one replaces it, at most L_H years
_spre(p, I_H, forste_driftsaar=t_v, belop=maskinvare, tau=tau) neste = anlegg.aarganger[nr + 1] if nr + 1 < len(anlegg.aarganger) else siste + 1
_betal(
p,
I_H,
eiendeler,
slag=IT,
kostnad=maskinvare,
start=t_v,
byggetid=inn["tau_D"] if t_v == anlegg.start else UTEN_BYGGETID,
levetid=p.plan.L_H,
siste_driftsaar=min(siste, neste - 1),
)
return inntekt, drift, kraftkjop, I_bygg, I_H return inntekt, drift, kraftkjop, I_bygg, I_H
def _kraftverk_i_anlegg( def _kraftverk_i_anlegg(
p: _Program, k: int, verk: Kraftverk, pris: Tabell p: _Program, k: int, verk: Kraftverk, pris: Tabell, eiendeler: list[Eiendel]
) -> tuple[Tabell, Tabell, Tabell, Tabell, Tabell, float]: ) -> tuple[Tabell, Tabell, Tabell, Tabell, Tabell, float]:
"""One plant of facility ``k``: sales, investment, operation, decommissioning, accident cost. """One plant of facility ``k``: sales, investment, operation, decommissioning, accident cost.
The last value is the decommissioning that falls after the final year. The last value is the decommissioning that falls after the final year.
""" """
salg, investering, drift, avvikling, ulykke = (p.null() for _ in range(5)) salg, investering, drift, avvikling, ulykke = (p.null() for _ in range(5))
siste = p.plan.anlegg[k].siste_driftsaar
for t in _fornyet(p, k, verk.levetid): for t in _fornyet(p, k, verk.levetid):
_spre(p, investering, forste_driftsaar=t, belop=verk.investering, tau=verk.byggetid) _betal(
p,
investering,
eiendeler,
slag=verk.teknologi,
kostnad=verk.investering,
budsjett=verk.investering / p.dim.xi_N if verk.teknologi == KJERNEKRAFT else None,
start=t,
byggetid=verk.byggetid,
levetid=siste - t + 1 if verk.levetid is None else verk.levetid,
siste_driftsaar=siste,
)
for t in p.driftsaar(k): for t in p.driftsaar(k):
j = t - p.T_0 j = t - p.T_0
drift[j] = verk.fast_drift drift[j] = verk.fast_drift
@ -769,7 +941,6 @@ def _kraftverk_i_anlegg(
ulykke[j] = verk.ulykke ulykke[j] = verk.ulykke
if verk.selges: if verk.selges:
salg[j] = verk.psi * pris[j] * verk.energi salg[j] = verk.psi * pris[j] * verk.energi
siste = p.plan.anlegg[k].siste_driftsaar
if siste <= p.T_s: if siste <= p.T_s:
avvikling[siste - p.T_0] = verk.avvikling avvikling[siste - p.T_0] = verk.avvikling
return salg, investering, drift, avvikling, ulykke, 0.0 return salg, investering, drift, avvikling, ulykke, 0.0
@ -780,7 +951,19 @@ def _fellesstrom(p: _Program, gruppe: Enhetsgruppe, pris: Tabell) -> Fellesstrom
"""The yearly amounts of one group of the programme's units in B.""" """The yearly amounts of one group of the programme's units in B."""
verk = gruppe.verk verk = gruppe.verk
salg, investering, drift, avvikling, ulykke = (p.null() for _ in range(5)) salg, investering, drift, avvikling, ulykke = (p.null() for _ in range(5))
_spre(p, investering, forste_driftsaar=gruppe.start, belop=verk.investering, tau=verk.byggetid) eiendeler: list[Eiendel] = []
_betal(
p,
investering,
eiendeler,
slag=KJERNEKRAFT,
kostnad=verk.investering,
budsjett=verk.investering / p.dim.xi_N,
start=gruppe.start,
byggetid=verk.byggetid,
levetid=gruppe.siste_driftsaar - gruppe.start + 1,
siste_driftsaar=gruppe.siste_driftsaar,
)
for t in range(gruppe.start, min(gruppe.siste_driftsaar, p.T_s) + 1): for t in range(gruppe.start, min(gruppe.siste_driftsaar, p.T_s) + 1):
j = t - p.T_0 j = t - p.T_0
drift[j] = verk.fast_drift + verk.variabel_drift drift[j] = verk.fast_drift + verk.variabel_drift
@ -798,34 +981,48 @@ def _fellesstrom(p: _Program, gruppe: Enhetsgruppe, pris: Tabell) -> Fellesstrom
ulykke=ulykke, ulykke=ulykke,
avvikling_etter=verk.avvikling if etter else 0.0, avvikling_etter=verk.avvikling if etter else 0.0,
L_rest=max(0, gruppe.siste_driftsaar - p.T_s), L_rest=max(0, gruppe.siste_driftsaar - p.T_s),
eiendeler=tuple(eiendeler),
) )
def _nett_buffer_og_forsyning(p: _Program, k: int) -> tuple[Tabell, Tabell, Tabell]: def _nett_buffer_og_forsyning(
p: _Program, k: int, eiendeler: list[Eiendel]
) -> tuple[Tabell, Tabell, Tabell]:
"""Grid connection (on the grid), and buffer and external supply (A), for facility ``k``.""" """Grid connection (on the grid), and buffer and external supply (A), for facility ``k``."""
inn, dim = p.inn, p.dim inn, dim = p.inn, p.dim
I_nett, buffer, I_g = p.null(), p.null(), p.null() I_nett, buffer, I_g = p.null(), p.null(), p.null()
L_nett, L_buf = inn.heltall("L_nett"), inn.heltall("L_buf") L_nett, L_buf = inn.heltall("L_nett"), inn.heltall("L_buf")
def betal(tabell: Tabell, belop: float, levetid: int) -> None: def betal(tabell: Tabell, slag: str, belop: float, levetid: int) -> None:
for t in _fornyet(p, k, levetid): for t in _fornyet(p, k, levetid):
_spre(p, tabell, forste_driftsaar=t, belop=belop, tau=UTEN_BYGGETID) _betal(
p,
tabell,
eiendeler,
slag=slag,
kostnad=belop,
start=t,
byggetid=UTEN_BYGGETID,
levetid=levetid,
siste_driftsaar=p.plan.anlegg[k].siste_driftsaar,
)
if p.losning.paa_nett: if p.losning.paa_nett:
uttak = (1.0 - inn["delta_V"]) * inn["PUE"] * inn["P_IT"] uttak = (1.0 - inn["delta_V"]) * inn["PUE"] * inn["P_IT"]
betal(I_nett, inn["I_nett"] * (uttak + dim.P_G_N), L_nett) betal(I_nett, NETT, inn["I_nett"] * (uttak + dim.P_G_N), L_nett)
return I_nett, buffer, I_g 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 = lg.s36_buffer(delta_L=inn["delta_L"], PUE=inn["PUE"], P_IT=inn["P_IT"])
betal(buffer, P_buf * inn["c_buf"], L_buf) betal(buffer, BUFFER, P_buf * inn["c_buf"], L_buf)
for t in p.driftsaar(k): for t in p.driftsaar(k):
buffer[t - p.T_0] += inn["f_buf"] * P_buf buffer[t - p.T_0] += inn["f_buf"] * P_buf
betal(I_g, 2.0 * inn["D_linje"] * inn["c_linje"], L_nett) betal(I_g, LINJE, 2.0 * inn["D_linje"] * inn["c_linje"], L_nett)
betal(I_g, inn["s_g"] * dim.N_u * dim.P_u * inn["c_gen"], L_buf) betal(I_g, AGGREGAT, inn["s_g"] * dim.N_u * dim.P_u * inn["c_gen"], L_buf)
return I_nett, buffer, I_g return I_nett, buffer, I_g
def _anleggsstrom(p: _Program, k: int, pris: Tabell) -> Anleggsstrom: def _anleggsstrom(p: _Program, k: int, pris: Tabell) -> Anleggsstrom:
inntekt, drift, kraftkjop, I_bygg, I_H = _datasenter(p, k, pris) eiendeler: list[Eiendel] = []
inntekt, drift, kraftkjop, I_bygg, I_H = _datasenter(p, k, pris, eiendeler)
teknologier = {verk.teknologi for verk in p.verk[k]} teknologier = {verk.teknologi for verk in p.verk[k]}
salg, investering, kraftdrift, avvikling = ( salg, investering, kraftdrift, avvikling = (
{i: p.null() for i in teknologier} for _ in range(4) {i: p.null() for i in teknologier} for _ in range(4)
@ -834,14 +1031,14 @@ def _anleggsstrom(p: _Program, k: int, pris: Tabell) -> Anleggsstrom:
ulykke = p.null() ulykke = p.null()
for verk in p.verk[k]: for verk in p.verk[k]:
i = verk.teknologi i = verk.teknologi
ledd = _kraftverk_i_anlegg(p, k, verk, pris) ledd = _kraftverk_i_anlegg(p, k, verk, pris, eiendeler)
salg[i] += ledd[0] salg[i] += ledd[0]
investering[i] += ledd[1] investering[i] += ledd[1]
kraftdrift[i] += ledd[2] kraftdrift[i] += ledd[2]
avvikling[i] += ledd[3] avvikling[i] += ledd[3]
ulykke += ledd[4] ulykke += ledd[4]
avvikling_etter[i] += ledd[5] avvikling_etter[i] += ledd[5]
I_nett, buffer, I_g = _nett_buffer_og_forsyning(p, k) I_nett, buffer, I_g = _nett_buffer_og_forsyning(p, k, eiendeler)
return Anleggsstrom( return Anleggsstrom(
inntekt=inntekt, inntekt=inntekt,
drift=drift, drift=drift,
@ -859,6 +1056,7 @@ def _anleggsstrom(p: _Program, k: int, pris: Tabell) -> Anleggsstrom:
bygg_i_drift=tuple(_fornyet(p, k, lg.avrundet_varighet(varighet=p.inn["L_B"]))), bygg_i_drift=tuple(_fornyet(p, k, lg.avrundet_varighet(varighet=p.inn["L_B"]))),
avvikling_etter=avvikling_etter, avvikling_etter=avvikling_etter,
L_rest=max(0, p.plan.anlegg[k].siste_driftsaar - p.T_s), L_rest=max(0, p.plan.anlegg[k].siste_driftsaar - p.T_s),
eiendeler=tuple(eiendeler),
) )
@ -1054,6 +1252,8 @@ def regn_program(
knapphet=knapphet, knapphet=knapphet,
plan=plan, plan=plan,
dim=dim, dim=dim,
verk=p.verk,
y=p.y,
aar=tuple(range(p.T_0, p.T_s + 1)), aar=tuple(range(p.T_0, p.T_s + 1)),
kraftaar=kraftaar, kraftaar=kraftaar,
anlegg=anlegg, anlegg=anlegg,

View file

@ -9,13 +9,13 @@ energy in MWh, power prices in kr/MWh, compute capacity in MW IT, time in years.
The parameter file states costs in other units (kr/kW, mill. kr ...); The parameter file states costs in other units (kr/kW, mill. kr ...);
``tokenfabrikker.parametere`` converts them before they reach these functions. ``tokenfabrikker.parametere`` converts them before they reach these functions.
This file covers chapters 1 to 6: the power plant, the data centre, the revenue, This file covers every equation: the power plant, the data centre, the revenue,
the build-out (S22, S33, S39, S41), the power system (S23 to S25, S38, S47) and the build-out (S22, S33, S39, S41), the power system (S23 to S25, S38, S47), the
the cash flow (S26, S34, S35, S40, S45). The functions for the build-out and the cash flow (S26, S34, S35, S40, S45), business economics (S27, S28, S42),
cash flow work on one year or one facility at a time; ``utbygging``, ownership (S29, S30), scale (S31), environment (S32) and the share behind a
``kraftsystem`` and ``kontantstrom`` put them together over the years. verdict (S37). The functions work on one year, one facility or one vintage at a
Business economics, ownership, scale, environment and the verdicts (S27 to S32, time; ``utbygging``, ``kraftsystem``, ``kontantstrom``, ``nivaaisert``,
S37, S42) are not implemented yet. ``eierskap``, ``skala``, ``miljo`` and ``dommer`` put them together.
""" """
from __future__ import annotations from __future__ import annotations
@ -689,10 +689,21 @@ def s47_effektkostnad(
R_minus = max(0.0, -Delta_R) R_minus = max(0.0, -Delta_R)
R_utfall_minus = max(0.0, -Delta_R_utfall) R_utfall_minus = max(0.0, -Delta_R_utfall)
fast_effekt = c_fast * R_minus + c_res * (R_utfall_minus - R_minus) fast_effekt = c_fast * R_minus + c_res * (R_utfall_minus - R_minus)
utkobling = h_knapp * mu * y / (TIMER_PER_AAR * PUE) * R_utfall_minus utkobling = s47_utkobling(Delta_R_utfall=Delta_R_utfall, h_knapp=h_knapp, mu=mu, y=y, PUE=PUE)
return min(fast_effekt, utkobling) return min(fast_effekt, utkobling)
def s47_utkobling(
*, Delta_R_utfall: float, h_knapp: float, mu: float, y: float, PUE: float
) -> float:
"""S47, second arm: the revenue lost when the data centres disconnect in the scarce hours.
kr per year for the whole programme. This is the only arm a business
connected on conditions pays (chapter 7).
"""
return h_knapp * mu * y / (TIMER_PER_AAR * PUE) * max(0.0, -Delta_R_utfall)
# ------------------------------------------- whole calendar years (chapter 16, 21) # ------------------------------------------- whole calendar years (chapter 16, 21)
@ -1039,3 +1050,218 @@ def s45_los_tilleggsfaktor(*, naaverdi: Callable[[float], float]) -> float:
else: else:
hoy = midt hoy = midt
return lav return lav
# ------------------------------------------ business economics: S27, S42 and S28
def s27_nettariff(*, t_nett: float, PUE: float, P_IT: float) -> float:
"""Chapter 7: the grid tariff of one facility, kr per year.
``t_nett`` in kr per MW and year (the file's kr/kW times 1000), charged on
the facility's largest draw, PUE P_IT.
"""
return t_nett * PUE * P_IT
def s27_kraftkostnad_bedrift_nett(
*,
p_z: float,
t_el: float,
portefolje: Sequence[Portefoljeledd],
E_G: float,
E_D: float,
tariff: float,
F_utkobling: float,
) -> float:
"""Chapter 7: S11 as a business pays it, kr/MWh.
Grid tariff (``tariff``, kr per year) and electricity tax ``t_el`` instead
of marginal grid losses; no grid investment H_a; the power plants' whole
net term, without the additionality rule S45; and only the disconnection
arm of S47 (``F_utkobling``, the facility's share in kr per year).
"""
kraftverk = sum(ledd.x * (ledd.LCOE - ledd.psi * p_z) for ledd in portefolje)
return p_z + t_el + kraftverk * E_G / E_D + (tariff + F_utkobling) / E_D
def s27_kraftkostnad_bedrift_dedikert(*, c_A: float, t_el: float) -> float:
"""Chapter 7: S9 as a business pays it, kr/MWh: the electricity tax also applies off-grid."""
return c_A + t_el
def s27_margin_bedrift(*, mu: float, Gamma: float, y: float, LCOC_bed: float) -> float:
"""S27: mu Gamma y - LCOC^bed per MW IT and year, kr. S27 holds when this is not negative."""
return mu * Gamma * y - LCOC_bed
def s42_naaverdivektet_margin(
*, marginer: Sequence[float], aarganger: Sequence[int], rho_D: float, T_0: int
) -> float:
"""S42: the margins of S27 for every vintage of the path, weighted by D_D(t_v), kr.
M2 is met in a draw when the sum is not negative.
"""
return math.fsum(
diskonteringsfaktor(rho=rho_D, t=t_v, T_0=T_0) * margin
for margin, t_v in zip(marginer, aarganger, strict=True)
)
def s28_avskrivning(*, kostnad: float, levetid: int, start: int, slutt: int, t: int) -> float:
"""Chapter 7: straight-line depreciation of one asset in year ``t``, kr.
``kostnad / levetid`` in each year from ``start``. An asset that leaves
operation in ``slutt``, before its lifetime is out, has the rest of its
booked value written off that year.
"""
if not start <= t <= slutt:
return 0.0
aarlig = kostnad / levetid
if t < slutt:
return aarlig
return kostnad - aarlig * (slutt - start)
def s28_etter_framforing(overskudd: Sequence[float]) -> tuple[float, ...]:
"""Chapter 7: the taxable profit per year when losses are carried forward without interest.
A loss gives no tax that year and is deducted from later profits, oldest
year first, until it is used up.
"""
underskudd = 0.0
grunnlag = []
for x in overskudd:
if x < 0:
underskudd -= x
grunnlag.append(0.0)
else:
brukt = min(underskudd, x)
underskudd -= brukt
grunnlag.append(x - brukt)
return tuple(grunnlag)
def s28_naaverdi(*, netto: Sequence[float], rente: float) -> float:
"""S28: the present value at T_0 of yearly amounts with index t - T_0, kr.
With ``netto`` = Y - K_drift - I - Skatt_e and ``rente`` = r_e this is NV_e.
The same sum gives the present value of S30 with the state's borrowing rate.
"""
return math.fsum(x * (1.0 + rente) ** -j for j, x in enumerate(netto))
# --------------------------------------------------------- ownership: S29 and S30
def realrente(*, nominell: float, iota: float) -> float:
"""Chapter 0: a nominal rate made real, (1 + r) / (1 + iota) - 1."""
return (1.0 + nominell) / (1.0 + iota) - 1.0
def s29_kapitalkostnad(*, h: float, r_d: float, r_q: float, tau_s: float, iota: float) -> float:
"""S29: the cost of capital of an ownership form, real, after tax.
``h`` is the share of debt, ``r_d`` the borrowing rate and ``r_q`` the
required return on equity (both nominal), ``tau_s`` the corporate tax and
``iota`` the expected inflation. With direct state ownership the cost of
capital is the state's borrowing rate, and this function is not used.
"""
nominell = h * r_d * (1.0 - tau_s) + (1.0 - h) * r_q
return realrente(nominell=nominell, iota=iota)
def s30_skatt(
*,
overskudd: Sequence[float],
kapital_inn: Sequence[float],
tau_s: float,
tau_g: float,
r_e: float,
) -> tuple[tuple[float, ...], tuple[float, ...]]:
"""S30: corporate tax and special tax per year, kr, for the project as one taxpayer.
``overskudd`` is revenue minus operating costs and depreciation,
``kapital_inn`` the booked capital at the start of each year. Corporate tax
is tau_s on the profit after losses carried forward. The special tax is
tau_g on the profit above the return ``r_e`` on booked capital, with its
own carry-forward of what is not used. Electricity tax and grid tariff are
not part of this; they are added where the state's revenue is summed.
"""
selskap = tuple(tau_s * x for x in s28_etter_framforing(overskudd))
utover = [x - r_e * k for x, k in zip(overskudd, kapital_inn, strict=True)]
saer = tuple(tau_g * x for x in s28_etter_framforing(utover))
return selskap, saer
def s30_statens_kontantstrom(
*,
skatt: Belop,
FKE: Belop,
NK: Belop,
overskridelse: Belop,
s: float,
theta: float,
zeta: float,
) -> Belop:
"""S30: the state's net cash flow in a year with ownership form e, kr.
``skatt`` is what the state receives in tax, electricity tax and grid
tariff, ``FKE`` the company's free cash flow to its owners, ``NK`` the
project's net cash flow before tax and financing, and ``overskridelse``
max(0, I - I^bud). ``s`` is the state's share of the company, ``theta`` its
direct share outside the company and ``zeta`` its share of overruns.
"""
return skatt + s * (1.0 - theta) * FKE + theta * NK - (zeta - s) * (1.0 - theta) * overskridelse
# ----------------------------------------------------- scale and environment
def s31_nettobidrag(
*,
u_e: float,
overskudd_utover_avkastning: Belop,
Delta_W: Belop,
K_prog: Belop,
V: Belop,
utslipp: Belop,
) -> Belop:
"""S31: the yearly net contribution to Norway's income above normal return on capital, kr.
``overskudd_utover_avkastning`` is the sum over the facilities of revenue
minus operating costs minus the yearly cost of all capital, ``u_e`` the
share owned outside Norway (zero in the verdict), ``utslipp`` is
p_CO2 U^NO.
"""
return (1.0 - u_e) * overskudd_utover_avkastning + Delta_W - K_prog - V - utslipp
def s32_utslipp(
*,
kraft: float,
u_H: float,
u_B: float,
P_IT: float,
nye_aarganger: int,
nye_bygg: int,
) -> float:
"""S32: life-cycle emissions in one year, tonnes CO2 equivalents.
``kraft`` is the sum over the facilities of u_a^kraft E_D (tonnes),
``nye_aarganger`` the vintages of IT hardware and ``nye_bygg`` the
buildings that enter operation that year; ``u_H`` and ``u_B`` in tonnes
per MW IT.
"""
return kraft + (nye_aarganger * u_H + nye_bygg * u_B) * P_IT
# ---------------------------------------------------------------------------- S37
def s37_andel(oppfylt: Sequence[bool]) -> float:
"""S37: the share of the draws in which the condition of a category is met."""
if not oppfylt:
msg = "a share needs at least one draw"
raise ValueError(msg)
return sum(oppfylt) / len(oppfylt)

169
src/tokenfabrikker/miljo.py Normal file
View file

@ -0,0 +1,169 @@
"""Environment (chapter 10): life-cycle emissions per year, S32, and the rules of M5.
Emissions are reported in tonnes per year without any deduction for compute
that would otherwise have been made with dirtier power. M5 (i) and (ii) are
properties of the technology and are decided without draws, source by source,
from values that are passed in; nothing here looks up a source.
"""
from __future__ import annotations
import math
from dataclasses import dataclass
from typing import TYPE_CHECKING
import numpy as np
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker.dommer import Dom
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Sequence
import numpy.typing as npt
from tokenfabrikker.inndata import Inndata
from tokenfabrikker.kontantstrom import Programresultat
Tabell = npt.NDArray[np.float64]
def kraftutslipp_per_mwh(inn: Inndata, res: Programresultat, k: int) -> float:
"""u_a^kraft for facility ``k`` (0 is the first), tonnes CO2 equivalents per MWh it uses.
Nuclear power in A, B and B'. In C the average of the facility's own
portfolio, weighted by production in a normal year (clarification 24). R
uses the same figure as C: the portfolio the same facility has in C.
"""
if res.losning.kjernekraft:
return inn["u_kjerne"]
verkene = (
res.verk[k]
if res.losning is Losning.C
else ks.kraftverk_for_anlegg(inn, Losning.C, res.dim, k + 1)
)
samlet = math.fsum(verk.energi for verk in verkene)
return math.fsum(inn[f"u_{verk.teknologi}"] * verk.energi for verk in verkene) / samlet
def utslipp_livslop(inn: Inndata, res: Programresultat) -> Tabell:
"""S32: life-cycle emissions per year, tonnes CO2 equivalents (index t - T_0).
Power for the energy the data centres actually use, and IT hardware and
buildings in the year they enter operation.
"""
plan = res.plan
per_mwh = [kraftutslipp_per_mwh(inn, res, k) for k in range(len(plan.anlegg))]
U = np.zeros(len(res.aar), dtype=np.float64)
for j, t in enumerate(res.aar):
U[j] = lg.s32_utslipp(
kraft=math.fsum(u * res.dim.E_D for k, u in enumerate(per_mwh) if plan.har_last(k, t)),
u_H=inn["u_H"],
u_B=inn["u_B"],
P_IT=inn["P_IT"],
nye_aarganger=sum(t in anlegg.aarganger for anlegg in plan.anlegg),
nye_bygg=sum(t in a.bygg_i_drift for a in res.anlegg),
)
return U
def brukt_brensel(inn: Inndata, res: Programresultat) -> Tabell:
"""Chapter 10: spent fuel per year, eta_N E_N, tonnes of uranium (reported, not judged)."""
plan = res.plan
tonn = np.zeros(len(res.aar), dtype=np.float64)
if not res.losning.kjernekraft:
return tonn
for j, t in enumerate(res.aar):
egne = math.fsum(
verk.energi
for k, verkene in enumerate(res.verk)
for verk in verkene
if (plan.har_last(k, t) if not verk.selges else plan.i_drift(k, t))
)
felles = math.fsum(
f.gruppe.verk.energi
for f in res.felles
if f.gruppe.start <= t <= f.gruppe.siste_driftsaar
)
tonn[j] = inn["eta_N"] * (egne + felles)
return tonn
def areal(inn: Inndata, *, teknologi: str, energi: float, P_IT: float) -> float:
"""M5 (ii): area for the power (alpha_a times MWh per year) plus the plot, km2."""
return inn.areal[teknologi] * energi + inn.areal["tomt"] * P_IT
# ---------------------------------------------------------- the rules of M5
@dataclass(frozen=True)
class Kildeverdier:
"""One source's life-cycle emissions per kWh (any unit, the same for all four numbers).
Attributes:
kilde: the source (IPCC, UNECE, NREL).
kjernekraft: the source's central value for nuclear power.
vind: its central value for onshore wind.
vann: its central value for hydropower.
vind_hoyeste: the highest value the source gives for onshore wind.
"""
kilde: str
kjernekraft: float
vind: float
vann: float
vind_hoyeste: float
def m5_utslipp(losning: Losning, kilder: Sequence[Kildeverdier]) -> Dom:
"""M5 (i), source by source (pre-registration, clarification 7).
«Holder» when nuclear power is not above the lower of onshore wind and
hydropower in any source. «Holder ikke» (clearly broken) when its central
value in at least one source is above the highest value that source gives
for onshore wind. Everything in between holds under conditions. C and R
meet (i) by definition.
"""
if not losning.kjernekraft:
return Dom.HOLDER
if not kilder:
msg = "M5 (i) needs at least one source"
raise ValueError(msg)
if any(k.kjernekraft > k.vind_hoyeste for k in kilder):
return Dom.HOLDER_IKKE
if all(k.kjernekraft <= min(k.vind, k.vann) for k in kilder):
return Dom.HOLDER
return Dom.BETINGELSER
def m5_areal(losning: Losning, *, kjernekraft: float, vind_direkte: float, vind_plan: float) -> Dom:
"""M5 (ii): area per TWh for nuclear power against onshore wind (clarification 7).
«Holder» when nuclear power does not use more than the direct area of
onshore wind, the lower of the two figures for wind. «Holder ikke» (clearly
broken) when it uses more than the whole planning area of wind, the
higher. In between it holds under conditions. C and R hold by definition.
"""
if not losning.kjernekraft or kjernekraft <= vind_direkte:
return Dom.HOLDER
if kjernekraft > vind_plan:
return Dom.HOLDER_IKKE
return Dom.BETINGELSER
def m5(utslipp: Dom, areal_dom: Dom, *, kostnadsfort: bool = True) -> Dom:
"""M5 as a whole from (i), (ii), and (iii) and (iv).
``kostnadsfort`` says that waste, decommissioning and accident risk are in
S26 and the emissions from chips and buildings in S32, which they are by
construction. «Holder ikke» when (i) or (ii) is clearly broken or that
fails; «holder» when both hold; otherwise it holds under conditions.
"""
if not kostnadsfort or Dom.HOLDER_IKKE in {utslipp, areal_dom}:
return Dom.HOLDER_IKKE
if utslipp is Dom.HOLDER and areal_dom is Dom.HOLDER:
return Dom.HOLDER
return Dom.BETINGELSER

View file

@ -0,0 +1,437 @@
"""The levelised cost of power and of compute over the years of a path (chapters 1 to 3 and 7).
The cash flow (``kontantstrom``) pays investments when they fall. The levelised
form turns them into a yearly cost instead, and is what the price of compute
(S18), the margin (S19) and the business economics (S27, S42) are built on.
This module puts the equations together for one path:
- ``kraftkostnad``: the power cost c_a per facility and year, S9 in A and S11 on
the grid, with the yearly price after the price effect, the factor of the
additionality rule and the facility's share of the capacity cost
(clarifications 2, 11 and 13 of the specification);
- the same per vintage, weighted by present value over the years the vintage is
in operation (clarification 15), and S15 and S19 with it;
- ``bedrift=True``: the cost as a business pays it (chapter 7), and with it S27
for each vintage and S42 for the path.
Nothing here reads the parameter file or draws random numbers.
"""
from __future__ import annotations
import math
from dataclasses import dataclass
from typing import TYPE_CHECKING
import numpy as np
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
import numpy.typing as npt
from tokenfabrikker.inndata import Inndata
from tokenfabrikker.kontantstrom import Programresultat
Tabell = npt.NDArray[np.float64]
@dataclass(frozen=True)
class Renter:
"""The required returns the levelised form is computed with.
Attributes:
rho_D: compute (the data centre).
rho_N: power sold in the market.
rho_A: the power plant in A.
"""
rho_D: float
rho_N: float
rho_A: float
@dataclass(frozen=True)
class Aargangskost:
"""One vintage of IT hardware in one facility, on levelised form, per MW IT and year.
Attributes:
anlegg: the facility (0 is the first).
t_v: the vintage's first operating year.
aar: the years the vintage is in operation.
c_a: the power cost weighted by present value over those years, kr/MWh.
LCOC: S15 with that power cost, kr per MW IT and year.
inntekt: mu Gamma y(t_v), kr per MW IT and year.
margin: the four parts of S19; None in the business version.
"""
anlegg: int
t_v: int
aar: tuple[int, ...]
c_a: float
LCOC: float
inntekt: float
margin: lg.Margin | None
@property
def overskudd(self) -> float:
"""Revenue minus cost per MW IT and year: M_a of S19, or the left side of S27."""
return self.inntekt - self.LCOC
@dataclass(frozen=True)
class Kraftkostnad:
"""The levelised cost of power and compute for one path.
Attributes:
bedrift: True when the cost is what a business pays (chapter 7).
c_a: kr/MWh per facility (row) and year (column, index t - T_0); NaN in years the
facility uses no power.
aarganger: every vintage of every facility.
F: the capacity cost of the programme per year, kr: S47, or its disconnection arm in
the business version.
S42: the sum of S42 over the vintages, kr per MW IT; only in the business version.
"""
bedrift: bool
c_a: Tabell
aarganger: tuple[Aargangskost, ...]
F: Tabell
S42: float | None
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)
def effektkostnad_bedrift(inn: Inndata, res: Programresultat) -> Tabell:
"""Chapter 7: the disconnection arm of S47 per year for the programme, kr. Zero in A."""
plan = res.plan
F = np.zeros(len(res.aar), dtype=np.float64)
if not res.losning.paa_nett:
return F
for j, t in enumerate(res.aar):
aarganger = [plan.aargang(k, t) for k in range(len(plan.anlegg))]
priser = [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,
h_knapp=inn["h_knapp"],
mu=inn["mu_rel"],
y=math.fsum(priser) / len(priser),
PUE=inn["PUE"],
)
return F
def lcoe_kjernekraft(
inn: Inndata, res: Programresultat, *, numre: range | tuple[int, ...], E_N: float, rho: float
) -> float:
"""S5 for the units with the numbers ``numre``, producing ``E_N`` MWh a year, kr/MWh."""
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),
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"],
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"],
q_N=lg.s6_ulykkeskostnad(
N_u=len(numre),
phi_U=inn["phi_U"],
K_U=inn["K_U"],
D_fors=inn["D_fors"],
P_u=P_u,
P_ref=inn["P_ref"],
E=E_N,
),
)
def lcoe_fornybar(inn: Inndata, teknologi: str, rho_N: float) -> float:
"""Clarification 10: LCOE_i for one renewable technology, kr/MWh."""
per_mw = teknologi in ks.DRIFT_PER_MW
drift = inn[f"{teknologi}.drift"]
return lg.lcoe_fornybar(
investering=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"],
levetid=inn[f"{teknologi}.levetid"],
byggetid=inn[f"{teknologi}.byggetid"],
rho=rho_N,
renter_i_investeringen=teknologi == ks.VANN,
)
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,
),
)
@dataclass(frozen=True)
class _Portefolje:
"""The power plants one facility's power cost is computed with in one year (S11)."""
ledd: tuple[lg.Portefoljeledd, ...]
E_G: float
def _egen_portefolje(
inn: Inndata, res: Programresultat, k: int, r: Renter, *, bedrift: bool
) -> _Portefolje:
"""B' and C: the plants that belong to facility ``k``. Empty in R (and in B, see below)."""
verk = res.verk[k]
E_G = math.fsum(v.energi for v in verk)
ledd = []
for v in verk:
if v.teknologi == ks.KJERNEKRAFT:
lcoe = lcoe_kjernekraft(
inn, res, numre=ks.enhetsnumre(res.dim, k + 1), E_N=v.energi, rho=r.rho_N
)
else:
lcoe = lcoe_fornybar(inn, v.teknologi, r.rho_N)
ledd.append(
lg.Portefoljeledd(
x=v.energi / E_G,
LCOE=lcoe,
psi=v.psi,
regelen_binder=not bedrift and res.varsigma[v.teknologi] < 1.0,
)
)
return _Portefolje(ledd=tuple(ledd), E_G=E_G)
def _felles_portefolje(
inn: Inndata, res: Programresultat, t: int, r: Renter, *, bedrift: bool
) -> _Portefolje:
"""B: the programme's units in operation in year ``t`` (clarifications 2 and 29)."""
i_drift = [f.gruppe for f in res.felles if f.gruppe.start <= t <= f.gruppe.siste_driftsaar]
if not i_drift:
return _Portefolje(ledd=(), E_G=0.0)
numre = tuple(n for gruppe in i_drift for n in gruppe.numre)
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),
psi=inn["psi_N"],
regelen_binder=not bedrift and res.varsigma[ks.KJERNEKRAFT] < 1.0,
)
return _Portefolje(ledd=(ledd,), E_G=E_N)
def _dedikert_per_aar(inn: Inndata, res: Programresultat, r: Renter, *, bedrift: bool) -> 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)
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):
if plan.har_last(k, t):
c_a[k, j] = c_A
return c_a
def _kraftkostnad_per_aar(
inn: Inndata, res: Programresultat, r: Renter, F: Tabell, *, bedrift: bool
) -> Tabell:
"""c_a per facility and year, kr/MWh; NaN where the facility uses no power."""
if res.losning is Losning.A:
return _dedikert_per_aar(inn, res, r, bedrift=bedrift)
plan, dim = res.plan, res.dim
c_a = np.full((len(plan.anlegg), len(res.aar)), np.nan, dtype=np.float64)
H_a = lg.s11_nettkostnad(
I_nett=inn["I_nett"],
delta_V=inn["delta_V"],
PUE=inn["PUE"],
P_IT=inn["P_IT"],
P_G_N=dim.P_G_N,
rho_N=r.rho_N,
L_nett=inn["L_nett"],
)
tariff = (
lg.s27_nettariff(t_nett=inn["t_nett"], PUE=inn["PUE"], P_IT=inn["P_IT"]) if bedrift else 0.0
)
egne = [_egen_portefolje(inn, res, k, r, bedrift=bedrift) for k in range(len(plan.anlegg))]
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)
for k in range(len(plan.anlegg)):
if not plan.har_last(k, t):
continue
# the programme's units are shared by energy use: equally among those with load
portefolje = (
_Portefolje(ledd=felles.ledd, E_G=felles.E_G / med_last)
if res.losning is Losning.B
else egne[k]
)
p_z = res.kraftaar[j].pris
if bedrift:
c_a[k, j] = lg.s27_kraftkostnad_bedrift_nett(
p_z=p_z,
t_el=inn["t_el"],
portefolje=portefolje.ledd,
E_G=portefolje.E_G,
E_D=dim.E_D,
tariff=tariff,
F_utkobling=F[j] / med_last,
)
else:
c_a[k, j] = lg.s11_kraftkostnad_nett(
p_z=p_z,
n_tap=inn["n_tap"],
portefolje=portefolje.ledd,
E_G=portefolje.E_G,
E_D=dim.E_D,
H_a=H_a,
F_a=F[j] / med_last,
)
return c_a
def _aarganger(
inn: Inndata, res: Programresultat, r: Renter, c_a: Tabell, *, bedrift: bool
) -> tuple[Aargangskost, ...]:
"""S15 per vintage with the power cost of clarification 15, and S19 or S27 with it."""
plan = res.plan
rader = []
for k, anlegg in enumerate(plan.anlegg):
for t_v in anlegg.aarganger:
aar = tuple(t for t in range(t_v, plan.T_s + 1) if plan.aargang(k, t) == t_v)
vekter = [lg.diskonteringsfaktor(rho=r.rho_D, t=t, T_0=t_v) for t in aar]
kraft = math.fsum(
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"],
d_bygg=inn["d_bygg"],
c_H=lg.s13_it_kostnad(c_H0=inn["c_H0"], gamma_H=inn["gamma_H"], t_v=t_v),
rho_D=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"],
lam=inn["lambda"],
PUE=inn["PUE"],
c_a=kraft,
)
margin = (
None
if bedrift
else lg.s19_margin(
lam=inn["lambda"],
PUE_v=inn["PUE_v"],
p_v=inn["p_v"],
PUE=inn["PUE"],
c_a=kraft,
pi_g=res.y.paaslag(t_v),
LCOC_v=res.y.lcoc_v(t_v),
o_D_v=inn["o_D_v"],
o_D=inn["o_D"],
d_o_D=inn["d_o_D"],
d_bygg=inn["d_bygg"],
c_bygg=inn["c_bygg"],
rho_D=r.rho_D,
L_B=inn["L_B"],
mu=inn["mu_rel"],
Gamma=res.dim.Gamma,
)
)
rader.append(
Aargangskost(
anlegg=k,
t_v=t_v,
aar=aar,
c_a=kraft,
LCOC=LCOC,
inntekt=inn["mu_rel"] * res.dim.Gamma * res.y(t_v),
margin=margin,
)
)
return tuple(rader)
def kraftkostnad(
inn: Inndata,
res: Programresultat,
*,
bedrift: bool = False,
renter: Renter | None = None,
) -> Kraftkostnad:
"""The levelised cost of power and compute for the path in ``res``.
``bedrift=True`` gives the cost as a business pays it (chapter 7): grid
tariff and electricity tax instead of marginal grid losses, no grid
investment, the power plants without the additionality rule, and only the
disconnection arm of S47; S42 is then summed over the vintages.
``renter`` replaces the required returns of the main run (used for the
cost of capital of an ownership form, chapter 8).
"""
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)
S42 = None
if bedrift:
S42 = lg.s42_naaverdivektet_margin(
marginer=[
lg.s27_margin_bedrift(
mu=inn["mu_rel"], Gamma=res.dim.Gamma, y=res.y(a.t_v), LCOC_bed=a.LCOC
)
for a in aarganger
],
aarganger=[a.t_v for a in aarganger],
rho_D=inn["rho_D"],
T_0=res.plan.T_0,
)
return Kraftkostnad(bedrift=bedrift, c_a=c_a, aarganger=aarganger, F=F, S42=S42)

227
src/tokenfabrikker/skala.py Normal file
View file

@ -0,0 +1,227 @@
"""Scale (chapter 9): the yearly net contribution to Norway's income, S31, and M6.
The contribution is what is left of the revenue after operating costs and after
the yearly cost of all capital at the required returns, so a programme cannot
reach M6 by being large alone. Capital is on levelised form here, as in S15,
S5, S9 and S11: an asset costs its annuity in each year it is in operation.
A power plant on the grid enters after the additionality rule: when S45 binds
for a technology, its plants neither add nor take (clarification 11).
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import TYPE_CHECKING, Final
import numpy as np
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import nivaaisert
if TYPE_CHECKING:
import numpy.typing as npt
from tokenfabrikker.inndata import Inndata
from tokenfabrikker.kontantstrom import Kraftverk, Programresultat
from tokenfabrikker.nivaaisert import Renter
Tabell = npt.NDArray[np.float64]
MAALEAAR: Final = 2050
"""The calendar year M6 is also reported for (pre-registration, M6)."""
@dataclass(frozen=True)
class Skala:
"""S31 year by year and the figures of M6 for one path.
The shares are of the state's net cash flow from petroleum (the ten-year
average in 2025 kroner, pre-registration clarification 6).
Attributes:
B_6: the net contribution per year, kr (index t - T_0).
stabilt_aar: the first year every facility of the path is in operation; None when
there is no such year.
M6: the contribution in that year as a share of the petroleum cash flow; this is the
figure the verdict is set on. None without a year of stable operation.
M6_snitt: the same for the average over L_H years from that year (to the final year
at most).
M6_median: M6 against the median of the ten years instead of the average.
M6_2050: the share in 2050; None when the analysis ends before that.
M6_topp: the share in the year the contribution is highest.
toppaar: that year.
"""
B_6: Tabell
stabilt_aar: int | None
M6: float | None
M6_snitt: float | None
M6_median: float | None
M6_2050: float | None
M6_topp: float
toppaar: int
def _kraftverk_netto(
inn: Inndata,
verk: Kraftverk,
*,
rho: float,
pris: float,
har_last: bool,
regelen_binder: bool,
) -> float:
"""The yearly cost of one power plant net of its sales, on levelised form, kr.
The annuity of the investment (with interest during construction), fixed and
variable operation, the yearly provision for decommissioning and the accident
cost, minus the sales. In A nothing is sold, and the variable costs run only
when the data centre uses power. On the grid the whole term is zero when the
additionality rule binds for the technology.
"""
kjernekraft = verk.teknologi == ks.KJERNEKRAFT
levetid = inn["L_N"] if kjernekraft else inn[f"{verk.teknologi}.levetid"]
faktor = (
1.0 if verk.renter_i_investeringen else lg.s3_byggetidsfaktor(rho=rho, tau=verk.byggetid)
)
kostnad = (
verk.investering * faktor * lg.s1_crf(rho=rho, L=levetid)
+ verk.fast_drift
+ verk.avvikling * lg.sff(rho=rho, L=levetid)
+ verk.ulykke
)
if not verk.selges:
return kostnad + (verk.variabel_drift if har_last else 0.0)
if regelen_binder:
return 0.0
return kostnad + verk.variabel_drift - verk.psi * pris * verk.energi
def _faste_aarskostnader(inn: Inndata, res: Programresultat, r: Renter) -> float:
"""What one facility carries each operating year besides plant and data centre, kr.
On the grid the grid connection H_a (S11); in A the buffer and the external
supply to the plant itself (S36, S9).
"""
if res.losning.paa_nett:
return lg.s11_nettkostnad(
I_nett=inn["I_nett"],
delta_V=inn["delta_V"],
PUE=inn["PUE"],
P_IT=inn["P_IT"],
P_G_N=res.dim.P_G_N,
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"])
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"],
c_linje=inn["c_linje"],
s_g=inn["s_g"],
N_u=res.dim.N_u,
P_u=res.dim.P_u,
c_gen=inn["c_gen"],
rho_A=r.rho_A,
L_nett=inn["L_nett"],
L_buf=inn["L_buf"],
)
def overskudd_utover_avkastning(
inn: Inndata, res: Programresultat, *, renter: Renter | None = None
) -> Tabell:
"""S31, the sum over the facilities of Y_k - K_k^drift - ann_k per year, kr.
Revenue minus operation, power and the yearly cost of all capital in
operation that year: the building, the vintage of IT hardware, the power
plants, and grid connection or buffer and external supply. In B the
programme's units count in every year they are in operation.
"""
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
bygg = (
inn["c_bygg"] * (1.0 + inn["d_bygg"]) * inn["P_IT"] * lg.s1_crf(rho=r.rho_D, L=inn["L_B"])
)
crf_H = lg.s1_crf(rho=r.rho_D, L=inn["L_H"])
faste = _faste_aarskostnader(inn, res, r)
ut = -res.F_a.copy()
for j, t in enumerate(res.aar):
pris = res.kraftaar[j].pris
for k, a in enumerate(res.anlegg):
if not plan.i_drift(k, t):
continue
ut[j] += a.inntekt[j] - a.drift[j] - a.kraftkjop[j] - bygg - faste
aargang = plan.aargang(k, t)
if aargang is not None:
ut[j] -= (
inn["P_IT"]
* crf_H
* lg.s13_it_kostnad(c_H0=inn["c_H0"], gamma_H=inn["gamma_H"], t_v=aargang)
)
for verk in res.verk[k]:
ut[j] -= _kraftverk_netto(
inn,
verk,
rho=rho_kraft,
pris=pris,
har_last=aargang is not None,
regelen_binder=res.varsigma[verk.teknologi] < 1.0,
)
for f in res.felles:
if f.gruppe.start <= t <= f.gruppe.siste_driftsaar:
ut[j] -= _kraftverk_netto(
inn,
f.gruppe.verk,
rho=rho_kraft,
pris=pris,
har_last=True,
regelen_binder=res.varsigma[ks.KJERNEKRAFT] < 1.0,
)
return ut
def forste_aar_med_stabil_drift(res: Programresultat) -> int | None:
"""Chapter 9: the first year every facility of the path is in operation, or None."""
plan = res.plan
for t in res.aar:
if plan.antall_i_drift(t) == plan.N_anlegg:
return t
return None
def skala(inn: Inndata, res: Programresultat, *, u_e: float = 0.0) -> Skala:
"""S31 per year and M6 for the path in ``res``.
``u_e`` is the share owned outside Norway; it is zero in the verdict, which
is computed with one wholly state-owned company.
"""
B_6 = lg.s31_nettobidrag(
u_e=u_e,
overskudd_utover_avkastning=overskudd_utover_avkastning(inn, res),
Delta_W=res.Delta_W,
K_prog=res.K_prog,
V=res.V,
utslipp=res.utslipp,
)
T_0, nevner = res.plan.T_0, inn["SNKS_snitt"]
stabilt = forste_aar_med_stabil_drift(res)
M6 = M6_snitt = M6_median = None
if stabilt is not None:
j = stabilt - T_0
M6 = float(B_6[j]) / nevner
M6_snitt = float(np.mean(B_6[j : j + res.plan.L_H])) / nevner
M6_median = float(B_6[j]) / inn.petroleum_median
topp = int(np.argmax(B_6))
return Skala(
B_6=B_6,
stabilt_aar=stabilt,
M6=M6,
M6_snitt=M6_snitt,
M6_median=M6_median,
M6_2050=float(B_6[MAALEAAR - T_0]) / nevner if res.plan.T_s >= MAALEAAR else None,
M6_topp=float(B_6[topp]) / nevner,
toppaar=T_0 + topp,
)

View file

@ -11,13 +11,23 @@ from typing import TYPE_CHECKING, Protocol
import pytest import pytest
from tokenfabrikker.inndata import Inndata, Prislinje from tokenfabrikker.inndata import Eierform, Inndata, Prislinje
if TYPE_CHECKING: if TYPE_CHECKING:
from collections.abc import Mapping from collections.abc import Mapping
OMRAADER = ("NO1", "NO2", "NO3", "NO4", "NO5", "Norge") OMRAADER = ("NO1", "NO2", "NO3", "NO4", "NO5", "Norge")
EIERFORMER: Mapping[str, Eierform] = {
"direkte": Eierform("direkte", 1.0, 0.0, 0.0, 1.0, 0.04, None, 1.0, skatt=False),
"heleid_selskap": Eierform("heleid_selskap", 1.0, 0.0, 0.0, 0.5, 0.05, 0.10, 1.0, skatt=True),
"majoritet_boers": Eierform("majoritet_boers", 0.6, 0.0, 0.0, 0.5, 0.05, 0.12, 1.0, skatt=True),
"petroleumsmodell": Eierform(
"petroleumsmodell", 0.6, 0.25, 0.5, 0.5, 0.05, 0.12, 1.0, skatt=True
),
}
"""Made-up ownership forms with round numbers, in the layout of the parameter file."""
GRUNNVERDIER: Mapping[str, float] = { GRUNNVERDIER: Mapping[str, float] = {
# time and size # time and size
"T0": 2027, "T0": 2027,
@ -132,6 +142,19 @@ GRUNNVERDIER: Mapping[str, float] = {
"D_X": 2.0, "D_X": 2.0,
"s_brikker": 0.04, "s_brikker": 0.04,
"G_server": 25_000.0, "G_server": 25_000.0,
# business economics and ownership
"t_nett": 0.3e6,
"tau_s": 0.2,
"iota": 0.02,
"r_stat": 0.02,
# scale and environment (emissions in tonnes per MWh and per MW IT)
"SNKS_snitt": 500e9,
"u_kjerne": 0.012,
"u_vind": 0.011,
"u_havvind": 0.012,
"u_vann": 0.004,
"u_H": 1000.0,
"eta_N": 3e-6,
} }
"""Round, invented values in the units of the equations (kr, MW, MWh, kr/MWh, years).""" """Round, invented values in the units of the equations (kr, MW, MWh, kr/MWh, years)."""
@ -165,6 +188,9 @@ def lag_inndata(*, u_eksport: tuple[float, ...] | None = None, **endringer: floa
linjer={omraade: Prislinje(alpha=700.0, b=-10e-6) for omraade in OMRAADER}, linjer={omraade: Prislinje(alpha=700.0, b=-10e-6) for omraade in OMRAADER},
karbonpris={2026: 1000.0, 2100: 1000.0}, karbonpris={2026: 1000.0, 2100: 1000.0},
u_eksport=(0.5,) * antall_aar if u_eksport is None else u_eksport, u_eksport=(0.5,) * antall_aar if u_eksport is None else u_eksport,
eierformer=EIERFORMER,
areal={"kjernekraft": 0.1e-6, "vind_direkte": 1.5e-6, "vind_plan": 30e-6, "tomt": 0.001},
petroleum_median=250e9,
) )

275
tests/test_dommer.py Normal file
View file

@ -0,0 +1,275 @@
"""The verdicts (chapter 11 and the pre-registration), tested on invented outcomes.
No array here comes from the model run on the frozen parameters: the outcomes per draw are
made up, and the two conditions that are read from the power system are computed on the
made-up set in ``conftest.py``. Nothing here says anything about the hypothesis.
"""
from __future__ import annotations
import math
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import dommer
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker.dommer import Dom, Forsyning, Grunnlag, Trinnvalg
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
_UENDRET = Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False)
_EFFEKT_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=False)
_ENERGI_MANGLER = Forsyning(ikke_svakere_uten_tiltak=False, svakere_ogsaa_med_tiltak=True)
def _utfall(*deler: tuple[float | None, int]) -> list[float | None]:
"""Invented outcomes: each value repeated the given number of draws."""
return [verdi for verdi, antall in deler for _ in range(antall)]
def _regn(inn: Inndata, losning: Losning, *, N_anlegg: int = 1) -> ks.Programresultat:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
return ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING, dim=dim)
# ------------------------------------------------------------------- shares
def test_s37_andel() -> None:
assert lg.s37_andel([True, False, True, True]) == 0.75
with pytest.raises(ValueError, match="at least one draw"):
lg.s37_andel([])
def test_trekning_uten_verdi_teller_i_nevneren() -> None:
utfall = _utfall((1.0, 6), (-1.0, 2), (None, 2))
assert dommer.andel_positiv(utfall) == 0.6
assert dommer.andel(utfall, 0.0, minst=True) == 0.6
assert dommer.andel(utfall, 0.0, minst=False) == 0.2
assert dommer.median(utfall) == 1.0
assert dommer.median(_utfall((1.0, 4), (None, 6))) == -math.inf
# -------------------------------------------------------------- M1, M2, M7
@pytest.mark.parametrize(
("positive", "negative", "uten", "dom"),
[
(80, 20, 0, Dom.HOLDER),
(79, 21, 0, Dom.BETINGELSER),
(20, 80, 0, Dom.BETINGELSER),
(19, 81, 0, Dom.HOLDER_IKKE),
(80, 0, 20, Dom.HOLDER),
(79, 0, 21, Dom.BETINGELSER),
(19, 0, 81, Dom.HOLDER_IKKE),
],
)
def test_dom_m1(positive: int, negative: int, uten: int, dom: Dom) -> None:
"""Positive in at least 80 % of all draws holds; in under 20 % it does not."""
assert dommer.dom_m1(_utfall((5.0, positive), (-5.0, negative), (None, uten))) is dom
def test_dom_m2_teller_null_som_oppfylt() -> None:
"""S42 is an inequality with >=: a sum of exactly zero meets it."""
assert dommer.dom_m2(_utfall((0.0, 80), (-1.0, 20))) is Dom.HOLDER
assert dommer.dom_m2(_utfall((0.0, 50), (-1.0, 50))) is Dom.BETINGELSER
assert dommer.dom_m2(_utfall((1.0, 10), (-1.0, 50), (None, 40))) is Dom.HOLDER_IKKE
def test_dom_m7_a_mot_b_og_c() -> None:
"""A is best in 5 of 10 draws: holds. A draw where A cannot be built is not one of them."""
A = _utfall((10.0, 5), (1.0, 3), (None, 2))
B = _utfall((5.0, 5), (2.0, 3), (-9.0, 2))
C = _utfall((None, 5), (0.0, 5))
assert dommer.a_er_best(A, B, C) == [True] * 5 + [False] * 5
assert dommer.dom_m7(A, B, C) is Dom.HOLDER
alltid_bedre = _utfall((5.0, 5), (2.0, 5))
assert dommer.dom_m7(_utfall((10.0, 4), (1.0, 6)), alltid_bedre, C) is Dom.BETINGELSER
assert dommer.dom_m7(_utfall((10.0, 1), (1.0, 9)), alltid_bedre, C) is Dom.HOLDER_IKKE
# equal is not best
assert dommer.a_er_best([1.0], [1.0], [0.0]) == [False]
# ------------------------------------------------------------------ M3 and M4
def test_m3_verste_prisvirkning_i_R(oppdiktet: LagInndata) -> None:
"""One facility in R takes 3.942 TWh from the balance: 39.42 kr/MWh on a price of 600.
In the dry year the effect is 1.2 times larger; the price level 1.5 is in both numerator
and denominator. The made-up lines are the same in all areas.
"""
inn = oppdiktet()
res = _regn(inn, Losning.R)
normal = 10e-6 * 0.5 * E_D / 600.0
assert dommer.m3_verste_prisvirkning(inn, res) == pytest.approx(1.2 * normal)
assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.A)) == 0.0
# B produces more than the data centres use: the price falls
assert dommer.m3_verste_prisvirkning(inn, _regn(inn, Losning.B)) < 0
def test_dom_m3() -> None:
assert dommer.dom_m3(_utfall((0.05, 80), (0.2, 20))) is Dom.HOLDER
assert dommer.dom_m3(_utfall((0.051, 80), (0.2, 20))) is Dom.BETINGELSER
assert dommer.dom_m3(_utfall((0.16, 80), (0.0, 20))) is Dom.HOLDER_IKKE
assert dommer.dom_m3(_utfall((0.15, 80), (0.0, 20))) is Dom.BETINGELSER
# a draw without a value meets neither condition
assert dommer.dom_m3(_utfall((0.16, 79), (None, 21))) is Dom.BETINGELSER
assert dommer.dom_m3(_utfall((0.0, 79), (None, 21))) is Dom.BETINGELSER
def test_m4_forsyning_i_de_fem_losningene(oppdiktet: LagInndata) -> None:
"""A changes nothing. R only takes power. B and one facility in C add more than they take.
With three facilities C has used up hydropower and wind on land; offshore wind counts
nothing in the scarcest hour, so capacity is missing, but energy is not.
"""
inn = oppdiktet()
assert dommer.m4_forsyning(inn, _regn(inn, Losning.A)) == _UENDRET
assert dommer.m4_forsyning(inn, _regn(inn, Losning.R)) == _ENERGI_MANGLER
assert dommer.m4_forsyning(inn, _regn(inn, Losning.B)) == _UENDRET
assert dommer.m4_forsyning(inn, _regn(inn, Losning.C)) == _UENDRET
tre = _regn(inn, Losning.C, N_anlegg=3)
assert dommer.m4_forsyning(inn, tre) == _EFFEKT_MANGLER
def test_m4_C_dekker_akkurat_forbruket_i_toerraaret(oppdiktet: LagInndata) -> None:
"""With nothing displaced in the grid queue, C's dry-year balance is zero, not weaker."""
inn = oppdiktet(delta_V=0.0, kappa_vind=1.0)
res = _regn(inn, Losning.C)
assert max(abs(rad.Delta_Q_tort) for rad in res.kraftaar) < 1.0
assert not dommer.m4_forsyning(inn, res).svakere_ogsaa_med_tiltak
def test_dom_m4() -> None:
ok, effekt, energi = _UENDRET, _EFFEKT_MANGLER, _ENERGI_MANGLER
assert dommer.dom_m4([ok] * 8 + [energi] * 2) is Dom.HOLDER
assert dommer.dom_m4([ok] * 7 + [effekt] * 3) is Dom.BETINGELSER
assert dommer.dom_m4([effekt] * 10) is Dom.BETINGELSER
assert dommer.dom_m4([energi] * 8 + [ok] * 2) is Dom.HOLDER_IKKE
assert dommer.dom_m4([energi] * 7 + [None] * 3) is Dom.BETINGELSER
# -------------------------------------------------------- M6 and the ladder
def test_dom_m6() -> None:
assert dommer.dom_m6(_utfall((0.25, 80), (0.0, 20))) is Dom.HOLDER
assert dommer.dom_m6(_utfall((0.24, 80), (0.0, 20))) is Dom.BETINGELSER
assert dommer.dom_m6(_utfall((0.049, 80), (0.3, 20))) is Dom.HOLDER_IKKE
assert dommer.dom_m6(_utfall((0.05, 80), (0.3, 20))) is Dom.BETINGELSER
# a path that cannot be built does not reach 5 %
assert dommer.dom_m6(_utfall((0.3, 20), (None, 80))) is Dom.HOLDER_IKKE
def _stige(**andel_per_trinn: tuple[float, int]) -> dict[int, dict[Losning, list[float | None]]]:
"""A made-up ladder: for A, M6 is the given value in the given number of 10 draws.
B can be built in the same draws and contributes nothing; R reaches 90 % everywhere.
"""
stige = {}
for navn, (verdi, antall) in andel_per_trinn.items():
trinn = int(navn.removeprefix("n"))
stige[trinn] = {
Losning.A: _utfall((verdi, antall), (None, 10 - antall)),
Losning.B: _utfall((0.0, antall), (None, 10 - antall)),
Losning.R: _utfall((0.9, 10)),
}
return stige
def test_dommene_leses_paa_det_laveste_trinnet_som_gir_25_prosent() -> None:
stige = _stige(n1=(0.03, 10), n5=(0.1, 10), n10=(0.3, 8), n20=(0.5, 10))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(10, Grunnlag.TRINN_25)
def test_ellers_paa_trinnet_som_gir_5_prosent() -> None:
"""25 % is reached in only 7 of 10 draws on the top step; 5 % in 8 of 10 from step 5."""
stige = _stige(n1=(0.03, 10), n5=(0.1, 8), n10=(0.3, 7))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.TRINN_5)
def test_ellers_paa_hoyeste_trinn_som_lar_seg_bygge() -> None:
"""No step reaches 5 %. Step 10 can be built in 7 of 10 draws, step 5 in 9."""
stige = _stige(n1=(0.01, 10), n5=(0.03, 9), n10=(0.04, 7))
assert dommer.trinn_for_dommene(stige) == Trinnvalg(5, Grunnlag.HOYESTE)
def test_referansekjoringen_kan_ikke_gi_trinnet() -> None:
"""R reaches 90 % on every step here, but only A, B and C decide the step."""
stige = _stige(n1=(0.0, 10), n5=(0.0, 10))
assert dommer.trinn_for_dommene(stige).grunnlag is Grunnlag.HOYESTE
def test_ingen_trinn_lar_seg_bygge() -> None:
stige = {
1: {
Losning.A: _utfall((None, 10)),
Losning.B: _utfall((0.1, 7), (None, 3)),
}
}
assert dommer.trinn_for_dommene(stige) == Trinnvalg(None, Grunnlag.INGEN)
# ---------------------------------------------------------------- overall verdicts
def _dommer(**endringer: Dom) -> dict[str, Dom]:
alle = dict.fromkeys(dommer.MAAL_DEL_I, Dom.HOLDER)
alle.update(endringer)
return alle
def test_del_I_holder_naar_en_losning_holder_paa_alle_maal() -> None:
per_losning = {
Losning.A: _dommer(M1=Dom.HOLDER_IKKE),
Losning.B: _dommer(),
Losning.C: _dommer(M3=Dom.BETINGELSER),
}
median = {Losning.A: -1.0, Losning.B: 5.0, Losning.C: 5.0}
paa_25 = Trinnvalg(10, Grunnlag.TRINN_25)
assert dommer.del_I(per_losning, median, paa_25) is Dom.HOLDER
# on the 5 % step, or with a single facility, it can at most hold under conditions
assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_5)) is Dom.BETINGELSER
assert dommer.del_I(per_losning, median, Trinnvalg(1, Grunnlag.TRINN_25)) is Dom.BETINGELSER
def test_del_I_holder_ikke_naar_hver_losning_er_felt() -> None:
"""A fails M1, B has a negative median, C fails M4. M6 alone cannot fell a solution."""
per_losning = {
Losning.A: _dommer(M1=Dom.HOLDER_IKKE),
Losning.B: _dommer(M1=Dom.BETINGELSER),
Losning.C: _dommer(M4=Dom.HOLDER_IKKE),
}
median = {Losning.A: -1.0, Losning.B: -0.5, Losning.C: 5.0}
valg = Trinnvalg(10, Grunnlag.TRINN_25)
assert dommer.del_I(per_losning, median, valg) is Dom.HOLDER_IKKE
per_losning[Losning.C] = _dommer(M6=Dom.HOLDER_IKKE)
assert dommer.del_I(per_losning, median, valg) is Dom.BETINGELSER
assert dommer.del_I(per_losning, median, Trinnvalg(None, Grunnlag.INGEN)) is Dom.HOLDER_IKKE
def test_del_I_ser_bare_paa_A_B_og_C() -> None:
"""The reference run R holds on everything here; it cannot give «holder»."""
per_losning = {
Losning.A: _dommer(M2=Dom.HOLDER_IKKE),
Losning.R: _dommer(),
}
median = {Losning.A: 1.0, Losning.R: 9.0}
assert dommer.del_I(per_losning, median, Trinnvalg(10, Grunnlag.TRINN_25)) is Dom.HOLDER_IKKE
def test_del_II_folger_M7() -> None:
assert dommer.del_II(Dom.BETINGELSER) is Dom.BETINGELSER

455
tests/test_eierskap.py Normal file
View file

@ -0,0 +1,455 @@
"""Business cash flow, tax and ownership (chapters 7 and 8): S28, S29 and S30.
Made-up round numbers only; the ownership forms are those of ``conftest.py``, not the
parameter file's. Nothing here says anything about the hypothesis.
"""
from __future__ import annotations
import math
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import eierskap as ei
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
def _crf(rho: float, levetid: float) -> float:
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
def _lcoc_v() -> float:
"""S15 for the made-up competitor, per MW IT and year."""
return 100e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 3e6 + 8760.0 * 0.75 * 1.2 * 800.0
def _regn(
inn: Inndata,
losning: Losning,
*,
N_anlegg: int = 1,
knapphet: Knapphet = Knapphet.NORMALISERING,
) -> ks.Programresultat:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
return ks.regn_program(inn, losning, plan, knapphet, dim=dim)
def _lonnsom(inn: Inndata) -> ei.Bedriftsstrom:
"""One facility in R with the scarcity markup: the made-up price is about twice the cost."""
return ei.bedriftsstrom(inn, _regn(inn, Losning.R, knapphet=Knapphet.VARER))
# ------------------------------------------------------- the equations one at a time
def test_avskrivning_er_lineaer_over_levetiden() -> None:
aar = [
lg.s28_avskrivning(kostnad=100.0, levetid=4, start=2030, slutt=2033, t=t)
for t in range(2029, 2035)
]
assert aar == pytest.approx([0.0, 25.0, 25.0, 25.0, 25.0, 0.0])
def test_resten_skrives_av_naar_eiendelen_gaar_ut_for_tiden() -> None:
"""A lifetime of ten years, but the facility goes out after three: 10, 10 and the last 80."""
aar = [
lg.s28_avskrivning(kostnad=100.0, levetid=10, start=2030, slutt=2032, t=t)
for t in range(2030, 2034)
]
assert aar == pytest.approx([10.0, 10.0, 80.0, 0.0])
assert math.fsum(aar) == pytest.approx(100.0)
def test_underskudd_fores_fram_uten_rente() -> None:
"""A loss of 100 is used against 60 and then against 40 of the next 80."""
assert lg.s28_etter_framforing([-100.0, 60.0, 80.0, 50.0]) == (0.0, 0.0, 40.0, 50.0)
assert lg.s28_etter_framforing([10.0, -5.0, -5.0, 30.0]) == (10.0, 0.0, 0.0, 20.0)
def test_s28_naaverdi() -> None:
assert lg.s28_naaverdi(netto=[-100.0, 0.0, 121.0], rente=0.1) == pytest.approx(0.0)
def test_s29_kapitalkostnad() -> None:
"""Half debt at 5 % (4 % after 20 % tax) and half equity at 10 %: 7 % nominal, 4.9 % real."""
r_e = lg.s29_kapitalkostnad(h=0.5, r_d=0.05, r_q=0.10, tau_s=0.2, iota=0.02)
assert r_e == pytest.approx(1.07 / 1.02 - 1.0)
assert lg.realrente(nominell=0.071, iota=0.05) == pytest.approx(0.02)
def test_s30_skatt_med_egen_framforing_for_saerskatten() -> None:
"""Corporate tax 20 % on profit after the loss; special tax 50 % above 5 % of capital 200.
Profit above the return: -100, 50, 70, 40. The loss of 100 takes the 50 and half of the
70, so the special tax base is 0, 0, 20, 40.
"""
selskap, saer = lg.s30_skatt(
overskudd=[-100.0, 60.0, 80.0, 50.0],
kapital_inn=[0.0, 200.0, 200.0, 200.0],
tau_s=0.2,
tau_g=0.5,
r_e=0.05,
)
assert selskap == pytest.approx((0.0, 0.0, 8.0, 10.0))
assert saer == pytest.approx((0.0, 0.0, 10.0, 20.0))
def test_s30_statens_kontantstrom() -> None:
"""State share 0.6, direct share 0.25, the state carries all overruns (zeta = 1)."""
KS = lg.s30_statens_kontantstrom(
skatt=30.0, FKE=100.0, NK=200.0, overskridelse=40.0, s=0.6, theta=0.25, zeta=1.0
)
assert KS == pytest.approx(30.0 + 0.6 * 0.75 * 100.0 + 0.25 * 200.0 - 0.4 * 0.75 * 40.0)
# with zeta equal to the ownership share the state covers nothing beyond its share
uten = lg.s30_statens_kontantstrom(
skatt=30.0, FKE=100.0, NK=200.0, overskridelse=40.0, s=0.6, theta=0.25, zeta=0.6
)
assert uten == pytest.approx(30.0 + 45.0 + 50.0)
# ------------------------------------------------------------ the business cash flow
def test_R_bedriftsstrom_haandregnet(oppdiktet: LagInndata) -> None:
"""One facility in R to 2040, as a business pays.
Building 110 mrd. kr and first vintage 200, paid in 2028 and 2029; vintages of 200 paid
in 2034 and 2039; no grid investment. In operation it pays operation, power at the
price, electricity tax, grid tariff on 1 200 MW and disconnection for 600 MW.
"""
inn = oppdiktet(T_slutt=2040)
res = _regn(inn, Losning.R)
strom = ei.bedriftsstrom(inn, res)
aar = dict(zip(res.aar, range(len(res.aar)), strict=True))
pris = 700.0 - 10e-6 * (10e6 - 0.5 * E_D)
utkobling = 100.0 * _lcoc_v() / (8760.0 * 1.2) * 600.0
assert strom.inntekt[aar[2031]] == pytest.approx(1000.0 * _lcoc_v())
assert strom.avgifter[aar[2031]] == pytest.approx(70.0 * E_D + 0.3e6 * 1200.0)
assert strom.drift[aar[2031]] == pytest.approx(
2.5e9 + pris * E_D + 70.0 * E_D + 0.3e6 * 1200.0 + utkobling
)
assert not strom.drift[: aar[2030]].any()
investert = {2028: 155e9, 2029: 155e9, 2034: 200e9, 2039: 200e9}
for t in res.aar:
assert strom.investering[aar[t]] == pytest.approx(investert.get(t, 0.0))
assert (strom.budsjett == strom.investering).all()
# the building over 15 years and one vintage at a time over 5
assert strom.avskrivning[aar[2030] :] == pytest.approx(110e9 / 15.0 + 40e9)
assert not strom.avskrivning[: aar[2030]].any()
assert strom.kapital[aar[2029]] == pytest.approx(310e9)
assert strom.kapital[aar[2030]] == pytest.approx(310e9 - 110e9 / 15.0 - 40e9)
assert strom.NK[aar[2034]] == pytest.approx(
strom.inntekt[aar[2034]] - strom.drift[aar[2034]] - 200e9
)
@pytest.mark.parametrize("losning", list(Losning))
@pytest.mark.parametrize(
"endringer", [{}, {"T_slutt": 2045, "u_xi": 0.1}, {"L_N": 12.0, "L_B": 7.0}]
)
def test_eiendelene_gir_de_samme_investeringene_som_kontantstrommen(
oppdiktet: LagInndata, losning: Losning, endringer: dict[str, float]
) -> None:
"""The booked assets, paid over their construction time, are the investments of S34 and S35.
All but the grid connection, which the tariff covers. In A the table for the buffer
also holds its fixed operation, which is taken out here.
"""
inn = oppdiktet(u_eksport=None, **endringer)
res = _regn(inn, losning, N_anlegg=2)
strom = ei.bedriftsstrom(inn, res)
ventet = np.zeros(len(res.aar))
for k, a in enumerate(res.anlegg):
ventet += a.I_bygg + a.I_H + a.I_g + a.buffer
for tabell in a.investering.values():
ventet += tabell
if losning is Losning.A:
i_drift = np.array([res.plan.i_drift(k, t) for t in res.aar], dtype=np.float64)
ventet -= i_drift * 0.4e6 * 600.0
for f in res.felles:
ventet += f.investering
assert strom.investering == pytest.approx(ventet)
# the overrun factor is 1.5 in the second set, and only nuclear power carries it
overskridelse = float((strom.investering - strom.budsjett).sum())
if losning.kjernekraft and res.dim.xi_N > 1.0:
eiendeler = [e for a in res.anlegg for e in a.eiendeler]
eiendeler += [e for f in res.felles for e in f.eiendeler]
kjernekraft = math.fsum(e.kostnad for e in eiendeler if e.slag == ks.KJERNEKRAFT)
assert overskridelse == pytest.approx(kjernekraft / 3.0)
else:
assert overskridelse == 0.0
def test_avskrivningene_summerer_seg_til_det_som_er_betalt(oppdiktet: LagInndata) -> None:
"""Every asset is out of operation by 2060, so the booked capital ends at zero."""
inn = oppdiktet()
res = _regn(inn, Losning.A)
strom = ei.bedriftsstrom(inn, res)
assert float(strom.avskrivning.sum()) == pytest.approx(float(strom.investering.sum()))
assert strom.kapital[-1] == pytest.approx(0.0, abs=1.0)
assert (strom.kapital > -1.0).all()
def test_A_betaler_elavgift_men_ikke_nettariff(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
res = _regn(inn, Losning.A)
strom = ei.bedriftsstrom(inn, res)
j = 2040 - 2027
assert strom.avgifter[j] == pytest.approx(70.0 * E_D)
anlegg = res.anlegg[0]
assert strom.drift[j] == pytest.approx(
2.5e9
+ float(anlegg.kraftdrift[ks.KJERNEKRAFT][j])
+ float(anlegg.ulykke[j])
+ 0.4e6 * 600.0
+ 70.0 * E_D
)
def test_kraftverk_paa_nettet_selger_uten_tilleggsregelen(oppdiktet: LagInndata) -> None:
"""The business keeps the plant's whole sales, also when S45 binds in M1."""
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6)
res = _regn(inn, Losning.B_MERKET)
assert res.varsigma[ks.KJERNEKRAFT] < 1.0
strom = ei.bedriftsstrom(inn, res)
j = 2040 - 2027
anlegg = res.anlegg[0]
uten_salg = (
2.5e9
+ float(anlegg.kraftdrift[ks.KJERNEKRAFT][j])
+ float(anlegg.ulykke[j])
+ res.kraftaar[j].pris * E_D
+ float(strom.avgifter[j])
)
assert strom.drift[j] == pytest.approx(uten_salg - float(anlegg.salg[ks.KJERNEKRAFT][j]))
# S30 is computed with the factor of S45 on the sales (chapter 1.4)
med_regel = ei.bedriftsstrom(inn, res, tilleggsregel=True)
assert med_regel.drift[j] == pytest.approx(
uten_salg - res.varsigma[ks.KJERNEKRAFT] * float(anlegg.salg[ks.KJERNEKRAFT][j])
)
assert (med_regel.investering == strom.investering).all()
# -------------------------------------------------------------- the ownership forms
def test_kapitalkostnad_per_eierform(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
assert ei.kapitalkostnad(inn, inn.eierformer["direkte"]) == 0.02
assert ei.kapitalkostnad(inn, inn.eierformer["heleid_selskap"]) == pytest.approx(
1.07 / 1.02 - 1.0
)
assert ei.kapitalkostnad(inn, inn.eierformer["majoritet_boers"]) == pytest.approx(
1.08 / 1.02 - 1.0
)
def test_direkte_eierskap_gir_staten_hele_kontantstrommen(oppdiktet: LagInndata) -> None:
"""No company and no corporate tax: FKE = NK, and the state also receives tax and tariff."""
inn = oppdiktet(T_slutt=2040)
strom = ei.bedriftsstrom(inn, _regn(inn, Losning.R))
ut = ei.eierresultat(inn, strom, inn.eierformer["direkte"])
assert not ut.selskapsskatt.any()
assert not ut.saerskatt.any()
assert (ut.FKE == strom.NK).all()
assert not ut.gjeld.any()
assert ut.KS_stat == pytest.approx(strom.NK + strom.avgifter)
NV = math.fsum(float(x) / 1.02**j for j, x in enumerate(strom.NK))
assert ei.naaverdi_etter_skatt(inn, strom, inn.eierformer["direkte"]) == pytest.approx(NV)
assert ut.NV_NK == pytest.approx(NV)
# 310 mrd. kr is paid before the first revenue
assert ut.storste_innskutte_kapital == pytest.approx(310e9)
def test_heleid_selskap_skatt_gjeld_og_statens_kontantstrom(oppdiktet: LagInndata) -> None:
"""One wholly owned company, half debt at 5 % nominal (1.05 / 1.02 - 1 real).
Tax is 20 % of revenue minus operation and depreciation; nothing is carried forward
because the first operating year already has a profit. The state owns everything, so
the tax cancels: what it gets is NK, tax and tariff, minus interest, plus new debt.
"""
inn = oppdiktet(T_slutt=2040)
strom = _lonnsom(inn)
ut = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
overskudd = strom.inntekt - strom.drift - strom.avskrivning
assert (overskudd[3:] > 0).all()
assert ut.selskapsskatt == pytest.approx(0.2 * overskudd)
assert not ut.saerskatt.any()
assert ut.gjeld[:-1] == pytest.approx(0.5 * strom.kapital[:-1])
assert ut.gjeld[-1] == 0.0
gjeld_inn = np.concatenate(([0.0], ut.gjeld[:-1]))
rente = 1.05 / 1.02 - 1.0
FKE = strom.NK - ut.selskapsskatt - rente * gjeld_inn + ut.gjeld - gjeld_inn
assert ut.FKE == pytest.approx(FKE)
assert ut.KS_stat == pytest.approx(
strom.NK + strom.avgifter - rente * gjeld_inn + ut.gjeld - gjeld_inn
)
r_e = 1.07 / 1.02 - 1.0
NV_e = ei.naaverdi_etter_skatt(inn, strom, inn.eierformer["heleid_selskap"])
assert NV_e == pytest.approx(
math.fsum(float(x) / (1.0 + r_e) ** j for j, x in enumerate(strom.NK - ut.selskapsskatt))
)
assert ut.NV_stat == pytest.approx(
math.fsum(float(x) / 1.02**j for j, x in enumerate(ut.KS_stat))
)
andel = ut.andel_av_overskudd
assert andel is not None
assert andel == pytest.approx(ut.NV_stat / ut.NV_NK)
# the owners put in half of what is built, and the interest in 2029 on what was borrowed
# in 2028; the other half is borrowed
assert ut.storste_innskutte_kapital == pytest.approx(155e9 + rente * 77.5e9)
def test_privat_minoritet_og_direkte_andel(oppdiktet: LagInndata) -> None:
"""The petroleum model: the state owns 60 % of the company and 25 % of the facilities directly.
The company's part, 75 %, pays corporate tax and special tax; the state's direct part
does not. Electricity tax and grid tariff come from the whole project.
"""
inn = oppdiktet(T_slutt=2040)
strom = _lonnsom(inn)
ut = ei.eierresultat(inn, strom, inn.eierformer["petroleumsmodell"])
assert ut.saerskatt.sum() > 0
skatt = ut.selskapsskatt + ut.saerskatt
ventet = 0.75 * skatt + strom.avgifter + 0.6 * 0.75 * ut.FKE + 0.25 * strom.NK
assert ut.KS_stat == pytest.approx(ventet)
# the special tax is 50 % of the profit above r_e on the capital booked at the start of the
# year; the return on what was booked during construction is carried forward and used in 2030
r_e = 1.08 / 1.02 - 1.0
overskudd = strom.inntekt - strom.drift - strom.avskrivning
j = 2031 - 2027
assert ut.saerskatt[j] == pytest.approx(0.5 * (overskudd[j] - r_e * strom.kapital[j - 1]))
boers = ei.eierresultat(inn, strom, inn.eierformer["majoritet_boers"])
assert boers.NV_stat < ut.NV_stat
# the special tax lowers the project's value after tax (S28)
assert ei.naaverdi_etter_skatt(
inn, strom, inn.eierformer["majoritet_boers"]
) > ei.naaverdi_etter_skatt(inn, strom, inn.eierformer["petroleumsmodell"])
def test_staten_dekker_overskridelser_ut_over_eierandelen(oppdiktet: LagInndata) -> None:
"""Overrun 50 % on nuclear power; the state owns 60 % but carries all of it (zeta = 1)."""
inn = oppdiktet(u_xi=0.1)
res = _regn(inn, Losning.A)
assert res.dim.xi_N == 1.5
strom = ei.bedriftsstrom(inn, res)
overskridelse = strom.investering - strom.budsjett
assert overskridelse.sum() > 0
ut = ei.eierresultat(inn, strom, inn.eierformer["majoritet_boers"])
skatt = ut.selskapsskatt + ut.saerskatt
uten = skatt + strom.avgifter + 0.6 * ut.FKE
assert ut.KS_stat == pytest.approx(uten - 0.4 * overskridelse)
def test_underskudd_i_oppstarten_gir_ingen_skatt(oppdiktet: LagInndata) -> None:
"""«Overkapasitet»: the price is 30 % under the competitor's cost, and nothing is taxable.
The last vintage, from 2040, is sold at cost and gives a small profit; the losses
carried forward cover it.
"""
inn = oppdiktet(T_slutt=2040)
strom = ei.bedriftsstrom(inn, _regn(inn, Losning.R, knapphet=Knapphet.OVERKAPASITET))
assert (strom.inntekt - strom.drift - strom.avskrivning)[-1] > 0
ut = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
assert not ut.selskapsskatt.any()
assert ut.NV_stat < 0
assert ut.andel_av_overskudd is None
def test_kapitalkostnaden_flytter_kostnaden_for_regnekraft(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
res = _regn(inn, Losning.B_MERKET)
lav = ei.lcoc_med_kapitalkostnad(inn, res, 0.02)
hoy = ei.lcoc_med_kapitalkostnad(inn, res, 0.06)
assert lav < hoy
# ------------------------------------------------------ the criteria over the draws
def test_risikomaalene() -> None:
utfall = [float(x) for x in range(-10, 30)] # 40 draws: -10 .. 29
assert ei.sannsynlighet_for_tap(utfall) == pytest.approx(10 / 40)
# 5 % of 40 draws is the two worst
assert ei.snitt_av_de_daarligste(utfall) == pytest.approx(-9.5)
assert ei.snitt_av_de_daarligste([3.0, 1.0, 2.0]) == 1.0
def test_storste_innskutte_kapital() -> None:
"""Paid in 100 and 50, then 30 back, then 40 more: 160 out at the most."""
KS = np.array([-100.0, -50.0, 30.0, -40.0, 500.0])
assert ei.storste_innskutte_kapital(KS) == pytest.approx(160.0)
assert ei.storste_innskutte_kapital(np.array([10.0, 20.0])) == 0.0
def _kriterier(navn: str, **endringer: float | None) -> ei.Eierkriterier:
verdier: dict[str, float | None] = {
"verdi": 100.0,
"andel_av_overskudd": 0.9,
"r_e": 0.05,
"LCOC": 80.0,
"tapssannsynlighet": 0.1,
"daarligste": -50.0,
"kapital_ute": 300.0,
}
verdier.update(endringer)
return ei.Eierkriterier(navn=navn, **verdier) # type: ignore[arg-type]
def test_eierkriterier_fra_utfallene(oppdiktet: LagInndata) -> None:
"""Two draws with the same made-up path: the averages are those of the one outcome."""
inn = oppdiktet(T_slutt=2040)
strom = _lonnsom(inn)
ut = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
k = ei.eierkriterier("heleid_selskap", [ut, ut], [80.0, 90.0])
assert k.verdi == pytest.approx(ut.NV_stat)
assert k.andel_av_overskudd == pytest.approx(ut.NV_stat / ut.NV_NK)
assert k.r_e == pytest.approx(ut.r_e)
assert k.LCOC == pytest.approx(85.0)
assert k.tapssannsynlighet == 0.0
assert k.daarligste == pytest.approx(ut.NV_stat)
assert k.kapital_ute == pytest.approx(ut.storste_innskutte_kapital)
def test_regelen_for_eierformer() -> None:
"""One form fails the EEA test, one is worse on everything, one breaks the risk limit."""
kriterier = [
_kriterier("a", verdi=120.0),
_kriterier("b", verdi=150.0, tapssannsynlighet=0.3),
_kriterier(
"c",
verdi=90.0,
andel_av_overskudd=0.8,
r_e=0.06,
LCOC=85.0,
tapssannsynlighet=0.2,
daarligste=-60.0,
kapital_ute=310.0,
),
_kriterier("d", verdi=200.0),
_kriterier("e", verdi=110.0, r_e=0.06, LCOC=85.0),
]
eos = {"a": "består", "b": "usikker", "c": "består", "d": "består ikke", "e": "består"}
rangering = ei.ranger_eierformer(kriterier, eos)
assert rangering.rangert == ("a", "e")
assert rangering.over_risikogrensen == ("b",)
assert set(rangering.ute) == {"c", "d"}
assert rangering.ute["d"] == "består ikke EØS-vurderingen"
assert "dårligere enn a" in rangering.ute["c"]
# e is worse than a on value and capital cost, but not on risk, so it stays
strengere = ei.ranger_eierformer(kriterier, eos, risikogrense=0.05)
assert strengere.rangert == ()
assert strengere.over_risikogrensen == ("b", "a", "e")

150
tests/test_miljo.py Normal file
View file

@ -0,0 +1,150 @@
"""Environment (chapter 10): S32 year by year and the rules of M5.
Made-up round numbers only; the source values in the tests of M5 are invented. Nothing
here says anything about the hypothesis.
"""
from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import miljo
from tokenfabrikker.dommer import Dom
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.miljo import Kildeverdier
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
PORTEFOLJE = {"vann": 2e6, "vind": 3e6, "havvind": E_D - 1.6e6 - 3e6}
"""The made-up portfolio of one facility in C: normal-year production per technology, MWh."""
U_FORNYBAR = (0.004 * 2e6 + 0.011 * 3e6 + 0.012 * PORTEFOLJE["havvind"]) / sum(PORTEFOLJE.values())
"""Its emissions per MWh, weighted by production."""
def _regn(inn: Inndata, losning: Losning, *, N_anlegg: int = 1) -> ks.Programresultat:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
return ks.regn_program(inn, losning, plan, Knapphet.NORMALISERING, dim=dim)
def test_s32_er_summen_av_kraft_maskinvare_og_bygg() -> None:
U = lg.s32_utslipp(kraft=500.0, u_H=1000.0, u_B=2000.0, P_IT=10.0, nye_aarganger=2, nye_bygg=1)
assert U == pytest.approx(500.0 + 20_000.0 + 20_000.0)
@pytest.mark.parametrize("losning", [Losning.C, Losning.R])
def test_utslipp_aar_for_aar_med_fornybar_kraft(oppdiktet: LagInndata, losning: Losning) -> None:
"""One facility from 2030: building and first vintage in 2030, a vintage every five years.
The building lasts 15 years and is renewed in 2045. R uses the same figure for power
as C: the portfolio the facility has in C.
"""
inn = oppdiktet()
res = _regn(inn, losning)
U = miljo.utslipp_livslop(inn, res)
kraft = U_FORNYBAR * E_D
assert miljo.kraftutslipp_per_mwh(inn, res, 0) == pytest.approx(U_FORNYBAR)
assert not U[:3].any()
assert U[2030 - 2027] == pytest.approx(kraft + 1000.0 * 1000.0 + 2000.0 * 1000.0)
assert U[2031 - 2027] == pytest.approx(kraft)
assert U[2035 - 2027] == pytest.approx(kraft + 1000.0 * 1000.0)
assert U[2045 - 2027] == pytest.approx(kraft + 1000.0 * 1000.0 + 2000.0 * 1000.0)
assert not U[2050 - 2027 :].any()
@pytest.mark.parametrize("losning", [Losning.A, Losning.B, Losning.B_MERKET])
def test_kjernekraftens_utslipp_regnes_paa_det_datasenteret_bruker(
oppdiktet: LagInndata, losning: Losning
) -> None:
inn = oppdiktet()
res = _regn(inn, losning)
U = miljo.utslipp_livslop(inn, res)
assert U[2036 - 2027] == pytest.approx(0.012 * E_D)
def test_anlegg_uten_brikker_bruker_ikke_kraft(oppdiktet: LagInndata) -> None:
u = tuple(0.0 if aar == 2035 else 0.5 for aar in range(2028, 2061))
inn = oppdiktet(u_eksport=u, phi_X=0.1, D_X=3.0)
U = miljo.utslipp_livslop(inn, _regn(inn, Losning.R))
assert U[2036 - 2027] == 0.0
assert U[2038 - 2027] > 1000.0 * 1000.0
@pytest.mark.parametrize("losning", [Losning.C, Losning.R])
def test_hvert_anlegg_bruker_sin_egen_portefolje(oppdiktet: LagInndata, losning: Losning) -> None:
"""The first facility takes the hydropower and the wind; the second gets offshore wind only.
In R, facility k uses the figure of the portfolio facility k has in C.
"""
inn = oppdiktet()
res = _regn(inn, losning, N_anlegg=2)
assert miljo.kraftutslipp_per_mwh(inn, res, 0) == pytest.approx(U_FORNYBAR)
assert miljo.kraftutslipp_per_mwh(inn, res, 1) == pytest.approx(0.012)
U = miljo.utslipp_livslop(inn, res)
# 2034: both facilities are in operation in both solutions, and no vintage is new
assert U[2034 - 2027] == pytest.approx((U_FORNYBAR + 0.012) * E_D)
def test_brukt_brensel_og_areal(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
res = _regn(inn, Losning.B_MERKET)
tonn = miljo.brukt_brensel(inn, res)
assert tonn[2036 - 2027] == pytest.approx(3e-6 * res.verk[0][0].energi)
assert not miljo.brukt_brensel(inn, _regn(inn, Losning.R)).any()
# A: only what the data centre uses is produced
assert miljo.brukt_brensel(inn, _regn(inn, Losning.A))[2036 - 2027] == pytest.approx(3e-6 * E_D)
# 0.1 km2 per TWh for nuclear power, 1.5 for wind, and 0.001 km2 per MW IT for the plot
assert miljo.areal(inn, teknologi="kjernekraft", energi=E_D, P_IT=1000.0) == pytest.approx(
0.7884 + 1.0
)
assert miljo.areal(inn, teknologi="vind_direkte", energi=E_D, P_IT=1000.0) == pytest.approx(
11.826 + 1.0
)
# ------------------------------------------------------------------------ M5
def test_m5_utslipp_kilde_for_kilde() -> None:
"""Invented source values. Nuclear must not be above the lower of wind and hydro in any."""
under = Kildeverdier("X", kjernekraft=5.0, vind=11.0, vann=6.0, vind_hoyeste=50.0)
mellom = Kildeverdier("Y", kjernekraft=12.0, vind=11.0, vann=24.0, vind_hoyeste=56.0)
over = Kildeverdier("Z", kjernekraft=60.0, vind=11.0, vann=24.0, vind_hoyeste=56.0)
assert miljo.m5_utslipp(Losning.A, [under, under]) is Dom.HOLDER
assert miljo.m5_utslipp(Losning.B, [under, mellom]) is Dom.BETINGELSER
assert miljo.m5_utslipp(Losning.A, [under, mellom, over]) is Dom.HOLDER_IKKE
lik = Kildeverdier("W", kjernekraft=6.0, vind=11.0, vann=6.0, vind_hoyeste=50.0)
assert miljo.m5_utslipp(Losning.A, [lik]) is Dom.HOLDER
# C and R meet (i) by definition
assert miljo.m5_utslipp(Losning.C, [over]) is Dom.HOLDER
assert miljo.m5_utslipp(Losning.R, []) is Dom.HOLDER
with pytest.raises(ValueError, match="at least one source"):
miljo.m5_utslipp(Losning.A, [])
def test_m5_areal_mot_vind_paa_land() -> None:
felles = {"vind_direkte": 1.5, "vind_plan": 35.0}
assert miljo.m5_areal(Losning.A, kjernekraft=0.1, **felles) is Dom.HOLDER
assert miljo.m5_areal(Losning.A, kjernekraft=1.5, **felles) is Dom.HOLDER
assert miljo.m5_areal(Losning.B, kjernekraft=10.0, **felles) is Dom.BETINGELSER
assert miljo.m5_areal(Losning.A, kjernekraft=40.0, **felles) is Dom.HOLDER_IKKE
assert miljo.m5_areal(Losning.C, kjernekraft=40.0, **felles) is Dom.HOLDER
def test_m5_samlet() -> None:
assert miljo.m5(Dom.HOLDER, Dom.HOLDER) is Dom.HOLDER
assert miljo.m5(Dom.BETINGELSER, Dom.HOLDER) is Dom.BETINGELSER
assert miljo.m5(Dom.BETINGELSER, Dom.BETINGELSER) is Dom.BETINGELSER
assert miljo.m5(Dom.HOLDER, Dom.HOLDER_IKKE) is Dom.HOLDER_IKKE
assert miljo.m5(Dom.HOLDER, Dom.HOLDER, kostnadsfort=False) is Dom.HOLDER_IKKE

405
tests/test_nivaaisert.py Normal file
View file

@ -0,0 +1,405 @@
"""The levelised cost of power and compute over a path: S9 and S11 per year, S15, S19, S27, S42.
Everything is computed on the made-up set in ``conftest.py``, and the expected numbers are
built up here from the round values of that set. They say nothing about the hypothesis.
"""
from __future__ import annotations
import math
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import nivaaisert as nv
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
E_ENHET = 8760.0 * 0.8 * 1000.0
"""Yearly production of one made-up reactor of 1 000 MW."""
def _crf(rho: float, levetid: float) -> float:
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
def _sff(rho: float, levetid: float) -> float:
return float(rho / ((1.0 + rho) ** levetid - 1.0))
def _byggetid(rho: float, tau: float) -> float:
"""S3: the factor for interest during construction."""
return float(((1.0 + rho) ** tau - 1.0) / (tau * math.log1p(rho)))
def _lcoc_v() -> float:
"""S15 for the made-up competitor, per MW IT and year."""
return 100e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 3e6 + 8760.0 * 0.75 * 1.2 * 800.0
def _lcoc(c_a: float) -> float:
"""S15 for the made-up Norwegian facility with power at ``c_a`` kr/MWh."""
return 110e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 2.5e6 + 8760.0 * 0.75 * 1.2 * c_a
def _pris(antall_med_last: int, ny_kraft: float = 0.0) -> float:
"""The made-up price line: 700 kr/MWh minus 10 kr per TWh of power balance."""
return 700.0 - 10e-6 * (10e6 - 0.5 * antall_med_last * E_D + ny_kraft)
def _utkobling(mw: float) -> float:
"""S47, disconnection: 100 hours of the competitor-cost price for ``mw`` missing."""
return 100.0 * _lcoc_v() / (8760.0 * 1.2) * mw
def _regn(
inn: Inndata,
losning: Losning,
*,
N_anlegg: int = 1,
knapphet: Knapphet = Knapphet.NORMALISERING,
) -> ks.Programresultat:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
return ks.regn_program(inn, losning, plan, knapphet, dim=dim)
# ------------------------------------------------------- the equations one at a time
def test_s47_utkobling_er_den_andre_armen() -> None:
felles = {"h_knapp": 100.0, "mu": 1.0, "y": 105.12e6, "PUE": 1.2}
assert lg.s47_utkobling(Delta_R_utfall=-600.0, **felles) == pytest.approx(600e6)
assert lg.s47_utkobling(Delta_R_utfall=50.0, **felles) == 0.0
# the full S47 takes the cheaper arm
billig = lg.s47_effektkostnad(
Delta_R=-600.0, Delta_R_utfall=-600.0, c_fast=0.5e6, c_res=1e6, **felles
)
assert billig == pytest.approx(300e6)
def test_s27_kraftkostnad_slik_en_bedrift_betaler() -> None:
"""Price 500, tax 70; a plant with LCOE 600 and value factor 1.1 covering twice the use."""
ledd = lg.Portefoljeledd(x=1.0, LCOE=600.0, psi=1.1, regelen_binder=True)
c = lg.s27_kraftkostnad_bedrift_nett(
p_z=500.0, t_el=70.0, portefolje=[ledd], E_G=2e6, E_D=1e6, tariff=30e6, F_utkobling=10e6
)
# the additionality rule does not apply in M2: the plant's net term counts in full
assert c == pytest.approx(500.0 + 70.0 + (600.0 - 550.0) * 2.0 + 40.0)
assert lg.s27_nettariff(t_nett=0.3e6, PUE=1.2, P_IT=1000.0) == pytest.approx(360e6)
assert lg.s27_kraftkostnad_bedrift_dedikert(c_A=900.0, t_el=70.0) == 970.0
def test_s27_og_s42() -> None:
assert lg.s27_margin_bedrift(mu=0.9, Gamma=1.0, y=100.0, LCOC_bed=80.0) == pytest.approx(10.0)
sum_42 = lg.s42_naaverdivektet_margin(
marginer=[10.0, -22.0], aarganger=[2027, 2029], rho_D=0.1, T_0=2027
)
assert sum_42 == pytest.approx(10.0 - 22.0 / 1.21)
# ------------------------------------------------------------ R: bought from the grid
def test_R_kraftkostnad_per_aar_og_aargang(oppdiktet: LagInndata) -> None:
"""One facility in R to 2040: c_a = (1 + n_tap) p + (H_a + F_a) / E_D in every year.
H_a is the annuity of the grid connection for 600 MW (half the draw displaces private
data centres), F_a the disconnection arm for the same 600 MW.
"""
inn = oppdiktet(T_slutt=2040)
res = _regn(inn, Losning.R)
kost = nv.kraftkostnad(inn, res)
H_a = 5e6 * 600.0 * _crf(0.06, 40)
c_a = 1.05 * _pris(1) + (H_a + _utkobling(600.0)) / E_D
assert np.isnan(kost.c_a[0, :3]).all()
assert kost.c_a[0, 3:] == pytest.approx(c_a)
assert not kost.bedrift
assert kost.S42 is None
assert kost.F is res.F_a
assert [(a.anlegg, a.t_v, a.aar) for a in kost.aarganger] == [
(0, 2030, (2030, 2031, 2032, 2033, 2034)),
(0, 2035, (2035, 2036, 2037, 2038, 2039)),
(0, 2040, (2040,)),
]
for aargang in kost.aarganger:
assert aargang.c_a == pytest.approx(c_a)
assert aargang.LCOC == pytest.approx(_lcoc(c_a))
assert aargang.inntekt == pytest.approx(_lcoc_v())
margin = aargang.margin
assert margin is not None
assert margin.kraftfortrinn == pytest.approx(8760.0 * 0.75 * 1.2 * (800.0 - c_a))
assert margin.knapphet == 0.0
assert margin.drift_bygg_skatt == pytest.approx(3e6 - 2.5e6 - 10e6 * _crf(0.08, 15))
assert margin.usolgt == 0.0
assert margin.sum == pytest.approx(aargang.overskudd)
def test_kraftkostnaden_vektes_med_naaverdi_over_aargangens_aar(oppdiktet: LagInndata) -> None:
"""Two facilities in R that start in 2030 and 2031 (clarification 15).
The second facility weakens the power balance, so the price is higher from 2031. The
first vintage of facility 1 has one year at the low cost and four at the high, each
discounted with rho_D to the vintage's first year.
"""
inn = oppdiktet(T_slutt=2040)
res = _regn(inn, Losning.R, N_anlegg=2)
assert [a.start for a in res.plan.anlegg] == [2030, 2031]
kost = nv.kraftkostnad(inn, res)
faste = (5e6 * 600.0 * _crf(0.06, 40) + _utkobling(600.0)) / E_D
lav, hoy = 1.05 * _pris(1) + faste, 1.05 * _pris(2) + faste
assert kost.c_a[0, 3] == pytest.approx(lav)
assert kost.c_a[0, 4] == pytest.approx(hoy)
assert kost.c_a[1, 4] == pytest.approx(hoy)
assert np.isnan(kost.c_a[1, 3])
vekter = [1.08**-x for x in range(5)]
ventet = (lav * vekter[0] + hoy * math.fsum(vekter[1:])) / math.fsum(vekter)
forste = next(a for a in kost.aarganger if (a.anlegg, a.t_v) == (0, 2030))
assert forste.c_a == pytest.approx(ventet)
assert lav < forste.c_a < hoy
def test_anlegg_uten_brikker_har_ingen_kraftkostnad(oppdiktet: LagInndata) -> None:
"""An export stop from 2035 to 2037: the vintage from 2030 is replaced in 2038."""
u = tuple(0.0 if aar == 2035 else 0.5 for aar in range(2028, 2061))
inn = oppdiktet(u_eksport=u, phi_X=0.1, D_X=3.0)
res = _regn(inn, Losning.R)
kost = nv.kraftkostnad(inn, res)
assert np.isnan(kost.c_a[0, 2035 - 2027 : 2038 - 2027]).all()
assert not np.isnan(kost.c_a[0, 2038 - 2027])
assert [a.aar[0] for a in kost.aarganger][:2] == [2030, 2038]
assert kost.aarganger[0].aar == (2030, 2031, 2032, 2033, 2034)
# ------------------------------------------------------------- A: the dedicated plant
def test_A_kraftkostnaden_er_S9(oppdiktet: LagInndata) -> None:
"""One facility in A: units of 50 MW at 100 mill. kr/MW, four years to build, 8 % return."""
inn = oppdiktet()
res = _regn(inn, Losning.A)
N_u = res.dim.N_u
enhet = (
100e6 * 50.0 * _byggetid(0.08, 4.0) * _crf(0.08, 20)
+ 1e6 * 50.0
+ 5e6 * 50.0 * _sff(0.08, 20)
)
buffer = 600.0 * (10e6 * _crf(0.08, 20) + 0.4e6)
forsyning = 2.0 * 50.0 * 10e6 * _crf(0.08, 40) + 0.02 * N_u * 50.0 * 10e6 * _crf(0.08, 20)
ulykke = N_u * 1e-5 * (1e12 * 50.0 / 1000.0 - 8e9)
c_A = (N_u * enhet + buffer + forsyning + ulykke) / E_D + 50.0 + 100.0 + 30.0
kost = nv.kraftkostnad(inn, res)
i_drift = [j for j, t in enumerate(res.aar) if res.plan.har_last(0, t)]
assert kost.c_a[0, i_drift] == pytest.approx(c_A)
assert nv.kraftkostnad_dedikert(inn, res, 0, 0.08) == pytest.approx(c_A)
assert not kost.F.any()
# as a business: the electricity tax also applies behind the meter, and there is no tariff
bedrift = nv.kraftkostnad(inn, res, bedrift=True)
assert bedrift.c_a[0, i_drift] == pytest.approx(c_A + 70.0)
# the revenue carries the revenue factor of S44
assert kost.aarganger[0].inntekt == pytest.approx(res.dim.Gamma * _lcoc_v())
margin = kost.aarganger[0].margin
assert margin is not None
assert margin.usolgt == pytest.approx((1.0 - res.dim.Gamma) * _lcoc_v())
def test_A_enhetene_nummereres_paa_tvers_av_anleggene(oppdiktet: LagInndata) -> None:
"""With learning the second facility's units are cheaper than the first's."""
inn = oppdiktet(ell=0.1, s_brikker=0.12)
res = _regn(inn, Losning.A, N_anlegg=2)
forste = nv.kraftkostnad_dedikert(inn, res, 0, 0.08)
andre = nv.kraftkostnad_dedikert(inn, res, 1, 0.08)
assert andre < forste
# ------------------------------------------------------ B and B': nuclear on the grid
def _lcoe_stor_enhet() -> float:
"""S5 for made-up units of 1 000 MW on the grid, without the accident cost, kr/MWh."""
aarlig = (
100e6 * 1000.0 * _byggetid(0.06, 4.0) * _crf(0.06, 20)
+ 1e6 * 1000.0
+ 5e6 * 1000.0 * _sff(0.06, 20)
)
return aarlig / E_ENHET + 50.0 + 70.0 + 30.0
def test_B_kraftkostnaden_bruker_programmets_enheter(oppdiktet: LagInndata) -> None:
"""Three facilities that start together in 2035 and four units of 1 000 MW (clarification 2).
The four units produce 28.0 TWh and the facilities use 23.7: the price falls. Each
MWh used carries the units' net cost times production over use for the programme.
"""
inn = oppdiktet(s_brikker=0.12)
res = _regn(inn, Losning.B, N_anlegg=3)
assert res.varsigma == {ks.KJERNEKRAFT: 1.0}
j = 2040 - 2027
pris = _pris(3, ny_kraft=4 * E_ENHET)
assert res.kraftaar[j].pris == pytest.approx(pris)
ulykke = 4 * 1e-5 * (1e12 - 8e9) / (4 * E_ENHET)
netto = (_lcoe_stor_enhet() + ulykke - pris) * 4 * E_ENHET / (3 * E_D)
H_a = 5e6 * (600.0 + 0.75 * 1.2 * 1000.0 / 0.8) * _crf(0.06, 40)
c_a = 1.05 * pris + netto + (H_a + float(res.F_a[j]) / 3.0) / E_D
kost = nv.kraftkostnad(inn, res)
assert kost.c_a[:, j] == pytest.approx(c_a)
def test_bindende_tilleggsregel_gir_nettoledd_null(oppdiktet: LagInndata) -> None:
"""A cheap reactor that pays its way on the grid neither adds nor takes (clarification 11)."""
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6, s_brikker=0.12)
for losning in (Losning.B, Losning.B_MERKET):
res = _regn(inn, losning, N_anlegg=2)
assert res.varsigma[ks.KJERNEKRAFT] < 1.0
j = 2040 - 2027
H_a = 5e6 * (600.0 + res.dim.P_G_N) * _crf(0.06, 40)
c_a = 1.05 * res.kraftaar[j].pris + (H_a + float(res.F_a[j]) / 2.0) / E_D
assert nv.kraftkostnad(inn, res).c_a[:, j] == pytest.approx(c_a)
# a business is credited the plant's surplus: S45 does not apply in M2
bedrift = nv.kraftkostnad(inn, res, bedrift=True)
uten_verk = res.kraftaar[j].pris + 70.0 + (0.3e6 * 1200.0 + float(bedrift.F[j]) / 2.0) / E_D
assert (bedrift.c_a[:, j] < uten_verk).all()
def test_B_merket_bruker_anleggets_eget_verk(oppdiktet: LagInndata) -> None:
"""B': the plant of A on the grid. Small units: fuel 100 kr/MWh and a lower capacity factor."""
inn = oppdiktet()
res = _regn(inn, Losning.B_MERKET)
N_u = res.dim.N_u
verk = res.verk[0][0]
assert verk.energi == pytest.approx(8760.0 * 0.8 * 0.96 / 0.98 * N_u * 50.0)
aarlig = N_u * (
100e6 * 50.0 * _byggetid(0.06, 4.0) * _crf(0.06, 20)
+ 1e6 * 50.0
+ 5e6 * 50.0 * _sff(0.06, 20)
)
ulykke = N_u * 1e-5 * (1e12 * 50.0 / 1000.0 - 8e9)
lcoe = (aarlig + ulykke) / verk.energi + 50.0 + 100.0 + 30.0
assert nv.lcoe_kjernekraft(
inn, res, numre=range(1, N_u + 1), E_N=verk.energi, rho=0.06
) == pytest.approx(lcoe)
j = 2040 - 2027
pris = res.kraftaar[j].pris
H_a = 5e6 * (600.0 + N_u * 50.0) * _crf(0.06, 40)
c_a = 1.05 * pris + (lcoe - pris) * verk.energi / E_D + (H_a + float(res.F_a[j])) / E_D
assert nv.kraftkostnad(inn, res).c_a[0, j] == pytest.approx(c_a)
# ----------------------------------------------------------------- C: renewable power
def test_C_bruker_anleggets_egen_portefolje(oppdiktet: LagInndata) -> None:
"""One facility in C: hydropower 2 TWh, wind 3 and offshore wind 3.284 (clarification 10).
Hydropower has interest during construction in its investment figure already; the two
others get the factor of S3. A technology the additionality rule binds for counts zero.
"""
inn = oppdiktet()
res = _regn(inn, Losning.C)
lcoe = {
"vann": 20e6 * _crf(0.06, 40) / 3000.0 + 70.0,
"vind": 14e6 * _byggetid(0.06, 2.0) * _crf(0.06, 30) / 3000.0 + 120.0,
"havvind": (50e6 * _byggetid(0.06, 3.0) * _crf(0.06, 30) + 0.9e6) / 4500.0,
}
for teknologi, ventet in lcoe.items():
assert nv.lcoe_fornybar(inn, teknologi, 0.06) == pytest.approx(ventet)
energi = {"vann": 2e6, "vind": 3e6, "havvind": E_D - 1.6e6 - 3e6}
psi = {"vann": 1.2, "vind": 0.9, "havvind": 1.0}
assert res.varsigma["vann"] < 1.0
j = 2035 - 2027
pris = res.kraftaar[j].pris
netto = math.fsum(
energi[i] * (lcoe[i] - psi[i] * pris) for i in energi if res.varsigma[i] >= 1.0
)
H_a = 5e6 * 600.0 * _crf(0.06, 40)
c_a = 1.05 * pris + (netto + H_a + float(res.F_a[j])) / E_D
assert nv.kraftkostnad(inn, res).c_a[0, j] == pytest.approx(c_a)
# ------------------------------------------------------------------- M2: S27 and S42
def test_R_bedriftsokonomi_haandregnet(oppdiktet: LagInndata) -> None:
"""One facility in R to 2040 as a business pays for it.
Price plus electricity tax (70 kr/MWh), the grid tariff on 1 200 MW at 0.3 mill. kr per
MW, and disconnection for the 600 MW that is missing; no grid investment and no losses.
S42 sums the three vintages with rho_D to their first year.
"""
inn = oppdiktet(T_slutt=2040)
res = _regn(inn, Losning.R)
kost = nv.kraftkostnad(inn, res, bedrift=True)
c_bed = _pris(1) + 70.0 + (0.3e6 * 1200.0 + _utkobling(600.0)) / E_D
assert kost.c_a[0, 3:] == pytest.approx(c_bed)
assert kost.F[3:] == pytest.approx(_utkobling(600.0))
assert not kost.F[:3].any()
margin = _lcoc_v() - _lcoc(c_bed)
for aargang in kost.aarganger:
assert aargang.LCOC == pytest.approx(_lcoc(c_bed))
assert aargang.overskudd == pytest.approx(margin)
assert aargang.margin is None
ventet = margin * (1.08**-3 + 1.08**-8 + 1.08**-13)
assert kost.S42 == pytest.approx(ventet)
def test_M2_bruker_bare_utkoblingsarmen(oppdiktet: LagInndata) -> None:
"""With cheap firm capacity S47 picks that arm in M1; a business still pays disconnection."""
inn = oppdiktet(T_slutt=2040, c_fast=0.1e6)
res = _regn(inn, Losning.R)
j = 2035 - 2027
assert res.F_a[j] == pytest.approx(0.1e6 * 600.0)
assert nv.effektkostnad_bedrift(inn, res)[j] == pytest.approx(_utkobling(600.0))
@pytest.mark.parametrize("losning", list(Losning))
@pytest.mark.parametrize("knapphet", list(Knapphet))
def test_s19_er_en_regnskapsidentitet(
oppdiktet: LagInndata, losning: Losning, knapphet: Knapphet
) -> None:
"""The four parts of S19 sum to mu Gamma y - LCOC_a for every vintage in every solution."""
inn = oppdiktet(mu_rel=0.95, s_brikker=0.08)
res = _regn(inn, losning, N_anlegg=2, knapphet=knapphet)
kost = nv.kraftkostnad(inn, res)
assert len(kost.aarganger) == sum(len(a.aarganger) for a in res.plan.anlegg)
for aargang in kost.aarganger:
assert aargang.margin is not None
assert aargang.margin.sum == pytest.approx(aargang.overskudd)
assert aargang.inntekt == pytest.approx(0.95 * res.dim.Gamma * res.y(aargang.t_v))
def test_knapphetspaaslaget_staar_i_marginen_i_ti_aar(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
res = _regn(inn, Losning.R, knapphet=Knapphet.VARER)
kost = nv.kraftkostnad(inn, res)
paaslag = 150e6 / _lcoc_v() - 1.0
for aargang in kost.aarganger:
assert aargang.margin is not None
ventet = paaslag * _lcoc_v() if aargang.t_v < 2040 else 0.0
assert aargang.margin.knapphet == pytest.approx(ventet)
def test_andre_avkastningskrav_kan_settes_inn(oppdiktet: LagInndata) -> None:
"""The cost of capital of an ownership form replaces the three required returns."""
inn = oppdiktet()
res = _regn(inn, Losning.B_MERKET)
som_for = nv.Renter(rho_D=0.08, rho_N=0.06, rho_A=0.08)
assert nv.renter_i_hovedkjoringen(inn, res) == som_for
hoved = nv.kraftkostnad(inn, res, bedrift=True)
samme = nv.kraftkostnad(inn, res, bedrift=True, renter=som_for)
assert samme.aarganger == hoved.aarganger
billig = nv.kraftkostnad(
inn, res, bedrift=True, renter=nv.Renter(rho_D=0.02, rho_N=0.02, rho_A=0.02)
)
assert billig.aarganger[0].LCOC < hoved.aarganger[0].LCOC
assert billig.aarganger[0].c_a < hoved.aarganger[0].c_a

254
tests/test_skala.py Normal file
View file

@ -0,0 +1,254 @@
"""Scale (chapter 9): S31 year by year, the first year with stable operation and M6.
Made-up round numbers only. Nothing here says anything about the hypothesis.
"""
from __future__ import annotations
from typing import TYPE_CHECKING
import numpy as np
import pytest
from tokenfabrikker import kontantstrom as ks
from tokenfabrikker import ligninger as lg
from tokenfabrikker import nivaaisert as nv
from tokenfabrikker import skala
from tokenfabrikker.kontantstrom import Knapphet
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from conftest import LagInndata
from tokenfabrikker.inndata import Inndata
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
def _crf(rho: float, levetid: float) -> float:
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
def _lcoc_v() -> float:
"""S15 for the made-up competitor, per MW IT and year."""
return 100e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 3e6 + 8760.0 * 0.75 * 1.2 * 800.0
BYGG = 110e9 * _crf(0.08, 15)
"""The yearly cost of the made-up building for 1 000 MW IT."""
MASKINVARE = 200e9 * _crf(0.08, 5)
"""The yearly cost of one made-up vintage of IT hardware for 1 000 MW IT."""
NETT = 5e6 * 600.0 * _crf(0.06, 40)
"""The yearly cost of the grid connection of one made-up facility without power plant."""
def _regn(
inn: Inndata,
losning: Losning,
*,
N_anlegg: int = 1,
knapphet: Knapphet = Knapphet.NORMALISERING,
) -> ks.Programresultat:
dim = ks.dimensjoner(inn, losning)
plan = ks.lag_plan(inn, losning, dim, N_anlegg=N_anlegg)
return ks.regn_program(inn, losning, plan, knapphet, dim=dim)
def test_s31_er_summen_av_leddene() -> None:
B_6 = lg.s31_nettobidrag(
u_e=0.25,
overskudd_utover_avkastning=100.0,
Delta_W=20.0,
K_prog=5.0,
V=3.0,
utslipp=2.0,
)
assert B_6 == pytest.approx(75.0 + 20.0 - 5.0 - 3.0 - 2.0)
def test_R_bidraget_aar_for_aar_og_M6(oppdiktet: LagInndata) -> None:
"""One facility in R to 2040, every term by hand.
Revenue minus operation, power with losses, the yearly cost of building, hardware and
grid connection, and disconnection; plus the gain for Norway of a higher power price,
minus what is displaced in the grid queue; and in 2030 the emissions from the building.
"""
inn = oppdiktet(T_slutt=2040)
res = _regn(inn, Losning.R)
ut = skala.skala(inn, res)
pris = 700.0 - 10e-6 * (10e6 - 0.5 * E_D)
utkobling = 100.0 * _lcoc_v() / (8760.0 * 1.2) * 600.0
overskudd = (
1000.0 * _lcoc_v() - 2.5e9 - 1.05 * pris * E_D - BYGG - MASKINVARE - NETT - utkobling
)
i_drift = overskudd + (pris - 600.0) * 10e6 - 0.5 * E_D * 70.0
assert not ut.B_6[:3].any()
assert ut.B_6[3] == pytest.approx(i_drift - 1e9)
assert ut.B_6[4:] == pytest.approx(i_drift)
assert ut.stabilt_aar == 2030
assert ut.M6 == pytest.approx((i_drift - 1e9) / 500e9)
assert ut.M6_snitt == pytest.approx((i_drift - 1e9 / 5.0) / 500e9)
assert ut.M6_median == pytest.approx((i_drift - 1e9) / 250e9)
assert ut.M6_2050 is None
# at the made-up cost-based price the contribution is negative, so no year beats 2027
assert i_drift < 0
assert (ut.M6_topp, ut.toppaar) == (0.0, 2027)
# with 40 % owned outside Norway only 60 % of the surplus above normal return counts
utenlandsk = skala.skala(inn, res, u_e=0.4)
assert utenlandsk.B_6[4] == pytest.approx(
0.6 * overskudd + (pris - 600.0) * 10e6 - 0.5 * E_D * 70.0
)
def test_toppaaret_ligger_i_aarene_med_knapphetspaaslag(oppdiktet: LagInndata) -> None:
"""«Knapphet varer»: vintages from before 2040 get the markup, so the best year is 2031-2039.
2030 carries the emissions from the building; from 2031 every year to 2039 is the same.
"""
inn = oppdiktet(T_slutt=2045)
ut = skala.skala(inn, _regn(inn, Losning.R, knapphet=Knapphet.VARER))
assert ut.toppaar == 2031
assert ut.M6_topp == pytest.approx(float(ut.B_6[2031 - 2027]) / 500e9)
assert ut.M6_topp > 0
assert ut.B_6[2039 - 2027] == pytest.approx(ut.B_6[2031 - 2027])
assert ut.B_6[2040 - 2027] < ut.B_6[2039 - 2027]
def test_maalet_i_2050_er_null_naar_anlegget_er_gaatt_ut(oppdiktet: LagInndata) -> None:
"""The made-up facility starts in 2030 and lives 20 years: nothing is left in 2050."""
inn = oppdiktet()
ut = skala.skala(inn, _regn(inn, Losning.R))
assert ut.M6_2050 == 0.0
assert ut.B_6[2049 - 2027] != 0.0
def test_stabil_drift_er_forste_aar_alle_anleggene_er_i_drift(oppdiktet: LagInndata) -> None:
inn = oppdiktet()
res = _regn(inn, Losning.R, N_anlegg=3)
assert [a.start for a in res.plan.anlegg] == [2030, 2031, 2032]
assert skala.forste_aar_med_stabil_drift(res) == 2032
ut = skala.skala(inn, res)
assert ut.M6 == pytest.approx(float(ut.B_6[2032 - 2027]) / 500e9)
assert ut.M6_snitt == pytest.approx(float(ut.B_6[5:10].mean()) / 500e9)
def test_uten_aar_med_alle_i_drift_finnes_ikke_M6(oppdiktet: LagInndata) -> None:
"""250 MW of chips a year and facilities that live three years: 2033-2035 and 2037-2039.
Both facilities start, so the path is built, but they are never in operation together.
"""
inn = oppdiktet(s_brikker=0.01, L_N=3.0)
res = _regn(inn, Losning.R, N_anlegg=2)
assert [(a.start, a.siste_driftsaar) for a in res.plan.anlegg] == [(2033, 2035), (2037, 2039)]
ut = skala.skala(inn, res)
assert ut.stabilt_aar is None
assert ut.M6 is None
assert ut.M6_snitt is None
assert ut.M6_median is None
assert ut.B_6[2033 - 2027] != 0.0
def test_anlegg_uten_brikker_baerer_bygg_og_nett_men_ikke_maskinvare(
oppdiktet: LagInndata,
) -> None:
"""An export stop from 2035 to 2037: no revenue, no power and no vintage in operation."""
u = tuple(0.0 if aar == 2035 else 0.5 for aar in range(2028, 2061))
inn = oppdiktet(u_eksport=u, phi_X=0.1, D_X=3.0)
res = _regn(inn, Losning.R)
ut = skala.skala(inn, res)
assert ut.B_6[2036 - 2027] == pytest.approx(-2.5e9 - BYGG - NETT)
assert ut.B_6[2036 - 2027] < ut.B_6[2034 - 2027]
def test_A_uten_brikker_betaler_ikke_variable_kostnader(oppdiktet: LagInndata) -> None:
"""In A the plant's capital and fixed costs run on; fuel, waste fee and variable do not."""
u = tuple(0.0 if aar == 2040 else 0.5 for aar in range(2028, 2061))
inn = oppdiktet(u_eksport=u, phi_X=0.1, D_X=3.0)
res = _regn(inn, Losning.A)
assert not res.plan.har_last(0, 2041)
c_A = nv.kraftkostnad_dedikert(inn, res, 0, 0.08)
ut = skala.overskudd_utover_avkastning(inn, res)
assert ut[2041 - 2027] == pytest.approx(-2.5e9 - BYGG - (c_A - 180.0) * E_D)
med_last = 1000.0 * res.dim.Gamma * _lcoc_v() - 2.5e9 - BYGG - MASKINVARE - c_A * E_D
assert ut[2039 - 2027] == pytest.approx(med_last)
def test_kraftverk_som_tilleggsregelen_binder_for_teller_null(oppdiktet: LagInndata) -> None:
"""Two facilities in B with a cheap reactor: the units neither add nor take in S31."""
inn = oppdiktet(c_N_ref=10e6, f_N=0.3e6, s_brikker=0.12)
res = _regn(inn, Losning.B, N_anlegg=2)
assert res.varsigma[ks.KJERNEKRAFT] < 1.0
j = 2040 - 2027
nett = 5e6 * (600.0 + res.dim.P_G_N) * _crf(0.06, 40)
per_anlegg = (
1000.0 * _lcoc_v() - 2.5e9 - 1.05 * res.kraftaar[j].pris * E_D - BYGG - MASKINVARE - nett
)
ut = skala.overskudd_utover_avkastning(inn, res)
assert ut[j] == pytest.approx(2.0 * per_anlegg - float(res.F_a[j]))
# without the rule the surplus of the units is credited
dim = ks.dimensjoner(inn, Losning.B)
uten = ks.regn_program(
inn, Losning.B, res.plan, Knapphet.NORMALISERING, dim=dim, tilleggsregel=False
)
assert skala.overskudd_utover_avkastning(inn, uten)[j] > ut[j]
@pytest.mark.parametrize("losning", list(Losning))
@pytest.mark.parametrize(
"endringer",
[{}, {"c_N_ref": 10e6, "f_N": 0.3e6}, {"T_slutt": 2045, "L_B": 7.0, "mu_rel": 0.9}],
)
def test_bidraget_er_inntekt_minus_nivaaisert_kostnad(
oppdiktet: LagInndata, losning: Losning, endringer: dict[str, float]
) -> None:
"""Two ways to the same number.
S31 is built from the yearly amounts of the cash flow and the annuity of each asset.
The price side (S15 with S9 or S11) is built per MWh. In every year all the operated
facilities use power, P_IT (mu Gamma y - LCOC_a) summed over them is the same amount.
"""
inn = oppdiktet(u_eksport=None, **endringer)
res = _regn(inn, losning, N_anlegg=3, knapphet=Knapphet.VARER)
kost = nv.kraftkostnad(inn, res)
ut = skala.overskudd_utover_avkastning(inn, res)
sjekket = 0
for j, t in enumerate(res.aar):
i_drift = [k for k in range(3) if res.plan.i_drift(k, t)]
if not i_drift or not all(res.plan.har_last(k, t) for k in i_drift):
continue
sum_margin = 0.0
for k in i_drift:
t_v = res.plan.aargang(k, t)
assert t_v is not None
LCOC = lg.s15_lcoc(
c_bygg=inn["c_bygg"],
d_bygg=inn["d_bygg"],
c_H=lg.s13_it_kostnad(c_H0=inn["c_H0"], gamma_H=inn["gamma_H"], t_v=t_v),
rho_D=inn["rho_D"],
L_B=inn["L_B"],
L_H=inn["L_H"],
o_D=inn["o_D"],
d_o_D=inn["d_o_D"],
lam=inn["lambda"],
PUE=inn["PUE"],
c_a=float(kost.c_a[k, j]),
)
sum_margin += inn["P_IT"] * (inn["mu_rel"] * res.dim.Gamma * res.y(t_v) - LCOC)
assert ut[j] == pytest.approx(sum_margin, rel=1e-9, abs=1.0)
sjekket += 1
assert sjekket >= 10
def test_programmets_enheter_i_B_teller_ogsaa_etter_at_anleggene_er_gaatt_ut(
oppdiktet: LagInndata,
) -> None:
"""Staggered starts: a unit from 2055 still runs in 2058, after the last facility is out."""
inn = oppdiktet()
res = _regn(inn, Losning.B, N_anlegg=2)
assert [(f.gruppe.start, f.gruppe.siste_driftsaar) for f in res.felles][-1] == (2055, 2074)
assert res.plan.antall_i_drift(2058) == 0
ut = skala.overskudd_utover_avkastning(inn, res)
assert ut[2058 - 2027] < 0
assert np.count_nonzero(ut[2056 - 2027 :]) == 5