utbyggingsplan_trinnvis follows chapter 17.1: the grid balance of the first stage, the payment condition for a module's power plants, S49, and in T-K the two stocks of chips and the queue for replacements. tidslinje gives MW IT in operation per type of power (S50). S48-S54 are pure functions in ligninger.py, and Inndata carries the new quantities, the scenarios for the loss of demand and the paths of u_alt. lag_plan returns a Trinnvisplan for T-F and T-K; regn_program refuses T until it is taken through the cash flow. Tested on made-up numbers only (59 new tests, hand-computed build-outs). Nothing is computed for the hypothesis. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
770 lines
34 KiB
Python
770 lines
34 KiB
Python
"""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 dataclasses
|
|
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
|
|
|
|
I_KONTANTSTROMMEN = tuple(a for a in Losning if not a.trinnvis)
|
|
"""The solutions the cash flow is coded for. Solution T only has its build-out so far."""
|
|
|
|
E_D = 8760.0 * 0.75 * 1.2 * 1000.0
|
|
"""Yearly energy to one made-up data centre: 7 884 000 MWh."""
|
|
|
|
|
|
def _crf(rho: float, levetid: float) -> float:
|
|
return float(rho / (1.0 - (1.0 + rho) ** -levetid))
|
|
|
|
|
|
def _lcoc_v() -> float:
|
|
"""S15 for the made-up competitor, per MW IT and year."""
|
|
return 100e6 * _crf(0.08, 15) + 200e6 * _crf(0.08, 5) + 3e6 + 8760.0 * 0.75 * 1.2 * 800.0
|
|
|
|
|
|
def _regn(
|
|
inn: Inndata,
|
|
losning: Losning,
|
|
*,
|
|
N_anlegg: int = 1,
|
|
knapphet: Knapphet = Knapphet.NORMALISERING,
|
|
) -> 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_framfort_underskudd_taper_realverdi() -> None:
|
|
"""Without interest means nominal: a loss of 100 is worth 100 / 1.1 the year after.
|
|
|
|
With 10 % price growth: the loss of 100 is 90.91 in year 2, where 60 is used (30.91 left);
|
|
28.10 in year 3, where it is used up and 80 - 28.10 is taxed.
|
|
"""
|
|
grunnlag = lg.s28_etter_framforing([-100.0, 60.0, 80.0], faktor=1.0 / 1.1)
|
|
assert grunnlag[:2] == (0.0, 0.0)
|
|
assert grunnlag[2] == pytest.approx(80.0 - (100.0 / 1.1 - 60.0) / 1.1)
|
|
assert lg.s28_realverdi(belop=121.0, iota=0.1, aar=2) == pytest.approx(100.0)
|
|
assert lg.s28_realverdi(belop=121.0, iota=0.0, aar=7) == 121.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.
|
|
|
|
Corporate tax: 0, 0, 8, 10. The basis of the special tax is the profit minus the corporate
|
|
tax and minus 5 % of 200: -100, 50, 62, 30. The negative basis is carried with 5 %
|
|
interest: 105 meets the 50 (55 left), 57.75 meets the 62 (4.25 taxed), then 30. The rate
|
|
on that basis is 0.5 / 0.8, so one more krone of profit pays 20 % + 50 %.
|
|
"""
|
|
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, 0.625 * 4.25, 0.625 * 30.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())
|
|
# the state's levies: the electricity tax, minus what the private data centres that are
|
|
# displaced from half of the grid capacity would have paid; the tariff is not the state's
|
|
assert strom.avgifter[aar[2031]] == pytest.approx(70.0 * E_D - 0.5 * 70.0 * E_D)
|
|
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. The deduction is fixed in
|
|
# the kroner of the year each half was paid (2028 and 2029; later vintages the year before
|
|
# they start) and loses 2 % a year in constant kroner (clarification 47). At the final
|
|
# year the project is valued as sold, and what is left is written off (clarification 62):
|
|
# 4 of the building's 15 years on top of the year's own, and the whole vintage of 2040.
|
|
def realt(aar_siden: int) -> float:
|
|
return 1.02**-aar_siden
|
|
|
|
assert strom.avskrivning[aar[2030]] == pytest.approx(
|
|
(55e9 / 15.0 + 20e9) * (realt(2) + realt(1))
|
|
)
|
|
assert strom.avskrivning[aar[2036]] == pytest.approx(
|
|
55e9 / 15.0 * (realt(8) + realt(7)) + 40e9 * realt(2)
|
|
)
|
|
assert strom.avskrivning[aar[2040]] == pytest.approx(
|
|
55e9 * 5.0 / 15.0 * (realt(12) + realt(11)) + 200e9 * realt(1)
|
|
)
|
|
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.kapital[aar[2040]] == pytest.approx(0.0, abs=1.0)
|
|
assert strom.NK[aar[2034]] == pytest.approx(
|
|
strom.inntekt[aar[2034]] - strom.drift[aar[2034]] - 200e9
|
|
)
|
|
# The residual value: the facility runs 20 years from 2030, so 9 are left after 2040.
|
|
# The average of the last five years holds one vintage of 200 mrd. kr (paid in 2039).
|
|
assert res.anlegg[0].L_rest == 9
|
|
snitt = float(strom.inntekt[aar[2040]] - strom.drift[aar[2040]]) - 200e9 / 5.0
|
|
ventet = max(0.0, snitt / _crf(0.08, 9))
|
|
assert strom.restverdi[aar[2040]] == pytest.approx(ventet)
|
|
assert strom.restverdi_anlegg == pytest.approx((ventet,))
|
|
assert not strom.restverdi[: aar[2040]].any()
|
|
assert strom.NK[aar[2040]] == pytest.approx(
|
|
strom.inntekt[aar[2040]] - strom.drift[aar[2040]] + ventet
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize("losning", I_KONTANTSTROMMEN)
|
|
@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.
|
|
|
|
Without price growth the tax depreciation sums to what is paid; with it, to less.
|
|
"""
|
|
for iota in (0.0, 0.02):
|
|
inn = oppdiktet(iota=iota)
|
|
res = _regn(inn, Losning.A)
|
|
strom = ei.bedriftsstrom(inn, res)
|
|
assert strom.kapital[-1] == pytest.approx(0.0, abs=1.0)
|
|
assert (strom.kapital > -1.0).all()
|
|
betalt = float(strom.investering.sum())
|
|
if iota == 0.0:
|
|
assert float(strom.avskrivning.sum()) == pytest.approx(betalt)
|
|
else:
|
|
assert 0.5 * betalt < float(strom.avskrivning.sum()) < 0.99 * betalt
|
|
|
|
|
|
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
|
|
+ 70.0 * E_D
|
|
+ 0.3e6 * 1200.0
|
|
)
|
|
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 the levies."""
|
|
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.elavgift)
|
|
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)
|
|
# the state's cash flow is valued with rho_D (clarification 65), with the electricity tax
|
|
# the displaced private data centres would have paid deducted (63): the whole surplus
|
|
assert strom.elavgift[4] == pytest.approx(70.0 * E_D)
|
|
assert strom.fortrengt[4] == pytest.approx(0.5 * 70.0 * E_D)
|
|
NV_stat = math.fsum(float(x) / 1.08**j for j, x in enumerate(strom.NK + strom.avgifter))
|
|
assert ut.NV_stat == pytest.approx(NV_stat)
|
|
assert ut.NV_samlet == pytest.approx(NV_stat)
|
|
assert not ut.KS_privat.any()
|
|
assert ut.NV_privat == 0.0
|
|
# with the state's borrowing rate, shown as a sensitivity
|
|
med_laanerente = ei.eierresultat(inn, strom, inn.eierformer["direkte"], rente=0.02)
|
|
assert med_laanerente.NV_stat == pytest.approx(
|
|
math.fsum(float(x) / 1.02**j for j, x in enumerate(strom.NK + strom.avgifter))
|
|
)
|
|
# 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. In the final year the residual
|
|
value is taxed as a sale. The state owns everything, so the tax cancels: what it gets
|
|
is NK and the levies, minus interest, plus new debt.
|
|
"""
|
|
inn = oppdiktet(T_slutt=2040)
|
|
strom = _lonnsom(inn)
|
|
assert strom.restverdi[-1] > 0
|
|
ut = ei.eierresultat(inn, strom, inn.eierformer["heleid_selskap"])
|
|
overskudd = strom.inntekt - strom.drift + strom.restverdi - 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.elavgift - 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))
|
|
)
|
|
# Valued with rho_D, and the debt flows with the borrowing rate, where they are worth
|
|
# nothing (clarification 65): the state's value is that of the whole surplus, exactly as
|
|
# with direct ownership
|
|
assert math.fsum(
|
|
float(x) / (1.0 + rente) ** j
|
|
for j, x in enumerate(ut.gjeld - gjeld_inn - rente * gjeld_inn)
|
|
) == pytest.approx(0.0, abs=1.0)
|
|
assert ut.NV_stat == pytest.approx(
|
|
math.fsum(float(x) / 1.08**j for j, x in enumerate(strom.NK + strom.avgifter))
|
|
)
|
|
direkte = ei.eierresultat(inn, strom, inn.eierformer["direkte"])
|
|
assert ut.NV_stat == pytest.approx(direkte.NV_stat)
|
|
assert ut.andel_av_overskudd == pytest.approx(1.0)
|
|
assert not ut.KS_privat.any()
|
|
# 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.elavgift + 0.6 * 0.75 * ut.FKE + 0.25 * strom.NK
|
|
assert ut.KS_stat == pytest.approx(ventet)
|
|
# the basis of the special tax is the profit with straight-line depreciation in constant
|
|
# kroner, minus the corporate tax and minus r_e on the capital booked at the start of the
|
|
# year; the rate on it is 0.5 / 0.8. The return on what was booked during construction is
|
|
# carried forward with interest and used in 2030
|
|
r_e = 1.08 / 1.02 - 1.0
|
|
overskudd = strom.inntekt - strom.drift - strom.avskrivning_fast
|
|
j = 2031 - 2027
|
|
grunnlag = overskudd[j] - ut.selskapsskatt[j] - r_e * strom.kapital[j - 1]
|
|
assert ut.saerskatt[j] == pytest.approx(0.5 / 0.8 * grunnlag)
|
|
boers = ei.eierresultat(inn, strom, inn.eierformer["majoritet_boers"])
|
|
assert boers.NV_stat < ut.NV_stat
|
|
# the private owners have 40 % of the company: all of it, or the 75 % outside the state's
|
|
# direct part. Their share is valued as the state's: with rho_D and without the debt flows
|
|
assert boers.KS_privat == pytest.approx(0.4 * boers.FKE)
|
|
assert ut.KS_privat == pytest.approx(0.4 * 0.75 * ut.FKE)
|
|
etter_skatt = strom.NK - boers.selskapsskatt
|
|
assert boers.NV_privat == pytest.approx(
|
|
math.fsum(float(x) / 1.08**j for j, x in enumerate(0.4 * etter_skatt))
|
|
)
|
|
# what the state and the private owners have together is the whole surplus
|
|
assert boers.NV_stat + boers.NV_privat == pytest.approx(boers.NV_samlet)
|
|
assert ut.NV_stat + ut.NV_privat == pytest.approx(ut.NV_samlet)
|
|
# 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"])
|
|
|
|
|
|
@pytest.mark.parametrize("navn", ["heleid_selskap", "majoritet_boers", "petroleumsmodell"])
|
|
def test_statens_eiernes_og_laangivernes_strommer_summerer_seg(
|
|
oppdiktet: LagInndata, navn: str
|
|
) -> None:
|
|
"""Clarifications 48 and 64: nothing is counted twice or lost between the parties.
|
|
|
|
What the state, the private owners and the lenders receive adds up to the project's net
|
|
cash flow plus the electricity tax, every year: when the state covers overruns by its share only
|
|
(zeta = s), and when it covers all of them and the private owners are spared theirs.
|
|
"""
|
|
inn = oppdiktet(u_xi=0.1)
|
|
strom = ei.bedriftsstrom(inn, _regn(inn, Losning.A, knapphet=Knapphet.VARER))
|
|
assert (strom.investering - strom.budsjett).sum() > 0
|
|
for zeta in (inn.eierformer[navn].s, 1.0):
|
|
e = dataclasses.replace(inn.eierformer[navn], zeta=zeta)
|
|
ut = ei.eierresultat(inn, strom, e)
|
|
gjeld_inn = np.concatenate(([0.0], ut.gjeld[:-1]))
|
|
rente = (1.0 + e.r_d) / 1.02 - 1.0
|
|
laangivere = (1.0 - e.theta) * (rente * gjeld_inn - (ut.gjeld - gjeld_inn))
|
|
assert ut.KS_stat + ut.KS_privat + laangivere == pytest.approx(
|
|
strom.NK + strom.elavgift, abs=1.0
|
|
)
|
|
|
|
|
|
def test_saerskatten_treffer_bare_avkastning_utover_r_e() -> None:
|
|
"""Clarification 48: the special tax is neutral.
|
|
|
|
100 paid in year 0 for an asset written off over 4 years, r_e 6 % after a corporate tax
|
|
of 20 %. The corporate tax has its own basis (20, 30, 10, 40: nominal deductions), so the
|
|
tax is 4, 6, 2, 8. A project whose profit after that tax is exactly 6 % of the booked
|
|
capital at the start of each year has no special tax, however the corporate tax is
|
|
computed. With 10 more in profit a year, corporate tax takes 2 and the special tax 5:
|
|
50 % of the 10. Negative bases are carried with interest.
|
|
"""
|
|
kapital_inn = [0.0, 100.0, 75.0, 50.0, 25.0]
|
|
selskapsgrunnlag = [0.0, 20.0, 30.0, 10.0, 40.0]
|
|
normal = [0.2 * g + 0.06 * k for g, k in zip(selskapsgrunnlag, kapital_inn, strict=True)]
|
|
for ekstra in (0.0, 10.0):
|
|
selskap, saer = lg.s30_skatt(
|
|
overskudd=[0.0] + [g + ekstra for g in selskapsgrunnlag[1:]],
|
|
overskudd_fast=[0.0] + [x + ekstra for x in normal[1:]],
|
|
kapital_inn=kapital_inn,
|
|
tau_s=0.2,
|
|
tau_g=0.5,
|
|
r_e=0.06,
|
|
iota=0.02,
|
|
)
|
|
assert saer == pytest.approx((0.0, *([0.5 * ekstra] * 4)))
|
|
assert selskap[1] == pytest.approx(0.2 * (20.0 + ekstra))
|
|
# a negative basis of 50 in year 1 is worth 53 in year 2
|
|
_, saer = lg.s30_skatt(
|
|
overskudd=[0.0] * 3,
|
|
overskudd_fast=[0.0, -50.0, 60.0],
|
|
kapital_inn=[0.0] * 3,
|
|
tau_s=0.0,
|
|
tau_g=0.5,
|
|
r_e=0.06,
|
|
)
|
|
assert saer == pytest.approx((0.0, 0.0, 0.5 * (60.0 - 53.0))) # tau_s = 0: the rate is tau_g
|
|
|
|
|
|
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.elavgift + 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 losses carried forward cover what little profit there is. At the final year the
|
|
project is valued as sold (clarification 62), but the value is lower than what is
|
|
written off, so the sale gives no tax either.
|
|
"""
|
|
inn = oppdiktet(T_slutt=2040)
|
|
strom = ei.bedriftsstrom(inn, _regn(inn, Losning.R, knapphet=Knapphet.OVERKAPASITET))
|
|
assert 0 < strom.restverdi[-1] < strom.avskrivning[-1]
|
|
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] = {
|
|
"oppgjor": 0.0,
|
|
"verdi": 100.0,
|
|
"andel_av_overskudd": 0.9,
|
|
"andel_for_oppgjor": 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.oppgjor == 0.0
|
|
assert k.verdi == pytest.approx(ut.NV_stat)
|
|
assert k.andel_av_overskudd == pytest.approx(1.0)
|
|
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")
|
|
# a form that fails the EEA assessment cannot take another form out: without a, only d is
|
|
# better than c on everything, and d is out itself
|
|
uten_a = ei.ranger_eierformer(kriterier[1:], eos)
|
|
assert set(uten_a.ute) == {"d"}
|
|
|
|
|
|
def test_private_eiere_betaler_det_andelen_er_verdt(oppdiktet: LagInndata) -> None:
|
|
"""Clarification 64: the settlement is the average present value of the private owners' share.
|
|
|
|
Two draws, one with the scarcity markup and one with overcapacity. The private owners
|
|
gain in the first and lose in the second; the settlement is the average, paid at T_0,
|
|
the same amount in both draws. It moves the state's present value and every cumulative
|
|
sum of its cash flow by that amount. After it the state's expected value is that of the
|
|
whole surplus, as with a wholly owned company, and the public's share is 1; what the
|
|
form changes is how the outcome is spread over the draws.
|
|
"""
|
|
inn = oppdiktet(T_slutt=2040)
|
|
strommer = [
|
|
ei.bedriftsstrom(inn, _regn(inn, Losning.R, knapphet=k))
|
|
for k in (Knapphet.VARER, Knapphet.OVERKAPASITET)
|
|
]
|
|
e = inn.eierformer["majoritet_boers"]
|
|
utfall = [ei.eierresultat(inn, strom, e) for strom in strommer]
|
|
assert utfall[0].NV_privat > 0 > utfall[1].NV_privat
|
|
k = ei.eierkriterier("majoritet_boers", utfall, [80.0, 90.0])
|
|
oppgjor = (utfall[0].NV_privat + utfall[1].NV_privat) / 2.0
|
|
assert oppgjor > 0
|
|
assert k.oppgjor == pytest.approx(oppgjor)
|
|
samlet = (utfall[0].NV_samlet + utfall[1].NV_samlet) / 2.0
|
|
assert k.verdi == pytest.approx(samlet)
|
|
assert k.andel_av_overskudd == pytest.approx(1.0)
|
|
assert k.andel_for_oppgjor == pytest.approx(1.0 - oppgjor / samlet)
|
|
assert k.tapssannsynlighet == ei.sannsynlighet_for_tap([u.NV_stat + oppgjor for u in utfall])
|
|
assert k.kapital_ute == pytest.approx(
|
|
math.fsum(max(0.0, -(u.laveste_sum + oppgjor)) for u in utfall) / 2.0
|
|
)
|
|
heleid = [ei.eierresultat(inn, s, inn.eierformer["heleid_selskap"]) for s in strommer]
|
|
h = ei.eierkriterier("heleid_selskap", heleid, [80.0, 90.0])
|
|
assert h.oppgjor == 0.0
|
|
assert h.verdi == pytest.approx(k.verdi)
|
|
# the private owners carry part of the loss in the bad draw, so the state's worst is better
|
|
assert k.daarligste > h.daarligste
|
|
# the sensitivity: the settlement priced with the private owners' own required return on
|
|
# equity (12 % nominal), on their cash flow with the debt
|
|
krav = ei.eierkriterier("majoritet_boers", utfall, [80.0, 90.0], egenkapitalkrav=True)
|
|
assert krav.oppgjor == pytest.approx(
|
|
math.fsum(float(x) / (1.12 / 1.02) ** j for u in utfall for j, x in enumerate(u.KS_privat))
|
|
/ 2.0
|
|
)
|
|
assert krav.verdi == pytest.approx(k.verdi - k.oppgjor + krav.oppgjor)
|
|
# with the state's borrowing rate as a sensitivity the price is still the market's
|
|
lav = [ei.eierresultat(inn, s, e, rente=0.02) for s in strommer]
|
|
assert [u.NV_privat for u in lav] == pytest.approx([u.NV_privat for u in utfall])
|
|
assert lav[0].NV_stat > utfall[0].NV_stat
|
|
|
|
|
|
@pytest.mark.parametrize("losning", I_KONTANTSTROMMEN)
|
|
def test_anleggenes_kontantstrom_summerer_seg_til_programmets(
|
|
oppdiktet: LagInndata, losning: Losning
|
|
) -> None:
|
|
"""Clarification 62: the facilities' parts add up to the business cash flow of the programme.
|
|
|
|
In B the programme's nuclear units are shared among the facilities operated that year,
|
|
so only the years with a facility in operation are compared.
|
|
"""
|
|
inn = oppdiktet(u_eksport=None)
|
|
res = _regn(inn, losning, N_anlegg=2)
|
|
for tilleggsregel in (False, True):
|
|
strom = ei.bedriftsstrom(inn, res, tilleggsregel=tilleggsregel)
|
|
sum_anlegg = np.sum(ei.netto_per_anlegg(inn, res, tilleggsregel=tilleggsregel), axis=0)
|
|
programmet = strom.inntekt - strom.drift - strom.investering
|
|
med = np.array(
|
|
[losning is not Losning.B or res.plan.antall_i_drift(t) > 0 for t in res.aar]
|
|
)
|
|
assert med.sum() > 20
|
|
assert sum_anlegg[med] == pytest.approx(programmet[med], abs=1.0)
|
|
|
|
|
|
def test_restverdien_trekker_fra_avvikling_etter_sluttaaret(oppdiktet: LagInndata) -> None:
|
|
"""Clarification 62 in A: the value of the years left, minus the decommissioning after them.
|
|
|
|
The decommissioning is discounted with the rate of the plant in A over the years left.
|
|
The value is the same whatever the ownership form, and the booked capital ends at zero.
|
|
"""
|
|
inn = oppdiktet(T_slutt=2045)
|
|
res = _regn(inn, Losning.A, knapphet=Knapphet.VARER)
|
|
anlegg = res.anlegg[0]
|
|
assert anlegg.L_rest > 0
|
|
strom = ei.bedriftsstrom(inn, res)
|
|
netto = ei.netto_per_anlegg(inn, res)[0]
|
|
avvikling = math.fsum(anlegg.avvikling_etter.values())
|
|
assert avvikling > 0
|
|
verdi = max(0.0, float(np.mean(netto[-5:])) / _crf(0.08, anlegg.L_rest))
|
|
assert verdi > 0
|
|
ventet = verdi - avvikling * (1.0 + res.dim.rho_A) ** -anlegg.L_rest
|
|
assert strom.restverdi[-1] == pytest.approx(ventet)
|
|
assert lg.s28_restverdi(
|
|
NK_snitt=-1.0, L_rest=10, rho_D=0.08, rho_avvikling=0.06, avvikling=100.0
|
|
) == pytest.approx(-100.0 / 1.06**10)
|
|
assert (
|
|
lg.s28_restverdi(NK_snitt=5.0, L_rest=0, rho_D=0.08, rho_avvikling=0.06, avvikling=9.0)
|
|
== 0.0
|
|
)
|
|
assert strom.kapital[-1] == pytest.approx(0.0, abs=1.0)
|
|
|
|
|
|
def test_kravet_for_skatt(oppdiktet: LagInndata) -> None:
|
|
"""Clarification 66: r_e / (1 - tau_s) for a form that pays corporate tax."""
|
|
inn = oppdiktet()
|
|
assert lg.s29_krav_for_skatt(r_e=0.06, tau_s=0.25) == pytest.approx(0.08)
|
|
assert ei.krav_for_skatt(inn, inn.eierformer["direkte"]) == 0.02
|
|
assert ei.krav_for_skatt(inn, inn.eierformer["heleid_selskap"]) == pytest.approx(
|
|
(1.07 / 1.02 - 1.0) / 0.8
|
|
)
|
|
|
|
|
|
def test_private_eieres_kontantstrom() -> None:
|
|
"""Clarification 64: 40 % of 75 % of the free cash flow, and the overruns they are spared."""
|
|
assert lg.s30_private_eiere(
|
|
FKE=100.0, overskridelse=20.0, s=0.6, theta=0.25, zeta=1.0
|
|
) == pytest.approx(0.4 * 0.75 * 100.0 + 0.4 * 0.75 * 20.0)
|
|
assert lg.s30_private_eiere(FKE=100.0, overskridelse=20.0, s=1.0, theta=0.0, zeta=1.0) == 0.0
|
|
|
|
|
|
def test_like_verdier_staar_likt_i_rangeringen() -> None:
|
|
"""Clarification 67: a difference below the tolerance is no difference."""
|
|
kriterier = [
|
|
_kriterier("a", verdi=100.0),
|
|
_kriterier(
|
|
"b",
|
|
verdi=100.0 * (1.0 - 1e-12),
|
|
andel_av_overskudd=0.9 * (1.0 - 1e-12),
|
|
r_e=0.06,
|
|
LCOC=85.0,
|
|
tapssannsynlighet=0.2,
|
|
daarligste=-60.0,
|
|
kapital_ute=310.0,
|
|
),
|
|
_kriterier("c", verdi=90.0),
|
|
]
|
|
eos = dict.fromkeys("abc", "består")
|
|
rangering = ei.ranger_eierformer(kriterier, eos)
|
|
# b is not strictly worse than a on value, so it is not taken out
|
|
assert rangering.ute == {}
|
|
assert rangering.rangert == ("a", "b", "c")
|
|
assert rangering.like == (("a", "b"),)
|
|
# within a group of equal values the order given decides, not the rounding residue
|
|
omvendt = ei.ranger_eierformer([kriterier[1], kriterier[0], kriterier[2]], eos)
|
|
assert omvendt.rangert == ("b", "a", "c")
|
|
assert ei.klart_lavere(1.0, 1.1)
|
|
assert not ei.klart_lavere(1.0, 1.0 + 1e-12)
|
|
# amounts in kroner near zero: rounding residue is no difference
|
|
assert ei.klart_lavere(-2e-4, 1e-4)
|
|
assert not ei.klart_lavere(-2e-4, 1e-4, kroner=True)
|
|
assert ei.klart_lavere(0.0, 2.0, kroner=True)
|