feat(verktoy): the tools of chapter 12 and the data files of the main run, on made-up numbers (clarifications 126 to 133)

grunnlag.py holds what a run needs besides the model code, from a made-up
basis file or from the freeze (which stops until the EEA assessment is
written down). datafiler.py writes the six files in a fixed format without
rounding and compares two folders. verktoy.py is the command line:
hovedkjoring, kontroll, scenario, folsomhet, terskel, sammenlign,
arbeidskopi. tests/oppdiktet holds a made-up basis of 200 draws and the files
written from it; they are reproduced byte for byte with 1 and 8 processes and
in a new process. Nothing is computed on the frozen parameters.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-13 21:55:03 +01:00
commit 7dd3edc68a
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
14 changed files with 75464 additions and 0 deletions

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,590 @@
"""The basis of a run (chapter 12; chapter 16, clarification 127).
Everything a run needs besides the model code is gathered in one basis: one
set of values per draw in the order of the draws, with the draw's row of the
stream for yearly events; the drawn values of every drawn quantity in the
order of the parameter file, with the status of each; the verdict in M5 per
solution; the EEA assessment per ownership form; the low and the high path of
the carbon price; the upper end of the contract prices and the fixed eps_d;
and for every quantity the factor from the file's unit to the equations'.
The basis comes from one of two places. From the freeze (``fra_frys``): the
parameter file, the stored draws and the stored stream, marked «frosset», or
«endret» when the parameter file is not the frozen one (a working copy,
clarification 132). Or from a basis file in JSON (``fra_fil``), marked
«oppdiktet»: it is used to try the tools and the reproduction before anything
is computed, and nothing that comes from it says anything about the hypothesis.
The EEA assessment per ownership form is not written down anywhere yet
(clarification 127, «Mangler før del 6»). Until it is, the basis from the
freeze cannot be made, and ``fra_frys`` stops before it reads anything.
Drawn values, and thresholds in a quantity, stand in the unit the basis has
them in: the parameter file's for the freeze, the file's own for a basis file.
"""
from __future__ import annotations
import hashlib
import json
import math
from dataclasses import dataclass, replace
from pathlib import Path
from typing import TYPE_CHECKING, Final, NoReturn, cast
from tokenfabrikker import inndata as ind
from tokenfabrikker import ligninger as lg
from tokenfabrikker.dommer import Dom
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Mapping, Sequence
from tokenfabrikker.inndata import Inndata
MERKE_FROSSET: Final = "frosset"
MERKE_ENDRET: Final = "endret"
MERKE_OPPDIKTET: Final = "oppdiktet"
"""The three marks of a basis (clarification 127)."""
STATUSER: Final = ("kilde", "avledet", "åpen forutsetning", "modellvalg")
"""The statuses a quantity can have, as in the parameter file."""
EOS_VURDERINGER: Final = ("består", "usikker", "består ikke")
"""The EEA assessment of an ownership form (chapter 8; ``eierskap.ranger_eierformer``)."""
KARBONBANER: Final = ("lav", "hoy")
"""The low and the high path of the carbon price (line 19 of the sensitivity list)."""
BORTFALLSNAVN: Final = (ind.BORTFALL_KILDE, ind.BORTFALL_EGNE_LAV, ind.BORTFALL_EGNE_HOY)
"""The three marked scenarios of chapter 17.3, by the names the run uses."""
FROSSEN_SJEKKSUM: Final = "4b8809bc56abdd8b2872b89eecffd8453199eef627110276dd10aecea8307f16"
"""SHA-256 of the frozen parameter file, as the pre-registration records it (version 1.1).
Kept apart from ``parametere.FROSSEN_SHA256``, which a working copy must change
to make new draws from a changed file (clarification 132): the basis of such a
copy is then still marked «endret». A test holds the two equal in the project.
"""
EOS_MANGLER: Final = (
"EØS-vurderingen per eierform er ikke fastsatt (avklaring 127): den er kvalitativ og står "
"ikke skrevet ned for de fire eierformene med kilde. Til den står i teksten, kan grunnlaget "
"fra frysen ikke lages; bruk en oppdiktet grunnlagsfil (--grunnlag)."
)
class GrunnlagError(ValueError):
"""A basis file or a basis from the freeze that cannot be used; the message is Norwegian."""
# ------------------------------------------------------------------ the basis
@dataclass(frozen=True)
class Grunnlag:
"""Everything a run needs besides the model code (clarification 127).
Attributes:
trekninger: one set of values per draw, in the order of the draws, each with its
row of the stream for yearly events (``Inndata.u_eksport``).
storrelser: the drawn values of every drawn quantity, one per draw, in the unit the
basis has them in, in the order of the parameter file.
status: the status of each drawn quantity in the parameter file.
M5: the verdict in M5 per solution.
eos: the EEA assessment per ownership form, as ``eierformer_paa_trinnet`` takes it.
karbonbaner: the low and the high path of the carbon price, ``lav`` and ``hoy``,
kr per tonne by year.
y_obs_maks: the upper end of the contract prices, in the equations' unit (kr per
MW IT and year; clarification 106).
eps_d: the fixed eps_d (clarification 107).
faktorer: per scalar quantity the factor from the basis' unit to the equations'.
merke: «frosset», «endret» or «oppdiktet».
sjekksummer: the checksums the mark carries: of the parameter file, the draws and the
stream for the freeze, of the basis file for a basis file.
"""
trekninger: tuple[Inndata, ...]
storrelser: Mapping[str, tuple[float, ...]]
status: Mapping[str, str]
M5: Mapping[Losning, Dom]
eos: Mapping[str, str]
karbonbaner: Mapping[str, Mapping[int, float]]
y_obs_maks: float
eps_d: float
faktorer: Mapping[str, float]
merke: str
sjekksummer: Mapping[str, str]
@property
def antall(self) -> int:
"""The number of draws."""
return len(self.trekninger)
@property
def merkelapp(self) -> dict[str, object]:
"""The mark with its checksums, as the files carry it."""
return {"merke": self.merke, "sjekksummer": dict(self.sjekksummer)}
def de_forste(self, N: int) -> Grunnlag:
"""The same basis with the first N draws only."""
if isinstance(N, bool) or not isinstance(N, int) or not 1 <= N <= self.antall:
msg = f"antall trekninger må være et heltall fra 1 til {self.antall}, fikk {N!r}"
raise GrunnlagError(msg)
return replace(
self,
trekninger=self.trekninger[:N],
storrelser={navn: x[:N] for navn, x in self.storrelser.items()},
)
def med_verdier(self, verdier: Mapping[str, float]) -> Grunnlag:
"""The same basis with quantities given one fixed value in every draw.
The values are in the basis' unit (the parameter file's for the
freeze) and are converted with the factor of each quantity. They are
set after the draw, as the sensitivity list does (clarification 116):
every other quantity keeps its drawn value, and the table of drawn
values keeps the drawn values. A fixed value of eps_d is also the
fixed eps_d of the basis.
"""
ukjent = [navn for navn in verdier if navn not in self.faktorer]
if ukjent:
msg = f"ukjent størrelse: {', '.join(ukjent)}"
raise GrunnlagError(msg)
if not verdier:
return self
omregnet = {navn: float(v) * self.faktorer[navn] for navn, v in verdier.items()}
return replace(
self,
trekninger=tuple(inn.med(omregnet) for inn in self.trekninger),
eps_d=omregnet.get("eps_d", self.eps_d),
)
# ------------------------------------------------------------- strict reading
def _feil(hvor: str, hva: str) -> NoReturn:
msg = f"{hvor}: {hva}"
raise GrunnlagError(msg)
def _uten_duplikater(par: list[tuple[str, object]]) -> dict[str, object]:
ut: dict[str, object] = {}
for navn, verdi in par:
if navn in ut:
msg = f"feltet {navn!r} står to ganger"
raise GrunnlagError(msg)
ut[navn] = verdi
return ut
def les_json(raa: bytes, hvor: str) -> object:
"""Parse JSON strictly: valid UTF-8, no field twice, no NaN or infinity."""
def ikke_tall(tekst: str) -> object:
msg = f"{hvor}: {tekst} er ikke et tall JSON tillater"
raise GrunnlagError(msg)
try:
return cast(
"object",
json.loads(
raa.decode("utf-8"),
object_pairs_hook=_uten_duplikater,
parse_constant=ikke_tall,
),
)
except (UnicodeDecodeError, json.JSONDecodeError) as feil:
msg = f"{hvor} er ikke gyldig JSON i UTF-8: {feil}"
raise GrunnlagError(msg) from feil
def objekt(
verdi: object,
hvor: str,
*,
felt: Sequence[str] | None = None,
valgfrie: Sequence[str] = (),
) -> dict[str, object]:
"""An object; with ``felt``, exactly those fields, plus any of ``valgfrie``."""
if not isinstance(verdi, dict):
_feil(hvor, "skal være et objekt")
ut = cast("dict[str, object]", verdi)
if felt is not None:
ukjent = [n for n in ut if n not in felt and n not in valgfrie]
if ukjent:
_feil(hvor, f"ukjent felt: {', '.join(ukjent)}")
mangler = [n for n in felt if n not in ut]
if mangler:
_feil(hvor, f"feltet mangler: {', '.join(mangler)}")
return ut
def liste(verdi: object, hvor: str) -> list[object]:
"""A list."""
if not isinstance(verdi, list):
_feil(hvor, "skal være en liste")
return cast("list[object]", verdi)
def tekst(verdi: object, hvor: str) -> str:
"""A string."""
if not isinstance(verdi, str):
_feil(hvor, "skal være en tekst")
return verdi
def tall(verdi: object, hvor: str) -> float:
"""A finite number; a whole number in JSON is taken as the same number."""
if isinstance(verdi, bool) or not isinstance(verdi, int | float):
_feil(hvor, "skal være et tall")
ut = float(verdi)
if not math.isfinite(ut):
_feil(hvor, "skal være et endelig tall")
return ut
def heltall(verdi: object, hvor: str) -> int:
"""A whole number written without decimals."""
if isinstance(verdi, bool) or not isinstance(verdi, int):
_feil(hvor, "skal være et heltall")
return verdi
def sannhet(verdi: object, hvor: str) -> bool:
"""A JSON true or false."""
if not isinstance(verdi, bool):
_feil(hvor, "skal være true eller false")
return verdi
def _tall_ordbok(verdi: object, hvor: str) -> dict[str, float]:
return {n: tall(v, f"{hvor}.{n}") for n, v in objekt(verdi, hvor).items()}
def _aarsbane(verdi: object, hvor: str) -> dict[int, float]:
ut = {}
for aar, v in objekt(verdi, hvor).items():
if not aar.isascii() or not aar.isdigit():
_feil(f"{hvor}.{aar}", "nøkkelen skal være et årstall")
ut[int(aar)] = tall(v, f"{hvor}.{aar}")
if not ut:
_feil(hvor, "skal ha minst ett år")
return ut
def _tall_rekke(verdi: object, hvor: str, lengde: int | None = None) -> tuple[float, ...]:
ut = tuple(tall(v, f"{hvor}[{i}]") for i, v in enumerate(liste(verdi, hvor)))
if lengde is not None and len(ut) != lengde:
_feil(hvor, f"skal ha {lengde} tall, har {len(ut)}")
return ut
# ------------------------------------------------------------- the basis file
TOPPFELT: Final = (
"merke",
"storrelser",
"tabeller",
"trekninger",
"M5",
"eos",
"karbonbaner",
"y_obs_maks",
)
"""The fields of a basis file, in the order they are written."""
TABELLFELT: Final = (
"design",
"P_u_sett",
"psi",
"kappa",
"linjer",
"karbonpris",
"eierformer",
"areal",
"petroleum_median",
"bortfall",
"u_alt",
"kjoletaarn",
"Gamma_trinn",
)
"""The parts of ``Inndata`` that are shared by every draw, in the equations' units."""
STORRELSESFELT: Final = ("navn", "faktor", "status", "verdi")
EIERFORMFELT: Final = ("s", "theta", "tau_g", "h", "r_d", "r_q", "zeta", "skatt")
TREKNINGSFELT: Final = ("verdier", "u_eksport")
@dataclass(frozen=True)
class _Storrelse:
navn: str
faktor: float
status: str
verdi: float | None
def _les_storrelser(verdi: object) -> tuple[_Storrelse, ...]:
ut = []
for i, raa in enumerate(liste(verdi, "storrelser")):
hvor = f"storrelser[{i}]"
felt = objekt(raa, hvor, felt=STORRELSESFELT)
navn = tekst(felt["navn"], f"{hvor}.navn")
faktor = tall(felt["faktor"], f"{hvor}.faktor")
if faktor <= 0:
_feil(f"{hvor}.faktor", "skal være positiv")
status = tekst(felt["status"], f"{hvor}.status")
if status not in STATUSER:
_feil(f"{hvor}.status", f"ukjent status {status!r}")
fast = None if felt["verdi"] is None else tall(felt["verdi"], f"{hvor}.verdi")
ut.append(_Storrelse(navn, faktor, status, fast))
navn_ = [s.navn for s in ut]
doble = [n for i, n in enumerate(navn_) if n in navn_[:i]]
if doble:
_feil("storrelser", f"står to ganger: {', '.join(doble)}")
return tuple(ut)
def _les_eierformer(verdi: object) -> dict[str, ind.Eierform]:
ut = {}
for navn, raa in objekt(verdi, "tabeller.eierformer").items():
hvor = f"tabeller.eierformer.{navn}"
felt = objekt(raa, hvor, felt=EIERFORMFELT)
ut[navn] = ind.Eierform(
navn=navn,
s=tall(felt["s"], f"{hvor}.s"),
theta=tall(felt["theta"], f"{hvor}.theta"),
tau_g=tall(felt["tau_g"], f"{hvor}.tau_g"),
h=tall(felt["h"], f"{hvor}.h"),
r_d=tall(felt["r_d"], f"{hvor}.r_d"),
r_q=None if felt["r_q"] is None else tall(felt["r_q"], f"{hvor}.r_q"),
zeta=tall(felt["zeta"], f"{hvor}.zeta"),
skatt=sannhet(felt["skatt"], f"{hvor}.skatt"),
)
return ut
def _les_tabeller(verdi: object) -> Inndata:
"""The shared parts of ``Inndata`` as a template with no scalars and no event row."""
hvor = "tabeller"
felt = objekt(verdi, hvor, felt=TABELLFELT)
linjer = {}
for omraade, raa in objekt(felt["linjer"], f"{hvor}.linjer").items():
linje = objekt(raa, f"{hvor}.linjer.{omraade}", felt=("alpha", "b"))
linjer[omraade] = ind.Prislinje(
alpha=tall(linje["alpha"], f"{hvor}.linjer.{omraade}.alpha"),
b=tall(linje["b"], f"{hvor}.linjer.{omraade}.b"),
)
bortfall = {}
for navn, v in objekt(felt["bortfall"], f"{hvor}.bortfall", felt=BORTFALLSNAVN).items():
d_30, d_35 = _tall_rekke(v, f"{hvor}.bortfall.{navn}", 2)
bortfall[navn] = (d_30, d_35)
kjoletaarn = {}
for navn, v in objekt(felt["kjoletaarn"], f"{hvor}.kjoletaarn").items():
lav, median, hoy = _tall_rekke(v, f"{hvor}.kjoletaarn.{navn}", 3)
kjoletaarn[navn] = (lav, median, hoy)
objekt(felt["Gamma_trinn"], f"{hvor}.Gamma_trinn", felt=lg.GAMMA_TRINN)
return ind.Inndata(
v={},
design=_tall_ordbok(felt["design"], f"{hvor}.design"),
P_u_sett=_tall_rekke(felt["P_u_sett"], f"{hvor}.P_u_sett"),
psi=_tall_ordbok(felt["psi"], f"{hvor}.psi"),
kappa=_tall_ordbok(felt["kappa"], f"{hvor}.kappa"),
linjer=linjer,
karbonpris=_aarsbane(felt["karbonpris"], f"{hvor}.karbonpris"),
u_eksport=(),
eierformer=_les_eierformer(felt["eierformer"]),
areal=_tall_ordbok(felt["areal"], f"{hvor}.areal"),
petroleum_median=tall(felt["petroleum_median"], f"{hvor}.petroleum_median"),
bortfall=bortfall,
u_alt={
navn: _aarsbane(v, f"{hvor}.u_alt.{navn}")
for navn, v in objekt(felt["u_alt"], f"{hvor}.u_alt").items()
},
kjoletaarn=kjoletaarn,
Gamma_trinn=_tall_ordbok(felt["Gamma_trinn"], f"{hvor}.Gamma_trinn"),
)
def les_losning(verdi: object, hvor: str) -> Losning:
"""A solution by its name in the specification (A, B, B', C, R, T-F, T-K)."""
navn = tekst(verdi, hvor)
for a in Losning:
if a.value == navn:
return a
msg = f"ukjent løsning {navn!r}; kjente er {', '.join(a.value for a in Losning)}"
_feil(hvor, msg)
def _les_m5(verdi: object) -> dict[Losning, Dom]:
felt = objekt(verdi, "M5", felt=tuple(a.value for a in Losning))
ut = {}
for a in Losning:
dom = tekst(felt[a.value], f"M5.{a.value}")
if dom not in tuple(d.value for d in Dom):
_feil(f"M5.{a.value}", f"ukjent dom {dom!r}")
ut[a] = Dom(dom)
return ut
def _les_eos(verdi: object, former: Sequence[str]) -> dict[str, str]:
felt = objekt(verdi, "eos", felt=former)
ut = {}
for navn in former:
vurdering = tekst(felt[navn], f"eos.{navn}")
if vurdering not in EOS_VURDERINGER:
_feil(f"eos.{navn}", f"ukjent vurdering {vurdering!r}")
ut[navn] = vurdering
return ut
def fra_fil(sti: Path) -> Grunnlag:
"""Read a basis file in JSON, marked «oppdiktet» (clarification 127).
The file is read strictly: an unknown field, a missing field or a value of
the wrong type is an error that names the field. Scalars stand in the
file's unit with a factor to the equations' unit, as in the parameter
file; a drawn quantity has ``verdi`` null and one value per draw, in the
order of the quantities. The shared tables stand once, in the equations'
units, as ``Inndata`` holds them. The upper end of the contract prices
stands in the unit of ``y_obs``.
"""
raa = Path(sti).read_bytes()
data = objekt(les_json(raa, str(sti)), "grunnlagsfila", felt=TOPPFELT)
merke = tekst(data["merke"], "merke")
if merke != MERKE_OPPDIKTET:
msg = (
f"en grunnlagsfil skal være merket {MERKE_OPPDIKTET!r}, fikk {merke!r}: grunnlaget "
"fra frysen lages bare fra parameterfila og de lagrede trekningene"
)
_feil("merke", msg)
storrelser = _les_storrelser(data["storrelser"])
mal = _les_tabeller(data["tabeller"])
trukne = [s for s in storrelser if s.verdi is None]
faste = {s.navn: s.verdi * s.faktor for s in storrelser if s.verdi is not None}
if not trukne:
_feil("storrelser", "minst én størrelse må være trukket (verdi null)")
rader = liste(data["trekninger"], "trekninger")
if not rader:
_feil("trekninger", "skal ha minst én trekning")
inndata = []
kolonner: list[list[float]] = [[] for _ in trukne]
for omega, rad in enumerate(rader):
hvor = f"trekninger[{omega}]"
felt = objekt(rad, hvor, felt=TREKNINGSFELT)
verdier = _tall_rekke(felt["verdier"], f"{hvor}.verdier", len(trukne))
for kolonne, v in zip(kolonner, verdier, strict=True):
kolonne.append(v)
trukket = {s.navn: v * s.faktor for s, v in zip(trukne, verdier, strict=True)}
inndata.append(
replace(
mal,
v={s.navn: faste.get(s.navn, trukket.get(s.navn, 0.0)) for s in storrelser},
u_eksport=_tall_rekke(felt["u_eksport"], f"{hvor}.u_eksport"),
)
)
navn_trukne = [s.navn for s in trukne]
for navn, partner in (("rho_N", "rho_D"),):
if navn in navn_trukne and partner not in navn_trukne:
msg = f"en terskel i {navn} trenger de trukne verdiene av {partner} (avklaring 115 c)"
_feil("storrelser", msg)
if "eps_d" not in faste:
_feil("storrelser", "eps_d skal være en fast størrelse (avklaring 107)")
if "y_obs" not in faste and "y_obs" not in navn_trukne:
_feil("storrelser", "y_obs mangler")
faktorer = {s.navn: s.faktor for s in storrelser}
return Grunnlag(
trekninger=tuple(inndata),
storrelser={s.navn: tuple(k) for s, k in zip(trukne, kolonner, strict=True)},
status={s.navn: s.status for s in trukne},
M5=_les_m5(data["M5"]),
eos=_les_eos(data["eos"], tuple(mal.eierformer)),
karbonbaner={
bane: _aarsbane(v, f"karbonbaner.{bane}")
for bane, v in objekt(data["karbonbaner"], "karbonbaner", felt=KARBONBANER).items()
},
y_obs_maks=tall(data["y_obs_maks"], "y_obs_maks") * faktorer["y_obs"],
eps_d=faste["eps_d"],
faktorer=faktorer,
merke=MERKE_OPPDIKTET,
sjekksummer={"grunnlagsfil": hashlib.sha256(raa).hexdigest()},
)
# ------------------------------------------------------------------ the freeze
def fra_frys(
eos: Mapping[str, str] | None,
*,
parametere: Path | None = None,
data: Path | None = None,
) -> Grunnlag:
"""The basis from the freeze: the parameter file, the stored draws and the stored stream.
``eos`` is the EEA assessment per ownership form. It is not written down
anywhere yet (clarification 127): with None the function stops at once,
before any file is read. The mark is «frosset» when the parameter file has
the frozen checksum, else «endret», and the basis carries the checksums of
the parameter file, the draws and the stream. The draws must be made from
this parameter file.
"""
if eos is None:
raise GrunnlagError(EOS_MANGLER)
# Imported here: only the freeze needs the loaders, and they read nothing until called.
from tokenfabrikker import hendelser, kjoring, miljo, trekninger # noqa: PLC0415
from tokenfabrikker import parametere as par # noqa: PLC0415
sti = par.STANDARDSTI if parametere is None else parametere
mappe = trekninger.DATAMAPPE if data is None else data
sjekksum = par.sjekksum(sti)
sett = par.les_parametere(sti, krev_frossen=False)
for fil in (trekninger.BESKRIVELSESFIL, hendelser.BESKRIVELSESFIL):
beskrivelse = objekt(les_json((mappe / fil).read_bytes(), fil), fil)
if beskrivelse.get("sha256_parametere") != sjekksum:
msg = (
f"{fil} er ikke laget fra denne parameterfila; trekningene og strømmen må lages "
"på nytt (avklaring 132)"
)
raise GrunnlagError(msg)
trukket = trekninger.les(mappe)
strom = hendelser.les(mappe)
stokastiske = sett.stokastiske()
if trukket.kolonner != tuple(s.navn for s in stokastiske):
msg = "de lagrede trekningene har ikke de trukne størrelsene i parameterfila"
raise GrunnlagError(msg)
N = sett.monte_carlo.antall_trekninger
if trukket.tabell.shape[0] != N or strom.tabell.shape[0] != N:
msg = f"trekningene og strømmen skal ha {N} rader"
raise GrunnlagError(msg)
status = {s.navn: p.status for p in sett.parametere for s in p.storrelser}
former = tuple(ind.tolk_eierformer(sett.tabell("eierformer")))
areal = ind.tolk_areal(sett.tabell("alpha"))
y_obs = sett.storrelse("y_obs")
karbon = sett.karbonpris()
return Grunnlag(
trekninger=tuple(
ind.fra_trekning(sett, trukket, strom.rad(omega), omega) for omega in range(N)
),
storrelser={s.navn: tuple(float(v) for v in trukket.kolonne(s.navn)) for s in stokastiske},
status={s.navn: status[s.navn] for s in stokastiske},
M5=kjoring.dommer_m5(
tuple(Losning),
miljo.KILDEVERDIER_M5,
kjernekraft=areal["kjernekraft"],
vind_direkte=areal["vind_direkte"],
vind_plan=areal["vind_plan"],
),
eos=_les_eos(dict(eos), former),
karbonbaner={bane: karbon[bane] for bane in KARBONBANER},
y_obs_maks=y_obs.fordeling.tall["hoy"] * y_obs.faktor,
eps_d=sett.fast("eps_d"),
faktorer={s.navn: s.faktor for s in sett.storrelser() if s.fordeling.tabell is None},
merke=MERKE_FROSSET if sjekksum == FROSSEN_SJEKKSUM else MERKE_ENDRET,
sjekksummer={
"parametere": sjekksum,
"trekninger": hashlib.sha256((mappe / trekninger.TABELLFIL).read_bytes()).hexdigest(),
"aarshendelser": hashlib.sha256((mappe / hendelser.TABELLFIL).read_bytes()).hexdigest(),
},
)

View file

@ -0,0 +1,620 @@
"""The tools of chapter 12 on the command line (chapter 16, clarifications 126 to 132).
PYTHONPATH=src python -m tokenfabrikker.verktoy <kommando> ...
``hovedkjoring`` writes the six data files of the main run (clarification
128). ``kontroll`` makes them anew from the basis and compares them with the
stored ones (129). ``scenario``, ``folsomhet`` and ``terskel`` are runs of
one's own from an input file in JSON, and ``sammenlign`` compares two folders
that each hold a ``dommer.json`` (130). ``arbeidskopi`` copies the code, the
tests, the parameter file, the draws, the stream, the specification and the
map to a folder the user owns (132).
Every command that computes takes the basis from exactly one of
``--grunnlag FIL`` (a made-up basis file) or ``--frys`` (the freeze). Until
the EEA assessment per ownership form is written down (clarification 127),
``--frys`` stops before anything is read. The number of processes is a choice
on the command line and changes no figure.
What the tools write for the user is Norwegian. An input file is read
strictly: an unknown field, a missing field, a value of the wrong type, and an
unknown name of a solution, a scenario, a quantity or a row are errors that
stop the tool before anything is computed.
"""
from __future__ import annotations
import argparse
import hashlib
import shutil
import sys
import tempfile
from dataclasses import dataclass
from pathlib import Path
from typing import TYPE_CHECKING, Final, cast
from tokenfabrikker import datafiler as df
from tokenfabrikker import folsomheter as fs
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import kjoring as kj
from tokenfabrikker.parametere import ParameterError
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Mapping, Sequence
from tokenfabrikker.grunnlag import Grunnlag
from tokenfabrikker.kjoring import Scenario
SETNING: Final = "Egen kjøring: ingen dom her er rapportens dom"
"""The sentence everything a tool of one's own writes carries (clarification 130)."""
ROT: Final = Path(__file__).resolve().parents[2]
"""The root of the repository, or of a working copy."""
ARBEIDSKOPI_DELER: Final = (
"src",
"tests",
"modell/parametere.json",
"modell/spesifikasjon.md",
"modell/kart.md",
"data",
"requirements.txt",
"requirements-dev.txt",
"pyproject.toml",
)
"""What a working copy holds (clarification 132); the map is copied when it exists."""
ARBEIDSKOPI_FIL: Final = "ARBEIDSKOPI.md"
TERSKEL_FIL: Final = "terskel.json"
SAMMENLIGNING_FIL: Final = "sammenligning.json"
class InngangsError(ValueError):
"""An input file or a command line the tool cannot use; the message is Norwegian."""
# ------------------------------------------------------------- input files
def _scenario(navn: str, hvor: str, lov: Sequence[Scenario] = kj.SCENARIOER) -> Scenario:
for s in lov:
if s.navn == navn:
return s
msg = f"{hvor}: ukjent scenario {navn!r}; kjente er {', '.join(s.navn for s in lov)}"
raise InngangsError(msg)
def _navneliste(verdi: object, hvor: str) -> list[str]:
navn = [gl.tekst(v, f"{hvor}[{i}]") for i, v in enumerate(gl.liste(verdi, hvor))]
if not navn:
msg = f"{hvor}: listen kan ikke være tom"
raise InngangsError(msg)
doble = [n for i, n in enumerate(navn) if n in navn[:i]]
if doble:
msg = f"{hvor}: står to ganger: {', '.join(doble)}"
raise InngangsError(msg)
return navn
def _stige(verdi: object, hvor: str) -> tuple[int, ...]:
trinn = [gl.heltall(v, f"{hvor}[{i}]") for i, v in enumerate(gl.liste(verdi, hvor))]
if not trinn or any(n < 1 for n in trinn) or len(set(trinn)) != len(trinn):
msg = f"{hvor}: skal være ulike hele antall anlegg, minst ett og hvert minst 1"
raise InngangsError(msg)
return tuple(trinn)
def _verdier(verdi: object, hvor: str) -> dict[str, float]:
return {n: gl.tall(v, f"{hvor}.{n}") for n, v in gl.objekt(verdi, hvor).items()}
def _trekninger(verdi: object, hvor: str) -> int:
antall = gl.heltall(verdi, hvor)
if antall < 1:
msg = f"{hvor}: skal være minst 1"
raise InngangsError(msg)
return antall
def les_inngang(sti: Path, felt: Sequence[str], valgfrie: Sequence[str]) -> dict[str, object]:
"""Read an input file strictly: the required fields, and any of the optional ones."""
try:
raa = sti.read_bytes()
except OSError as feil:
msg = f"kan ikke lese inngangsfila {sti}: {feil.strerror}"
raise InngangsError(msg) from feil
return gl.objekt(gl.les_json(raa, sti.name), "inngangsfila", felt=felt, valgfrie=valgfrie)
@dataclass(frozen=True)
class Scenarioinngang:
"""The input of ``scenario`` as read (clarification 130)."""
navn: str
verdier: Mapping[str, float]
losninger: tuple[Losning, ...]
stige: tuple[int, ...]
scenarioer: tuple[Scenario, ...]
trekninger: int | None
def tolk_scenario(data: Mapping[str, object]) -> Scenarioinngang:
"""The fields of ``scenario``: ``navn`` must stand; the rest have defaults."""
losninger = tuple(Losning)
if "losninger" in data:
navn = _navneliste(data["losninger"], "losninger")
losninger = tuple(gl.les_losning(n, "losninger") for n in navn)
scenarioer: tuple[Scenario, ...] = kj.SCENARIOER
if "scenarioer" in data:
navn = _navneliste(data["scenarioer"], "scenarioer")
scenarioer = tuple(_scenario(n, "scenarioer") for n in navn)
if not any(s.teller for s in scenarioer):
msg = "scenarioer: «normalisering» må være med; trinnet velges fra det (avklaring 97)"
raise InngangsError(msg)
return Scenarioinngang(
navn=gl.tekst(data["navn"], "navn"),
verdier=_verdier(data["verdier"], "verdier") if "verdier" in data else {},
losninger=losninger,
stige=_stige(data["stige"], "stige") if "stige" in data else kj.STIGE,
scenarioer=scenarioer,
trekninger=_trekninger(data["trekninger"], "trekninger") if "trekninger" in data else None,
)
def tolk_folsomhet(data: Mapping[str, object]) -> tuple[tuple[fs.Rad, ...], int | None]:
"""The fields of ``folsomhet``: ``rader`` (all 42 without it) and ``trekninger``."""
rader = tuple(fs.RADER.values())
if "rader" in data:
navn = _navneliste(data["rader"], "rader")
ukjent = [n for n in navn if n not in fs.RADER]
if ukjent:
msg = f"rader: ukjent rad {', '.join(ukjent)}; radene er {', '.join(fs.RADER)}"
raise InngangsError(msg)
rader = tuple(rad for n, rad in fs.RADER.items() if n in navn)
antall = _trekninger(data["trekninger"], "trekninger") if "trekninger" in data else None
return rader, antall
@dataclass(frozen=True)
class Terskelinngang:
"""The input of ``terskel`` as read (clarification 130)."""
losning: Losning
trinn: int
scenario: Scenario
verdier: Mapping[str, float]
trekninger: int | None
def tolk_terskel(data: Mapping[str, object]) -> Terskelinngang:
"""The fields of ``terskel``: ``losning`` and ``trinn`` must stand."""
trinn = gl.heltall(data["trinn"], "trinn")
if trinn < 1:
msg = "trinn: skal være et helt antall anlegg, minst 1"
raise InngangsError(msg)
prisscenarioer = tuple(s for s in kj.SCENARIOER if s.bortfall is None)
scenario = df.HOVEDSCENARIO
if "scenario" in data:
scenario = _scenario(gl.tekst(data["scenario"], "scenario"), "scenario", prisscenarioer)
return Terskelinngang(
losning=gl.les_losning(data["losning"], "losning"),
trinn=trinn,
scenario=scenario,
verdier=_verdier(data["verdier"], "verdier") if "verdier" in data else {},
trekninger=_trekninger(data["trekninger"], "trekninger") if "trekninger" in data else None,
)
def tilpass(grunnlag: Grunnlag, verdier: Mapping[str, float], antall: int | None) -> Grunnlag:
"""The first N draws, with the fixed values set after the draw; names checked first."""
ukjent = [n for n in verdier if n not in grunnlag.faktorer]
if ukjent:
msg = f"verdier: ukjent størrelse {', '.join(ukjent)}"
raise InngangsError(msg)
if antall is not None and antall > grunnlag.antall:
msg = f"trekninger: grunnlaget har {grunnlag.antall} trekninger, ba om {antall}"
raise InngangsError(msg)
return (grunnlag if antall is None else grunnlag.de_forste(antall)).med_verdier(verdier)
def verktoyfelt(kommando: str, inngang: object) -> dict[str, object]:
"""The one field a tool of one's own adds: the sentence, the command and its input."""
return {"verktoy": {"setning": SETNING, "kommando": kommando, "inngang": inngang}}
# ------------------------------------------------------------------ the basis
def hent_grunnlag(valg: argparse.Namespace) -> Grunnlag:
"""The basis from ``--grunnlag`` or ``--frys`` (clarification 127)."""
if valg.frys:
return gl.fra_frys(None)
return gl.fra_fil(Path(valg.grunnlag))
def _stige_fra_tekst(tekst: str) -> tuple[int, ...]:
try:
return _stige([int(n) for n in tekst.split(",")], "--stige")
except ValueError as feil:
msg = f"--stige skal være hele tall skilt med komma, fikk {tekst!r}"
raise InngangsError(msg) from feil
# ------------------------------------------------------------------ commands
def kjor_hovedkjoring(valg: argparse.Namespace) -> int:
"""``hovedkjoring``: write the chosen data files of the main run."""
filer = df.FILER if valg.filer is None else tuple(valg.filer.split(","))
ukjent = [f for f in filer if f not in df.FILER]
if ukjent:
msg = f"--filer: ukjent fil {', '.join(ukjent)}; filene er {', '.join(df.FILER)}"
raise InngangsError(msg)
stige = kj.STIGE if valg.stige is None else _stige_fra_tekst(valg.stige)
grunnlag = hent_grunnlag(valg)
skrevet = df.skriv_hovedkjoring(
grunnlag, Path(valg.ut), stige=stige, prosesser=valg.prosesser, filer=filer
)
sys.stdout.write(f"Grunnlaget er merket «{grunnlag.merke}». Skrevet: {', '.join(skrevet)}\n")
return 0
def kjor_kontroll(valg: argparse.Namespace) -> int:
"""``kontroll``: make the six files anew and compare them with the stored ones (129)."""
fasit = Path(valg.fasit)
innhold = gl.objekt(gl.les_json((fasit / df.INNHOLD).read_bytes(), df.INNHOLD), df.INNHOLD)
stige = _stige(innhold["stige"], f"{df.INNHOLD}.stige")
scenarioer = tuple(
_scenario(n, f"{df.INNHOLD}.scenarioer")
for n in _navneliste(innhold["scenarioer"], f"{df.INNHOLD}.scenarioer")
)
losninger = tuple(
gl.les_losning(n, f"{df.INNHOLD}.losninger")
for n in _navneliste(innhold["losninger"], f"{df.INNHOLD}.losninger")
)
grunnlag = hent_grunnlag(valg)
with tempfile.TemporaryDirectory() as midlertidig:
ny = Path(valg.ut) if valg.ut is not None else Path(midlertidig)
df.skriv_hovedkjoring(
grunnlag,
ny,
stige=stige,
scenarioer=scenarioer,
losninger=losninger,
prosesser=valg.prosesser,
)
resultat = df.sammenlign_mapper(ny, fasit)
for fil in resultat.filer:
linje = f"{fil.navn}: {fil.dom}"
if fil.storste_avvik > 0:
linje += f" (største relative avvik {fil.storste_avvik:.3g} i {fil.hvor})"
if fil.forskjell is not None:
linje += f"; første forskjell: {fil.forskjell}"
sys.stdout.write(linje + "\n")
samlet = f"Samlet: {resultat.dom}"
if resultat.hvor is not None:
samlet += f" (største relative avvik {resultat.storste_avvik:.3g} i {resultat.hvor})"
else:
samlet += " (største relative avvik 0)"
sys.stdout.write(f"{samlet}. Grunnlaget er merket «{grunnlag.merke}».\n")
return 1 if resultat.dom == df.ENDRET else 0
def kjor_scenario(valg: argparse.Namespace) -> int:
"""``scenario``: a run of one's own; writes ``dommer.json`` and ``tidslinje.json``."""
raa = les_inngang(
Path(valg.inngang),
("navn",),
("verdier", "losninger", "stige", "scenarioer", "trekninger"),
)
inngang = tolk_scenario(raa)
grunnlag = tilpass(hent_grunnlag(valg), inngang.verdier, inngang.trekninger)
dommer, tidslinje = df.scenariokjoring(
grunnlag,
inngang.stige,
inngang.scenarioer,
inngang.losninger,
prosesser=valg.prosesser,
)
ut = Path(valg.ut)
felt = verktoyfelt("scenario", raa)
df.skriv(ut / df.DOMMER, {**felt, **dommer})
df.skriv(ut / df.TIDSLINJE, {**felt, **tidslinje})
sys.stdout.write(f"{SETNING}. Skrevet: {df.DOMMER}, {df.TIDSLINJE}\n")
return 0
def kjor_folsomhet(valg: argparse.Namespace) -> int:
"""``folsomhet``: rows of the sensitivity list; writes ``folsomheter.json``."""
raa = les_inngang(Path(valg.inngang), (), ("rader", "trekninger"))
rader, antall = tolk_folsomhet(raa)
stige = kj.STIGE if valg.stige is None else _stige_fra_tekst(valg.stige)
grunnlag = tilpass(hent_grunnlag(valg), {}, antall)
data = df.folsomhetskjoring(grunnlag, rader, stige=stige, prosesser=valg.prosesser)
df.skriv(Path(valg.ut) / df.FOLSOMHETER, {**verktoyfelt("folsomhet", raa), **data})
sys.stdout.write(f"{SETNING}. Skrevet: {df.FOLSOMHETER}\n")
return 0
def kjor_terskel(valg: argparse.Namespace) -> int:
"""``terskel``: the price threshold for one solution; writes ``terskel.json``."""
raa = les_inngang(
Path(valg.inngang), ("losning", "trinn"), ("scenario", "verdier", "trekninger")
)
inngang = tolk_terskel(raa)
grunnlag = tilpass(hent_grunnlag(valg), inngang.verdier, inngang.trekninger)
data = df.terskelkjoring(
grunnlag, inngang.losning, inngang.trinn, inngang.scenario, prosesser=valg.prosesser
)
df.skriv(Path(valg.ut) / TERSKEL_FIL, {**verktoyfelt("terskel", raa), **data})
sys.stdout.write(f"{SETNING}. Skrevet: {TERSKEL_FIL}\n")
return 0
# ------------------------------------------------------------- sammenlign
def _les_dommer(mappe: Path) -> dict[str, object]:
sti = mappe / df.DOMMER
if not sti.is_file():
msg = f"{mappe} har ingen {df.DOMMER}"
raise InngangsError(msg)
return gl.objekt(gl.les_json(sti.read_bytes(), str(sti)), str(sti))
def _per_navn(liste: object, navn: str) -> dict[str, dict[str, object]]:
return {
cast("str", cast("dict[str, object]", x)[navn]): cast("dict[str, object]", x)
for x in cast("list[object]", liste)
}
def _forskjell(a: object, b: object) -> float | None:
if isinstance(a, float | int) and isinstance(b, float | int):
return float(b) - float(a)
return None
def _maal(a: Mapping[str, object], b: Mapping[str, object]) -> dict[str, object]:
ut: dict[str, object] = {}
for m in ("M1", "M2", "M3", "M4", "M5", "M6"):
if m == "M5":
ut[m] = {"a": a[m], "b": b[m]}
continue
ma, mb = cast("dict[str, object]", a[m]), cast("dict[str, object]", b[m])
ut[m] = {
"a": ma["dom"],
"b": mb["dom"],
"endring_andel_holder": _forskjell(ma["andel_holder"], mb["andel_holder"]),
}
ut["median_M1"] = {
"a": a["median_M1"],
"b": b["median_M1"],
"endring": _forskjell(a["median_M1"], b["median_M1"]),
}
return ut
def _m7(a: object, b: object) -> dict[str, object]:
da, db = cast("dict[str, object] | None", a), cast("dict[str, object] | None", b)
return {
"a": None if da is None else da["dom"],
"b": None if db is None else db["dom"],
"endring_andel_holder": None
if da is None or db is None
else _forskjell(da["andel_holder"], db["andel_holder"]),
}
def sammenlign_dommer(a: Mapping[str, object], b: Mapping[str, object]) -> dict[str, object]:
"""``sammenligning.json`` from two ``dommer.json`` (clarification 130, ``sammenlign``).
For every scenario, step and solution in both: the verdict per target in
both, the change in the share that meets the condition for «holder» (b
minus a), and the median in M1 in both with the difference; M7, part I,
part II and the step in both. When the two come from different bases or
different numbers of draws, that stands first.
"""
ulikt = []
if a["grunnlag"] != b["grunnlag"]:
ulikt.append("De to er laget fra ulikt grunnlag.")
if a["antall_trekninger"] != b["antall_trekninger"]:
ulikt.append(
f"De to har ulikt antall trekninger: {a['antall_trekninger']} og "
f"{b['antall_trekninger']}."
)
per_a, per_b = _per_navn(a["per_scenario"], "navn"), _per_navn(b["per_scenario"], "navn")
scenarioer: dict[str, object] = {}
for navn, sa in per_a.items():
if navn not in per_b:
continue
sb = per_b[navn]
ta = {cast("int", t["trinn"]): t for t in cast("list[dict[str, object]]", sa["trinn"])}
tb = {cast("int", t["trinn"]): t for t in cast("list[dict[str, object]]", sb["trinn"])}
trinn = []
for n, ra in ta.items():
if n not in tb:
continue
la = cast("dict[str, dict[str, object]]", ra["losninger"])
lb = cast("dict[str, dict[str, object]]", tb[n]["losninger"])
trinn.append(
{
"trinn": n,
"losninger": {x: _maal(la[x], lb[x]) for x in la if x in lb},
"M7": _m7(ra["M7"], tb[n]["M7"]),
}
)
scenarioer[navn] = {
"trinn": trinn,
"del_I": {"a": sa["del_I"], "b": sb["del_I"]},
"del_II": {"a": sa["del_II"], "b": sb["del_II"]},
}
return {
"ulikt_grunnlag": ulikt,
"a": {
"grunnlag": a["grunnlag"],
"antall_trekninger": a["antall_trekninger"],
"egen_kjoring": "verktoy" in a,
},
"b": {
"grunnlag": b["grunnlag"],
"antall_trekninger": b["antall_trekninger"],
"egen_kjoring": "verktoy" in b,
},
"trinnet": {
"a": {"trinn": a["trinn"], "grunnlag_for_trinnet": a["grunnlag_for_trinnet"]},
"b": {"trinn": b["trinn"], "grunnlag_for_trinnet": b["grunnlag_for_trinnet"]},
},
"per_scenario": scenarioer,
}
def kjor_sammenlign(valg: argparse.Namespace) -> int:
"""``sammenlign``: compare two folders that each hold a ``dommer.json``; nothing is run."""
a, b = _les_dommer(Path(valg.a)), _les_dommer(Path(valg.b))
data = sammenlign_dommer(a, b)
inngang = {"a": valg.a, "b": valg.b}
df.skriv(Path(valg.ut) / SAMMENLIGNING_FIL, {**verktoyfelt("sammenlign", inngang), **data})
for linje in cast("list[str]", data["ulikt_grunnlag"]):
sys.stdout.write(linje + "\n")
sys.stdout.write(f"{SETNING}. Skrevet: {SAMMENLIGNING_FIL}\n")
return 0
# ------------------------------------------------------------- arbeidskopi
def _commit(rot: Path) -> str | None:
head = rot / ".git" / "HEAD"
if not head.is_file():
return None
ref = head.read_text(encoding="utf-8").strip()
if not ref.startswith("ref: "):
return ref
sti = rot / ".git" / ref.removeprefix("ref: ")
return sti.read_text(encoding="utf-8").strip() if sti.is_file() else None
def arbeidskopi_tekst(rot: Path, sjekksum: str, kopiert: Sequence[str]) -> str:
"""The text of ``ARBEIDSKOPI.md``: what the copy is copied from, and what it is not."""
commit = _commit(rot)
frossen = sjekksum == gl.FROSSEN_SJEKKSUM
linjer = [
"# Arbeidskopi",
"",
"Dette er en arbeidskopi av modellen i prosjektet «tokenfabrikker» (kapittel 12 i",
"spesifikasjonen, avklaring 132). Alt her kan endres.",
"",
f"- Kopiert fra: `{rot}`",
f"- Commit: `{commit}`" if commit else "- Commit: ukjent (ingen git-mappe funnet)",
f"- SHA-256 for parameterfila ved kopieringen: `{sjekksum}`",
"- Parameterfila var den frosne." if frossen else "- Parameterfila var ikke den frosne.",
"- Kopiert: " + ", ".join(f"`{d}`" for d in kopiert),
"",
"Ingenting i en arbeidskopi er rapportens tall. En parameterfil som ikke har den frosne",
"sjekksummen, gir grunnlaget merket «endret», og trekningene og strømmen for årlige",
"hendelser må da lages på nytt i kopien. `kontroll` sier «endret» om det den lager, når",
"det avviker fra de lagrede filene.",
"",
]
return "\n".join(linjer)
def lag_arbeidskopi(mappe: Path, rot: Path = ROT) -> tuple[str, ...]:
"""Copy what a working copy holds to a folder that does not exist or is empty (132)."""
if mappe.exists() and (not mappe.is_dir() or any(mappe.iterdir())):
msg = f"{mappe} finnes og er ikke en tom mappe"
raise InngangsError(msg)
mappe.mkdir(parents=True, exist_ok=True)
kopiert = []
for del_ in ARBEIDSKOPI_DELER:
kilde = rot / del_
if not kilde.exists():
continue
maal = mappe / del_
if kilde.is_dir():
shutil.copytree(
kilde, maal, ignore=shutil.ignore_patterns("__pycache__", "*.pyc", ".pytest_cache")
)
else:
maal.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(kilde, maal)
kopiert.append(del_)
sjekksum = hashlib.sha256((rot / "modell" / "parametere.json").read_bytes()).hexdigest()
(mappe / ARBEIDSKOPI_FIL).write_bytes(arbeidskopi_tekst(rot, sjekksum, kopiert).encode("utf-8"))
return tuple(kopiert)
def kjor_arbeidskopi(valg: argparse.Namespace) -> int:
"""``arbeidskopi MAPPE``."""
kopiert = lag_arbeidskopi(Path(valg.mappe))
sys.stdout.write(f"Arbeidskopi laget i {valg.mappe}: {', '.join(kopiert)}\n")
return 0
# ------------------------------------------------------------- command line
def _grunnlagsvalg(tolker: argparse.ArgumentParser) -> None:
gruppe = tolker.add_mutually_exclusive_group(required=True)
gruppe.add_argument("--grunnlag", metavar="FIL", help="en oppdiktet grunnlagsfil i JSON")
gruppe.add_argument("--frys", action="store_true", help="grunnlaget fra frysen")
tolker.add_argument("--prosesser", type=int, default=1, metavar="N")
def tolker() -> argparse.ArgumentParser:
"""The command line of the tools."""
hoved = argparse.ArgumentParser(
prog="python -m tokenfabrikker.verktoy", description="Verktøyene i kapittel 12."
)
under = hoved.add_subparsers(dest="kommando", required=True)
t = under.add_parser("hovedkjoring", help="skriv datafilene til hovedkjøringen")
_grunnlagsvalg(t)
t.add_argument("--ut", required=True, metavar="MAPPE")
t.add_argument("--stige", metavar="1,5,10")
t.add_argument("--filer", metavar="dommer.json,...")
t.set_defaults(kjor=kjor_hovedkjoring)
t = under.add_parser("kontroll", help="lag filene på nytt og sammenlign med de lagrede")
_grunnlagsvalg(t)
t.add_argument("--fasit", required=True, metavar="MAPPE")
t.add_argument("--ut", metavar="MAPPE")
t.set_defaults(kjor=kjor_kontroll)
for navn, hjelp, kjor in (
("scenario", "egen kjøring med egne forutsetninger", kjor_scenario),
("folsomhet", "rader fra følsomhetslista", kjor_folsomhet),
("terskel", "pristerskelen for én løsning", kjor_terskel),
):
t = under.add_parser(navn, help=hjelp)
t.add_argument("inngang", metavar="INNGANG.json")
_grunnlagsvalg(t)
t.add_argument("--ut", required=True, metavar="MAPPE")
if navn == "folsomhet":
t.add_argument("--stige", metavar="1,5,10")
t.set_defaults(kjor=kjor)
t = under.add_parser("sammenlign", help="sammenlign dommene i to mapper")
t.add_argument("a", metavar="MAPPE_A")
t.add_argument("b", metavar="MAPPE_B")
t.add_argument("--ut", required=True, metavar="MAPPE")
t.set_defaults(kjor=kjor_sammenlign)
t = under.add_parser("arbeidskopi", help="lag en arbeidskopi")
t.add_argument("mappe", metavar="MAPPE")
t.set_defaults(kjor=kjor_arbeidskopi)
return hoved
def main(argumenter: Sequence[str] | None = None) -> int:
"""Run one command; 0 on success, 1 when ``kontroll`` says «endret», 2 on an error."""
valg = tolker().parse_args(argumenter)
if getattr(valg, "prosesser", 1) < 1:
sys.stderr.write("Feil: --prosesser skal være minst 1\n")
return 2
try:
return cast("int", valg.kjor(valg))
except (gl.GrunnlagError, InngangsError, ParameterError) as feil:
sys.stderr.write(f"Feil: {feil}\n")
return 2
if __name__ == "__main__":
raise SystemExit(main())

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,387 @@
{
"grunnlag": {
"merke": "oppdiktet",
"sjekksummer": {
"grunnlagsfil": "0efb3267412a4e44a873c2d6dd95195d9102be46a55947ef504de8d886987791"
}
},
"antall_trekninger": 200,
"stige": [
1,
2,
5
],
"scenarioer": [
"knapphet varer",
"normalisering",
"overkapasitet",
"kildenes lave forlop",
"80 % paa egne maskiner, lav",
"80 % paa egne maskiner, hoy"
],
"losninger": [
"A",
"B",
"B'",
"C",
"R",
"T-F",
"T-K"
],
"trinn": 2,
"grunnlag_for_trinnet": "25 %-trinnet",
"scenario": "normalisering",
"per_losning": {
"A": {
"antall_byggbare": 194,
"kriterier": {
"direkte": {
"oppgjor": 0.0,
"verdi": -25334941528.078373,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.02,
"LCOC": 69920080.99124701,
"tapssannsynlighet": 0.6030927835051546,
"daarligste": -242648121637.29062,
"kapital_ute": 857639702037.2913
},
"heleid_selskap": {
"oppgjor": 0.0,
"verdi": -25334941528.078365,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.0490196078431373,
"LCOC": 85048675.35527526,
"tapssannsynlighet": 0.6030927835051546,
"daarligste": -242648121637.29062,
"kapital_ute": 434238117637.5252
},
"majoritet_boers": {
"oppgjor": -22635911318.03607,
"verdi": -25334941528.078365,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.05882352941176472,
"LCOC": 90160365.19345519,
"tapssannsynlighet": 0.6030927835051546,
"daarligste": -196133105060.47174,
"kapital_ute": 305294736922.14526
},
"petroleumsmodell": {
"oppgjor": -22552166310.966908,
"verdi": -25334941528.078373,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.05882352941176472,
"LCOC": 90160365.19345519,
"tapssannsynlighet": 0.6030927835051546,
"daarligste": -213166378869.3298,
"kapital_ute": 448340291135.83234
}
},
"rangering": {
"rangert": [],
"over_risikogrensen": [
"heleid_selskap",
"majoritet_boers",
"direkte",
"petroleumsmodell"
],
"ute": {},
"like": []
},
"statens_kontantstrom": {
"antall": 194,
"median": 2.554720712594043,
"p10": 2.0402318218340114,
"p90": 3.0856901090224405
}
},
"B": {
"antall_byggbare": 198,
"kriterier": {
"direkte": {
"oppgjor": 0.0,
"verdi": -13967122617.194185,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.02,
"LCOC": 68216606.50584075,
"tapssannsynlighet": 0.5808080808080808,
"daarligste": -225105380665.25912,
"kapital_ute": 831510387695.5769
},
"heleid_selskap": {
"oppgjor": 0.0,
"verdi": -13967122617.194185,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.0490196078431373,
"LCOC": 83060116.87436873,
"tapssannsynlighet": 0.5808080808080808,
"daarligste": -225105380665.25912,
"kapital_ute": 422989669235.1709
},
"majoritet_boers": {
"oppgjor": -18180409400.863255,
"verdi": -13967122617.194183,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.05882352941176472,
"LCOC": 88076941.30163962,
"tapssannsynlighet": 0.5757575757575758,
"daarligste": -181378436595.49942,
"kapital_ute": 293062098747.2403
},
"petroleumsmodell": {
"oppgjor": -21148962545.47204,
"verdi": -13967122617.194187,
"andel_av_overskudd": null,
"andel_for_oppgjor": null,
"r_e": 0.05882352941176472,
"LCOC": 88076941.30163962,
"tapssannsynlighet": 0.5757575757575758,
"daarligste": -199783170945.99042,
"kapital_ute": 434907580383.76263
}
},
"rangering": {
"rangert": [],
"over_risikogrensen": [
"majoritet_boers",
"direkte",
"heleid_selskap",
"petroleumsmodell"
],
"ute": {},
"like": []
},
"statens_kontantstrom": {
"antall": 198,
"median": 2.668525005123071,
"p10": 2.1607555440758706,
"p90": 3.1730684730954213
}
},
"C": {
"antall_byggbare": 200,
"kriterier": {
"direkte": {
"oppgjor": 0.0,
"verdi": 191809061299.96848,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0,
"r_e": 0.02,
"LCOC": 59964492.5286716,
"tapssannsynlighet": 0.02,
"daarligste": 1418793799.112741,
"kapital_ute": 625336108289.1396
},
"heleid_selskap": {
"oppgjor": 0.0,
"verdi": 191809061299.96848,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0,
"r_e": 0.0490196078431373,
"LCOC": 70765623.94863696,
"tapssannsynlighet": 0.02,
"daarligste": 1418793799.112738,
"kapital_ute": 294103775081.34735
},
"majoritet_boers": {
"oppgjor": 25999721593.033604,
"verdi": 191809061299.96848,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 0.8644499826190543,
"r_e": 0.05882352941176472,
"LCOC": 74257736.6967626,
"tapssannsynlighet": 0.0,
"daarligste": 62338723682.64895,
"kapital_ute": 144642248579.66385
},
"petroleumsmodell": {
"oppgjor": -13499752661.313438,
"verdi": 191809061299.96848,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0703812039421918,
"r_e": 0.05882352941176472,
"LCOC": 74257736.6967626,
"tapssannsynlighet": 0.005,
"daarligste": 24407668724.7351,
"kapital_ute": 297124837132.0643
}
},
"rangering": {
"rangert": [
"direkte",
"heleid_selskap",
"majoritet_boers",
"petroleumsmodell"
],
"over_risikogrensen": [],
"ute": {},
"like": [
[
"direkte",
"heleid_selskap",
"majoritet_boers",
"petroleumsmodell"
]
]
},
"statens_kontantstrom": {
"antall": 200,
"median": 2.872835357871859,
"p10": 2.3578638645333165,
"p90": 3.4480049402406654
}
},
"T-F": {
"antall_byggbare": 200,
"kriterier": {
"direkte": {
"oppgjor": 0.0,
"verdi": 190232335400.17938,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0,
"r_e": 0.02,
"LCOC": 59984048.881280765,
"tapssannsynlighet": 0.025,
"daarligste": -4559768035.317429,
"kapital_ute": 701672927496.3727
},
"heleid_selskap": {
"oppgjor": 0.0,
"verdi": 190232335400.17938,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0,
"r_e": 0.0490196078431373,
"LCOC": 70789239.18978119,
"tapssannsynlighet": 0.025,
"daarligste": -4559768035.317426,
"kapital_ute": 348170443963.1428
},
"majoritet_boers": {
"oppgjor": 25171791580.642715,
"verdi": 190232335400.17938,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 0.8676786912819503,
"r_e": 0.05882352941176472,
"LCOC": 74282798.09782054,
"tapssannsynlighet": 0.005,
"daarligste": 58282155003.21283,
"kapital_ute": 181624254393.59137
},
"petroleumsmodell": {
"oppgjor": -14026025259.333214,
"verdi": 190232335400.17938,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0737310259574302,
"r_e": 0.05882352941176472,
"LCOC": 74282798.09782054,
"tapssannsynlighet": 0.005,
"daarligste": 19238329914.628075,
"kapital_ute": 344521025274.89233
}
},
"rangering": {
"rangert": [
"direkte",
"heleid_selskap",
"majoritet_boers",
"petroleumsmodell"
],
"over_risikogrensen": [],
"ute": {},
"like": [
[
"direkte",
"heleid_selskap",
"majoritet_boers",
"petroleumsmodell"
]
]
},
"statens_kontantstrom": {
"antall": 200,
"median": 2.8703392874838665,
"p10": 2.3617958166959605,
"p90": 3.4537499593515455
}
},
"T-K": {
"antall_byggbare": 200,
"kriterier": {
"direkte": {
"oppgjor": 0.0,
"verdi": 189813518284.15546,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0,
"r_e": 0.02,
"LCOC": 60004881.08240367,
"tapssannsynlighet": 0.025,
"daarligste": -5679174821.060016,
"kapital_ute": 702217230960.8506
},
"heleid_selskap": {
"oppgjor": 0.0,
"verdi": 189813518284.15546,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.0,
"r_e": 0.0490196078431373,
"LCOC": 70819296.42262359,
"tapssannsynlighet": 0.025,
"daarligste": -5679174821.060014,
"kapital_ute": 348456669292.9458
},
"majoritet_boers": {
"oppgjor": 25128963959.646065,
"verdi": 189813518284.15546,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 0.8676123587676859,
"r_e": 0.05882352941176472,
"LCOC": 74316127.91349624,
"tapssannsynlighet": 0.005,
"daarligste": 54909691678.68481,
"kapital_ute": 181975173489.62808
},
"petroleumsmodell": {
"oppgjor": -14058145975.0807,
"verdi": 189813518284.15546,
"andel_av_overskudd": 1.0,
"andel_for_oppgjor": 1.074062933463123,
"r_e": 0.05882352941176472,
"LCOC": 74316127.91349624,
"tapssannsynlighet": 0.005,
"daarligste": 15823663084.08958,
"kapital_ute": 344920290463.03937
}
},
"rangering": {
"rangert": [
"direkte",
"heleid_selskap",
"majoritet_boers",
"petroleumsmodell"
],
"over_risikogrensen": [],
"ute": {},
"like": [
[
"direkte",
"heleid_selskap",
"majoritet_boers",
"petroleumsmodell"
]
]
},
"statens_kontantstrom": {
"antall": 200,
"median": 2.8703392874838665,
"p10": 2.3617958166959605,
"p90": 3.4537499593515455
}
}
}
}

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,38 @@
{
"grunnlag": {
"merke": "oppdiktet",
"sjekksummer": {
"grunnlagsfil": "0efb3267412a4e44a873c2d6dd95195d9102be46a55947ef504de8d886987791"
}
},
"antall_trekninger": 200,
"stige": [
1,
2,
5
],
"scenarioer": [
"knapphet varer",
"normalisering",
"overkapasitet",
"kildenes lave forlop",
"80 % paa egne maskiner, lav",
"80 % paa egne maskiner, hoy"
],
"losninger": [
"A",
"B",
"B'",
"C",
"R",
"T-F",
"T-K"
],
"filer": {
"dommer.json": "39ba305e19ae04bb77c912d0c7c5547d5e225ca60bd3277000a0ed4890c202b8",
"tidslinje.json": "a6dd290e13a2cee9de1b5030aea553f3c592a64c01ec67d1e6081b7038dbe5bf",
"eierformer.json": "5460b8e836edb60638ea56db239ad0d2d1a7ba939c50a55e0deb147a5ca38342",
"terskler.json": "6d8df88997947a1bf980258ef7076e1cb97856af100dd0cce1de5bae67f1677e",
"folsomheter.json": "879248ce9753a3f76a8df98fb726fb6431a672913f233621d2a85cfa192a54fa"
}
}

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,513 @@
{
"merke": "oppdiktet",
"storrelser": [
{"navn": "T0", "faktor": 1.0, "status": "modellvalg", "verdi": 2027.0},
{"navn": "T_slutt", "faktor": 1.0, "status": "modellvalg", "verdi": 2060.0},
{"navn": "P_IT", "faktor": 1.0, "status": "modellvalg", "verdi": 1000.0},
{"navn": "c_N_ref", "faktor": 1000.0, "status": "kilde", "verdi": null},
{"navn": "P_ref", "faktor": 1.0, "status": "modellvalg", "verdi": 1000.0},
{"navn": "nu", "faktor": 1.0, "status": "kilde", "verdi": 1.0},
{"navn": "ell", "faktor": 1.0, "status": "kilde", "verdi": 0.0},
{"navn": "n_0", "faktor": 1.0, "status": "kilde", "verdi": 5.0},
{"navn": "u_xi", "faktor": 1.0, "status": "modellvalg", "verdi": null},
{"navn": "w_xi", "faktor": 1.0, "status": "åpen forutsetning", "verdi": null},
{"navn": "o_xi", "faktor": 1.0, "status": "kilde", "verdi": 0.5},
{"navn": "tau_F", "faktor": 1.0, "status": "kilde", "verdi": 8.0},
{"navn": "tau_reg_min", "faktor": 1.0, "status": "kilde", "verdi": 2.0},
{"navn": "tau_N", "faktor": 1.0, "status": "kilde", "verdi": null},
{"navn": "KF", "faktor": 1.0, "status": "kilde", "verdi": 0.8},
{"navn": "o_p", "faktor": 1.0, "status": "kilde", "verdi": 0.05},
{"navn": "o_f_stor", "faktor": 1.0, "status": "kilde", "verdi": 0.02},
{"navn": "o_f_liten", "faktor": 1.0, "status": "kilde", "verdi": 0.04},
{"navn": "beta_F", "faktor": 1.0, "status": "kilde", "verdi": 0.1},
{"navn": "chi", "faktor": 1.0, "status": "kilde", "verdi": 0.1},
{"navn": "A_krav", "faktor": 1.0, "status": "kilde", "verdi": 0.99},
{"navn": "L_N", "faktor": 1.0, "status": "kilde", "verdi": 20.0},
{"navn": "f_N", "faktor": 1.0, "status": "kilde", "verdi": 1000000.0},
{"navn": "nu_f", "faktor": 1.0, "status": "kilde", "verdi": 0.0},
{"navn": "v_N", "faktor": 1.0, "status": "kilde", "verdi": 50.0},
{"navn": "u_N", "faktor": 1.0, "status": "kilde", "verdi": 70.0},
{"navn": "u_N_liten", "faktor": 1.0, "status": "kilde", "verdi": 100.0},
{"navn": "d_N", "faktor": 1.0, "status": "kilde", "verdi": 30.0},
{"navn": "D_avv", "faktor": 1000000.0, "status": "kilde", "verdi": 5.0},
{"navn": "phi_U", "faktor": 1.0, "status": "kilde", "verdi": 1e-05},
{"navn": "K_U", "faktor": 1000000000.0, "status": "kilde", "verdi": 1000.0},
{"navn": "D_fors", "faktor": 1.0, "status": "kilde", "verdi": 8000000000.0},
{"navn": "aarsverk_prog", "faktor": 1.0, "status": "kilde", "verdi": 1000.0},
{"navn": "andel_myndighet", "faktor": 1.0, "status": "kilde", "verdi": 0.2},
{"navn": "c_aarsverk", "faktor": 1.0, "status": "kilde", "verdi": 1000000.0},
{"navn": "n_reaktor", "faktor": 1.0, "status": "åpen forutsetning", "verdi": null},
{"navn": "delta_L", "faktor": 1.0, "status": "kilde", "verdi": 0.5},
{"navn": "c_buf", "faktor": 1.0, "status": "kilde", "verdi": 10000000.0},
{"navn": "f_buf", "faktor": 1.0, "status": "kilde", "verdi": 400000.0},
{"navn": "L_buf", "faktor": 1.0, "status": "modellvalg", "verdi": 20.0},
{"navn": "s_g", "faktor": 1.0, "status": "kilde", "verdi": 0.02},
{"navn": "c_gen", "faktor": 1.0, "status": "kilde", "verdi": 10000000.0},
{"navn": "D_linje", "faktor": 1.0, "status": "kilde", "verdi": 50.0},
{"navn": "c_linje", "faktor": 1.0, "status": "kilde", "verdi": 10000000.0},
{"navn": "c_H0", "faktor": 1000000.0, "status": "kilde", "verdi": null},
{"navn": "gamma_H", "faktor": 1.0, "status": "kilde", "verdi": 0.0},
{"navn": "c_bygg", "faktor": 1000000.0, "status": "kilde", "verdi": 100.0},
{"navn": "d_bygg", "faktor": 1.0, "status": "kilde", "verdi": 0.1},
{"navn": "L_H", "faktor": 1.0, "status": "kilde", "verdi": 5.0},
{"navn": "L_B", "faktor": 1.0, "status": "kilde", "verdi": 15.0},
{"navn": "tau_D", "faktor": 1.0, "status": "kilde", "verdi": 2.0},
{"navn": "PUE", "faktor": 1.0, "status": "kilde", "verdi": null},
{"navn": "PUE_v", "faktor": 1.0, "status": "kilde", "verdi": null},
{"navn": "lambda", "faktor": 1.0, "status": "kilde", "verdi": 0.75},
{"navn": "o_D_v", "faktor": 1.0, "status": "kilde", "verdi": 3000000.0},
{"navn": "o_D", "faktor": 1.0, "status": "kilde", "verdi": 2000000.0},
{"navn": "d_o_D", "faktor": 1.0, "status": "kilde", "verdi": 500000.0},
{"navn": "mu_rel", "faktor": 1.0, "status": "kilde", "verdi": 1.0},
{"navn": "h_knapp", "faktor": 1.0, "status": "kilde", "verdi": 100.0},
{"navn": "p_v", "faktor": 1.0, "status": "kilde", "verdi": null},
{"navn": "y_obs", "faktor": 1000000.0, "status": "kilde", "verdi": null},
{"navn": "T_knapp", "faktor": 1.0, "status": "kilde", "verdi": 10.0},
{"navn": "pi_neg", "faktor": 1.0, "status": "kilde", "verdi": -0.3},
{"navn": "S0", "faktor": 1000000.0, "status": "kilde", "verdi": 10.0},
{"navn": "b_ut", "faktor": 1.0, "status": "kilde", "verdi": 2.0},
{"navn": "m_tort", "faktor": 1.0, "status": "kilde", "verdi": 1.5},
{"navn": "s_tort", "faktor": 1.0, "status": "kilde", "verdi": 1.2},
{"navn": "w_tort_vann", "faktor": 1.0, "status": "kilde", "verdi": 0.8},
{"navn": "psi_N", "faktor": 1.0, "status": "kilde", "verdi": 1.0},
{"navn": "kappa_vind", "faktor": 1.0, "status": "kilde", "verdi": 0.05},
{"navn": "c_fast", "faktor": 1.0, "status": "kilde", "verdi": 1400000.0},
{"navn": "c_res", "faktor": 1.0, "status": "kilde", "verdi": 1000000.0},
{"navn": "I_nett", "faktor": 1.0, "status": "kilde", "verdi": 5000000.0},
{"navn": "L_nett", "faktor": 1.0, "status": "kilde", "verdi": 40.0},
{"navn": "tau_nett", "faktor": 1.0, "status": "kilde", "verdi": 3.0},
{"navn": "n_tap", "faktor": 1.0, "status": "kilde", "verdi": 0.05},
{"navn": "t_el", "faktor": 1.0, "status": "kilde", "verdi": 70.0},
{"navn": "delta_V", "faktor": 1.0, "status": "kilde", "verdi": 0.5},
{"navn": "vind.investering", "faktor": 1.0, "status": "kilde", "verdi": 14000000.0},
{"navn": "vind.drift", "faktor": 1.0, "status": "kilde", "verdi": 120.0},
{"navn": "vind.fullasttimer", "faktor": 1.0, "status": "kilde", "verdi": 3000.0},
{"navn": "vind.levetid", "faktor": 1.0, "status": "kilde", "verdi": 30.0},
{"navn": "vind.byggetid", "faktor": 1.0, "status": "kilde", "verdi": 2.0},
{"navn": "vann.investering", "faktor": 1.0, "status": "kilde", "verdi": 20000000.0},
{"navn": "vann.drift", "faktor": 1.0, "status": "kilde", "verdi": 70.0},
{"navn": "vann.fullasttimer", "faktor": 1.0, "status": "kilde", "verdi": 3000.0},
{"navn": "vann.levetid", "faktor": 1.0, "status": "kilde", "verdi": 40.0},
{"navn": "vann.byggetid", "faktor": 1.0, "status": "kilde", "verdi": 3.0},
{"navn": "havvind.investering", "faktor": 1.0, "status": "kilde", "verdi": 50000000.0},
{"navn": "havvind.drift", "faktor": 1.0, "status": "kilde", "verdi": 900000.0},
{"navn": "havvind.fullasttimer", "faktor": 1.0, "status": "kilde", "verdi": 4500.0},
{"navn": "havvind.levetid", "faktor": 1.0, "status": "kilde", "verdi": 30.0},
{"navn": "havvind.byggetid", "faktor": 1.0, "status": "kilde", "verdi": 3.0},
{"navn": "E_vann_rest", "faktor": 1.0, "status": "kilde", "verdi": 2000000.0},
{"navn": "E_vind_rest", "faktor": 1.0, "status": "kilde", "verdi": 3000000.0},
{"navn": "g_fornybar", "faktor": 1.0, "status": "kilde", "verdi": 4000000.0},
{"navn": "rho_N", "faktor": 1.0, "status": "kilde", "verdi": null},
{"navn": "rho_D", "faktor": 1.0, "status": "åpen forutsetning", "verdi": null},
{"navn": "varphi", "faktor": 1.0, "status": "kilde", "verdi": 0.2},
{"navn": "s_B_NO", "faktor": 1.0, "status": "kilde", "verdi": 0.5},
{"navn": "u_B", "faktor": 1.0, "status": "kilde", "verdi": 2000.0},
{"navn": "phi_X", "faktor": 1.0, "status": "åpen forutsetning", "verdi": null},
{"navn": "D_X", "faktor": 1.0, "status": "kilde", "verdi": 2.0},
{"navn": "s_brikker", "faktor": 1.0, "status": "kilde", "verdi": 0.04},
{"navn": "G_server", "faktor": 1.0, "status": "kilde", "verdi": 25000.0},
{"navn": "t_nett", "faktor": 1.0, "status": "kilde", "verdi": 300000.0},
{"navn": "tau_s", "faktor": 1.0, "status": "kilde", "verdi": 0.2},
{"navn": "iota", "faktor": 1.0, "status": "kilde", "verdi": 0.02},
{"navn": "r_stat", "faktor": 1.0, "status": "kilde", "verdi": 0.02},
{"navn": "SNKS_snitt", "faktor": 1000000000.0, "status": "kilde", "verdi": 40.0},
{"navn": "u_kjerne", "faktor": 1.0, "status": "kilde", "verdi": 0.012},
{"navn": "u_vind", "faktor": 1.0, "status": "kilde", "verdi": 0.011},
{"navn": "u_havvind", "faktor": 1.0, "status": "kilde", "verdi": 0.012},
{"navn": "u_vann", "faktor": 1.0, "status": "kilde", "verdi": 0.004},
{"navn": "u_H", "faktor": 1.0, "status": "kilde", "verdi": 1000.0},
{"navn": "eta_N", "faktor": 1.0, "status": "kilde", "verdi": 3e-06},
{"navn": "P_m", "faktor": 1.0, "status": "modellvalg", "verdi": 100.0},
{"navn": "tau_1", "faktor": 1.0, "status": "kilde", "verdi": 2.0},
{"navn": "n_1", "faktor": 1.0, "status": "åpen forutsetning", "verdi": null},
{"navn": "eps_d", "faktor": 1.0, "status": "kilde", "verdi": 1.0},
{"navn": "w_D_uttak", "faktor": 1.0, "status": "kilde", "verdi": 0.1},
{"navn": "w_N_uttak", "faktor": 1.0, "status": "kilde", "verdi": 150.0},
{"navn": "w_N_forbruk", "faktor": 1.0, "status": "kilde", "verdi": 0.0},
{"navn": "w_D_sjo", "faktor": 1.0, "status": "kilde", "verdi": 100.0},
{"navn": "tau_pi", "faktor": 1.0, "status": "kilde", "verdi": null},
{"navn": "P_dim0", "faktor": 1.0, "status": "kilde", "verdi": 1450.0},
{"navn": "eps_e", "faktor": 1.0, "status": "åpen forutsetning", "verdi": null}
],
"tabeller": {
"design": {
"o_f_liten": 0.04,
"o_f_stor": 0.02,
"o_p": 0.05,
"beta_F": 0.1
},
"P_u_sett": [
5.0,
10.0,
20.0,
50.0,
100.0,
200.0,
300.0,
400.0,
500.0,
1000.0
],
"psi": {
"vind": 0.9,
"vann": 1.2,
"havvind": 1.0
},
"kappa": {
"vann": 0.9,
"havvind": 0.0
},
"linjer": {
"NO1": {
"alpha": 700.0,
"b": -1e-05
},
"NO2": {
"alpha": 700.0,
"b": -1e-05
},
"NO3": {
"alpha": 700.0,
"b": -1e-05
},
"NO4": {
"alpha": 700.0,
"b": -1e-05
},
"NO5": {
"alpha": 700.0,
"b": -1e-05
},
"Norge": {
"alpha": 700.0,
"b": -1e-05
}
},
"karbonpris": {
"2026": 1000.0,
"2100": 1000.0
},
"eierformer": {
"direkte": {
"s": 1.0,
"theta": 0.0,
"tau_g": 0.0,
"h": 1.0,
"r_d": 0.04,
"r_q": null,
"zeta": 1.0,
"skatt": false
},
"heleid_selskap": {
"s": 1.0,
"theta": 0.0,
"tau_g": 0.0,
"h": 0.5,
"r_d": 0.05,
"r_q": 0.1,
"zeta": 1.0,
"skatt": true
},
"majoritet_boers": {
"s": 0.6,
"theta": 0.0,
"tau_g": 0.0,
"h": 0.5,
"r_d": 0.05,
"r_q": 0.12,
"zeta": 1.0,
"skatt": true
},
"petroleumsmodell": {
"s": 0.6,
"theta": 0.25,
"tau_g": 0.5,
"h": 0.5,
"r_d": 0.05,
"r_q": 0.12,
"zeta": 1.0,
"skatt": true
}
},
"areal": {
"kjernekraft": 1e-07,
"vind_direkte": 1.5e-06,
"vind_plan": 3e-05,
"tomt": 0.001
},
"petroleum_median": 30000000000.0,
"bortfall": {
"kildenes lave forlop": [
0.12,
0.21
],
"80 % paa egne maskiner, lav": [
0.19,
0.38
],
"80 % paa egne maskiner, hoy": [
0.32,
0.64
]
},
"u_alt": {
"hoved": {
"2025": 0.4,
"2035": 0.2,
"2045": 0.1
},
"fast": {
"2025": 0.5
},
"null": {
"2025": 0.0
}
},
"kjoletaarn": {
"forbruk": [
2.0,
2.5,
3.0
],
"uttak": [
3.0,
4.0,
10.0
]
},
"Gamma_trinn": {
"A>=A*": 1.0,
"0.99<=A<A*": 0.9,
"0.95<=A<0.99": 0.7,
"A<0.95": 0.0
}
},
"trekninger": [
{"verdier": [57900.0, 0.36, 0.7, 6.2, 60.0, 157.0, 1.14, 1.12, 2300.0, 115.0, 0.052, 0.064, 0.05, 231.0, 2.59, 0.053], "u_eksport": [0.5043, 0.9431, 0.9729, 0.8014, 0.4878, 0.762, 0.3325, 0.7276, 0.1342, 0.1659, 0.8588, 0.0716, 0.4818, 0.7982, 0.3941, 0.787, 0.3138, 0.0499, 0.4396, 0.7371, 0.3518, 0.4664, 0.2862, 0.275, 0.0008, 0.1574, 0.1627, 0.6732, 0.8483, 0.076, 0.9734, 0.9751, 0.5132]},
{"verdier": [78600.0, 0.21, 0.61, 4.6, 1740.0, 226.0, 1.36, 1.48, 2510.0, 179.0, 0.069, 0.086, 0.071, 224.0, 2.05, -0.029], "u_eksport": [0.0185, 0.7075, 0.5489, 0.6001, 0.0073, 0.9308, 0.7652, 0.8806, 0.8502, 0.9721, 0.1353, 0.5295, 0.9733, 0.3111, 0.8985, 0.6433, 0.9562, 0.0019, 0.5797, 0.7467, 0.3942, 0.7901, 0.373, 0.0486, 0.7656, 0.1041, 0.2326, 0.7758, 0.1319, 0.3499, 0.8264, 0.0453, 0.8979]},
{"verdier": [133700.0, 0.21, 0.4, 7.3, 1910.0, 191.0, 1.29, 1.24, 4050.0, 217.0, 0.041, 0.052, 0.007, 141.0, 2.67, -0.006], "u_eksport": [0.6733, 0.3633, 0.3014, 0.5372, 0.523, 0.18, 0.645, 0.0481, 0.5515, 0.4712, 0.5917, 0.1582, 0.1013, 0.0629, 0.8867, 0.4287, 0.1133, 0.6058, 0.7175, 0.7102, 0.7064, 0.0589, 0.1655, 0.0811, 0.6935, 0.967, 0.2513, 0.6256, 0.9877, 0.4326, 0.5496, 0.1508, 0.623]},
{"verdier": [95900.0, 0.01, 0.26, 6.3, 630.0, 170.0, 1.28, 1.31, 3700.0, 118.0, 0.064, 0.071, 0.031, 197.0, 2.56, 0.087], "u_eksport": [0.871, 0.5508, 0.9323, 0.5818, 0.9034, 0.8959, 0.2833, 0.9646, 0.683, 0.8458, 0.2705, 0.7392, 0.6626, 0.6105, 0.1333, 0.4032, 0.0487, 0.6631, 0.9441, 0.6083, 0.5309, 0.1731, 0.3488, 0.7528, 0.531, 0.1321, 0.403, 0.4118, 0.1975, 0.7599, 0.9627, 0.4326, 0.7878]},
{"verdier": [97900.0, 0.78, 0.55, 6.8, 1670.0, 184.0, 1.34, 1.18, 3330.0, 183.0, 0.041, 0.073, 0.05, 169.0, 2.1, 0.003], "u_eksport": [0.7417, 0.0831, 0.7751, 0.8731, 0.3225, 0.5608, 0.8102, 0.8231, 0.5905, 0.094, 0.11, 0.2937, 0.9898, 0.2438, 0.8731, 0.9311, 0.893, 0.7312, 0.1821, 0.3693, 0.6614, 0.9384, 0.5429, 0.2991, 0.3047, 0.2837, 0.8311, 0.1662, 0.317, 0.9433, 0.1264, 0.6049, 0.0883]},
{"verdier": [62900.0, 0.68, 0.22, 7.5, 80.0, 203.0, 1.38, 1.32, 2370.0, 146.0, 0.041, 0.062, 0.085, 246.0, 2.32, 0.053], "u_eksport": [0.6328, 0.8278, 0.3638, 0.286, 0.5048, 0.3403, 0.2229, 0.4948, 0.9186, 0.5079, 0.006, 0.3508, 0.3105, 0.8871, 0.9823, 0.5344, 0.9621, 0.4587, 0.8542, 0.1354, 0.4512, 0.2806, 0.0884, 0.8688, 0.4578, 0.6256, 0.7322, 0.0242, 0.3343, 0.8798, 0.8277, 0.2736, 0.5407]},
{"verdier": [81800.0, 0.25, 0.4, 7.5, 190.0, 207.0, 1.26, 1.28, 3160.0, 101.0, 0.049, 0.052, 0.07, 147.0, 2.62, 0.08], "u_eksport": [0.5676, 0.6902, 0.6956, 0.0918, 0.4258, 0.0675, 0.925, 0.02, 0.6417, 0.9525, 0.9541, 0.3092, 0.977, 0.4002, 0.5321, 0.6808, 0.7908, 0.7173, 0.2453, 0.2847, 0.0962, 0.3488, 0.7164, 0.1707, 0.7129, 0.9331, 0.0071, 0.9785, 0.8432, 0.1525, 0.1337, 0.3355, 0.6718]},
{"verdier": [101400.0, 0.8, 0.74, 7.5, 1140.0, 229.0, 1.24, 1.29, 2730.0, 226.0, 0.063, 0.103, 0.01, 208.0, 2.68, 0.05], "u_eksport": [0.614, 0.4568, 0.8265, 0.094, 0.0322, 0.0509, 0.2998, 0.0619, 0.4196, 0.7856, 0.0775, 0.8933, 0.7267, 0.4068, 0.6081, 0.3803, 0.0053, 0.66, 0.8053, 0.3986, 0.3304, 0.5135, 0.4036, 0.1614, 0.0533, 0.5019, 0.4069, 0.7898, 0.8707, 0.3371, 0.6067, 0.3223, 0.2273]},
{"verdier": [101500.0, 0.2, 0.41, 7.4, 1770.0, 188.0, 1.18, 1.45, 2460.0, 198.0, 0.067, 0.069, 0.042, 230.0, 2.42, 0.057], "u_eksport": [0.4025, 0.4365, 0.768, 0.5823, 0.7492, 0.636, 0.7527, 0.2173, 0.7939, 0.219, 0.3796, 0.6186, 0.3292, 0.064, 0.1373, 0.7662, 0.6002, 0.3334, 0.9953, 0.9623, 0.1378, 0.858, 0.8002, 0.0957, 0.7922, 0.5655, 0.7484, 0.8914, 0.5677, 0.516, 0.637, 0.572, 0.248]},
{"verdier": [93200.0, 0.78, 0.77, 8.0, 780.0, 205.0, 1.33, 1.19, 3890.0, 117.0, 0.07, 0.102, 0.069, 195.0, 2.05, 0.021], "u_eksport": [0.3884, 0.0758, 0.2494, 0.5293, 0.699, 0.9624, 0.6764, 0.8961, 0.9776, 0.8867, 0.8201, 0.65, 0.3945, 0.7609, 0.238, 0.8528, 0.3993, 0.4952, 0.688, 0.3542, 0.6666, 0.9416, 0.9073, 0.8149, 0.4396, 0.8701, 0.0949, 0.6844, 0.4194, 0.8379, 0.3185, 0.2333, 0.2653]},
{"verdier": [122000.0, 0.25, 0.5, 5.4, 1940.0, 161.0, 1.32, 1.3, 3710.0, 112.0, 0.074, 0.112, 0.08, 227.0, 2.23, -0.003], "u_eksport": [0.4157, 0.8147, 0.9522, 0.8192, 0.0701, 0.774, 0.3382, 0.8789, 0.0522, 0.2391, 0.4346, 0.7755, 0.1461, 0.8462, 0.4503, 0.8989, 0.0504, 0.1829, 0.6941, 0.5717, 0.0517, 0.2783, 0.4348, 0.0761, 0.6696, 0.9923, 0.606, 0.3037, 0.4353, 0.9281, 0.4657, 0.4784, 0.6339]},
{"verdier": [109100.0, 0.94, 0.73, 6.4, 1180.0, 167.0, 1.29, 1.24, 2290.0, 200.0, 0.045, 0.079, 0.001, 196.0, 2.41, 0.019], "u_eksport": [0.5669, 0.275, 0.0133, 0.0853, 0.1547, 0.8995, 0.2444, 0.5551, 0.4252, 0.0584, 0.8323, 0.6907, 0.8572, 0.4034, 0.3784, 0.3673, 0.6081, 0.3286, 0.5253, 0.8624, 0.71, 0.0471, 0.9705, 0.5006, 0.5258, 0.464, 0.2663, 0.9406, 0.0948, 0.2527, 0.4269, 0.2998, 0.3873]},
{"verdier": [122500.0, 0.73, 0.4, 7.2, 1830.0, 219.0, 1.2, 1.12, 3420.0, 164.0, 0.041, 0.067, 0.019, 286.0, 2.78, 0.075], "u_eksport": [0.743, 0.0814, 0.1348, 0.8294, 0.524, 0.769, 0.9828, 0.4122, 0.179, 0.9173, 0.4348, 0.1302, 0.384, 0.1548, 0.5919, 0.4517, 0.011, 0.411, 0.6725, 0.5796, 0.5125, 0.1206, 0.7731, 0.3737, 0.3123, 0.7187, 0.2144, 0.8214, 0.5122, 0.7999, 0.2782, 0.7903, 0.988]},
{"verdier": [84000.0, 0.67, 0.73, 7.8, 1520.0, 223.0, 1.24, 1.48, 2710.0, 116.0, 0.07, 0.106, 0.001, 183.0, 2.55, 0.098], "u_eksport": [0.5148, 0.7886, 0.2764, 0.1598, 0.0131, 0.8905, 0.1383, 0.1386, 0.6131, 0.544, 0.0219, 0.2554, 0.7797, 0.9912, 0.4039, 0.5708, 0.4957, 0.2472, 0.7398, 0.3152, 0.2428, 0.1953, 0.5924, 0.269, 0.8844, 0.6619, 0.6279, 0.0778, 0.8732, 0.9557, 0.6199, 0.8016, 0.9679]},
{"verdier": [64200.0, 0.96, 0.67, 4.0, 1370.0, 170.0, 1.15, 1.31, 4060.0, 129.0, 0.045, 0.062, 0.032, 252.0, 2.35, 0.081], "u_eksport": [0.642, 0.0182, 0.6659, 0.7622, 0.0367, 0.2046, 0.7453, 0.7756, 0.8193, 0.5744, 0.3281, 0.2025, 0.2612, 0.2333, 0.6455, 0.9337, 0.5762, 0.001, 0.8343, 0.3465, 0.3687, 0.9821, 0.1388, 0.796, 0.6289, 0.2275, 0.0733, 0.581, 0.3567, 0.0862, 0.8761, 0.518, 0.6671]},
{"verdier": [102200.0, 0.38, 0.39, 3.6, 590.0, 182.0, 1.27, 1.35, 3250.0, 130.0, 0.065, 0.075, 0.024, 170.0, 2.5, 0.029], "u_eksport": [0.0412, 0.1043, 0.9746, 0.5305, 0.8796, 0.8124, 0.4179, 0.7212, 0.0078, 0.5927, 0.3683, 0.6423, 0.7243, 0.3198, 0.3236, 0.9778, 0.3987, 0.2173, 0.0699, 0.5232, 0.7418, 0.567, 0.9171, 0.6002, 0.3498, 0.9655, 0.1763, 0.0671, 0.2363, 0.6616, 0.4018, 0.3081, 0.0188]},
{"verdier": [63300.0, 0.06, 0.7, 6.8, 980.0, 237.0, 1.12, 1.21, 2970.0, 181.0, 0.07, 0.086, 0.004, 207.0, 2.66, 0.092], "u_eksport": [0.3941, 0.8544, 0.3538, 0.183, 0.6258, 0.5585, 0.6804, 0.0588, 0.0584, 0.6668, 0.1414, 0.2122, 0.1993, 0.7409, 0.7363, 0.7968, 0.9422, 0.1885, 0.3503, 0.5378, 0.6909, 0.8682, 0.8403, 0.0535, 0.0599, 0.4989, 0.1632, 0.6935, 0.3651, 0.8659, 0.8284, 0.9854, 0.2669]},
{"verdier": [82900.0, 0.41, 0.22, 3.6, 350.0, 188.0, 1.32, 1.24, 3470.0, 208.0, 0.045, 0.084, 0.076, 151.0, 2.38, 0.061], "u_eksport": [0.7975, 0.5676, 0.9706, 0.3594, 0.203, 0.013, 0.1114, 0.3051, 0.6575, 0.7259, 0.0492, 0.7364, 0.0888, 0.0986, 0.3892, 0.7743, 0.0838, 0.2994, 0.6518, 0.3788, 0.7424, 0.5034, 0.8795, 0.4285, 0.6138, 0.6689, 0.5888, 0.1411, 0.2121, 0.7191, 0.3777, 0.2923, 0.3205]},
{"verdier": [109500.0, 0.5, 0.79, 3.0, 840.0, 243.0, 1.24, 1.26, 2920.0, 154.0, 0.076, 0.087, 0.089, 240.0, 2.12, 0.008], "u_eksport": [0.7231, 0.6291, 0.3514, 0.54, 0.133, 0.9692, 0.6914, 0.9858, 0.4248, 0.7996, 0.7352, 0.7167, 0.501, 0.2502, 0.8723, 0.5658, 0.4412, 0.1681, 0.6375, 0.4364, 0.2037, 0.3854, 0.8211, 0.5762, 0.0349, 0.0579, 0.6271, 0.8459, 0.8992, 0.312, 0.3422, 0.9926, 0.5621]},
{"verdier": [76600.0, 0.05, 0.34, 3.7, 1470.0, 245.0, 1.29, 1.11, 2500.0, 150.0, 0.072, 0.078, 0.061, 102.0, 2.57, 0.089], "u_eksport": [0.7961, 0.8246, 0.7296, 0.4641, 0.3129, 0.3876, 0.9122, 0.6013, 0.6516, 0.531, 0.1672, 0.4336, 0.876, 0.7545, 0.5902, 0.9172, 0.5768, 0.6742, 0.9358, 0.797, 0.3224, 0.8273, 0.3691, 0.5562, 0.5832, 0.1563, 0.9982, 0.1624, 0.3984, 0.1842, 0.2281, 0.9632, 0.5005]},
{"verdier": [106100.0, 0.07, 0.25, 5.9, 660.0, 155.0, 1.34, 1.49, 3350.0, 148.0, 0.052, 0.076, 0.038, 223.0, 2.32, -0.008], "u_eksport": [0.5999, 0.4491, 0.3303, 0.6435, 0.844, 0.7952, 0.4713, 0.8389, 0.3627, 0.2097, 0.7066, 0.1192, 0.9072, 0.8594, 0.0012, 0.4933, 0.3125, 0.1932, 0.6768, 0.6052, 0.4135, 0.5676, 0.0246, 0.8243, 0.5155, 0.1333, 0.7105, 0.9691, 0.0478, 0.8304, 0.1541, 0.078, 0.656]},
{"verdier": [115600.0, 0.95, 0.22, 7.7, 1620.0, 207.0, 1.21, 1.12, 3280.0, 196.0, 0.063, 0.088, 0.004, 191.0, 2.27, 0.096], "u_eksport": [0.5625, 0.5066, 0.0394, 0.3112, 0.253, 0.5873, 0.9535, 0.207, 0.8921, 0.4445, 0.7387, 0.6377, 0.5488, 0.2366, 0.793, 0.292, 0.786, 0.8818, 0.6363, 0.3126, 0.092, 0.6204, 0.5156, 0.1683, 0.8159, 0.4202, 0.9161, 0.6364, 0.6461, 0.2423, 0.4226, 0.7585, 0.8071]},
{"verdier": [89800.0, 0.95, 0.67, 8.0, 530.0, 204.0, 1.31, 1.2, 2420.0, 144.0, 0.057, 0.094, 0.066, 265.0, 2.32, 0.069], "u_eksport": [0.183, 0.4667, 0.1465, 0.7727, 0.2839, 0.7436, 0.9207, 0.8769, 0.0094, 0.6859, 0.3542, 0.9827, 0.1957, 0.1608, 0.8983, 0.2671, 0.5463, 0.2837, 0.9017, 0.2992, 0.7931, 0.4264, 0.0216, 0.0928, 0.6099, 0.2733, 0.6172, 0.6777, 0.5538, 0.1086, 0.4973, 0.3719, 0.1206]},
{"verdier": [66500.0, 0.71, 0.29, 6.4, 1490.0, 151.0, 1.25, 1.3, 3570.0, 191.0, 0.052, 0.089, 0.039, 285.0, 2.63, 0.091], "u_eksport": [0.6684, 0.4418, 0.539, 0.3073, 0.119, 0.2711, 0.1212, 0.3181, 0.8687, 0.6036, 0.6786, 0.0427, 0.6706, 0.4149, 0.9664, 0.9477, 0.1081, 0.2933, 0.7263, 0.1435, 0.3069, 0.8042, 0.9756, 0.0272, 0.4587, 0.0732, 0.4719, 0.5303, 0.6842, 0.4927, 0.0062, 0.3187, 0.1787]},
{"verdier": [119800.0, 0.5, 0.44, 3.0, 280.0, 162.0, 1.27, 1.19, 2210.0, 133.0, 0.046, 0.076, 0.069, 149.0, 2.6, 0.054], "u_eksport": [0.1576, 0.5402, 0.5447, 0.3704, 0.2561, 0.4647, 0.7172, 0.1745, 0.8481, 0.9966, 0.509, 0.8306, 0.0057, 0.9286, 0.5394, 0.4848, 0.4934, 0.5187, 0.6379, 0.51, 0.5533, 0.7553, 0.1061, 0.6801, 0.4823, 0.3573, 0.4709, 0.7203, 0.7088, 0.496, 0.8481, 0.0528, 0.8006]},
{"verdier": [56600.0, 0.14, 0.4, 3.8, 1010.0, 248.0, 1.2, 1.11, 2320.0, 130.0, 0.074, 0.09, 0.058, 158.0, 2.14, 0.019], "u_eksport": [0.4672, 0.1611, 0.6073, 0.3992, 0.2132, 0.0942, 0.2151, 0.0247, 0.8676, 0.0173, 0.6249, 0.498, 0.185, 0.7119, 0.6516, 0.4214, 0.2359, 0.5031, 0.2701, 0.9105, 0.7841, 0.7735, 0.2835, 0.6819, 0.0292, 0.2133, 0.4971, 0.4024, 0.0505, 0.295, 0.0319, 0.524, 0.5879]},
{"verdier": [115900.0, 0.94, 0.55, 7.0, 1250.0, 186.0, 1.37, 1.27, 3070.0, 157.0, 0.077, 0.113, 0.048, 119.0, 2.72, -0.017], "u_eksport": [0.0803, 0.596, 0.1846, 0.6701, 0.8642, 0.4597, 0.0594, 0.3822, 0.2907, 0.7817, 0.7729, 0.1472, 0.2119, 0.8814, 0.9479, 0.1012, 0.8937, 0.6865, 0.521, 0.7247, 0.2324, 0.5837, 0.8196, 0.6916, 0.92, 0.5048, 0.2477, 0.5225, 0.1671, 0.7533, 0.8095, 0.0325, 0.2214]},
{"verdier": [117300.0, 0.71, 0.58, 5.0, 1810.0, 220.0, 1.18, 1.15, 4050.0, 184.0, 0.066, 0.072, 0.07, 258.0, 2.22, 0.057], "u_eksport": [0.1402, 0.1459, 0.4559, 0.7095, 0.3749, 0.3133, 0.5456, 0.6944, 0.4325, 0.0085, 0.8685, 0.6975, 0.3571, 0.181, 0.3758, 0.9871, 0.6827, 0.4845, 0.7912, 0.4339, 0.5458, 0.746, 0.9638, 0.1152, 0.3681, 0.9593, 0.6438, 0.1298, 0.5463, 0.6384, 0.2562, 0.0268, 0.2315]},
{"verdier": [69900.0, 0.83, 0.71, 5.3, 860.0, 226.0, 1.21, 1.36, 4050.0, 109.0, 0.042, 0.074, 0.085, 238.0, 2.41, 0.049], "u_eksport": [0.843, 0.6869, 0.3462, 0.5152, 0.6497, 0.2359, 0.7252, 0.7733, 0.0157, 0.0778, 0.3391, 0.2782, 0.195, 0.7234, 0.2999, 0.5924, 0.7859, 0.8836, 0.6173, 0.876, 0.0586, 0.6035, 0.3906, 0.5383, 0.8241, 0.3581, 0.0777, 0.975, 0.6828, 0.6618, 0.5198, 0.6635, 0.9487]},
{"verdier": [126300.0, 0.98, 0.52, 6.2, 220.0, 203.0, 1.27, 1.35, 3230.0, 179.0, 0.066, 0.101, 0.071, 209.0, 2.54, 0.082], "u_eksport": [0.7177, 0.5408, 0.9479, 0.9272, 0.2438, 0.3104, 0.7563, 0.7717, 0.0091, 0.3773, 0.8173, 0.5239, 0.5607, 0.6413, 0.5777, 0.8137, 0.3148, 0.8182, 0.2249, 0.7472, 0.4635, 0.7743, 0.8486, 0.3744, 0.7186, 0.1566, 0.7782, 0.824, 0.782, 0.9518, 0.3542, 0.8963, 0.6384]},
{"verdier": [87000.0, 0.25, 0.67, 6.0, 1410.0, 183.0, 1.2, 1.35, 3980.0, 212.0, 0.072, 0.091, 0.042, 131.0, 2.3, 0.08], "u_eksport": [0.5654, 0.9153, 0.6634, 0.5975, 0.3168, 0.129, 0.1604, 0.8959, 0.2479, 0.3004, 0.0845, 0.898, 0.8339, 0.8783, 0.2015, 0.9678, 0.8081, 0.8957, 0.0258, 0.2461, 0.835, 0.3342, 0.1686, 0.9605, 0.3201, 0.3886, 0.9176, 0.2882, 0.3012, 0.6996, 0.8824, 0.778, 0.3953]},
{"verdier": [106600.0, 0.52, 0.28, 6.4, 510.0, 204.0, 1.38, 1.16, 3840.0, 153.0, 0.058, 0.076, 0.007, 101.0, 2.1, -0.002], "u_eksport": [0.9489, 0.6283, 0.4952, 0.3876, 0.5306, 0.4082, 0.6543, 0.4479, 0.3517, 0.1815, 0.8989, 0.7124, 0.422, 0.7725, 0.6655, 0.8388, 0.3449, 0.2305, 0.5754, 0.5746, 0.2066, 0.7775, 0.2735, 0.1342, 0.8008, 0.0739, 0.5986, 0.9164, 0.4762, 0.8405, 0.8313, 0.15, 0.0964]},
{"verdier": [76200.0, 0.9, 0.52, 5.2, 1090.0, 246.0, 1.12, 1.35, 2950.0, 106.0, 0.068, 0.072, 0.064, 125.0, 2.23, -0.012], "u_eksport": [0.7676, 0.7616, 0.8457, 0.1362, 0.7018, 0.6742, 0.1575, 0.3571, 0.6614, 0.2492, 0.4401, 0.9967, 0.367, 0.6116, 0.5753, 0.3194, 0.4369, 0.4519, 0.8519, 0.3831, 0.1067, 0.599, 0.1287, 0.5662, 0.7263, 0.8488, 0.2793, 0.7933, 0.908, 0.4706, 0.6776, 0.1608, 0.807]},
{"verdier": [118300.0, 0.25, 0.77, 4.1, 1850.0, 154.0, 1.29, 1.1, 3940.0, 109.0, 0.056, 0.088, 0.042, 187.0, 2.34, -0.047], "u_eksport": [0.1706, 0.3082, 0.3828, 0.7291, 0.3549, 0.5266, 0.0366, 0.1866, 0.241, 0.8312, 0.92, 0.9885, 0.6493, 0.8453, 0.2266, 0.1233, 0.7865, 0.3916, 0.1146, 0.0332, 0.9251, 0.2149, 0.1395, 0.6305, 0.5433, 0.2467, 0.6318, 0.0096, 0.3544, 0.9626, 0.4025, 0.5106, 0.1652]},
{"verdier": [77500.0, 0.88, 0.65, 4.5, 150.0, 231.0, 1.14, 1.48, 2660.0, 190.0, 0.049, 0.066, 0.049, 202.0, 2.23, 0.038], "u_eksport": [0.9198, 0.918, 0.2948, 0.6634, 0.9536, 0.4168, 0.8601, 0.305, 0.7558, 0.9256, 0.9719, 0.7669, 0.1195, 0.7174, 0.8474, 0.7192, 0.6612, 0.6971, 0.7008, 0.0381, 0.1124, 0.0498, 0.2994, 0.2937, 0.4735, 0.6245, 0.4441, 0.48, 0.5781, 0.2141, 0.4072, 0.4048, 0.0166]},
{"verdier": [59800.0, 0.15, 0.44, 4.3, 1650.0, 187.0, 1.26, 1.48, 2420.0, 138.0, 0.043, 0.062, 0.013, 300.0, 2.44, 0.043], "u_eksport": [0.5336, 0.8922, 0.9276, 0.7554, 0.7373, 0.8316, 0.424, 0.3317, 0.7935, 0.9249, 0.9059, 0.647, 0.479, 0.3866, 0.1335, 0.568, 0.829, 0.4422, 0.081, 0.9114, 0.2561, 0.761, 0.6722, 0.362, 0.4825, 0.0701, 0.0589, 0.4814, 0.581, 0.5695, 0.4825, 0.3443, 0.8395]},
{"verdier": [57800.0, 0.61, 0.24, 8.0, 1300.0, 245.0, 1.28, 1.45, 4080.0, 140.0, 0.047, 0.063, 0.078, 184.0, 2.6, -0.033], "u_eksport": [0.6066, 0.8824, 0.5781, 0.7914, 0.5973, 0.683, 0.4899, 0.6487, 0.2745, 0.402, 0.904, 0.8205, 0.5743, 0.4735, 0.9287, 0.2805, 0.8874, 0.2086, 0.177, 0.6403, 0.1481, 0.0853, 0.5184, 0.7181, 0.004, 0.1755, 0.167, 0.0725, 0.2469, 0.6986, 0.6287, 0.3446, 0.0852]},
{"verdier": [62400.0, 0.97, 0.75, 6.1, 1580.0, 229.0, 1.39, 1.42, 3480.0, 180.0, 0.044, 0.062, 0.035, 162.0, 2.46, -0.014], "u_eksport": [0.9994, 0.8166, 0.2508, 0.0079, 0.4833, 0.5314, 0.8301, 0.2519, 0.455, 0.2001, 0.5607, 0.4683, 0.4342, 0.6035, 0.5327, 0.4185, 0.1369, 0.5857, 0.3223, 0.7416, 0.6683, 0.0141, 0.9113, 0.5559, 0.5254, 0.9518, 0.3085, 0.2959, 0.1371, 0.0086, 0.0065, 0.2936, 0.0391]},
{"verdier": [70600.0, 0.05, 0.79, 3.7, 870.0, 202.0, 1.14, 1.4, 4100.0, 227.0, 0.068, 0.102, 0.077, 149.0, 2.73, 0.073], "u_eksport": [0.2892, 0.005, 0.5159, 0.3125, 0.828, 0.0562, 0.1281, 0.6857, 0.1745, 0.4749, 0.721, 0.0874, 0.1177, 0.1864, 0.5398, 0.2817, 0.7906, 0.4618, 0.5231, 0.0421, 0.3611, 0.2274, 0.4822, 0.8651, 0.491, 0.2728, 0.697, 0.4035, 0.3865, 0.2294, 0.1755, 0.6405, 0.0864]},
{"verdier": [115300.0, 0.31, 0.24, 5.0, 540.0, 250.0, 1.16, 1.26, 2240.0, 147.0, 0.043, 0.059, 0.095, 120.0, 2.14, -0.034], "u_eksport": [0.7787, 0.4423, 0.5517, 0.7408, 0.1463, 0.1922, 0.9021, 0.2947, 0.7004, 0.3623, 0.6315, 0.8075, 0.2992, 0.6693, 0.8655, 0.4976, 0.9376, 0.9557, 0.5337, 0.8875, 0.7435, 0.3576, 0.4776, 0.3869, 0.4493, 0.4142, 0.3304, 0.3069, 0.9285, 0.4241, 0.3288, 0.5086, 0.0161]},
{"verdier": [109700.0, 0.85, 0.68, 3.4, 990.0, 238.0, 1.22, 1.37, 4090.0, 206.0, 0.077, 0.078, 0.011, 123.0, 2.6, -0.028], "u_eksport": [0.8428, 0.5649, 0.1802, 0.6325, 0.865, 0.4368, 0.8852, 0.9357, 0.7186, 0.4766, 0.5338, 0.5271, 0.4066, 0.9764, 0.3548, 0.7221, 0.3093, 0.8462, 0.9332, 0.3337, 0.2893, 0.4928, 0.5988, 0.6624, 0.0696, 0.9574, 0.2217, 0.6758, 0.1051, 0.3913, 0.7663, 0.3929, 0.0307]},
{"verdier": [139100.0, 0.8, 0.48, 7.3, 1600.0, 228.0, 1.1, 1.16, 2500.0, 198.0, 0.052, 0.092, 0.078, 254.0, 2.11, -0.022], "u_eksport": [0.2139, 0.8406, 0.2803, 0.1571, 0.2412, 0.1761, 0.0908, 0.0995, 0.752, 0.1286, 0.2012, 0.9782, 0.4815, 0.8479, 0.1247, 0.9189, 0.04, 0.3017, 0.5737, 0.6544, 0.1813, 0.9245, 0.6453, 0.5233, 0.7279, 0.7283, 0.8048, 0.4619, 0.4415, 0.6563, 0.387, 0.2414, 0.9591]},
{"verdier": [103700.0, 0.88, 0.75, 3.6, 120.0, 177.0, 1.1, 1.27, 3200.0, 168.0, 0.044, 0.076, 0.047, 240.0, 2.4, 0.045], "u_eksport": [0.101, 0.3423, 0.8302, 0.9673, 0.0162, 0.811, 0.8502, 0.5924, 0.884, 0.6814, 0.9386, 0.6074, 0.132, 0.2772, 0.9026, 0.1055, 0.163, 0.6436, 0.0141, 0.0573, 0.8316, 0.274, 0.0999, 0.6453, 0.8209, 0.0125, 0.8335, 0.9115, 0.8831, 0.3479, 0.9102, 0.8534, 0.3662]},
{"verdier": [107400.0, 0.63, 0.53, 7.1, 90.0, 153.0, 1.16, 1.34, 3500.0, 164.0, 0.046, 0.055, 0.084, 232.0, 2.45, -0.004], "u_eksport": [0.1588, 0.4563, 0.3996, 0.9043, 0.83, 0.1263, 0.0308, 0.6488, 0.9322, 0.4947, 0.5767, 0.5688, 0.9219, 0.5602, 0.1052, 0.7505, 0.8538, 0.0913, 0.0769, 0.0318, 0.9576, 0.6494, 0.746, 0.8028, 0.4173, 0.675, 0.5954, 0.1105, 0.0025, 0.7548, 0.6361, 0.4758, 0.4067]},
{"verdier": [93300.0, 0.9, 0.74, 5.2, 330.0, 152.0, 1.16, 1.24, 4170.0, 109.0, 0.052, 0.064, 0.071, 267.0, 2.28, 0.099], "u_eksport": [0.4052, 0.6372, 0.3689, 0.84, 0.6607, 0.1869, 0.198, 0.9314, 0.543, 0.1322, 0.5679, 0.1177, 0.4316, 0.3374, 0.421, 0.146, 0.3609, 0.8278, 0.8023, 0.0986, 0.6827, 0.7861, 0.2434, 0.7489, 0.8245, 0.0775, 0.8749, 0.5361, 0.3453, 0.9798, 0.2436, 0.4028, 0.3427]},
{"verdier": [127900.0, 0.13, 0.51, 5.3, 1300.0, 239.0, 1.18, 1.12, 4020.0, 146.0, 0.065, 0.084, 0.002, 288.0, 2.01, 0.06], "u_eksport": [0.607, 0.3771, 0.3668, 0.5226, 0.3182, 0.7964, 0.6341, 0.9384, 0.9096, 0.7944, 0.4615, 0.7052, 0.8394, 0.3221, 0.4055, 0.9835, 0.4808, 0.1797, 0.2021, 0.7818, 0.6919, 0.0474, 0.4375, 0.3738, 0.5158, 0.9815, 0.0576, 0.5011, 0.0868, 0.185, 0.0884, 0.6927, 0.1942]},
{"verdier": [102600.0, 0.99, 0.31, 8.0, 680.0, 233.0, 1.23, 1.49, 2280.0, 121.0, 0.074, 0.076, 0.014, 209.0, 2.43, 0.084], "u_eksport": [0.2091, 0.9106, 0.7467, 0.622, 0.0799, 0.5343, 0.7723, 0.6685, 0.976, 0.4962, 0.1461, 0.323, 0.7415, 0.266, 0.1504, 0.4338, 0.3892, 0.4584, 0.1339, 0.8875, 0.0855, 0.7838, 0.6002, 0.0578, 0.187, 0.6157, 0.0011, 0.8986, 0.5099, 0.4219, 0.4526, 0.667, 0.3114]},
{"verdier": [73000.0, 0.87, 0.66, 3.4, 140.0, 198.0, 1.28, 1.34, 3570.0, 112.0, 0.041, 0.078, 0.035, 235.0, 2.57, -0.016], "u_eksport": [0.8886, 0.568, 0.2533, 0.3742, 0.4472, 0.2796, 0.509, 0.6607, 0.5147, 0.1249, 0.5327, 0.5373, 0.7827, 0.7664, 0.0598, 0.4991, 0.5622, 0.3327, 0.7865, 0.2647, 0.2556, 0.2361, 0.7074, 0.1331, 0.661, 0.084, 0.3542, 0.8383, 0.2659, 0.9093, 0.6927, 0.6767, 0.01]},
{"verdier": [125000.0, 1.0, 0.64, 6.8, 1180.0, 165.0, 1.15, 1.23, 3300.0, 168.0, 0.064, 0.094, 0.05, 292.0, 2.08, 0.007], "u_eksport": [0.4885, 0.3546, 0.529, 0.5691, 0.7105, 0.5511, 0.221, 0.6716, 0.2096, 0.064, 0.0003, 0.7685, 0.2911, 0.4406, 0.0687, 0.2328, 0.5108, 0.3509, 0.3828, 0.9389, 0.3653, 0.3419, 0.8385, 0.1737, 0.2962, 0.3548, 0.3828, 0.9017, 0.7502, 0.9036, 0.6953, 0.0063, 0.0637]},
{"verdier": [54000.0, 0.43, 0.59, 4.4, 1800.0, 214.0, 1.24, 1.37, 3610.0, 143.0, 0.064, 0.102, 0.015, 138.0, 2.37, 0.064], "u_eksport": [0.5308, 0.8515, 0.2919, 0.9796, 0.0668, 0.2192, 0.9223, 0.3206, 0.5595, 0.5745, 0.4773, 0.7853, 0.5445, 0.7233, 0.6452, 0.617, 0.9514, 0.3735, 0.1335, 0.0049, 0.1202, 0.0672, 0.3458, 0.7998, 0.6499, 0.1067, 0.1691, 0.2107, 0.4417, 0.623, 0.9403, 0.3102, 0.2283]},
{"verdier": [73500.0, 0.97, 0.28, 7.4, 330.0, 154.0, 1.13, 1.2, 2300.0, 162.0, 0.074, 0.091, 0.061, 279.0, 2.41, 0.006], "u_eksport": [0.1464, 0.9827, 0.0733, 0.9378, 0.035, 0.0131, 0.9878, 0.1302, 0.3276, 0.1257, 0.3133, 0.9485, 0.6294, 0.0844, 0.2288, 0.5247, 0.9291, 0.2091, 0.2239, 0.1933, 0.0999, 0.6727, 0.1528, 0.2936, 0.2121, 0.0246, 0.8008, 0.2888, 0.2588, 0.0686, 0.2435, 0.9006, 0.645]},
{"verdier": [81800.0, 0.55, 0.46, 4.4, 1250.0, 230.0, 1.31, 1.21, 3770.0, 164.0, 0.07, 0.078, 0.073, 203.0, 2.59, 0.073], "u_eksport": [0.5561, 0.6695, 0.6634, 0.3782, 0.0721, 0.3867, 0.8675, 0.0639, 0.4013, 0.2165, 0.0334, 0.3187, 0.6516, 0.9129, 0.0343, 0.4992, 0.1915, 0.2259, 0.2819, 0.6561, 0.8448, 0.5493, 0.9039, 0.8795, 0.0282, 0.9146, 0.1627, 0.0846, 0.7384, 0.7372, 0.6418, 0.1074, 0.5501]},
{"verdier": [79300.0, 0.91, 0.61, 6.6, 1870.0, 182.0, 1.29, 1.39, 3330.0, 181.0, 0.068, 0.095, 0.065, 175.0, 2.74, 0.017], "u_eksport": [0.3765, 0.8648, 0.894, 0.3393, 0.9046, 0.3399, 0.0992, 0.1801, 0.973, 0.7589, 0.6621, 0.0984, 0.2819, 0.377, 0.4858, 0.6379, 0.5273, 0.3133, 0.9663, 0.1169, 0.4981, 0.5679, 0.8448, 0.2609, 0.4213, 0.1046, 0.5824, 0.0698, 0.7097, 0.7737, 0.0277, 0.214, 0.2935]},
{"verdier": [114900.0, 0.46, 0.46, 6.2, 1260.0, 219.0, 1.11, 1.32, 3220.0, 147.0, 0.061, 0.066, 0.05, 283.0, 2.39, -0.01], "u_eksport": [0.7382, 0.06, 0.3295, 0.2212, 0.018, 0.218, 0.7288, 0.1035, 0.7215, 0.151, 0.0162, 0.0267, 0.0859, 0.7446, 0.7691, 0.5398, 0.5625, 0.2245, 0.1592, 0.2749, 0.7057, 0.0078, 0.6757, 0.6419, 0.3564, 0.7241, 0.8829, 0.2267, 0.6328, 0.3315, 0.0705, 0.8486, 0.8103]},
{"verdier": [134600.0, 0.4, 0.55, 4.4, 780.0, 163.0, 1.28, 1.12, 4160.0, 112.0, 0.069, 0.106, 0.049, 110.0, 2.1, -0.04], "u_eksport": [0.4891, 0.9103, 0.2061, 0.9452, 0.953, 0.6443, 0.7373, 0.4341, 0.8858, 0.6839, 0.0251, 0.1346, 0.733, 0.7095, 0.1189, 0.1309, 0.8739, 0.4182, 0.6719, 0.9184, 0.3095, 0.2446, 0.3626, 0.3545, 0.1091, 0.5272, 0.6498, 0.406, 0.6944, 0.7949, 0.7495, 0.1674, 0.1002]},
{"verdier": [121600.0, 0.65, 0.57, 3.9, 1990.0, 173.0, 1.38, 1.2, 3370.0, 156.0, 0.079, 0.098, 0.017, 170.0, 2.06, 0.055], "u_eksport": [0.1592, 0.6827, 0.8206, 0.796, 0.5146, 0.8383, 0.2726, 0.0753, 0.9862, 0.8351, 0.7691, 0.1845, 0.9335, 0.0383, 0.1418, 0.9502, 0.8694, 0.7055, 0.2427, 0.4774, 0.5082, 0.2424, 0.1725, 0.8827, 0.2881, 0.3386, 0.0549, 0.7919, 0.8558, 0.8571, 0.5978, 0.1949, 0.7008]},
{"verdier": [74500.0, 0.08, 0.32, 4.8, 1500.0, 218.0, 1.3, 1.25, 2410.0, 161.0, 0.066, 0.08, 0.076, 160.0, 2.22, 0.095], "u_eksport": [0.4841, 0.4298, 0.4623, 0.3747, 0.6476, 0.9479, 0.8233, 0.9267, 0.0884, 0.8141, 0.1649, 0.2843, 0.461, 0.8589, 0.2431, 0.4941, 0.2141, 0.322, 0.8726, 0.623, 0.9662, 0.5113, 0.9601, 0.6098, 0.1769, 0.0428, 0.2104, 0.4485, 0.3813, 0.2015, 0.7176, 0.5906, 0.0258]},
{"verdier": [85500.0, 0.85, 0.27, 5.6, 930.0, 238.0, 1.15, 1.25, 2630.0, 213.0, 0.079, 0.092, 0.002, 136.0, 2.56, 0.057], "u_eksport": [0.3116, 0.2493, 0.8992, 0.5443, 0.6492, 0.3948, 0.7635, 0.1759, 0.3361, 0.7889, 0.0421, 0.8249, 0.2814, 0.8375, 0.3262, 0.6742, 0.5929, 0.8174, 0.0491, 0.5866, 0.4091, 0.8754, 0.636, 0.4351, 0.3852, 0.7489, 0.9387, 0.991, 0.1795, 0.3549, 0.3326, 0.0891, 0.4472]},
{"verdier": [67100.0, 0.65, 0.76, 6.4, 1450.0, 178.0, 1.37, 1.35, 2810.0, 195.0, 0.067, 0.081, 0.009, 286.0, 2.13, -0.029], "u_eksport": [0.8967, 0.269, 0.6342, 0.5492, 0.886, 0.7635, 0.2492, 0.9739, 0.5023, 0.1715, 0.1505, 0.7874, 0.8704, 0.4911, 0.8579, 0.2662, 0.2358, 0.241, 0.1001, 0.9829, 0.6526, 0.9086, 0.2267, 0.4933, 0.7024, 0.1466, 0.2021, 0.7848, 0.1535, 0.9349, 0.2444, 0.1909, 0.0911]},
{"verdier": [129500.0, 0.47, 0.52, 7.1, 560.0, 181.0, 1.36, 1.27, 3910.0, 132.0, 0.051, 0.08, 0.046, 103.0, 2.18, 0.057], "u_eksport": [0.6109, 0.3353, 0.4032, 0.8333, 0.5533, 0.9384, 0.2725, 0.6449, 0.9841, 0.7874, 0.4631, 0.1588, 0.7512, 0.5978, 0.5412, 0.225, 0.2728, 0.9146, 0.9239, 0.0959, 0.2063, 0.1081, 0.1023, 0.2961, 0.5496, 0.472, 0.9025, 0.5285, 0.1463, 0.7714, 0.7231, 0.3837, 0.8308]},
{"verdier": [133200.0, 0.85, 0.23, 4.9, 230.0, 246.0, 1.3, 1.21, 3570.0, 183.0, 0.048, 0.085, 0.087, 233.0, 2.59, -0.03], "u_eksport": [0.1192, 0.5939, 0.1074, 0.1221, 0.9709, 0.1536, 0.0746, 0.7586, 0.1105, 0.4211, 0.6764, 0.6822, 0.9298, 0.341, 0.5205, 0.0949, 0.2596, 0.6556, 0.3301, 0.8083, 0.3417, 0.9984, 0.0688, 0.7529, 0.049, 0.2202, 0.7931, 0.1356, 0.9278, 0.5047, 0.0521, 0.5741, 0.3804]},
{"verdier": [78900.0, 0.08, 0.46, 7.8, 1730.0, 177.0, 1.27, 1.13, 2260.0, 167.0, 0.045, 0.05, 0.085, 267.0, 2.58, 0.092], "u_eksport": [0.7759, 0.7487, 0.9966, 0.5791, 0.0293, 0.0459, 0.2398, 0.276, 0.6784, 0.7222, 0.0411, 0.2296, 0.9663, 0.4429, 0.0747, 0.0665, 0.4927, 0.0285, 0.1536, 0.2919, 0.331, 0.7003, 0.8954, 0.8858, 0.3269, 0.1015, 0.9304, 0.328, 0.1627, 0.3238, 0.6116, 0.7779, 0.6324]},
{"verdier": [80600.0, 0.12, 0.63, 8.0, 1020.0, 235.0, 1.38, 1.25, 2430.0, 115.0, 0.068, 0.091, 0.013, 290.0, 2.7, -0.001], "u_eksport": [0.9822, 0.8884, 0.7127, 0.7418, 0.946, 0.0388, 0.487, 0.009, 0.0693, 0.9838, 0.3349, 0.7146, 0.2256, 0.7025, 0.0603, 0.2497, 0.4715, 0.9126, 0.9832, 0.7241, 0.0744, 0.7753, 0.4743, 0.1963, 0.7595, 0.5313, 0.8899, 0.7063, 0.0523, 0.6191, 0.6812, 0.4188, 0.7905]},
{"verdier": [46900.0, 0.94, 0.58, 6.0, 480.0, 184.0, 1.1, 1.46, 2520.0, 156.0, 0.053, 0.091, 0.049, 136.0, 2.6, 0.014], "u_eksport": [0.1961, 0.7213, 0.4701, 0.9314, 0.472, 0.9917, 0.6454, 0.9274, 0.032, 0.2513, 0.2422, 0.8169, 0.7201, 0.3896, 0.7946, 0.7959, 0.7117, 0.8358, 0.2181, 0.538, 0.1801, 0.367, 0.4494, 0.5326, 0.6141, 0.3221, 0.5879, 0.0124, 0.5354, 0.5694, 0.9344, 0.4339, 0.2486]},
{"verdier": [49300.0, 0.36, 0.32, 6.7, 1350.0, 159.0, 1.37, 1.46, 2500.0, 145.0, 0.058, 0.085, 0.002, 254.0, 2.7, -0.027], "u_eksport": [0.2866, 0.4754, 0.3462, 0.1353, 0.8966, 0.5575, 0.524, 0.1727, 0.7534, 0.9869, 0.1376, 0.8446, 0.1782, 0.4614, 0.3648, 0.5296, 0.0682, 0.8079, 0.1672, 0.9082, 0.4185, 0.4227, 0.7049, 0.6852, 0.8015, 0.6017, 0.9222, 0.1126, 0.5725, 0.3715, 0.1939, 0.7274, 0.3098]},
{"verdier": [121000.0, 0.03, 0.4, 7.7, 1610.0, 215.0, 1.12, 1.43, 3880.0, 116.0, 0.075, 0.098, 0.092, 267.0, 2.22, 0.069], "u_eksport": [0.2346, 0.947, 0.3726, 0.12, 0.4197, 0.0653, 0.222, 0.2779, 0.1362, 0.762, 0.5059, 0.2006, 0.6219, 0.4501, 0.1903, 0.0634, 0.0069, 0.7269, 0.3374, 0.2752, 0.9047, 0.9883, 0.0888, 0.1598, 0.1608, 0.7792, 0.6978, 0.8966, 0.6585, 0.0419, 0.1722, 0.6067, 0.5763]},
{"verdier": [47500.0, 0.25, 0.41, 4.1, 330.0, 171.0, 1.16, 1.41, 3390.0, 191.0, 0.069, 0.075, 0.047, 281.0, 2.22, -0.046], "u_eksport": [0.1178, 0.0551, 0.9536, 0.7602, 0.4221, 0.3485, 0.6823, 0.0182, 0.7482, 0.7046, 0.2199, 0.3091, 0.7891, 0.5174, 0.7228, 0.1733, 0.0011, 0.9036, 0.2396, 0.625, 0.122, 0.1763, 0.3914, 0.9718, 0.4885, 0.385, 0.0671, 0.8687, 0.8553, 0.2975, 0.9909, 0.9373, 0.7392]},
{"verdier": [61100.0, 0.95, 0.76, 3.4, 440.0, 153.0, 1.23, 1.3, 2980.0, 118.0, 0.068, 0.076, 0.019, 154.0, 2.11, 0.01], "u_eksport": [0.506, 0.1996, 0.662, 0.6403, 0.1126, 0.8411, 0.2682, 0.1309, 0.3062, 0.7212, 0.1454, 0.5967, 0.0006, 0.0943, 0.0548, 0.5378, 0.8462, 0.1909, 0.8189, 0.1951, 0.0293, 0.0217, 0.2502, 0.0822, 0.56, 0.2907, 0.3146, 0.1127, 0.052, 0.9882, 0.403, 0.5438, 0.9796]},
{"verdier": [43300.0, 0.97, 0.26, 4.4, 530.0, 216.0, 1.25, 1.25, 3630.0, 229.0, 0.057, 0.071, 0.058, 201.0, 2.05, 0.002], "u_eksport": [0.3379, 0.4709, 0.0565, 0.1822, 0.2267, 0.1333, 0.6338, 0.4301, 0.8814, 0.4338, 0.5657, 0.4552, 0.7909, 0.7585, 0.8831, 0.2003, 0.4051, 0.5161, 0.9831, 0.2001, 0.2547, 0.9529, 0.4108, 0.5947, 0.7554, 0.6819, 0.1116, 0.3755, 0.2812, 0.1788, 0.2279, 0.7026, 0.1392]},
{"verdier": [49400.0, 0.79, 0.53, 4.0, 1810.0, 210.0, 1.22, 1.29, 2560.0, 226.0, 0.056, 0.076, 0.051, 130.0, 2.3, 0.084], "u_eksport": [0.4267, 0.1999, 0.9489, 0.7531, 0.8663, 0.9502, 0.868, 0.2055, 0.8349, 0.3185, 0.4411, 0.5826, 0.6289, 0.2137, 0.6847, 0.2932, 0.4023, 0.2805, 0.3742, 0.6823, 0.6715, 0.0565, 0.4043, 0.5138, 0.2813, 0.9802, 0.2457, 0.2512, 0.1361, 0.0462, 0.4241, 0.8758, 0.8255]},
{"verdier": [91300.0, 0.2, 0.32, 7.7, 950.0, 195.0, 1.2, 1.39, 2590.0, 133.0, 0.049, 0.056, 0.009, 293.0, 2.5, 0.001], "u_eksport": [0.9876, 0.5158, 0.7073, 0.4453, 0.9064, 0.3807, 0.6815, 0.121, 0.8882, 0.4846, 0.7428, 0.2513, 0.7302, 0.0626, 0.7901, 0.4203, 0.506, 0.0181, 0.5109, 0.9477, 0.2927, 0.8016, 0.0769, 0.3586, 0.2995, 0.1077, 0.1825, 0.8668, 0.9155, 0.3583, 0.4432, 0.9112, 0.7262]},
{"verdier": [96100.0, 0.89, 0.57, 3.5, 130.0, 179.0, 1.11, 1.11, 3850.0, 204.0, 0.068, 0.072, 0.089, 203.0, 2.61, -0.019], "u_eksport": [0.1839, 0.1089, 0.5993, 0.8196, 0.9329, 0.5105, 0.5119, 0.8524, 0.5977, 0.3119, 0.5396, 0.1137, 0.3375, 0.8893, 0.2738, 0.4124, 0.9155, 0.7973, 0.0399, 0.1866, 0.7776, 0.7956, 0.9298, 0.5365, 0.5727, 0.5743, 0.7878, 0.8548, 0.0893, 0.0087, 0.8363, 0.7626, 0.358]},
{"verdier": [61200.0, 0.73, 0.5, 6.8, 940.0, 151.0, 1.29, 1.29, 3350.0, 151.0, 0.041, 0.063, 0.042, 149.0, 2.56, -0.004], "u_eksport": [0.1717, 0.6505, 0.9573, 0.1203, 0.2925, 0.5637, 0.1493, 0.4346, 0.3632, 0.5227, 0.6314, 0.6957, 0.9285, 0.2185, 0.5696, 0.7338, 0.9648, 0.2353, 0.2664, 0.2856, 0.6473, 0.275, 0.5137, 0.7818, 0.8212, 0.7426, 0.1247, 0.1442, 0.9932, 0.7936, 0.3365, 0.7426, 0.1413]},
{"verdier": [65000.0, 0.77, 0.73, 6.8, 1940.0, 247.0, 1.15, 1.28, 3680.0, 107.0, 0.071, 0.097, 0.087, 294.0, 2.66, 0.055], "u_eksport": [0.701, 0.6652, 0.8769, 0.5002, 0.2719, 0.4591, 0.1485, 0.7621, 0.0453, 0.3787, 0.9239, 0.4683, 0.5453, 0.6626, 0.2167, 0.7597, 0.8764, 0.0127, 0.8399, 0.163, 0.1091, 0.5369, 0.9553, 0.2964, 0.3271, 0.1181, 0.7551, 0.2546, 0.109, 0.8508, 0.0211, 0.9524, 0.8505]},
{"verdier": [136600.0, 0.6, 0.68, 5.5, 820.0, 166.0, 1.21, 1.26, 3620.0, 200.0, 0.051, 0.084, 0.024, 210.0, 2.63, 0.042], "u_eksport": [0.6094, 0.9642, 0.308, 0.991, 0.9267, 0.691, 0.8679, 0.3962, 0.9341, 0.7325, 0.3266, 0.9692, 0.4192, 0.9967, 0.0025, 0.5708, 0.9831, 0.817, 0.7513, 0.412, 0.1169, 0.6677, 0.0801, 0.7017, 0.4674, 0.1662, 0.0699, 0.7694, 0.145, 0.0425, 0.7725, 0.8491, 0.8998]},
{"verdier": [59700.0, 0.26, 0.4, 5.3, 950.0, 209.0, 1.21, 1.26, 3430.0, 157.0, 0.05, 0.067, 0.058, 218.0, 2.61, 0.039], "u_eksport": [0.4701, 0.8518, 0.1575, 0.0229, 0.2291, 0.1074, 0.8891, 0.6118, 0.4327, 0.093, 0.6008, 0.5593, 0.2241, 0.3539, 0.2151, 0.2839, 0.697, 0.4473, 0.9601, 0.6824, 0.3938, 0.1922, 0.5798, 0.6203, 0.4299, 0.9027, 0.2497, 0.514, 0.6371, 0.8647, 0.5117, 0.6687, 0.6449]},
{"verdier": [129800.0, 0.72, 0.58, 7.4, 1910.0, 228.0, 1.18, 1.27, 2690.0, 198.0, 0.042, 0.08, 0.013, 188.0, 2.1, 0.069], "u_eksport": [0.2517, 0.8038, 0.6456, 0.5003, 0.787, 0.7964, 0.0284, 0.8189, 0.772, 0.464, 0.5495, 0.5771, 0.2097, 0.8703, 0.4676, 0.9666, 0.3184, 0.3919, 0.6821, 0.361, 0.9419, 0.0018, 0.5155, 0.9115, 0.4643, 0.9436, 0.1108, 0.4161, 0.7245, 0.7072, 0.805, 0.5054, 0.5278]},
{"verdier": [130500.0, 0.97, 0.65, 7.4, 100.0, 216.0, 1.38, 1.37, 2650.0, 219.0, 0.053, 0.054, 0.046, 258.0, 2.28, -0.025], "u_eksport": [0.4253, 0.1358, 0.0643, 0.7327, 0.1962, 0.1994, 0.5758, 0.8885, 0.1901, 0.3884, 0.3448, 0.1587, 0.0944, 0.133, 0.5619, 0.9609, 0.0702, 0.0418, 0.1193, 0.1014, 0.2278, 0.9397, 0.9234, 0.0869, 0.0107, 0.5676, 0.2472, 0.9165, 0.126, 0.7076, 0.3514, 0.6519, 0.1671]},
{"verdier": [67100.0, 0.89, 0.51, 7.3, 1650.0, 225.0, 1.12, 1.39, 2310.0, 151.0, 0.076, 0.095, 0.008, 245.0, 2.05, 0.063], "u_eksport": [0.8521, 0.1683, 0.7258, 0.5745, 0.3806, 0.9564, 0.5322, 0.1079, 0.4511, 0.5735, 0.9373, 0.8197, 0.5292, 0.1887, 0.1385, 0.3193, 0.9455, 0.3024, 0.8268, 0.9244, 0.1871, 0.1672, 0.2417, 0.0749, 0.8963, 0.2341, 0.716, 0.1124, 0.2857, 0.9898, 0.1868, 0.1343, 0.2112]},
{"verdier": [75700.0, 0.82, 0.6, 5.3, 1230.0, 152.0, 1.22, 1.31, 3340.0, 200.0, 0.05, 0.064, 0.075, 268.0, 2.78, 0.055], "u_eksport": [0.8623, 0.6318, 0.8517, 0.6114, 0.3264, 0.8783, 0.6452, 0.1373, 0.5824, 0.5365, 0.9015, 0.1606, 0.1636, 0.9676, 0.7117, 0.4994, 0.519, 0.4422, 0.8939, 0.8607, 0.9707, 0.3291, 0.2994, 0.1607, 0.6365, 0.961, 0.3947, 0.931, 0.9392, 0.9636, 0.8868, 0.2563, 0.333]},
{"verdier": [95700.0, 0.64, 0.39, 5.7, 1110.0, 158.0, 1.33, 1.21, 3310.0, 223.0, 0.041, 0.067, 0.066, 262.0, 2.62, 0.096], "u_eksport": [0.3131, 0.978, 0.1963, 0.4038, 0.6108, 0.8602, 0.3547, 0.5004, 0.9991, 0.8059, 0.5697, 0.7299, 0.1802, 0.9361, 0.2133, 0.1875, 0.0966, 0.3829, 0.8002, 0.5658, 0.4771, 0.3439, 0.5402, 0.3176, 0.7919, 0.1711, 0.6782, 0.6375, 0.2748, 0.9374, 0.2626, 0.2775, 0.2409]},
{"verdier": [52200.0, 0.79, 0.27, 6.4, 790.0, 216.0, 1.23, 1.22, 3570.0, 177.0, 0.07, 0.072, 0.059, 136.0, 2.8, 0.04], "u_eksport": [0.5257, 0.8239, 0.3591, 0.7544, 0.8845, 0.0774, 0.1592, 0.0057, 0.3837, 0.1725, 0.9449, 0.1095, 0.8819, 0.2732, 0.256, 0.94, 0.8667, 0.0531, 0.3967, 0.1977, 0.1324, 0.3625, 0.0843, 0.6527, 0.8626, 0.999, 0.1063, 0.1038, 0.9093, 0.5324, 0.3787, 0.424, 0.6366]},
{"verdier": [57800.0, 0.0, 0.28, 4.5, 310.0, 175.0, 1.26, 1.18, 2630.0, 153.0, 0.054, 0.079, 0.01, 200.0, 2.2, 0.023], "u_eksport": [0.0798, 0.0764, 0.7054, 0.6763, 0.7651, 0.4614, 0.4852, 0.1299, 0.6985, 0.4586, 0.4829, 0.0218, 0.4399, 0.3725, 0.533, 0.5353, 0.9714, 0.6438, 0.0291, 0.1091, 0.9969, 0.8288, 0.8224, 0.3684, 0.4613, 0.9981, 0.4579, 0.6447, 0.6071, 0.8189, 0.4347, 0.2429, 0.9476]},
{"verdier": [68200.0, 0.0, 0.44, 3.8, 950.0, 198.0, 1.31, 1.19, 2310.0, 105.0, 0.041, 0.046, 0.076, 131.0, 2.38, 0.04], "u_eksport": [0.7215, 0.3165, 0.0098, 0.3188, 0.0578, 0.4061, 0.1565, 0.9972, 0.9625, 0.2529, 0.2554, 0.7863, 0.3397, 0.8666, 0.331, 0.1534, 0.3906, 0.4083, 0.6085, 0.586, 0.6271, 0.4849, 0.3158, 0.7377, 0.1082, 0.882, 0.5869, 0.6812, 0.4892, 0.2668, 0.5196, 0.396, 0.7443]},
{"verdier": [91400.0, 0.07, 0.25, 4.6, 740.0, 168.0, 1.3, 1.34, 3240.0, 210.0, 0.07, 0.108, 0.04, 139.0, 2.33, 0.034], "u_eksport": [0.1072, 0.1818, 0.0359, 0.3072, 0.2408, 0.3829, 0.4698, 0.1688, 0.0189, 0.6925, 0.2131, 0.8952, 0.5589, 0.9884, 0.8995, 0.3995, 0.166, 0.0436, 0.8678, 0.6787, 0.0883, 0.2038, 0.1466, 0.1291, 0.5559, 0.5333, 0.4556, 0.9001, 0.5156, 0.5116, 0.474, 0.2433, 0.6783]},
{"verdier": [89700.0, 0.43, 0.63, 6.4, 1860.0, 234.0, 1.14, 1.36, 3970.0, 194.0, 0.061, 0.087, 0.065, 285.0, 2.47, -0.011], "u_eksport": [0.4523, 0.9334, 0.089, 0.5734, 0.3669, 0.5151, 0.1638, 0.3998, 0.8769, 0.2591, 0.6366, 0.5997, 0.2466, 0.111, 0.8518, 0.8981, 0.2218, 0.9831, 0.9443, 0.671, 0.4803, 0.1721, 0.5313, 0.0529, 0.9598, 0.4158, 0.635, 0.5579, 0.9287, 0.8055, 0.103, 0.8542, 0.4743]},
{"verdier": [123000.0, 0.44, 0.59, 7.0, 1760.0, 220.0, 1.27, 1.18, 2400.0, 194.0, 0.042, 0.056, 0.076, 294.0, 2.73, 0.036], "u_eksport": [0.8998, 0.9973, 0.9317, 0.862, 0.0254, 0.0744, 0.9678, 0.6825, 0.2122, 0.3462, 0.0009, 0.2162, 0.5907, 0.7153, 0.833, 0.5641, 0.1347, 0.2752, 0.5652, 0.9055, 0.3168, 0.1433, 0.7751, 0.4499, 0.267, 0.3581, 0.4496, 0.8395, 0.8167, 0.2927, 0.9723, 0.9938, 0.7502]},
{"verdier": [99400.0, 1.0, 0.52, 4.3, 380.0, 178.0, 1.29, 1.12, 3340.0, 103.0, 0.059, 0.096, 0.033, 199.0, 2.19, 0.072], "u_eksport": [0.3784, 0.3613, 0.3526, 0.9458, 0.496, 0.6224, 0.1518, 0.5703, 0.2922, 0.0396, 0.6345, 0.2891, 0.1682, 0.8628, 0.0565, 0.1717, 0.581, 0.34, 0.1649, 0.4804, 0.8224, 0.2052, 0.2094, 0.0566, 0.2437, 0.988, 0.1429, 0.0608, 0.4954, 0.7583, 0.65, 0.9006, 0.8205]},
{"verdier": [62500.0, 0.42, 0.77, 4.9, 600.0, 187.0, 1.32, 1.35, 3550.0, 165.0, 0.067, 0.089, 0.026, 200.0, 2.52, 0.059], "u_eksport": [0.776, 0.1457, 0.5391, 0.4918, 0.6688, 0.7813, 0.7651, 0.1198, 0.9054, 0.2252, 0.4084, 0.9609, 0.6888, 0.1322, 0.9912, 0.2238, 0.7642, 0.4247, 0.8864, 0.8422, 0.7659, 0.9624, 0.8581, 0.1169, 0.2396, 0.12, 0.7784, 0.6343, 0.305, 0.8034, 0.208, 0.2434, 0.6747]},
{"verdier": [62500.0, 0.6, 0.57, 7.4, 1210.0, 239.0, 1.19, 1.43, 3690.0, 209.0, 0.058, 0.072, 0.082, 222.0, 2.04, -0.023], "u_eksport": [0.4499, 0.7284, 0.0917, 0.611, 0.6647, 0.0914, 0.5728, 0.7986, 0.4424, 0.4534, 0.9561, 0.1334, 0.8215, 0.2377, 0.8719, 0.3585, 0.0231, 0.2991, 0.3547, 0.963, 0.4557, 0.2378, 0.8356, 0.6402, 0.3239, 0.3888, 0.5251, 0.9709, 0.838, 0.8129, 0.0372, 0.4511, 0.4411]},
{"verdier": [99800.0, 0.67, 0.78, 3.5, 70.0, 156.0, 1.23, 1.45, 4160.0, 156.0, 0.048, 0.05, 0.019, 121.0, 2.53, 0.002], "u_eksport": [0.5321, 0.0234, 0.2086, 0.8847, 0.5537, 0.4787, 0.7661, 0.1782, 0.6074, 0.5395, 0.4843, 0.6844, 0.8531, 0.997, 0.1481, 0.5033, 0.1756, 0.1397, 0.3043, 0.4813, 0.0159, 0.9844, 0.3791, 0.1425, 0.0515, 0.4706, 0.9338, 0.9534, 0.3286, 0.1874, 0.46, 0.236, 0.8592]},
{"verdier": [75500.0, 0.08, 0.77, 7.3, 1890.0, 232.0, 1.28, 1.26, 4020.0, 167.0, 0.049, 0.084, 0.033, 219.0, 2.57, -0.019], "u_eksport": [0.6122, 0.7556, 0.0161, 0.8873, 0.2062, 0.3368, 0.0231, 0.6248, 0.5831, 0.7071, 0.5181, 0.6253, 0.7816, 0.0262, 0.2648, 0.5865, 0.7445, 0.3094, 0.5054, 0.7095, 0.0098, 0.0603, 0.4183, 0.0022, 0.3123, 0.8571, 0.1643, 0.8631, 0.6248, 0.1757, 0.4281, 0.1786, 0.5]},
{"verdier": [90300.0, 0.88, 0.79, 4.0, 410.0, 154.0, 1.19, 1.36, 2780.0, 140.0, 0.046, 0.067, 0.086, 271.0, 2.27, 0.007], "u_eksport": [0.8153, 0.7925, 0.6491, 0.7937, 0.399, 0.5217, 0.309, 0.5813, 0.948, 0.3536, 0.5953, 0.4353, 0.141, 0.5987, 0.5577, 0.7948, 0.7173, 0.2536, 0.8778, 0.0235, 0.3388, 0.8257, 0.2636, 0.7008, 0.3319, 0.1591, 0.2716, 0.8804, 0.5745, 0.522, 0.7909, 0.824, 0.1413]},
{"verdier": [108000.0, 0.58, 0.57, 7.3, 680.0, 243.0, 1.13, 1.43, 4180.0, 208.0, 0.042, 0.075, 0.042, 122.0, 2.23, 0.009], "u_eksport": [0.2912, 0.2594, 0.5864, 0.8026, 0.6148, 0.1769, 0.4791, 0.9557, 0.1477, 0.3815, 0.6843, 0.6189, 0.7125, 0.4471, 0.7366, 0.9918, 0.8202, 0.0234, 0.6569, 0.0599, 0.3715, 0.6578, 0.5761, 0.3281, 0.9446, 0.3551, 0.0093, 0.8653, 0.5331, 0.9824, 0.9564, 0.5744, 0.2375]},
{"verdier": [69300.0, 0.66, 0.73, 5.8, 520.0, 232.0, 1.35, 1.17, 2690.0, 143.0, 0.065, 0.092, 0.017, 120.0, 2.12, 0.094], "u_eksport": [0.8968, 0.6233, 0.1806, 0.8233, 0.2224, 0.9028, 0.1626, 0.9922, 0.5457, 0.3873, 0.1049, 0.3948, 0.2238, 0.6372, 0.918, 0.8306, 0.3955, 0.7656, 0.6749, 0.1668, 0.6862, 0.652, 0.7545, 0.9871, 0.1492, 0.6422, 0.9409, 0.3983, 0.8428, 0.4265, 0.1769, 0.5569, 0.0036]},
{"verdier": [138800.0, 0.76, 0.56, 7.8, 1030.0, 178.0, 1.12, 1.47, 3250.0, 126.0, 0.065, 0.07, 0.041, 160.0, 2.64, 0.008], "u_eksport": [0.0373, 0.3833, 0.2987, 0.1538, 0.6815, 0.2694, 0.1619, 0.9275, 0.9628, 0.7258, 0.4501, 0.6938, 0.1387, 0.4926, 0.245, 0.8507, 0.3636, 0.3213, 0.1545, 0.7291, 0.5504, 0.4906, 0.7638, 0.7865, 0.6054, 0.0969, 0.7865, 0.444, 0.9359, 0.0691, 0.9731, 0.0143, 0.4623]},
{"verdier": [98000.0, 0.09, 0.53, 6.9, 780.0, 201.0, 1.32, 1.36, 3360.0, 162.0, 0.077, 0.096, 0.002, 216.0, 2.48, -0.049], "u_eksport": [0.068, 0.3411, 0.11, 0.6127, 0.2735, 0.5243, 0.8773, 0.5591, 0.2782, 0.6454, 0.5733, 0.8891, 0.7953, 0.9636, 0.9748, 0.7871, 0.1404, 0.4466, 0.9756, 0.9046, 0.8578, 0.4278, 0.527, 0.5112, 0.9194, 0.8714, 0.6753, 0.6114, 0.7253, 0.8323, 0.2769, 0.5822, 0.2134]},
{"verdier": [75400.0, 0.35, 0.51, 3.4, 1350.0, 162.0, 1.39, 1.46, 3680.0, 229.0, 0.074, 0.105, 0.054, 146.0, 2.39, 0.03], "u_eksport": [0.8588, 0.7805, 0.1393, 0.9401, 0.3866, 0.4278, 0.9996, 0.4977, 0.6145, 0.4999, 0.5184, 0.1811, 0.2791, 0.802, 0.7465, 0.7527, 0.9259, 0.2848, 0.8711, 0.1513, 0.4753, 0.1753, 0.2211, 0.8655, 0.5156, 0.3246, 0.6586, 0.1506, 0.4273, 0.1042, 0.0011, 0.96, 0.7717]},
{"verdier": [95200.0, 0.23, 0.38, 6.1, 850.0, 189.0, 1.14, 1.26, 3430.0, 112.0, 0.069, 0.099, 0.045, 131.0, 2.13, -0.028], "u_eksport": [0.0193, 0.5388, 0.1066, 0.6295, 0.8823, 0.0845, 0.2618, 0.0971, 0.6058, 0.437, 0.9475, 0.8558, 0.8504, 0.6766, 0.0483, 0.9538, 0.4477, 0.9604, 0.3416, 0.1029, 0.1024, 0.2658, 0.1012, 0.1284, 0.9727, 0.6842, 0.3486, 0.7403, 0.2774, 0.8645, 0.8551, 0.1618, 0.0812]},
{"verdier": [63100.0, 0.65, 0.36, 4.9, 1670.0, 178.0, 1.38, 1.42, 3760.0, 139.0, 0.051, 0.086, 0.021, 239.0, 2.43, -0.05], "u_eksport": [0.5459, 0.9344, 0.7574, 0.4721, 0.6392, 0.7839, 0.6021, 0.4404, 0.8444, 0.8371, 0.4095, 0.8789, 0.9016, 0.2793, 0.3094, 0.605, 0.6282, 0.8879, 0.6188, 0.2757, 0.1691, 0.4594, 0.2513, 0.0851, 0.7689, 0.7359, 0.6269, 0.4255, 0.577, 0.0879, 0.46, 0.5214, 0.2341]},
{"verdier": [99400.0, 0.86, 0.36, 3.3, 1790.0, 183.0, 1.31, 1.45, 3480.0, 138.0, 0.054, 0.056, 0.017, 183.0, 2.52, -0.005], "u_eksport": [0.7532, 0.2859, 0.4996, 0.0594, 0.1381, 0.5032, 0.5989, 0.408, 0.7681, 0.4749, 0.8731, 0.6895, 0.3998, 0.465, 0.2914, 0.1463, 0.5061, 0.9946, 0.4782, 0.1163, 0.1292, 0.862, 0.6688, 0.2984, 0.2023, 0.7805, 0.1494, 0.5053, 0.9753, 0.6449, 0.0694, 0.721, 0.2496]},
{"verdier": [95000.0, 0.22, 0.24, 4.6, 1220.0, 161.0, 1.27, 1.14, 3010.0, 129.0, 0.042, 0.066, 0.027, 143.0, 2.52, -0.014], "u_eksport": [0.6346, 0.7391, 0.7657, 0.0793, 0.8693, 0.6589, 0.1361, 0.9781, 0.95, 0.9167, 0.6048, 0.0047, 0.9533, 0.3487, 0.7324, 0.9515, 0.432, 0.1545, 0.8321, 0.702, 0.4205, 0.4114, 0.0757, 0.8858, 0.1475, 0.7049, 0.4837, 0.2685, 0.6387, 0.0032, 0.4957, 0.0437, 0.4083]},
{"verdier": [64400.0, 0.56, 0.53, 8.0, 1900.0, 228.0, 1.32, 1.48, 2880.0, 222.0, 0.06, 0.092, 0.024, 155.0, 2.68, 0.06], "u_eksport": [0.0383, 0.8059, 0.2577, 0.4531, 0.0467, 0.5415, 0.717, 0.812, 0.4871, 0.5046, 0.1347, 0.18, 0.935, 0.894, 0.1879, 0.7935, 0.0037, 0.5862, 0.5028, 0.0278, 0.8352, 0.4132, 0.1394, 0.8911, 0.7766, 0.056, 0.55, 0.8457, 0.2925, 0.544, 0.2143, 0.3429, 0.3097]},
{"verdier": [110600.0, 0.66, 0.32, 6.5, 1520.0, 249.0, 1.36, 1.46, 3600.0, 152.0, 0.061, 0.08, 0.022, 174.0, 2.47, -0.041], "u_eksport": [0.1001, 0.6921, 0.8716, 0.1976, 0.6903, 0.4056, 0.1174, 0.0217, 0.326, 0.6621, 0.754, 0.0327, 0.847, 0.4376, 0.8796, 0.3582, 0.1385, 0.1987, 0.6762, 0.2293, 0.678, 0.1865, 0.7241, 0.6919, 0.1323, 0.7871, 0.1844, 0.0599, 0.8285, 0.9437, 0.4515, 0.4104, 0.5867]},
{"verdier": [53800.0, 0.83, 0.26, 5.5, 1620.0, 192.0, 1.33, 1.19, 3210.0, 148.0, 0.056, 0.073, 0.086, 211.0, 2.14, 0.093], "u_eksport": [0.3984, 0.8769, 0.7928, 0.4097, 0.9255, 0.7477, 0.3708, 0.8861, 0.4746, 0.5043, 0.7567, 0.6132, 0.5876, 0.1943, 0.6847, 0.2515, 0.6615, 0.8563, 0.0685, 0.5782, 0.4034, 0.5313, 0.1989, 0.8609, 0.8265, 0.0952, 0.5629, 0.0495, 0.2258, 0.3893, 0.8844, 0.4173, 0.3228]},
{"verdier": [40300.0, 0.37, 0.36, 6.7, 1600.0, 245.0, 1.17, 1.45, 3370.0, 178.0, 0.075, 0.083, 0.09, 201.0, 2.46, 0.052], "u_eksport": [0.704, 0.1003, 0.3868, 0.6991, 0.7171, 0.4913, 0.7313, 0.0031, 0.8231, 0.4228, 0.8417, 0.4726, 0.7603, 0.8018, 0.5874, 0.0905, 0.4786, 0.4277, 0.1831, 0.5527, 0.9347, 0.065, 0.3049, 0.5845, 0.6059, 0.7207, 0.2785, 0.4389, 0.703, 0.756, 0.4344, 0.7274, 0.147]},
{"verdier": [116500.0, 0.74, 0.32, 6.0, 630.0, 229.0, 1.27, 1.25, 2320.0, 190.0, 0.062, 0.068, 0.014, 233.0, 2.2, -0.026], "u_eksport": [0.6259, 0.3701, 0.5408, 0.7081, 0.7135, 0.3966, 0.9344, 0.7879, 0.4134, 0.4589, 0.5986, 0.1641, 0.4348, 0.5666, 0.1477, 0.3177, 0.2494, 0.401, 0.6488, 0.5257, 0.4019, 0.2481, 0.3796, 0.3725, 0.2174, 0.0389, 0.3505, 0.308, 0.7756, 0.7315, 0.0249, 0.4931, 0.0373]},
{"verdier": [80700.0, 0.98, 0.51, 6.8, 850.0, 223.0, 1.24, 1.4, 3710.0, 222.0, 0.048, 0.049, 0.054, 166.0, 2.55, 0.011], "u_eksport": [0.5923, 0.6096, 0.9104, 0.7433, 0.7615, 0.1626, 0.6649, 0.2508, 0.5868, 0.1493, 0.0283, 0.8409, 0.5123, 0.7256, 0.735, 0.3438, 0.5886, 0.4571, 0.1714, 0.7255, 0.2232, 0.7898, 0.8416, 0.9968, 0.6643, 0.9377, 0.3979, 0.0195, 0.5316, 0.7378, 0.3617, 0.4821, 0.0603]},
{"verdier": [98400.0, 0.28, 0.52, 5.3, 1370.0, 249.0, 1.38, 1.29, 3360.0, 103.0, 0.079, 0.093, 0.025, 207.0, 2.63, 0.062], "u_eksport": [0.4703, 0.9886, 0.8009, 0.3868, 0.5248, 0.5508, 0.2424, 0.989, 0.2774, 0.6543, 0.5106, 0.1148, 0.2583, 0.2249, 0.0435, 0.7268, 0.6176, 0.7159, 0.9169, 0.4609, 0.4692, 0.0041, 0.568, 0.9792, 0.0199, 0.1183, 0.2459, 0.4359, 0.854, 0.5103, 0.3746, 0.2181, 0.0407]},
{"verdier": [74800.0, 0.93, 0.32, 5.3, 170.0, 235.0, 1.15, 1.39, 3200.0, 131.0, 0.066, 0.087, 0.034, 282.0, 2.29, 0.08], "u_eksport": [0.4283, 0.1664, 0.0864, 0.0061, 0.5228, 0.5531, 0.5072, 0.2004, 0.1798, 0.5664, 0.6839, 0.0095, 0.4836, 0.0665, 0.6268, 0.7472, 0.4957, 0.2733, 0.6234, 0.3363, 0.1887, 0.3022, 0.1664, 0.3749, 0.9359, 0.9062, 0.1888, 0.1986, 0.8924, 0.2693, 0.1467, 0.3202, 0.3573]},
{"verdier": [76600.0, 0.4, 0.25, 7.7, 1920.0, 207.0, 1.16, 1.18, 2830.0, 147.0, 0.059, 0.072, 0.049, 137.0, 2.44, 0.061], "u_eksport": [0.4065, 0.254, 0.2076, 0.8508, 0.4952, 0.0038, 0.0461, 0.2963, 0.4292, 0.0397, 0.7151, 0.3424, 0.8484, 0.8042, 0.6382, 0.4268, 0.2192, 0.9746, 0.8217, 0.4083, 0.7132, 0.3701, 0.7783, 0.6882, 0.4132, 0.3673, 0.2448, 0.3934, 0.0449, 0.9674, 0.4113, 0.6591, 0.9831]},
{"verdier": [113200.0, 0.75, 0.64, 3.2, 1780.0, 217.0, 1.32, 1.17, 3590.0, 149.0, 0.066, 0.104, 0.006, 257.0, 2.23, 0.083], "u_eksport": [0.2993, 0.7493, 0.2181, 0.6625, 0.9368, 0.5909, 0.16, 0.3446, 0.1054, 0.5706, 0.2504, 0.3534, 0.759, 0.7937, 0.7292, 0.6431, 0.2259, 0.1098, 0.4688, 0.115, 0.6668, 0.8564, 0.8787, 0.1461, 0.3459, 0.9107, 0.6063, 0.3197, 0.9281, 0.864, 0.0454, 0.1871, 0.2096]},
{"verdier": [99200.0, 0.52, 0.39, 8.0, 770.0, 170.0, 1.18, 1.21, 2680.0, 214.0, 0.041, 0.064, 0.095, 203.0, 2.41, -0.022], "u_eksport": [0.9595, 0.5384, 0.1504, 0.4718, 0.1748, 0.3188, 0.5999, 0.0122, 0.3478, 0.5998, 0.7351, 0.3807, 0.0362, 0.4915, 0.6929, 0.0823, 0.4722, 0.7156, 0.7747, 0.7999, 0.5944, 0.5491, 0.2663, 0.3859, 0.4898, 0.962, 0.0982, 0.4547, 0.231, 0.7239, 0.8061, 0.6805, 0.7558]},
{"verdier": [102700.0, 0.86, 0.55, 4.8, 50.0, 232.0, 1.26, 1.44, 3620.0, 177.0, 0.055, 0.086, 0.023, 172.0, 2.01, 0.088], "u_eksport": [0.4058, 0.3955, 0.6282, 0.4249, 0.6528, 0.6242, 0.2889, 0.1045, 0.1365, 0.2216, 0.3444, 0.4043, 0.4673, 0.7773, 0.7207, 0.4987, 0.2679, 0.568, 0.284, 0.6259, 0.7228, 0.6789, 0.1734, 0.5211, 0.4439, 0.4004, 0.1092, 0.0261, 0.4523, 0.2784, 0.6627, 0.6521, 0.9263]},
{"verdier": [64400.0, 0.39, 0.25, 6.4, 1300.0, 163.0, 1.33, 1.49, 3860.0, 216.0, 0.062, 0.094, 0.078, 287.0, 2.34, 0.01], "u_eksport": [0.8154, 0.2764, 0.4287, 0.7054, 0.3735, 0.334, 0.7263, 0.621, 0.5175, 0.8533, 0.8313, 0.4907, 0.3182, 0.0518, 0.6985, 0.8498, 0.4024, 0.5107, 0.4096, 0.6529, 0.9428, 0.9194, 0.4611, 0.3347, 0.2463, 0.0727, 0.4481, 0.4948, 0.0316, 0.6537, 0.8834, 0.6982, 0.8218]},
{"verdier": [105400.0, 0.53, 0.27, 7.0, 1470.0, 235.0, 1.33, 1.13, 3740.0, 216.0, 0.047, 0.087, 0.006, 247.0, 2.67, 0.003], "u_eksport": [0.0865, 0.9122, 0.782, 0.4174, 0.7846, 0.8548, 0.7673, 0.9311, 0.5502, 0.7604, 0.0033, 0.636, 0.7811, 0.461, 0.9539, 0.7338, 0.2712, 0.7997, 0.7681, 0.6307, 0.63, 0.9518, 0.8725, 0.4572, 0.0811, 0.8003, 0.4105, 0.7912, 0.4812, 0.746, 0.9886, 0.3636, 0.4158]},
{"verdier": [66900.0, 0.51, 0.54, 4.5, 590.0, 223.0, 1.26, 1.28, 2360.0, 106.0, 0.062, 0.075, 0.076, 206.0, 2.19, 0.045], "u_eksport": [0.8528, 0.2784, 0.3402, 0.5698, 0.0166, 0.4187, 0.9111, 0.8485, 0.6337, 0.7484, 0.7266, 0.9599, 0.511, 0.6593, 0.475, 0.5209, 0.1384, 0.6819, 0.9676, 0.8387, 0.063, 0.5463, 0.3157, 0.7781, 0.4134, 0.4582, 0.6678, 0.6229, 0.678, 0.7128, 0.1523, 0.4344, 0.773]},
{"verdier": [43600.0, 0.3, 0.64, 5.9, 680.0, 229.0, 1.15, 1.41, 3240.0, 157.0, 0.051, 0.075, 0.036, 222.0, 2.4, 0.021], "u_eksport": [0.5594, 0.5455, 0.7046, 0.9823, 0.4745, 0.4768, 0.276, 0.6772, 0.8229, 0.4754, 0.2266, 0.5197, 0.3855, 0.3376, 0.3286, 0.364, 0.705, 0.6863, 0.1424, 0.6939, 0.0271, 0.7238, 0.7927, 0.3038, 0.7263, 0.3209, 0.5074, 0.6671, 0.3555, 0.5101, 0.3297, 0.8851, 0.3981]},
{"verdier": [80500.0, 0.22, 0.51, 3.1, 290.0, 225.0, 1.26, 1.44, 3910.0, 172.0, 0.052, 0.073, 0.051, 230.0, 2.52, 0.08], "u_eksport": [0.5719, 0.1458, 0.2822, 0.3952, 0.2847, 0.0017, 0.0151, 0.5163, 0.595, 0.6204, 0.4439, 0.0653, 0.6976, 0.3684, 0.6201, 0.0764, 0.1501, 0.0095, 0.163, 0.8398, 0.2021, 0.5447, 0.275, 0.3536, 0.5195, 0.0138, 0.5783, 0.1631, 0.9076, 0.4251, 0.912, 0.0094, 0.7123]},
{"verdier": [130400.0, 0.04, 0.64, 5.9, 1040.0, 223.0, 1.38, 1.3, 3740.0, 170.0, 0.076, 0.107, 0.038, 250.0, 2.71, 0.067], "u_eksport": [0.9662, 0.1615, 0.1511, 0.4452, 0.8707, 0.9419, 0.035, 0.6086, 0.6629, 0.7762, 0.6932, 0.7384, 0.4005, 0.9057, 0.588, 0.5798, 0.9575, 0.8884, 0.6288, 0.2594, 0.7549, 0.1353, 0.295, 0.2486, 0.0455, 0.1627, 0.3575, 0.7804, 0.0749, 0.2945, 0.7137, 0.0351, 0.2394]},
{"verdier": [114200.0, 0.68, 0.22, 5.4, 1780.0, 249.0, 1.28, 1.2, 3150.0, 119.0, 0.048, 0.071, 0.063, 205.0, 2.32, 0.087], "u_eksport": [0.575, 0.0916, 0.0198, 0.1012, 0.9933, 0.6719, 0.3983, 0.357, 0.8327, 0.1826, 0.4122, 0.3655, 0.3816, 0.4096, 0.538, 0.8317, 0.1116, 0.2649, 0.2605, 0.154, 0.0151, 0.0598, 0.0957, 0.3696, 0.6913, 0.2603, 0.3374, 0.5417, 0.6599, 0.7252, 0.5814, 0.1805, 0.561]},
{"verdier": [66600.0, 0.82, 0.22, 4.3, 760.0, 160.0, 1.24, 1.43, 3130.0, 137.0, 0.08, 0.099, 0.007, 167.0, 2.79, -0.019], "u_eksport": [0.5475, 0.3685, 0.6321, 0.5363, 0.7939, 0.5915, 0.5229, 0.1155, 0.4311, 0.8236, 0.01, 0.1651, 0.4076, 0.2427, 0.2139, 0.2161, 0.961, 0.2733, 0.4872, 0.1451, 0.1301, 0.7873, 0.8576, 0.3175, 0.0729, 0.328, 0.7243, 0.4136, 0.4809, 0.7318, 0.7445, 0.2629, 0.5694]},
{"verdier": [52900.0, 0.69, 0.5, 6.7, 1480.0, 226.0, 1.14, 1.18, 3010.0, 217.0, 0.068, 0.07, 0.077, 149.0, 2.14, 0.058], "u_eksport": [0.0167, 0.2016, 0.8025, 0.0161, 0.1279, 0.8817, 0.5264, 0.086, 0.1045, 0.6409, 0.7645, 0.9405, 0.5427, 0.0619, 0.5362, 0.0857, 0.546, 0.8652, 0.4997, 0.7331, 0.2439, 0.6621, 0.881, 0.6307, 0.0585, 0.0008, 0.3413, 0.531, 0.5952, 0.9321, 0.8592, 0.9088, 0.809]},
{"verdier": [124200.0, 0.07, 0.47, 7.2, 1340.0, 171.0, 1.13, 1.37, 3550.0, 103.0, 0.044, 0.064, 0.064, 286.0, 2.27, 0.097], "u_eksport": [0.5313, 0.1128, 0.1078, 0.7058, 0.6959, 0.0171, 0.8126, 0.1314, 0.3725, 0.4256, 0.6391, 0.5049, 0.3803, 0.3594, 0.4482, 0.8918, 0.4704, 0.684, 0.4049, 0.7932, 0.2498, 0.1639, 0.9462, 0.0918, 0.5202, 0.2975, 0.7844, 0.1924, 0.0341, 0.2474, 0.2265, 0.7146, 0.5866]},
{"verdier": [98400.0, 0.05, 0.75, 7.4, 1000.0, 224.0, 1.26, 1.48, 3660.0, 144.0, 0.056, 0.095, 0.045, 169.0, 2.29, 0.032], "u_eksport": [0.7396, 0.1109, 0.1219, 0.1023, 0.7353, 0.7006, 0.759, 0.6125, 0.1801, 0.1917, 0.9305, 0.4281, 0.8945, 0.4252, 0.3326, 0.3811, 0.9526, 0.1908, 0.2873, 0.4906, 0.6631, 0.6171, 0.2855, 0.1251, 0.6051, 0.674, 0.8865, 0.0336, 0.0024, 0.3118, 0.9171, 0.4799, 0.5358]},
{"verdier": [139300.0, 0.73, 0.23, 8.0, 630.0, 242.0, 1.35, 1.12, 2960.0, 189.0, 0.077, 0.103, 0.012, 186.0, 2.19, -0.049], "u_eksport": [0.2516, 0.0836, 0.8729, 0.8577, 0.6302, 0.8593, 0.1863, 0.5718, 0.1302, 0.381, 0.5514, 0.8496, 0.8231, 0.3148, 0.6653, 0.8022, 0.371, 0.2822, 0.1897, 0.9143, 0.7417, 0.5474, 0.7978, 0.9984, 0.5866, 0.9074, 0.5098, 0.6381, 0.0328, 0.5637, 0.4116, 0.7667, 0.5128]},
{"verdier": [67600.0, 0.95, 0.76, 5.8, 1770.0, 229.0, 1.32, 1.48, 2640.0, 178.0, 0.08, 0.104, 0.079, 264.0, 2.42, 0.02], "u_eksport": [0.0834, 0.6332, 0.1724, 0.4027, 0.6807, 0.8703, 0.6788, 0.0195, 0.1733, 0.7961, 0.2248, 0.5297, 0.7632, 0.4124, 0.4072, 0.6592, 0.981, 0.7206, 0.6543, 0.9583, 0.2988, 0.3077, 0.8965, 0.0589, 0.0735, 0.6507, 0.0884, 0.7635, 0.8002, 0.8179, 0.0443, 0.3135, 0.8311]},
{"verdier": [120000.0, 0.71, 0.75, 4.1, 990.0, 176.0, 1.23, 1.18, 3560.0, 165.0, 0.074, 0.099, 0.017, 109.0, 2.41, 0.095], "u_eksport": [0.1703, 0.3807, 0.9502, 0.9697, 0.2233, 0.091, 0.9638, 0.085, 0.6461, 0.6975, 0.5548, 0.8539, 0.7026, 0.0945, 0.5094, 0.7361, 0.8647, 0.8938, 0.4004, 0.1847, 0.2119, 0.0839, 0.2479, 0.8811, 0.9089, 0.3874, 0.1874, 0.2468, 0.9661, 0.9923, 0.0623, 0.3871, 0.517]},
{"verdier": [59300.0, 0.14, 0.5, 8.0, 1480.0, 196.0, 1.19, 1.12, 3280.0, 156.0, 0.078, 0.092, 0.017, 111.0, 2.41, -0.011], "u_eksport": [0.8658, 0.204, 0.6887, 0.1393, 0.5784, 0.327, 0.2199, 0.4528, 0.956, 0.2708, 0.3369, 0.3462, 0.9918, 0.0518, 0.1533, 0.0688, 0.3507, 0.8833, 0.2853, 0.1212, 0.2626, 0.6933, 0.3379, 0.1418, 0.3562, 0.244, 0.1491, 0.6707, 0.4719, 0.864, 0.1747, 0.8976, 0.1268]},
{"verdier": [97800.0, 0.84, 0.74, 3.8, 1040.0, 220.0, 1.17, 1.37, 3980.0, 200.0, 0.04, 0.042, 0.02, 147.0, 2.56, -0.003], "u_eksport": [0.9833, 0.7967, 0.3785, 0.4554, 0.3193, 0.5625, 0.4703, 0.5111, 0.8053, 0.7106, 0.8514, 0.9791, 0.0507, 0.4538, 0.9847, 0.7537, 0.3546, 0.3945, 0.2256, 0.3475, 0.5785, 0.8133, 0.2226, 0.4893, 0.1958, 0.3951, 0.9793, 0.7834, 0.648, 0.697, 0.8391, 0.2313, 0.5821]},
{"verdier": [52500.0, 0.77, 0.44, 5.0, 150.0, 204.0, 1.16, 1.12, 2290.0, 178.0, 0.052, 0.059, 0.087, 109.0, 2.39, 0.073], "u_eksport": [0.2226, 0.8023, 0.2057, 0.0144, 0.6754, 0.8398, 0.2432, 0.1935, 0.462, 0.9792, 0.528, 0.642, 0.9051, 0.2611, 0.6378, 0.3248, 0.5027, 0.5303, 0.7604, 0.5801, 0.0189, 0.321, 0.3421, 0.647, 0.0898, 0.9958, 0.148, 0.2303, 0.6685, 0.8169, 0.1115, 0.9938, 0.0434]},
{"verdier": [97100.0, 0.07, 0.58, 3.0, 1380.0, 244.0, 1.13, 1.43, 3840.0, 204.0, 0.046, 0.068, 0.076, 223.0, 2.35, -0.01], "u_eksport": [0.5216, 0.9482, 0.7193, 0.1051, 0.9246, 0.8838, 0.0771, 0.7698, 0.9418, 0.1622, 0.0114, 0.222, 0.4315, 0.3143, 0.4643, 0.8744, 0.0382, 0.2138, 0.333, 0.1655, 0.589, 0.8998, 0.3152, 0.7904, 0.831, 0.8696, 0.5638, 0.2427, 0.4299, 0.2957, 0.0264, 0.0219, 0.6141]},
{"verdier": [54700.0, 0.95, 0.77, 5.9, 890.0, 177.0, 1.39, 1.24, 3240.0, 112.0, 0.052, 0.064, 0.097, 121.0, 2.06, 0.031], "u_eksport": [0.2155, 0.7399, 0.5486, 0.5482, 0.4588, 0.3802, 0.5416, 0.2674, 0.1491, 0.4184, 0.5383, 0.8327, 0.5609, 0.9652, 0.5896, 0.8425, 0.994, 0.1772, 0.1606, 0.1898, 0.453, 0.0755, 0.9388, 0.9326, 0.9424, 0.6061, 0.5255, 0.1509, 0.9135, 0.9822, 0.7892, 0.9675, 0.3315]},
{"verdier": [87000.0, 0.23, 0.48, 5.6, 1780.0, 178.0, 1.32, 1.47, 2410.0, 149.0, 0.075, 0.083, 0.034, 188.0, 2.11, -0.042], "u_eksport": [0.2001, 0.2404, 0.7202, 0.825, 0.7452, 0.8911, 0.3045, 0.13, 0.9184, 0.0035, 0.757, 0.3823, 0.1447, 0.8366, 0.9498, 0.4203, 0.7024, 0.9846, 0.2335, 0.3515, 0.7025, 0.8903, 0.9124, 0.7858, 0.8734, 0.5009, 0.4371, 0.4567, 0.8009, 0.6418, 0.0977, 0.0735, 0.9641]},
{"verdier": [110900.0, 1.0, 0.41, 3.5, 1890.0, 249.0, 1.36, 1.49, 3690.0, 183.0, 0.054, 0.08, 0.098, 242.0, 2.5, -0.04], "u_eksport": [0.4296, 0.7122, 0.8757, 0.1489, 0.5416, 0.1338, 0.7125, 0.2235, 0.7439, 0.4831, 0.8263, 0.4961, 0.7646, 0.8241, 0.6351, 0.7402, 0.4296, 0.0957, 0.0919, 0.4112, 0.9297, 0.2956, 0.8306, 0.3694, 0.9283, 0.9912, 0.3275, 0.6813, 0.9568, 0.8258, 0.5217, 0.7493, 0.4106]},
{"verdier": [70300.0, 0.26, 0.37, 5.3, 1060.0, 162.0, 1.22, 1.23, 3010.0, 149.0, 0.05, 0.088, 0.005, 270.0, 2.74, -0.032], "u_eksport": [0.2402, 0.6642, 0.9497, 0.9532, 0.5103, 0.8135, 0.7022, 0.9857, 0.7532, 0.7703, 0.9678, 0.113, 0.455, 0.3763, 0.2595, 0.4472, 0.1061, 0.9292, 0.8584, 0.7896, 0.7013, 0.4518, 0.3867, 0.8298, 0.6882, 0.2531, 0.3915, 0.6799, 0.522, 0.872, 0.1928, 0.1153, 0.5249]},
{"verdier": [51400.0, 0.94, 0.39, 5.2, 1420.0, 244.0, 1.2, 1.31, 3100.0, 115.0, 0.04, 0.053, 0.008, 297.0, 2.56, -0.027], "u_eksport": [0.7468, 0.0543, 0.2504, 0.2672, 0.0457, 0.2987, 0.0718, 0.9704, 0.8036, 0.4854, 0.39, 0.6945, 0.2727, 0.8691, 0.9145, 0.9422, 0.3055, 0.8678, 0.1051, 0.9375, 0.132, 0.2254, 0.5339, 0.2556, 0.4893, 0.0575, 0.6923, 0.2831, 0.5891, 0.7643, 0.3356, 0.949, 0.9472]},
{"verdier": [54000.0, 0.79, 0.48, 6.1, 1110.0, 203.0, 1.28, 1.39, 3770.0, 196.0, 0.06, 0.077, 0.097, 107.0, 2.09, 0.004], "u_eksport": [0.4959, 0.3002, 0.0516, 0.8065, 0.4603, 0.1878, 0.2753, 0.4927, 0.4779, 0.9732, 0.0481, 0.0329, 0.6059, 0.0222, 0.2942, 0.9694, 0.2495, 0.4376, 0.7768, 0.466, 0.4325, 0.2792, 0.8212, 0.425, 0.551, 0.9932, 0.5434, 0.0096, 0.148, 0.1587, 0.9332, 0.1095, 0.3642]},
{"verdier": [115600.0, 0.4, 0.51, 5.6, 310.0, 213.0, 1.22, 1.43, 3870.0, 173.0, 0.064, 0.081, 0.05, 161.0, 2.39, -0.017], "u_eksport": [0.0832, 0.7402, 0.3953, 0.9935, 0.9083, 0.8574, 0.3581, 0.3753, 0.4569, 0.0417, 0.3784, 0.3673, 0.8318, 0.5081, 0.6939, 0.4284, 0.7181, 0.5528, 0.8451, 0.7053, 0.9841, 0.2363, 0.0807, 0.9003, 0.0998, 0.3691, 0.7644, 0.5348, 0.06, 0.0834, 0.101, 0.3874, 0.3614]},
{"verdier": [41500.0, 0.77, 0.59, 5.5, 1730.0, 199.0, 1.14, 1.2, 4100.0, 171.0, 0.078, 0.086, 0.021, 287.0, 2.53, 0.027], "u_eksport": [0.8733, 0.7643, 0.0512, 0.4736, 0.3176, 0.9393, 0.2781, 0.3375, 0.9363, 0.0396, 0.4274, 0.5286, 0.042, 0.4518, 0.6601, 0.8281, 0.9041, 0.7754, 0.183, 0.8341, 0.3746, 0.554, 0.8812, 0.8088, 0.2802, 0.0556, 0.4617, 0.6258, 0.723, 0.4979, 0.3539, 0.8401, 0.7181]},
{"verdier": [56000.0, 0.34, 0.3, 3.4, 810.0, 237.0, 1.22, 1.45, 2380.0, 214.0, 0.074, 0.084, 0.055, 116.0, 2.47, -0.039], "u_eksport": [0.4916, 0.0925, 0.2973, 0.6143, 0.6462, 0.4796, 0.0898, 0.7451, 0.4324, 0.9024, 0.5452, 0.2844, 0.6275, 0.4789, 0.6552, 0.5098, 0.1924, 0.6863, 0.8637, 0.882, 0.1077, 0.0805, 0.0928, 0.3693, 0.1645, 0.6876, 0.6034, 0.2338, 0.5863, 0.3267, 0.8488, 0.9851, 0.5343]},
{"verdier": [80300.0, 0.1, 0.67, 4.7, 1200.0, 230.0, 1.32, 1.47, 2490.0, 198.0, 0.063, 0.07, 0.098, 240.0, 2.69, 0.093], "u_eksport": [0.7417, 0.9021, 0.0187, 0.0504, 0.3714, 0.5364, 0.543, 0.5649, 0.2433, 0.0063, 0.9266, 0.6789, 0.7108, 0.0807, 0.0608, 0.6394, 0.4409, 0.3969, 0.4509, 0.8467, 0.9832, 0.0023, 0.06, 0.5883, 0.7581, 0.4744, 0.4323, 0.3242, 0.8532, 0.3774, 0.4932, 0.4137, 0.0693]},
{"verdier": [134100.0, 0.04, 0.21, 7.3, 150.0, 239.0, 1.28, 1.47, 3380.0, 172.0, 0.05, 0.084, 0.062, 261.0, 2.77, -0.044], "u_eksport": [0.3279, 0.7107, 0.9867, 0.2859, 0.21, 0.3939, 0.0278, 0.6773, 0.6562, 0.5885, 0.3944, 0.5757, 0.164, 0.298, 0.1269, 0.8599, 0.4613, 0.9065, 0.7083, 0.2534, 0.833, 0.6153, 0.6862, 0.5596, 0.5131, 0.4761, 0.3454, 0.3332, 0.7377, 0.202, 0.4498, 0.4295, 0.0645]},
{"verdier": [76600.0, 0.32, 0.67, 3.7, 1090.0, 174.0, 1.18, 1.23, 2380.0, 203.0, 0.057, 0.084, 0.062, 261.0, 2.31, 0.045], "u_eksport": [0.1194, 0.0594, 0.9964, 0.557, 0.3135, 0.1144, 0.2424, 0.1261, 0.238, 0.8253, 0.0836, 0.101, 0.9333, 0.8813, 0.6988, 0.7608, 0.9173, 0.055, 0.0053, 0.7644, 0.0395, 0.8606, 0.1338, 0.0439, 0.8788, 0.8505, 0.5757, 0.3671, 0.0857, 0.4647, 0.3844, 0.0908, 0.5832]},
{"verdier": [119300.0, 0.27, 0.25, 3.0, 1210.0, 172.0, 1.34, 1.35, 3500.0, 118.0, 0.056, 0.089, 0.071, 254.0, 2.35, 0.011], "u_eksport": [0.518, 0.7501, 0.7083, 0.5852, 0.9448, 0.4536, 0.8235, 0.8172, 0.3624, 0.2109, 0.2794, 0.026, 0.4009, 0.5359, 0.1973, 0.1065, 0.9733, 0.2418, 0.5638, 0.8414, 0.0609, 0.9942, 0.1564, 0.6089, 0.1942, 0.8561, 0.4974, 0.7105, 0.389, 0.285, 0.9405, 0.6685, 0.5555]},
{"verdier": [45300.0, 0.6, 0.27, 3.3, 1220.0, 239.0, 1.28, 1.36, 2830.0, 214.0, 0.058, 0.068, 0.087, 226.0, 2.09, 0.011], "u_eksport": [0.9449, 0.4765, 0.6846, 0.5172, 0.229, 0.1829, 0.1101, 0.1274, 0.4737, 0.6812, 0.8529, 0.5194, 0.6504, 0.1288, 0.5905, 0.7126, 0.004, 0.3492, 0.1588, 0.0631, 0.8182, 0.3677, 0.9289, 0.6642, 0.0513, 0.6762, 0.2762, 0.5614, 0.5806, 0.4695, 0.398, 0.1795, 0.3488]},
{"verdier": [83100.0, 0.79, 0.26, 3.9, 1840.0, 199.0, 1.4, 1.2, 3950.0, 148.0, 0.065, 0.072, 0.032, 153.0, 2.17, 0.034], "u_eksport": [0.2064, 0.6083, 0.0796, 0.5813, 0.7137, 0.795, 0.9508, 0.5102, 0.4155, 0.3796, 0.6482, 0.7345, 0.6255, 0.3332, 0.326, 0.694, 0.209, 0.164, 0.4402, 0.3513, 0.5536, 0.0126, 0.2573, 0.0492, 0.1597, 0.282, 0.9189, 0.8479, 0.8439, 0.6409, 0.0512, 0.4063, 0.3173]},
{"verdier": [99100.0, 0.66, 0.32, 3.3, 1210.0, 211.0, 1.16, 1.49, 4180.0, 207.0, 0.066, 0.096, 0.091, 119.0, 2.45, 0.078], "u_eksport": [0.3685, 0.943, 0.3631, 0.3271, 0.7679, 0.709, 0.9509, 0.6796, 0.1022, 0.6461, 0.4919, 0.2456, 0.3341, 0.7472, 0.5808, 0.8694, 0.0303, 0.9133, 0.8362, 0.9163, 0.5092, 0.1184, 0.19, 0.7146, 0.8113, 0.0033, 0.6394, 0.1021, 0.5291, 0.8023, 0.7836, 0.3097, 0.0108]},
{"verdier": [112900.0, 0.01, 0.51, 7.5, 290.0, 172.0, 1.17, 1.42, 4130.0, 216.0, 0.08, 0.084, 0.0, 171.0, 2.0, -0.016], "u_eksport": [0.4504, 0.6934, 0.4927, 0.2949, 0.0663, 0.0261, 0.4344, 0.9352, 0.5895, 0.2178, 0.4996, 0.5009, 0.0242, 0.465, 0.504, 0.1802, 0.1769, 0.2553, 0.5437, 0.1703, 0.6946, 0.8179, 0.6226, 0.5045, 0.8771, 0.9827, 0.9758, 0.7414, 0.9465, 0.9932, 0.7364, 0.7581, 0.3437]},
{"verdier": [107900.0, 0.86, 0.59, 6.7, 200.0, 195.0, 1.3, 1.48, 2300.0, 142.0, 0.049, 0.086, 0.015, 197.0, 2.74, 0.006], "u_eksport": [0.7643, 0.2238, 0.0187, 0.9682, 0.8474, 0.2969, 0.7624, 0.4364, 0.9924, 0.2676, 0.6534, 0.3328, 0.7747, 0.3826, 0.2294, 0.4832, 0.111, 0.2303, 0.3954, 0.2263, 0.9797, 0.1174, 0.9234, 0.8876, 0.2979, 0.1429, 0.8801, 0.7773, 0.9302, 0.6953, 0.8706, 0.7833, 0.8873]},
{"verdier": [63900.0, 0.03, 0.49, 7.1, 1910.0, 225.0, 1.11, 1.43, 3900.0, 114.0, 0.049, 0.053, 0.087, 282.0, 2.6, 0.029], "u_eksport": [0.3707, 0.0759, 0.7023, 0.7178, 0.1105, 0.8131, 0.44, 0.0434, 0.6391, 0.1265, 0.116, 0.1632, 0.566, 0.4548, 0.555, 0.3917, 0.6359, 0.3138, 0.5366, 0.8238, 0.8374, 0.9656, 0.0941, 0.0691, 0.7458, 0.8768, 0.1582, 0.8735, 0.284, 0.9519, 0.6349, 0.0203, 0.3705]},
{"verdier": [105700.0, 0.18, 0.71, 4.4, 1140.0, 205.0, 1.36, 1.22, 2690.0, 227.0, 0.075, 0.079, 0.037, 256.0, 2.19, -0.037], "u_eksport": [0.701, 0.5571, 0.145, 0.9772, 0.6134, 0.6272, 0.1914, 0.6077, 0.496, 0.9987, 0.9341, 0.444, 0.1044, 0.6061, 0.4448, 0.5269, 0.7456, 0.6858, 0.3729, 0.1994, 0.8059, 0.3648, 0.3044, 0.9537, 0.401, 0.9159, 0.7433, 0.4639, 0.8898, 0.6175, 0.0324, 0.3638, 0.7617]},
{"verdier": [139600.0, 0.18, 0.39, 7.4, 1040.0, 248.0, 1.15, 1.41, 2250.0, 192.0, 0.053, 0.072, 0.075, 257.0, 2.43, 0.091], "u_eksport": [0.4376, 0.593, 0.5221, 0.3725, 0.7403, 0.696, 0.6266, 0.1055, 0.5732, 0.2729, 0.9564, 0.1307, 0.8305, 0.5502, 0.296, 0.1025, 0.0418, 0.0721, 0.7989, 0.7955, 0.5929, 0.3978, 0.2446, 0.3164, 0.1473, 0.2216, 0.8452, 0.2477, 0.8483, 0.4929, 0.4013, 0.8242, 0.3137]},
{"verdier": [104400.0, 0.31, 0.64, 3.7, 200.0, 156.0, 1.28, 1.43, 2610.0, 179.0, 0.045, 0.079, 0.023, 225.0, 2.39, 0.053], "u_eksport": [0.3575, 0.1973, 0.3388, 0.0838, 0.2615, 0.2325, 0.9227, 0.268, 0.7263, 0.3581, 0.1889, 0.8926, 0.0322, 0.3776, 0.0242, 0.8579, 0.1575, 0.5791, 0.5589, 0.5045, 0.4598, 0.8707, 0.576, 0.193, 0.1123, 0.8967, 0.8829, 0.9833, 0.851, 0.1081, 0.3385, 0.3401, 0.4126]},
{"verdier": [61700.0, 0.4, 0.25, 4.7, 1500.0, 152.0, 1.17, 1.22, 3630.0, 208.0, 0.075, 0.09, 0.079, 234.0, 2.76, 0.03], "u_eksport": [0.6321, 0.8103, 0.7464, 0.0031, 0.7642, 0.7791, 0.0094, 0.9995, 0.5491, 0.5139, 0.7075, 0.399, 0.7948, 0.7763, 0.9944, 0.3405, 0.6036, 0.4294, 0.2816, 0.5215, 0.6776, 0.8405, 0.8981, 0.5521, 0.0762, 0.0738, 0.0868, 0.9779, 0.0447, 0.4802, 0.8754, 0.5412, 0.4559]},
{"verdier": [76700.0, 0.91, 0.48, 5.9, 270.0, 221.0, 1.29, 1.23, 4090.0, 146.0, 0.053, 0.06, 0.038, 175.0, 2.02, -0.012], "u_eksport": [0.3911, 0.653, 0.623, 0.5584, 0.4633, 0.6047, 0.3659, 0.3344, 0.2985, 0.7425, 0.9946, 0.6823, 0.8356, 0.6745, 0.4918, 0.1948, 0.3587, 0.3975, 0.9275, 0.2592, 0.4241, 0.8208, 0.5098, 0.3939, 0.2117, 0.076, 0.032, 0.8922, 0.5056, 0.7665, 0.4612, 0.1027, 0.3805]},
{"verdier": [114900.0, 0.91, 0.38, 5.9, 290.0, 240.0, 1.24, 1.34, 3860.0, 125.0, 0.077, 0.1, 0.082, 287.0, 2.42, 0.081], "u_eksport": [0.8713, 0.5359, 0.6374, 0.249, 0.4834, 0.1113, 0.3037, 0.004, 0.8824, 0.0753, 0.2887, 0.1714, 0.3003, 0.1247, 0.7504, 0.1732, 0.0051, 0.8173, 0.5627, 0.787, 0.3518, 0.3531, 0.7562, 0.9481, 0.6749, 0.1016, 0.9011, 0.5504, 0.1967, 0.9914, 0.9706, 0.5979, 0.0197]},
{"verdier": [73400.0, 0.18, 0.42, 3.3, 1350.0, 199.0, 1.33, 1.45, 3790.0, 125.0, 0.063, 0.066, 0.018, 225.0, 2.46, 0.007], "u_eksport": [0.7066, 0.6221, 0.3149, 0.9095, 0.4978, 0.1271, 0.36, 0.6947, 0.7757, 0.7172, 0.0723, 0.5808, 0.5965, 0.3738, 0.7373, 0.3514, 0.6273, 0.6536, 0.7028, 0.7195, 0.9729, 0.7138, 0.2277, 0.4255, 0.2632, 0.1535, 0.9691, 0.0409, 0.5532, 0.5838, 0.9131, 0.9142, 0.8655]},
{"verdier": [58200.0, 0.33, 0.44, 3.0, 1190.0, 163.0, 1.34, 1.41, 4130.0, 202.0, 0.065, 0.079, 0.002, 292.0, 2.15, -0.046], "u_eksport": [0.6644, 0.2031, 0.4797, 0.3173, 0.4988, 0.5491, 0.5568, 0.0268, 0.5039, 0.0268, 0.2566, 0.0083, 0.9232, 0.5563, 0.9974, 0.2162, 0.9689, 0.9695, 0.7201, 0.3418, 0.539, 0.9828, 0.7868, 0.0403, 0.853, 0.5539, 0.4072, 0.8054, 0.5193, 0.694, 0.2621, 0.8053, 0.4699]},
{"verdier": [73200.0, 0.18, 0.43, 7.0, 1750.0, 227.0, 1.29, 1.34, 3410.0, 219.0, 0.044, 0.056, 0.061, 293.0, 2.1, 0.037], "u_eksport": [0.1097, 0.3862, 0.6675, 0.3702, 0.4265, 0.4325, 0.9724, 0.1054, 0.0977, 0.4931, 0.2316, 0.169, 0.6926, 0.1696, 0.799, 0.7894, 0.039, 0.2085, 0.8231, 0.0628, 0.0799, 0.0023, 0.1993, 0.1365, 0.2347, 0.8888, 0.1394, 0.9365, 0.8558, 0.8066, 0.2046, 0.0548, 0.7898]},
{"verdier": [105000.0, 0.81, 0.47, 4.4, 750.0, 151.0, 1.32, 1.29, 2360.0, 187.0, 0.047, 0.053, 0.054, 150.0, 2.0, 0.033], "u_eksport": [0.3582, 0.1308, 0.3147, 0.6929, 0.5984, 0.7294, 0.084, 0.5784, 0.3644, 0.672, 0.0598, 0.0828, 0.8093, 0.6511, 0.035, 0.8395, 0.249, 0.7204, 0.0923, 0.9647, 0.3612, 0.8347, 0.495, 0.0662, 0.397, 0.591, 0.4371, 0.6111, 0.3561, 0.6077, 0.359, 0.0081, 0.9911]},
{"verdier": [128900.0, 0.79, 0.57, 3.6, 1730.0, 181.0, 1.36, 1.47, 3550.0, 158.0, 0.057, 0.06, 0.001, 252.0, 2.74, -0.026], "u_eksport": [0.4095, 0.7578, 0.8591, 0.1729, 0.9216, 0.9714, 0.777, 0.1282, 0.792, 0.8058, 0.9494, 0.5389, 0.0606, 0.066, 0.7767, 0.9494, 0.1834, 0.0243, 0.128, 0.039, 0.4601, 0.1335, 0.1492, 0.2153, 0.528, 0.966, 0.1886, 0.8143, 0.3755, 0.8136, 0.2348, 0.294, 0.6257]},
{"verdier": [40100.0, 0.74, 0.79, 5.1, 930.0, 195.0, 1.16, 1.49, 2320.0, 194.0, 0.072, 0.074, 0.056, 130.0, 2.76, 0.048], "u_eksport": [0.6352, 0.1376, 0.295, 0.6266, 0.5176, 0.0497, 0.9571, 0.5579, 0.1385, 0.7852, 0.3435, 0.3481, 0.996, 0.4914, 0.3434, 0.5818, 0.9256, 0.5526, 0.1401, 0.9838, 0.382, 0.7304, 0.0724, 0.0374, 0.3423, 0.3385, 0.1047, 0.1188, 0.43, 0.4131, 0.5439, 0.2993, 0.6023]},
{"verdier": [91700.0, 0.24, 0.23, 5.9, 1190.0, 182.0, 1.36, 1.35, 3720.0, 151.0, 0.074, 0.085, 0.091, 279.0, 2.56, 0.064], "u_eksport": [0.245, 0.253, 0.7513, 0.565, 0.9322, 0.1372, 0.3688, 0.5065, 0.7232, 0.2762, 0.5625, 0.4987, 0.4654, 0.0073, 0.4791, 0.5044, 0.6104, 0.9018, 0.4477, 0.1202, 0.4098, 0.7407, 0.3778, 0.4765, 0.5651, 0.4226, 0.442, 0.0016, 0.9306, 0.071, 0.2558, 0.4246, 0.918]},
{"verdier": [46200.0, 0.21, 0.4, 3.2, 240.0, 183.0, 1.15, 1.49, 3020.0, 167.0, 0.046, 0.048, 0.005, 176.0, 2.31, 0.073], "u_eksport": [0.631, 0.9371, 0.9204, 0.4499, 0.9153, 0.5883, 0.6555, 0.9049, 0.7448, 0.956, 0.0038, 0.3348, 0.7267, 0.0336, 0.4079, 0.5497, 0.0733, 0.1298, 0.5961, 0.2327, 0.5252, 0.6261, 0.1751, 0.7448, 0.7848, 0.2311, 0.2498, 0.7288, 0.4007, 0.5699, 0.5955, 0.305, 0.7198]},
{"verdier": [82600.0, 0.3, 0.35, 3.0, 230.0, 223.0, 1.2, 1.17, 3470.0, 217.0, 0.043, 0.063, 0.045, 191.0, 2.68, 0.006], "u_eksport": [0.6775, 0.5997, 0.9984, 0.0439, 0.2598, 0.2878, 0.5491, 0.4436, 0.8813, 0.4228, 0.8858, 0.6662, 0.9307, 0.181, 0.3655, 0.6817, 0.4322, 0.9775, 0.7266, 0.5064, 0.7588, 0.0385, 0.1099, 0.1448, 0.6531, 0.0857, 0.5889, 0.5048, 0.3547, 0.3665, 0.9701, 0.2346, 0.4881]},
{"verdier": [44800.0, 0.37, 0.38, 4.2, 510.0, 161.0, 1.15, 1.28, 2990.0, 218.0, 0.079, 0.085, 0.065, 197.0, 2.38, 0.092], "u_eksport": [0.0114, 0.4158, 0.2302, 0.3956, 0.9292, 0.9141, 0.0745, 0.2087, 0.7361, 0.6088, 0.1155, 0.9623, 0.3733, 0.0394, 0.504, 0.8589, 0.1349, 0.9784, 0.0255, 0.9944, 0.6194, 0.2795, 0.6754, 0.0804, 0.345, 0.655, 0.7512, 0.6032, 0.412, 0.7802, 0.1997, 0.386, 0.6029]},
{"verdier": [60600.0, 0.33, 0.76, 4.0, 280.0, 166.0, 1.13, 1.27, 3900.0, 203.0, 0.044, 0.082, 0.02, 220.0, 2.02, 0.022], "u_eksport": [0.4071, 0.9745, 0.8568, 0.0804, 0.1402, 0.9695, 0.9464, 0.966, 0.5486, 0.6002, 0.7212, 0.806, 0.2751, 0.0683, 0.3771, 0.1699, 0.9882, 0.8786, 0.6367, 0.0059, 0.3083, 0.1738, 0.0573, 0.515, 0.7326, 0.7077, 0.282, 0.2237, 0.6452, 0.8152, 0.4671, 0.1593, 0.0102]},
{"verdier": [117300.0, 0.32, 0.75, 4.8, 1070.0, 209.0, 1.19, 1.44, 2720.0, 126.0, 0.069, 0.084, 0.034, 209.0, 2.13, 0.009], "u_eksport": [0.15, 0.147, 0.0387, 0.1323, 0.9115, 0.657, 0.4151, 0.0131, 0.4426, 0.8431, 0.8431, 0.9464, 0.5847, 0.6971, 0.4248, 0.4809, 0.5565, 0.2144, 0.7065, 0.1468, 0.4782, 0.9702, 0.2198, 0.6231, 0.5216, 0.2376, 0.4572, 0.5753, 0.5251, 0.1758, 0.7585, 0.6039, 0.0525]},
{"verdier": [46400.0, 0.32, 0.64, 3.0, 100.0, 240.0, 1.31, 1.48, 2440.0, 204.0, 0.061, 0.085, 0.041, 279.0, 2.29, 0.074], "u_eksport": [0.5516, 0.8271, 0.3097, 0.6538, 0.289, 0.6105, 0.6637, 0.3899, 0.2106, 0.2893, 0.6455, 0.6491, 0.1661, 0.032, 0.7274, 0.5982, 0.4163, 0.7793, 0.0105, 0.7375, 0.5047, 0.4407, 0.5613, 0.4158, 0.4045, 0.2014, 0.9565, 0.3087, 0.6014, 0.2236, 0.8658, 0.6171, 0.553]},
{"verdier": [116500.0, 0.55, 0.56, 5.5, 1760.0, 158.0, 1.33, 1.31, 4110.0, 200.0, 0.068, 0.108, 0.055, 186.0, 2.37, 0.001], "u_eksport": [0.9311, 0.8657, 0.8292, 0.1081, 0.9286, 0.9777, 0.1034, 0.6702, 0.5213, 0.3252, 0.3739, 0.5208, 0.4573, 0.199, 0.0492, 0.644, 0.5688, 0.3244, 0.6837, 0.3507, 0.4373, 0.609, 0.822, 0.7316, 0.2882, 0.3599, 0.3767, 0.9052, 0.9216, 0.5732, 0.8336, 0.9344, 0.5363]},
{"verdier": [69400.0, 0.34, 0.78, 3.8, 630.0, 226.0, 1.32, 1.41, 2520.0, 223.0, 0.049, 0.056, 0.084, 262.0, 2.58, 0.086], "u_eksport": [0.7354, 0.2251, 0.5607, 0.6016, 0.477, 0.4258, 0.2766, 0.6867, 0.5971, 0.4698, 0.4089, 0.9008, 0.3506, 0.0693, 0.2451, 0.812, 0.7126, 0.2394, 0.1589, 0.6434, 0.5992, 0.6063, 0.4157, 0.448, 0.5426, 0.8866, 0.3754, 0.4443, 0.3995, 0.371, 0.0017, 0.8394, 0.2384]},
{"verdier": [86700.0, 0.52, 0.51, 4.6, 1940.0, 236.0, 1.33, 1.17, 3120.0, 161.0, 0.069, 0.072, 0.081, 146.0, 2.44, 0.011], "u_eksport": [0.5533, 0.4911, 0.4317, 0.1453, 0.9866, 0.9917, 0.956, 0.633, 0.6568, 0.9541, 0.9176, 0.0656, 0.4445, 0.5689, 0.3436, 0.8073, 0.7452, 0.127, 0.4464, 0.2583, 0.1184, 0.5207, 0.2596, 0.6024, 0.2854, 0.2422, 0.8901, 0.5512, 0.4072, 0.1554, 0.8555, 0.912, 0.9458]},
{"verdier": [102800.0, 0.39, 0.46, 6.4, 910.0, 199.0, 1.21, 1.48, 3040.0, 144.0, 0.067, 0.099, 0.045, 120.0, 2.11, 0.096], "u_eksport": [0.581, 0.951, 0.7583, 0.4707, 0.8408, 0.4455, 0.056, 0.7185, 0.1135, 0.4601, 0.6135, 0.3557, 0.1744, 0.2983, 0.466, 0.3755, 0.5323, 0.4839, 0.333, 0.3105, 0.8319, 0.9577, 0.83, 0.4796, 0.6887, 0.2116, 0.8401, 0.0694, 0.9266, 0.9529, 0.4868, 0.6, 0.427]},
{"verdier": [137400.0, 0.24, 0.32, 4.6, 500.0, 245.0, 1.27, 1.35, 4040.0, 201.0, 0.079, 0.096, 0.034, 270.0, 2.41, 0.088], "u_eksport": [0.6191, 0.2096, 0.4595, 0.2823, 0.1986, 0.6408, 0.5616, 0.9047, 0.883, 0.585, 0.8336, 0.2685, 0.6353, 0.2614, 0.288, 0.9954, 0.7343, 0.8339, 0.003, 0.6863, 0.7104, 0.6873, 0.4265, 0.0073, 0.3634, 0.7536, 0.8804, 0.912, 0.6545, 0.3518, 0.0806, 0.9779, 0.0992]},
{"verdier": [121400.0, 0.3, 0.37, 6.3, 810.0, 242.0, 1.2, 1.43, 3800.0, 163.0, 0.059, 0.066, 0.076, 281.0, 2.51, 0.055], "u_eksport": [0.1814, 0.0784, 0.9874, 0.3628, 0.0283, 0.1733, 0.3166, 0.8765, 0.0472, 0.7369, 0.2419, 0.6665, 0.4896, 0.6658, 0.1747, 0.0727, 0.1102, 0.5226, 0.681, 0.7846, 0.2057, 0.681, 0.6905, 0.4983, 0.5617, 0.1962, 0.7192, 0.0137, 0.1253, 0.7214, 0.942, 0.338, 0.0336]},
{"verdier": [125200.0, 0.88, 0.73, 3.7, 1160.0, 207.0, 1.37, 1.3, 2500.0, 157.0, 0.058, 0.092, 0.047, 176.0, 2.34, 0.055], "u_eksport": [0.3656, 0.2084, 0.7563, 0.7084, 0.1106, 0.2978, 0.7918, 0.9814, 0.1785, 0.221, 0.7008, 0.7258, 0.0785, 0.6658, 0.3137, 0.6345, 0.5524, 0.4956, 0.9706, 0.8914, 0.8801, 0.754, 0.3584, 0.7011, 0.5525, 0.7468, 0.9466, 0.2057, 0.8134, 0.008, 0.5042, 0.452, 0.5939]},
{"verdier": [119100.0, 0.91, 0.57, 7.3, 270.0, 196.0, 1.13, 1.41, 2390.0, 104.0, 0.051, 0.07, 0.004, 116.0, 2.29, -0.017], "u_eksport": [0.3057, 0.4818, 0.0879, 0.4389, 0.3289, 0.1236, 0.7685, 0.813, 0.0818, 0.1672, 0.6398, 0.4092, 0.8105, 0.1297, 0.488, 0.4504, 0.3241, 0.2511, 0.4159, 0.5403, 0.2462, 0.0133, 0.1078, 0.6435, 0.1647, 0.2137, 0.2418, 0.2939, 0.1037, 0.87, 0.4207, 0.0656, 0.598]},
{"verdier": [97800.0, 0.12, 0.55, 5.3, 1850.0, 243.0, 1.22, 1.35, 2430.0, 141.0, 0.043, 0.076, 0.054, 296.0, 2.4, 0.006], "u_eksport": [0.6767, 0.3454, 0.8181, 0.9299, 0.2779, 0.7625, 0.9491, 0.2832, 0.8353, 0.5612, 0.0287, 0.5843, 0.7087, 0.0395, 0.0466, 0.2313, 0.6816, 0.3563, 0.0385, 0.6468, 0.7173, 0.9545, 0.8196, 0.825, 0.8644, 0.1968, 0.9584, 0.4785, 0.5579, 0.2748, 0.313, 0.0504, 0.675]},
{"verdier": [131400.0, 0.75, 0.25, 3.2, 1760.0, 159.0, 1.18, 1.32, 3480.0, 103.0, 0.07, 0.104, 0.068, 244.0, 2.22, 0.002], "u_eksport": [0.5496, 0.363, 0.6024, 0.425, 0.4164, 0.6915, 0.3915, 0.7785, 0.1158, 0.0851, 0.4143, 0.409, 0.4717, 0.186, 0.4522, 0.9337, 0.827, 0.4449, 0.8528, 0.6322, 0.3267, 0.0628, 0.1228, 0.4285, 0.2356, 0.5237, 0.4842, 0.4252, 0.9751, 0.3715, 0.5379, 0.3136, 0.8206]},
{"verdier": [127300.0, 0.56, 0.46, 5.4, 1120.0, 210.0, 1.37, 1.43, 2590.0, 128.0, 0.072, 0.077, 0.098, 204.0, 2.21, 0.076], "u_eksport": [0.638, 0.4963, 0.2993, 0.4849, 0.0958, 0.0026, 0.6802, 0.0285, 0.238, 0.5098, 0.8424, 0.976, 0.688, 0.2124, 0.6268, 0.4773, 0.0447, 0.3907, 0.9796, 0.098, 0.411, 0.013, 0.6694, 0.5245, 0.4073, 0.0216, 0.1262, 0.8529, 0.893, 0.6767, 0.6537, 0.3765, 0.3881]},
{"verdier": [58800.0, 0.67, 0.65, 5.2, 1920.0, 202.0, 1.13, 1.42, 3680.0, 142.0, 0.063, 0.095, 0.072, 295.0, 2.3, 0.1], "u_eksport": [0.4009, 0.0684, 0.241, 0.8245, 0.2995, 0.1131, 0.0838, 0.4304, 0.6673, 0.8061, 0.7722, 0.6404, 0.2516, 0.5967, 0.355, 0.0978, 0.1503, 0.3356, 0.566, 0.4702, 0.4823, 0.9448, 0.4739, 0.0138, 0.4464, 0.3868, 0.7484, 0.9036, 0.1523, 0.1521, 0.9355, 0.6328, 0.9844]},
{"verdier": [52400.0, 0.37, 0.45, 3.3, 1090.0, 164.0, 1.14, 1.43, 3900.0, 213.0, 0.058, 0.083, 0.099, 110.0, 2.41, 0.028], "u_eksport": [0.9604, 0.2618, 0.663, 0.1845, 0.2095, 0.8505, 0.9121, 0.3888, 0.6401, 0.5464, 0.0438, 0.9338, 0.6498, 0.3739, 0.1177, 0.5421, 0.136, 0.2943, 0.6752, 0.263, 0.7555, 0.3134, 0.9471, 0.68, 0.1859, 0.5969, 0.394, 0.0202, 0.3809, 0.4778, 0.4853, 0.9381, 0.1098]},
{"verdier": [98300.0, 0.16, 0.41, 7.1, 820.0, 182.0, 1.1, 1.31, 2450.0, 152.0, 0.051, 0.091, 0.081, 195.0, 2.33, 0.038], "u_eksport": [0.9999, 0.3085, 0.5473, 0.6232, 0.2294, 0.5834, 0.9396, 0.7726, 0.0258, 0.0911, 0.0031, 0.9658, 0.5839, 0.7043, 0.9494, 0.5602, 0.306, 0.4838, 0.4836, 0.0779, 0.9475, 0.7806, 0.2923, 0.3293, 0.8791, 0.5385, 0.626, 0.5229, 0.803, 0.8747, 0.5674, 0.7676, 0.4449]},
{"verdier": [76900.0, 0.58, 0.51, 4.9, 120.0, 211.0, 1.28, 1.14, 2540.0, 196.0, 0.042, 0.058, 0.097, 297.0, 2.26, 0.055], "u_eksport": [0.2287, 0.0185, 0.1449, 0.0782, 0.6969, 0.3922, 0.9873, 0.3229, 0.6696, 0.7694, 0.1075, 0.3925, 0.2253, 0.1907, 0.3922, 0.8978, 0.0603, 0.8475, 0.0005, 0.4653, 0.7292, 0.6164, 0.1674, 0.0347, 0.8296, 0.055, 0.1564, 0.748, 0.9029, 0.4013, 0.7836, 0.5131, 0.7619]},
{"verdier": [101200.0, 0.49, 0.44, 6.5, 1730.0, 223.0, 1.19, 1.37, 2580.0, 164.0, 0.047, 0.079, 0.011, 143.0, 2.57, -0.023], "u_eksport": [0.0194, 0.6811, 0.7385, 0.9736, 0.0101, 0.103, 0.7253, 0.1191, 0.2175, 0.377, 0.1971, 0.9734, 0.2769, 0.7687, 0.2244, 0.2473, 0.8278, 0.783, 0.6009, 0.8403, 0.3705, 0.2618, 0.7687, 0.5236, 0.8456, 0.1339, 0.1817, 0.8431, 0.3617, 0.4646, 0.9321, 0.1147, 0.4848]},
{"verdier": [48400.0, 0.94, 0.32, 5.4, 1870.0, 211.0, 1.26, 1.34, 4110.0, 221.0, 0.051, 0.061, 0.082, 119.0, 2.32, 0.034], "u_eksport": [0.3029, 0.4057, 0.3548, 0.5838, 0.2958, 0.8056, 0.4999, 0.0562, 0.6781, 0.9533, 0.8036, 0.3586, 0.0718, 0.9538, 0.5449, 0.3085, 0.7637, 0.3153, 0.4397, 0.2963, 0.3739, 0.6532, 0.7034, 0.5946, 0.3765, 0.857, 0.4769, 0.6627, 0.3957, 0.0959, 0.9471, 0.4997, 0.24]},
{"verdier": [87700.0, 0.21, 0.47, 5.1, 850.0, 159.0, 1.36, 1.22, 3940.0, 128.0, 0.046, 0.082, 0.09, 299.0, 2.5, 0.099], "u_eksport": [0.2411, 0.4375, 0.5229, 0.1611, 0.4323, 0.9263, 0.8426, 0.4948, 0.3613, 0.1805, 0.6449, 0.0529, 0.7537, 0.0908, 0.3546, 0.8097, 0.5179, 0.4779, 0.2267, 0.7394, 0.5079, 0.3031, 0.593, 0.7087, 0.6656, 0.4869, 0.6766, 0.5824, 0.3477, 0.2769, 0.6707, 0.0764, 0.2975]},
{"verdier": [102700.0, 0.45, 0.75, 7.1, 920.0, 168.0, 1.14, 1.36, 3390.0, 132.0, 0.067, 0.099, 0.061, 183.0, 2.09, 0.02], "u_eksport": [0.9159, 0.6814, 0.4113, 0.2891, 0.1217, 0.526, 0.4534, 0.2935, 0.2099, 0.6053, 0.6751, 0.6033, 0.8121, 0.1397, 0.7441, 0.841, 0.0323, 0.987, 0.642, 0.5948, 0.5293, 0.2568, 0.6873, 0.4334, 0.1162, 0.3188, 0.6412, 0.5632, 0.6089, 0.374, 0.8027, 0.0059, 0.3986]},
{"verdier": [75100.0, 0.28, 0.72, 6.4, 360.0, 173.0, 1.24, 1.22, 3560.0, 147.0, 0.07, 0.075, 0.098, 118.0, 2.65, 0.003], "u_eksport": [0.1601, 0.7125, 0.8984, 0.4645, 0.391, 0.4955, 0.0696, 0.51, 0.0015, 0.8009, 0.4135, 0.3185, 0.8407, 0.0346, 0.5501, 0.3246, 0.3582, 0.024, 0.0352, 0.5173, 0.7778, 0.0518, 0.172, 0.613, 0.7061, 0.9868, 0.6394, 0.4004, 0.5777, 0.8722, 0.2207, 0.3498, 0.4749]},
{"verdier": [85600.0, 0.95, 0.29, 6.4, 1900.0, 184.0, 1.15, 1.37, 3640.0, 147.0, 0.047, 0.06, 0.058, 200.0, 2.45, 0.054], "u_eksport": [0.1793, 0.2197, 0.5178, 0.6963, 0.2713, 0.8248, 0.4525, 0.0084, 0.73, 0.4946, 0.5505, 0.2375, 0.9662, 0.6281, 0.5134, 0.9078, 0.6228, 0.8836, 0.731, 0.2035, 0.0573, 0.9054, 0.9402, 0.7624, 0.6721, 0.2832, 0.6444, 0.4751, 0.4677, 0.5546, 0.1466, 0.17, 0.5531]},
{"verdier": [68600.0, 0.25, 0.47, 6.8, 520.0, 190.0, 1.2, 1.17, 4140.0, 201.0, 0.062, 0.072, 0.039, 217.0, 2.27, 0.029], "u_eksport": [0.1315, 0.6908, 0.3029, 0.771, 0.2863, 0.7443, 0.2357, 0.87, 0.336, 0.5262, 0.0561, 0.5011, 0.3584, 0.5506, 0.3161, 0.3419, 0.1179, 0.8573, 0.4761, 0.6643, 0.8962, 0.7879, 0.6377, 0.9221, 0.2603, 0.94, 0.312, 0.1823, 0.1552, 0.2298, 0.4764, 0.9486, 0.2513]},
{"verdier": [109800.0, 0.11, 0.54, 6.6, 240.0, 246.0, 1.38, 1.38, 2250.0, 139.0, 0.052, 0.067, 0.094, 236.0, 2.13, -0.002], "u_eksport": [0.5235, 0.411, 0.5025, 0.449, 0.5376, 0.0446, 0.7185, 0.5311, 0.5255, 0.597, 0.313, 0.3775, 0.5213, 0.0437, 0.5279, 0.2533, 0.2546, 0.5043, 0.7737, 0.8463, 0.2176, 0.5465, 0.1657, 0.5609, 0.5935, 0.4435, 0.136, 0.6436, 0.585, 0.4453, 0.9261, 0.6623, 0.2841]},
{"verdier": [69600.0, 0.15, 0.63, 7.3, 360.0, 165.0, 1.26, 1.46, 2840.0, 206.0, 0.064, 0.077, 0.07, 140.0, 2.4, 0.095], "u_eksport": [0.666, 0.0187, 0.7723, 0.1716, 0.6318, 0.3714, 0.6643, 0.9623, 0.8454, 0.1277, 0.9124, 0.4999, 0.6026, 0.2125, 0.8782, 0.325, 0.659, 0.7791, 0.2774, 0.6779, 0.5467, 0.0899, 0.8961, 0.8081, 0.0293, 0.1934, 0.0714, 0.2363, 0.5808, 0.4484, 0.5146, 0.9472, 0.5658]},
{"verdier": [89900.0, 0.56, 0.32, 7.5, 890.0, 193.0, 1.25, 1.37, 2630.0, 206.0, 0.073, 0.094, 0.079, 143.0, 2.15, 0.074], "u_eksport": [0.5033, 0.9785, 0.8321, 0.9206, 0.9097, 0.9819, 0.241, 0.1399, 0.6356, 0.5694, 0.362, 0.2037, 0.2484, 0.147, 0.9243, 0.866, 0.7789, 0.4489, 0.1077, 0.3658, 0.649, 0.6357, 0.3045, 0.7999, 0.7779, 0.5911, 0.6362, 0.8784, 0.3004, 0.9753, 0.812, 0.4607, 0.5201]},
{"verdier": [89300.0, 0.91, 0.79, 5.9, 110.0, 190.0, 1.28, 1.38, 2320.0, 201.0, 0.053, 0.082, 0.044, 129.0, 2.59, 0.093], "u_eksport": [0.7341, 0.9436, 0.9722, 0.4261, 0.4012, 0.1077, 0.2481, 0.8994, 0.5575, 0.9691, 0.9004, 0.2246, 0.8129, 0.4351, 0.8576, 0.5287, 0.0078, 0.5738, 0.3858, 0.447, 0.8913, 0.8678, 0.6235, 0.8109, 0.6501, 0.1805, 0.2197, 0.6579, 0.0949, 0.1578, 0.7927, 0.1416, 0.9049]},
{"verdier": [103000.0, 0.26, 0.75, 3.1, 1880.0, 247.0, 1.32, 1.17, 2250.0, 174.0, 0.052, 0.077, 0.062, 256.0, 2.23, 0.006], "u_eksport": [0.7949, 0.6512, 0.0619, 0.7238, 0.9452, 0.7513, 0.5829, 0.3573, 0.9385, 0.9361, 0.0742, 0.5955, 0.3516, 0.0141, 0.1888, 0.3073, 0.3412, 0.3123, 0.0085, 0.3167, 0.6146, 0.4229, 0.5842, 0.8446, 0.2849, 0.8305, 0.386, 0.8561, 0.2931, 0.7062, 0.1306, 0.0597, 0.5003]},
{"verdier": [47100.0, 0.42, 0.66, 3.5, 1410.0, 249.0, 1.26, 1.37, 2300.0, 221.0, 0.048, 0.053, 0.068, 283.0, 2.0, 0.092], "u_eksport": [0.7682, 0.0491, 0.3653, 0.0959, 0.1928, 0.2385, 0.1793, 0.7908, 0.5979, 0.977, 0.7601, 0.3364, 0.797, 0.6703, 0.9456, 0.7066, 0.7852, 0.7531, 0.6803, 0.767, 0.3732, 0.7441, 0.8901, 0.6448, 0.658, 0.4783, 0.6706, 0.3435, 0.5065, 0.6847, 0.0256, 0.1251, 0.0707]},
{"verdier": [132100.0, 0.68, 0.51, 3.4, 1700.0, 235.0, 1.13, 1.36, 3350.0, 196.0, 0.057, 0.063, 0.008, 210.0, 2.4, -0.001], "u_eksport": [0.7147, 0.2756, 0.3113, 0.0557, 0.6369, 0.8947, 0.284, 0.0827, 0.4435, 0.7043, 0.6314, 0.3265, 0.7866, 0.9461, 0.3508, 0.7629, 0.4968, 0.9769, 0.0282, 0.8021, 0.3459, 0.3962, 0.9567, 0.8439, 0.6941, 0.7866, 0.8022, 0.5052, 0.6583, 0.2978, 0.4092, 0.6793, 0.1761]},
{"verdier": [53100.0, 0.3, 0.46, 3.1, 310.0, 209.0, 1.38, 1.45, 3010.0, 105.0, 0.054, 0.082, 0.064, 106.0, 2.17, -0.048], "u_eksport": [0.0478, 0.2239, 0.3824, 0.3149, 0.9443, 0.9704, 0.1906, 0.5061, 0.2367, 0.0903, 0.6777, 0.978, 0.952, 0.9568, 0.6415, 0.318, 0.3894, 0.614, 0.2897, 0.2636, 0.0114, 0.2161, 0.3828, 0.5493, 0.345, 0.1629, 0.0994, 0.2077, 0.263, 0.9428, 0.5419, 0.2913, 0.5941]}
],
"M5": {
"A": "holder under betingelser",
"B": "holder under betingelser",
"B'": "holder under betingelser",
"C": "holder",
"R": "holder",
"T-F": "holder",
"T-K": "holder under betingelser"
},
"eos": {
"direkte": "består",
"heleid_selskap": "består",
"majoritet_boers": "usikker",
"petroleumsmodell": "består"
},
"karbonbaner": {
"lav": {
"2026": 500.0,
"2100": 500.0
},
"hoy": {
"2026": 3000.0,
"2100": 4000.0
}
},
"y_obs_maks": 229.0
}

View file

@ -0,0 +1,288 @@
"""Write the made-up basis file ``grunnlag.json`` (chapter 16, clarifications 127 and 129).
Every number is invented: the made-up set of ``tests/conftest.py``, with a
few quantities varied per draw by a seeded generator, and with made-up values
for what only the sensitivity rows and the three marked scenarios read. The
file is marked «oppdiktet»; nothing computed from it says anything about the
hypothesis. The stored reference in ``fasit/`` is the main run written from it.
Run from the root of the repository:
PYTHONPATH=src .venv/bin/python tests/oppdiktet/lag_grunnlag.py [antall]
The reference in ``fasit/`` is the main run of this file on the ladder 1, 2, 5, and is
checked against a run made anew (clarification 129):
PYTHONPATH=src .venv/bin/python -m tokenfabrikker.verktoy hovedkjoring \
--grunnlag tests/oppdiktet/grunnlag.json --ut tests/oppdiktet/fasit --stige 1,2,5 \
--prosesser 8
PYTHONPATH=src .venv/bin/python -m tokenfabrikker.verktoy kontroll \
--grunnlag tests/oppdiktet/grunnlag.json --fasit tests/oppdiktet/fasit --prosesser 8
A set the build-out rejects (nuclear power before the new grid, a step that
is not a whole number of modules) would stop the run (clarification 96); such
sets are drawn again, so the file holds only sets the build-out accepts.
"""
from __future__ import annotations
import dataclasses
import json
import random
import sys
from pathlib import Path
from typing import TYPE_CHECKING, Final, cast
HER: Final = Path(__file__).resolve().parent
sys.path.insert(0, str(HER.parent))
from conftest import GRUNNVERDIER, lag_inndata # noqa: E402
from tokenfabrikker import folsomheter as fs # noqa: E402
from tokenfabrikker import inndata as ind # noqa: E402
from tokenfabrikker import kontantstrom as ks # noqa: E402
from tokenfabrikker import ligninger as lg # noqa: E402
from tokenfabrikker.utbygging import Losning # noqa: E402
if TYPE_CHECKING:
from collections.abc import Callable, Iterator, Mapping
from tokenfabrikker.inndata import Inndata
FIL: Final = HER / "grunnlag.json"
FROE: Final = 20261113
ANTALL: Final = 200
STIGE: Final = (1, 2, 5)
"""The ladder of the made-up reference; every set must be accepted on every step of it."""
FAKTORER: Final[Mapping[str, float]] = {
"c_N_ref": 1e3,
"y_obs": 1e6,
"c_H0": 1e6,
"c_bygg": 1e6,
"D_avv": 1e6,
"S0": 1e6,
"K_U": 1e9,
"SNKS_snitt": 1e9,
}
"""The made-up file's units: kr/kW, mill. kr, TWh and mrd. kr, as the parameter file has them."""
TILLEGG: Final[Mapping[str, float]] = {"tau_pi": 2.5, "P_dim0": 1450.0, "eps_e": 0.0}
"""What only the sensitivity rows read (lines 13, 21 and 28), in the equations' units."""
ENDRET: Final[Mapping[str, float]] = {"SNKS_snitt": 40e9, "T_slutt": 2060}
"""Values of the made-up set changed so that M6 can reach the 25 % step on made-up numbers."""
MODELLVALG: Final = ("T0", "T_slutt", "P_IT", "P_m", "P_ref", "L_buf")
def _rund(x: float, steg: float) -> float:
return round(round(x / steg) * steg, 10)
TRUKNE: Final[Mapping[str, tuple[str, Callable[[random.Random], float]]]] = {
# name: (status, drawn value in the made-up file's unit)
"c_N_ref": ("kilde", lambda r: _rund(r.uniform(40_000.0, 140_000.0), 100.0)),
"w_xi": ("åpen forutsetning", lambda r: _rund(r.uniform(0.2, 0.8), 0.01)),
"u_xi": ("modellvalg", lambda r: _rund(r.random(), 0.01)),
"tau_N": ("kilde", lambda r: _rund(r.uniform(3.0, 8.0), 0.1)),
"n_reaktor": ("åpen forutsetning", lambda r: _rund(r.uniform(40.0, 2000.0), 10.0)),
"c_H0": ("kilde", lambda r: _rund(r.uniform(150.0, 250.0), 1.0)),
"PUE": ("kilde", lambda r: _rund(r.uniform(1.1, 1.4), 0.01)),
"PUE_v": ("kilde", lambda r: _rund(r.uniform(1.1, 1.5), 0.01)),
"p_v": ("kilde", lambda r: _rund(r.uniform(2200.0, 4200.0), 10.0)),
"y_obs": ("kilde", lambda r: _rund(r.uniform(101.0, 229.0), 1.0)),
"rho_N": ("kilde", lambda r: _rund(r.uniform(0.04, 0.08), 0.001)),
"rho_D": ("åpen forutsetning", lambda r: _rund(r.uniform(0.0, 0.04), 0.001)),
"phi_X": ("åpen forutsetning", lambda r: _rund(r.uniform(0.0, 0.1), 0.001)),
"n_1": ("åpen forutsetning", lambda r: _rund(r.uniform(100.0, 300.0), 1.0)),
"tau_pi": ("kilde", lambda r: _rund(r.uniform(2.0, 2.8), 0.01)),
"eps_e": ("åpen forutsetning", lambda r: _rund(r.uniform(-0.05, 0.1), 0.001)),
}
"""The drawn quantities; rho_D is drawn as rho_N plus a margin, so the two are correlated."""
Y_OBS_MAKS: Final = 229.0
"""The upper end of the made-up contract prices, in mill. kr per MW IT and year."""
BORTFALL: Final[Mapping[str, list[float]]] = {
ind.BORTFALL_KILDE: [0.12, 0.21],
ind.BORTFALL_EGNE_LAV: [0.19, 0.38],
ind.BORTFALL_EGNE_HOY: [0.32, 0.64],
}
GAMMA_TRINN: Final[Mapping[str, float]] = dict(
zip(lg.GAMMA_TRINN, (1.0, 0.9, 0.7, 0.0), strict=True)
)
M5: Final[Mapping[str, str]] = {
"A": "holder under betingelser",
"B": "holder under betingelser",
"B'": "holder under betingelser",
"C": "holder",
"R": "holder",
"T-F": "holder",
"T-K": "holder under betingelser",
}
EOS: Final[Mapping[str, str]] = {
"direkte": "består",
"heleid_selskap": "består",
"majoritet_boers": "usikker",
"petroleumsmodell": "består",
}
KARBONBANER: Final[Mapping[str, Mapping[str, float]]] = {
"lav": {"2026": 500.0, "2100": 500.0},
"hoy": {"2026": 3000.0, "2100": 4000.0},
}
def grunnverdier() -> dict[str, float]:
"""Every scalar in the equations' units: the made-up set, changed and extended."""
return {**GRUNNVERDIER, **ENDRET, **TILLEGG}
def trekk(rng: random.Random) -> dict[str, float]:
"""One draw, in the made-up file's units."""
verdier = {navn: trekker(rng) for navn, (_, trekker) in TRUKNE.items()}
verdier["rho_D"] = _rund(verdier["rho_N"] + verdier["rho_D"], 0.001)
return verdier
def som_inndata(verdier: Mapping[str, float], u_eksport: tuple[float, ...]) -> Inndata:
"""The set of one draw, as the basis file will give it."""
mal = lag_inndata()
v = grunnverdier()
for navn, x in verdier.items():
v[navn] = x * FAKTORER.get(navn, 1.0)
return dataclasses.replace(
mal,
v=v,
u_eksport=u_eksport,
bortfall={n: (d[0], d[1]) for n, d in BORTFALL.items()},
Gamma_trinn=GAMMA_TRINN,
)
def varianter(
inn: Inndata, losning: Losning
) -> Iterator[tuple[Inndata, Losning, dict[str, object], dict[str, object]]]:
"""The set, and the set as each sensitivity row that touches the build-out changes it."""
yield inn, losning, {}, {}
for rad in fs.RADER.values():
if not rad.er_kjoring or losning not in rad.gjelder:
continue
x, a = inn.med(rad.verdier) if rad.verdier else inn, losning
dim, plan = dict(rad.brytere.dim), dict(rad.brytere.plan)
if rad.saerskilt is fs.Saerskilt.BESLUTNINGSAAR:
x = fs.med_beslutningsaar(x, fs.BESLUTNINGSAAR)
elif rad.saerskilt is fs.Saerskilt.C_I_MODULER:
a, plan = Losning.T_F, {"uten_forste_trinn": True}
elif rad.saerskilt is fs.Saerskilt.RHO_A:
dim = {"rho_A": x["rho_N"]}
elif rad.saerskilt is fs.Saerskilt.HALV_TAU_N:
x = x.med({"tau_N": x["tau_N"] / 2.0})
yield x, a, dim, plan
def godtatt(inn: Inndata) -> bool:
"""True when the build-out accepts the set on every step, also as the rows change it."""
try:
for losning in Losning:
for x, a, dim, plan in varianter(inn, losning):
d = ks.dimensjoner(x, a, **dim) # type: ignore[arg-type]
for n in STIGE:
ks.lag_plan(x, a, d, N_anlegg=n, **plan) # type: ignore[arg-type]
except ValueError:
return False
return True
def lag(antall: int = ANTALL, froe: int = FROE) -> dict[str, object]:
"""The content of the basis file."""
rng = random.Random(froe) # noqa: S311 - made-up numbers, not a secret
v = grunnverdier()
antall_aar = round(v["T_slutt"] - v["T0"])
trekninger: list[dict[str, object]] = []
while len(trekninger) < antall:
verdier = trekk(rng)
u_eksport = tuple(_rund(rng.random(), 0.0001) for _ in range(antall_aar))
if not godtatt(som_inndata(verdier, u_eksport)):
continue
trekninger.append({"verdier": list(verdier.values()), "u_eksport": list(u_eksport)})
mal = lag_inndata()
storrelser = [
{
"navn": navn,
"faktor": FAKTORER.get(navn, 1.0),
"status": TRUKNE[navn][0]
if navn in TRUKNE
else ("modellvalg" if navn in MODELLVALG else "kilde"),
"verdi": None if navn in TRUKNE else verdi / FAKTORER.get(navn, 1.0),
}
for navn, verdi in v.items()
]
# the values of a draw stand in the order of the quantities in the file
rekkefolge = [list(TRUKNE).index(navn) for navn in v if navn in TRUKNE]
for t in trekninger:
rad = cast("list[float]", t["verdier"])
t["verdier"] = [rad[i] for i in rekkefolge]
return {
"merke": "oppdiktet",
"storrelser": storrelser,
"tabeller": {
"design": dict(mal.design),
"P_u_sett": list(mal.P_u_sett),
"psi": dict(mal.psi),
"kappa": dict(mal.kappa),
"linjer": {n: {"alpha": p.alpha, "b": p.b} for n, p in mal.linjer.items()},
"karbonpris": {str(t): p for t, p in mal.karbonpris.items()},
"eierformer": {
n: {
"s": f.s,
"theta": f.theta,
"tau_g": f.tau_g,
"h": f.h,
"r_d": f.r_d,
"r_q": f.r_q,
"zeta": f.zeta,
"skatt": f.skatt,
}
for n, f in mal.eierformer.items()
},
"areal": dict(mal.areal),
"petroleum_median": 30e9,
"bortfall": dict(BORTFALL),
"u_alt": {n: {str(t): x for t, x in b.items()} for n, b in mal.u_alt.items()},
"kjoletaarn": {n: list(x) for n, x in mal.kjoletaarn.items()},
"Gamma_trinn": dict(GAMMA_TRINN),
},
"trekninger": trekninger,
"M5": dict(M5),
"eos": dict(EOS),
"karbonbaner": {n: dict(b) for n, b in KARBONBANER.items()},
"y_obs_maks": Y_OBS_MAKS,
}
def tekst(data: Mapping[str, object]) -> str:
"""The file's text: indent one, one quantity and one draw per line, UTF-8 as is, LF."""
deler = []
for navn, verdi in data.items():
if navn in {"storrelser", "trekninger"}:
rader = ",\n".join(
" " + json.dumps(r, ensure_ascii=False, allow_nan=False)
for r in verdi # type: ignore[attr-defined]
)
kropp = "[\n" + rader + "\n ]"
else:
kropp = json.dumps(verdi, ensure_ascii=False, indent=1, allow_nan=False)
kropp = kropp.replace("\n", "\n ")
deler.append(f" {json.dumps(navn)}: {kropp}")
return "{\n" + ",\n".join(deler) + "\n}\n"
def main() -> None:
"""Write the file; the number of draws may be given on the command line."""
antall = int(sys.argv[1]) if len(sys.argv) > 1 else ANTALL
FIL.write_bytes(tekst(lag(antall)).encode("utf-8"))
sys.stdout.write(f"{antall} oppdiktede trekninger skrevet til {FIL.name}\n")
if __name__ == "__main__":
main()

323
tests/test_datafiler.py Normal file
View file

@ -0,0 +1,323 @@
"""The data files of the main run and the comparison of ``kontroll`` (clarifications 128, 129).
Invented outcomes per draw for the builders, and made-up files for the comparison. The files
of a real (made-up) run are tested in ``test_verktoy.py``. Nothing here says anything about
the hypothesis.
"""
from __future__ import annotations
import json
import math
import shutil
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import datafiler as df
from tokenfabrikker import kjoring as kj
from tokenfabrikker.dommer import Dom, Forsyning
from tokenfabrikker.kjoring import Bane, Kjoring, Utfall
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
from pathlib import Path
from tokenfabrikker.kjoring import Scenario
NORM, VARER = kj.SCENARIOER[1], kj.SCENARIOER[0]
X40 = [float(v) for v in range(1, 41)]
"""An invented quantity over forty draws: its 10th percentile is 4.9 and its 90th 36.1."""
def _u(NNV: float, M6: float | None = 0.3) -> Utfall:
return Utfall(
NNV=NNV,
S42=1.0,
M3=0.0,
M4=Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False),
M6=M6,
M6_snitt=M6,
M6_median=M6,
M6_2050=None,
M6_topp=0.0 if M6 is None else M6,
stabilt_aar=None if M6 is None else 2040,
toppaar=2040,
)
def _bane(utfall: Utfall | None, scenarioer: tuple[Scenario, ...]) -> Bane:
return Bane(
byggbar=utfall is not None,
forste_aar=2028,
tidslinje={Kraft.NY_FORNYBAR: (0.0, 100.0, 1000.0)},
utfall={} if utfall is None else dict.fromkeys((s.navn for s in scenarioer), utfall),
)
def _kjoring() -> Kjoring:
"""Forty invented draws of A and B on step 5: A positive in the first 28, B mostly unbuilt."""
scenarioer = (VARER, NORM)
return Kjoring(
stige=(5,),
scenarioer=scenarioer,
losninger=(Losning.A, Losning.B),
trekninger=tuple(
{
(Losning.A, 5): _bane(_u(1.0 + j if j < 28 else -1.0 - j), scenarioer),
(Losning.B, 5): _bane(_u(-2.0) if j < 15 else None, scenarioer),
}
for j in range(40)
),
)
M5 = {Losning.A: Dom.HOLDER, Losning.B: Dom.BETINGELSER}
STORRELSER = {"x": X40, "z": [41.0 - v for v in X40]}
STATUS = {"x": "kilde", "z": "åpen forutsetning"}
HODE: dict[str, object] = {"grunnlag": {"merke": "oppdiktet", "sjekksummer": {}}}
# ------------------------------------------------------------------- the format
def test_formatet_er_utf8_lf_innrykk_en_og_ingen_koder() -> None:
tekst = df.json_tekst({"b": [1, 2.5], "a": "ø «holder»", "c": None, "d": (0.1,)})
assert tekst == (
'{\n "b": [\n 1,\n 2.5\n ],\n "a": "ø «holder»",\n "c": null,\n "d": [\n 0.1\n ]\n}\n'
)
assert "\r" not in tekst
assert tekst.endswith("}\n")
assert not tekst.endswith("\n\n")
def test_ingen_avrunding_og_ingen_uendelighet() -> None:
tall = [0.1 + 0.2, 1 / 3, 2.0**-1074, 1e300, -123456.78901234567]
assert json.loads(df.json_tekst(tall)) == tall
assert all(str(x) in df.json_tekst(tall) for x in tall)
for feil in (math.inf, -math.inf, math.nan):
with pytest.raises(ValueError, match="cannot be written"):
df.json_tekst({"x": [feil]})
with pytest.raises(TypeError, match="not a plain JSON value"):
df.json_tekst({"x": {1, 2}})
def test_rekkefolgen_i_stigen_scenarioene_og_losningene() -> None:
stige, scenarioer, losninger = df.ordne(
(5, 1, 2), (kj.SCENARIOER[3], NORM, VARER), (Losning.T_K, Losning.A, Losning.B_MERKET)
)
assert stige == (1, 2, 5)
assert scenarioer == (VARER, NORM, kj.SCENARIOER[3])
assert losninger == (Losning.A, Losning.B_MERKET, Losning.T_K)
with pytest.raises(ValueError, match="stands twice"):
df.ordne((1, 1), (NORM,), (Losning.A,))
# ---------------------------------------------------------------- the builders
def _lest(data: object) -> object:
return json.loads(df.json_tekst(data))
def test_dommer_json_har_tallene_sett_dommer_gir() -> None:
kjoring = _kjoring()
dommer = kj.sett_dommer(kjoring, M5, storrelser=STORRELSER, status=STATUS)
data = df.lag_dommer(HODE, kjoring, dommer)
lest = _lest(data)
assert lest == data | {} # every float reads back to the same float
assert isinstance(lest, dict)
assert list(lest) == [
"grunnlag",
"trinn",
"grunnlag_for_trinnet",
"teller",
"del_I",
"del_II",
"per_scenario",
]
assert (lest["trinn"], lest["grunnlag_for_trinnet"]) == (5, "25 %-trinnet")
assert (lest["teller"], lest["del_I"]) == ("normalisering", dommer.del_I.value)
assert [s["navn"] for s in lest["per_scenario"]] == ["knapphet varer", "normalisering"]
norm = lest["per_scenario"][1]
sd = dommer.scenarioer["normalisering"]
a = norm["trinn"][0]["losninger"]["A"]
assert list(a) == ["M1", "M2", "M3", "M4", "M5", "M6", "median_M1", "ved_siden_av_M6"]
m1 = sd.per_trinn[5][Losning.A].maal["M1"]
assert a["M1"] == {
"dom": m1.dom.value,
"andel_holder": m1.andel_holder,
"andel_holder_ikke": None,
"ikke_byggbar": 0.0,
"oppfylt_blant_byggbare": m1.oppfylt_blant_byggbare,
}
assert a["median_M1"] == sd.per_trinn[5][Losning.A].median_M1
assert a["M5"] == "holder"
# B cannot be built in 25 of 40 draws: the median in M1 has no value
assert sd.per_trinn[5][Losning.B].median_M1 == -math.inf
assert norm["trinn"][0]["losninger"]["B"]["median_M1"] is None
assert norm["trinn"][0]["M7"]["dom"] == sd.M7[5].dom.value
ved = kj.ved_siden_av_m6(kjoring.utfall(NORM, Losning.A, 5))["snitt"]
assert a["ved_siden_av_M6"]["snitt"] == {
"antall": ved.antall,
"median": ved.median,
"p10": ved.persentiler[0] if ved.persentiler else None,
"p90": ved.persentiler[1] if ved.persentiler else None,
}
# the conditions of A with the threshold that counts, and taken together
b = norm["betingelser"]["A"]
assert (b["felt"], b["maal"], b["kan_navngis"]) == (False, ["M1"], True)
terskel = b["terskler"]["M1"][0]
assert list(terskel) == [
"storrelse",
"retning",
"verdi",
"sannsynlighet",
"andel_oppfylt",
"teller",
"kilde",
"indeks",
"paavist",
"begge_halvdeler",
]
assert (terskel["storrelse"], terskel["retning"], terskel["verdi"]) == ("x", "høyst", 35.0)
assert terskel["teller"] is True
assert b["samtidig"]["valgt"]["M1"] == terskel
assert norm["del_I"] == "holder under betingelser"
assert norm["del_I_avgjort"] is True
def test_dommer_json_uten_terskler_sier_at_del_I_ikke_er_avgjort() -> None:
kjoring = _kjoring()
lest = _lest(df.lag_dommer(HODE, kjoring, kj.sett_dommer(kjoring, M5)))
assert isinstance(lest, dict)
norm = lest["per_scenario"][1]
assert (norm["del_I"], norm["del_I_avgjort"], norm["betingelser"]) == (
"holder under betingelser",
False,
None,
)
def test_tidslinje_json_har_tallene_over_trekningene() -> None:
kjoring = _kjoring()
lest = _lest(df.lag_tidslinje(HODE, kjoring))
assert isinstance(lest, dict)
assert lest["typer"] == [*(x.value for x in Kraft), "alle"]
linje = kj.tidslinje_over_trekningene(kjoring, Losning.B, 5)
rader = lest["per_losning"]["B"][0]["typer"]["ny fornybar kraft"]
assert lest["per_losning"]["B"][0]["trinn"] == 5
assert [r["aar"] for r in rader] == [2028, 2029, 2030]
for r, x in zip(rader, linje[Kraft.NY_FORNYBAR.value], strict=True):
assert r == {
"aar": x.aar,
"median": x.median,
"p10": x.persentiler[0],
"p90": x.persentiler[1],
"andel_minst_100_MW": x.andel_minst[0],
"andel_minst_1000_MW": x.andel_minst[1],
}
assert isinstance(rader[0]["aar"], int)
def test_d_stjerne_med_den_faste_eps_d_og_med_0_5_og_2() -> None:
assert df.d_stjerne(0.6, 1.0) == [
{"eps_d": 1.0, "d_stjerne": 0.4},
{"eps_d": 0.5, "d_stjerne": 0.8},
{"eps_d": 2.0, "d_stjerne": 0.2},
]
assert [x["d_stjerne"] for x in df.d_stjerne(None, 1.0)] == [None, None, None] # type: ignore[index]
# --------------------------------------------------------------- the comparison
def _mappe(sti: Path, filer: dict[str, object]) -> Path:
sti.mkdir()
for navn, data in filer.items():
df.skriv(sti / navn, data)
return sti
FILER: dict[str, object] = {
"dommer.json": {"trinn": 5, "andel": 0.1 + 0.2, "dom": "holder", "x": [1.5, None, True]},
"innhold.json": {"stige": [1, 5], "filer": {"dommer.json": "abc"}},
}
def test_like_mapper_er_identiske(tmp_path: Path) -> None:
a, b = _mappe(tmp_path / "a", FILER), _mappe(tmp_path / "b", FILER)
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert (r.dom, r.storste_avvik, r.hvor) == ("identisk", 0.0, None)
assert [f.dom for f in r.filer] == ["identisk", "identisk"]
def test_siste_siffer_er_innenfor_toleransen(tmp_path: Path) -> None:
andel = 0.1 + 0.2
ny = math.nextafter(andel, 1.0)
a = _mappe(tmp_path / "a", FILER)
b = _mappe(tmp_path / "b", {**FILER, "dommer.json": {**FILER["dommer.json"], "andel": ny}}) # type: ignore[dict-item]
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "innenfor toleranse"
assert r.filer[0].dom == "innenfor toleranse"
assert r.storste_avvik == abs(ny - andel) / ny
assert r.hvor == "dommer.json:$.andel"
@pytest.mark.parametrize(
("endring", "forskjell"),
[
({"andel": 0.30000001}, "$.andel"),
({"dom": "holder ikke"}, "$.dom"),
({"trinn": 5.0}, "$.trinn: heltall mot desimaltall"),
({"trinn": 6}, "$.trinn"),
({"x": [1.5, None, 1]}, "$.x[2]: sannhetsverdi mot heltall"),
({"x": [1.5, None]}, "$.x: 3 mot 2 elementer"),
],
)
def test_alt_annet_er_endret(tmp_path: Path, endring: dict[str, object], forskjell: str) -> None:
dommer = FILER["dommer.json"]
assert isinstance(dommer, dict)
a = _mappe(tmp_path / "a", FILER)
b = _mappe(tmp_path / "b", {**FILER, "dommer.json": {**dommer, **endring}})
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "endret"
assert r.filer[0].forskjell is not None
assert r.filer[0].forskjell.startswith(forskjell)
def test_feltenes_rekkefolge_og_et_felt_som_mangler_er_endret(tmp_path: Path) -> None:
dommer = FILER["dommer.json"]
assert isinstance(dommer, dict)
snudd = dict(reversed(list(dommer.items())))
uten = {k: v for k, v in dommer.items() if k != "dom"}
for nr, endret in enumerate((snudd, uten)):
a = _mappe(tmp_path / f"a{nr}", FILER)
b = _mappe(tmp_path / f"b{nr}", {**FILER, "dommer.json": endret})
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "endret"
assert r.filer[0].forskjell == "$: ulike felt eller ulik rekkefølge"
def test_en_fil_som_mangler_er_endret(tmp_path: Path) -> None:
a = _mappe(tmp_path / "a", FILER)
b = _mappe(tmp_path / "b", {"innhold.json": FILER["innhold.json"]})
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "endret"
assert r.filer[0].forskjell == "den lagrede fila finnes ikke"
def test_sjekksummene_i_innhold_holdes_utenfor_den_tolerante_proven(tmp_path: Path) -> None:
a = _mappe(tmp_path / "a", FILER)
b = _mappe(
tmp_path / "b",
{**FILER, "innhold.json": {"stige": [1, 5], "filer": {"dommer.json": "def"}}},
)
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert [f.dom for f in r.filer] == ["identisk", "innenfor toleranse"]
assert r.dom == "innenfor toleranse"
c = tmp_path / "c"
shutil.copytree(b, c)
df.skriv(c / "innhold.json", {"stige": [1, 6], "filer": {"dommer.json": "def"}})
assert df.sammenlign_mapper(a, c, filer=tuple(FILER)).dom == "endret"

246
tests/test_grunnlag.py Normal file
View file

@ -0,0 +1,246 @@
"""The basis of a run (chapter 12; chapter 16, clarification 127).
Made-up numbers only: the made-up basis file in ``tests/oppdiktet`` and variants of it. The
basis from the freeze is only tried up to its guard: until the EEA assessment per ownership
form is written down, it stops before it reads anything.
"""
from __future__ import annotations
import json
import re
from pathlib import Path
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import parametere
from tokenfabrikker.dommer import Dom
from tokenfabrikker.utbygging import Losning
if TYPE_CHECKING:
from collections.abc import Callable
GRUNNLAGSFIL = Path(__file__).resolve().parent / "oppdiktet" / "grunnlag.json"
@pytest.fixture(scope="module")
def grunnlag() -> gl.Grunnlag:
return gl.fra_fil(GRUNNLAGSFIL)
def _raa() -> dict[str, object]:
data: dict[str, object] = json.loads(GRUNNLAGSFIL.read_text(encoding="utf-8"))
return data
def _skriv(tmp_path: Path, data: object) -> Path:
sti = tmp_path / "grunnlag.json"
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
return sti
def test_grunnlagsfila_er_merket_oppdiktet_med_sin_sjekksum(grunnlag: gl.Grunnlag) -> None:
import hashlib # noqa: PLC0415
assert grunnlag.merke == "oppdiktet"
assert grunnlag.sjekksummer == {
"grunnlagsfil": hashlib.sha256(GRUNNLAGSFIL.read_bytes()).hexdigest()
}
assert grunnlag.merkelapp == {"merke": "oppdiktet", "sjekksummer": dict(grunnlag.sjekksummer)}
assert grunnlag.antall >= 40
assert set(grunnlag.M5) == set(Losning)
assert grunnlag.M5[Losning.C] is Dom.HOLDER
assert set(grunnlag.karbonbaner) == {"lav", "hoy"}
def test_trukne_verdier_i_filas_enhet_og_tallsettet_i_ligningenes(grunnlag: gl.Grunnlag) -> None:
"""c_N_ref stands in kr/kW in the file, and in kr/MW in the equations."""
raa = _raa()
storrelser = raa["storrelser"]
assert isinstance(storrelser, list)
trukne = [s["navn"] for s in storrelser if s["verdi"] is None]
assert list(grunnlag.storrelser) == trukne
assert list(grunnlag.status) == trukne
assert grunnlag.faktorer["c_N_ref"] == 1000.0
for omega, inn in enumerate(grunnlag.trekninger):
assert inn["c_N_ref"] == grunnlag.storrelser["c_N_ref"][omega] * 1000.0
assert inn["y_obs"] == grunnlag.storrelser["y_obs"][omega] * 1e6
assert inn["eps_d"] == grunnlag.eps_d
assert len(inn.u_eksport) == round(inn["T_slutt"] - inn["T0"])
assert grunnlag.y_obs_maks == 229e6
assert all(len(x) == grunnlag.antall for x in grunnlag.storrelser.values())
def test_de_forste_N_trekningene(grunnlag: gl.Grunnlag) -> None:
tre = grunnlag.de_forste(3)
assert tre.trekninger == grunnlag.trekninger[:3]
assert tre.storrelser["p_v"] == grunnlag.storrelser["p_v"][:3]
assert tre.sjekksummer == grunnlag.sjekksummer
for feil in (0, grunnlag.antall + 1):
with pytest.raises(gl.GrunnlagError, match="antall trekninger"):
grunnlag.de_forste(feil)
def test_faste_verdier_settes_etter_trekningen_i_filas_enhet(grunnlag: gl.Grunnlag) -> None:
"""Clarification 130: a fixed value in the file's unit, set after the draw (116)."""
med = grunnlag.med_verdier({"c_N_ref": 90_000.0, "eps_d": 0.5})
for gammel, ny in zip(grunnlag.trekninger, med.trekninger, strict=True):
assert ny["c_N_ref"] == 90e6
assert ny["eps_d"] == 0.5
assert ny["p_v"] == gammel["p_v"]
assert ny.med({"c_N_ref": gammel["c_N_ref"], "eps_d": gammel["eps_d"]}) == gammel
# the table of drawn values keeps the drawn values
assert med.storrelser == grunnlag.storrelser
assert med.eps_d == 0.5
assert grunnlag.med_verdier({}) is grunnlag
with pytest.raises(gl.GrunnlagError, match="ukjent størrelse: finnes_ikke"):
grunnlag.med_verdier({"finnes_ikke": 1.0})
def test_grunnlaget_fra_frysen_stanser_foer_noe_leses_uten_EOS_vurderingen() -> None:
"""Clarification 127, «Mangler før del 6»: the guard comes before any file is read."""
with pytest.raises(gl.GrunnlagError, match=r"EØS-vurderingen per eierform er ikke fastsatt"):
gl.fra_frys(None, parametere=Path("/finnes/ikke.json"), data=Path("/finnes/ikke"))
with pytest.raises(gl.GrunnlagError, match=r"avklaring 127"):
gl.fra_frys(None)
def test_den_frosne_sjekksummen_er_den_i_parameterkoden() -> None:
assert gl.FROSSEN_SJEKKSUM == parametere.FROSSEN_SHA256
def _uten(felt: str) -> Callable[[dict[str, object]], None]:
def endre(data: dict[str, object]) -> None:
del data[felt]
return endre
def _sett(felt: str, *args: object, verdi: object = None) -> Callable[[dict[str, object]], None]:
ny = args[0] if args else verdi
def endre(data: dict[str, object]) -> None:
data[felt] = ny
return endre
def _forste_trekning(endring: Callable[[dict[str, object]], object]) -> Callable[..., None]:
def endre(data: dict[str, object]) -> None:
trekninger = data["trekninger"]
assert isinstance(trekninger, list)
endring(trekninger[0])
return endre
def _forste_storrelse(endring: Callable[[dict[str, object]], object]) -> Callable[..., None]:
def endre(data: dict[str, object]) -> None:
storrelser = data["storrelser"]
assert isinstance(storrelser, list)
endring(storrelser[0])
return endre
@pytest.mark.parametrize(
("endring", "melding"),
[
(_sett("ekstra", 1), "grunnlagsfila: ukjent felt: ekstra"),
(_uten("eos"), "grunnlagsfila: feltet mangler: eos"),
(_sett("merke", "frosset"), "merke: en grunnlagsfil skal være merket 'oppdiktet'"),
(_sett("y_obs_maks", "229"), "y_obs_maks: skal være et tall"),
(_sett("y_obs_maks", verdi=True), "y_obs_maks: skal være et tall"),
(_sett("trekninger", []), "trekninger: skal ha minst én trekning"),
(_sett("M5", {"A": "holder"}), "M5: feltet mangler: B"),
(_sett("eos", {"direkte": "består"}), "eos: feltet mangler: heleid_selskap"),
(
_forste_trekning(lambda t: t.update(verdier=[1.0])),
"trekninger[0].verdier: skal ha 16 tall, har 1",
),
(
_forste_trekning(lambda t: t.pop("u_eksport")),
"trekninger[0]: feltet mangler: u_eksport",
),
(
_forste_trekning(lambda t: t.update(u_eksport=["0.5"])),
"trekninger[0].u_eksport[0]: skal være et tall",
),
(
_forste_storrelse(lambda s: s.update(status="kanskje")),
"storrelser[0].status: ukjent status 'kanskje'",
),
(
_forste_storrelse(lambda s: s.update(faktor=0.0)),
"storrelser[0].faktor: skal være positiv",
),
(_forste_storrelse(lambda s: s.update(enhet="år")), "storrelser[0]: ukjent felt: enhet"),
],
)
def test_grunnlagsfila_leses_strengt(
tmp_path: Path, endring: Callable[[dict[str, object]], None], melding: str
) -> None:
data = _raa()
endring(data)
with pytest.raises(gl.GrunnlagError, match=re.escape(melding)):
gl.fra_fil(_skriv(tmp_path, data))
def test_ukjent_dom_i_M5_og_ukjent_vurdering_i_EOS(tmp_path: Path) -> None:
data = _raa()
m5 = data["M5"]
assert isinstance(m5, dict)
m5["A"] = "holder kanskje"
with pytest.raises(gl.GrunnlagError, match=re.escape("M5.A: ukjent dom 'holder kanskje'")):
gl.fra_fil(_skriv(tmp_path, data))
data = _raa()
eos = data["eos"]
assert isinstance(eos, dict)
eos["direkte"] = "ja"
with pytest.raises(gl.GrunnlagError, match=re.escape("eos.direkte: ukjent vurdering 'ja'")):
gl.fra_fil(_skriv(tmp_path, data))
def test_tabellene_leses_strengt(tmp_path: Path) -> None:
data = _raa()
tabeller = data["tabeller"]
assert isinstance(tabeller, dict)
tabeller["bortfall"] = {"lavt": [0.1, 0.2]}
with pytest.raises(gl.GrunnlagError, match=re.escape("tabeller.bortfall: ukjent felt: lavt")):
gl.fra_fil(_skriv(tmp_path, data))
data = _raa()
tabeller = data["tabeller"]
assert isinstance(tabeller, dict)
tabeller["karbonpris"] = {"to tusen": 1.0}
with pytest.raises(gl.GrunnlagError, match="nøkkelen skal være et årstall"):
gl.fra_fil(_skriv(tmp_path, data))
def test_et_felt_to_ganger_og_tall_JSON_ikke_tillater_er_feil(tmp_path: Path) -> None:
sti = tmp_path / "grunnlag.json"
sti.write_text('{"merke": "oppdiktet", "merke": "oppdiktet"}', encoding="utf-8")
with pytest.raises(gl.GrunnlagError, match="feltet 'merke' står to ganger"):
gl.fra_fil(sti)
sti.write_text('{"y_obs_maks": NaN}', encoding="utf-8")
with pytest.raises(gl.GrunnlagError, match="NaN er ikke et tall JSON tillater"):
gl.fra_fil(sti)
def test_rho_N_trukket_krever_rho_D_trukket(tmp_path: Path) -> None:
"""Clarification 115 c: a threshold in rho_N is read in the two halves by rho_D."""
data = _raa()
storrelser = data["storrelser"]
trekninger = data["trekninger"]
assert isinstance(storrelser, list)
assert isinstance(trekninger, list)
trukne = [s["navn"] for s in storrelser if s["verdi"] is None]
i = trukne.index("rho_D")
for s in storrelser:
if s["navn"] == "rho_D":
s["verdi"] = 0.08
for t in trekninger:
del t["verdier"][i]
with pytest.raises(gl.GrunnlagError, match="trenger de trukne verdiene av rho_D"):
gl.fra_fil(_skriv(tmp_path, data))

472
tests/test_verktoy.py Normal file
View file

@ -0,0 +1,472 @@
"""The tools of chapter 12 on the command line (chapter 16, clarifications 126 to 132).
A tiny made-up main run (the first draw of the made-up basis, the ladder 1, 2) is written
once and the tools are tried against it. Made-up numbers only; nothing here says anything about
the hypothesis. The full reproduction of the stored made-up reference in ``oppdiktet/fasit`` is
too slow for the suite and is run by hand (see ``oppdiktet/lag_grunnlag.py``); here only its
checksums are checked.
"""
from __future__ import annotations
import hashlib
import json
import shutil
from pathlib import Path
import pytest
from tokenfabrikker import datafiler as df
from tokenfabrikker import folsomheter as fs
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import kjoring as kj
from tokenfabrikker import verktoy as vt
from tokenfabrikker.utbygging import Losning
OPPDIKTET = Path(__file__).resolve().parent / "oppdiktet"
STIGE = (1, 2)
NORM = kj.SCENARIOER[1]
@pytest.fixture(scope="module")
def liten(tmp_path_factory: pytest.TempPathFactory) -> Path:
"""A basis file with the first made-up draw; one draw keeps the suite fast."""
data = json.loads((OPPDIKTET / "grunnlag.json").read_text(encoding="utf-8"))
data["trekninger"] = data["trekninger"][:1]
sti = tmp_path_factory.mktemp("grunnlag") / "grunnlag.json"
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
return sti
@pytest.fixture(scope="module")
def hoved(liten: Path, tmp_path_factory: pytest.TempPathFactory) -> Path:
"""The tiny main run, written on one process through the command line."""
ut = tmp_path_factory.mktemp("hoved")
assert (
vt.main(["hovedkjoring", "--grunnlag", str(liten), "--ut", str(ut), "--stige", "1,2"]) == 0
)
return ut
def _les(sti: Path) -> dict[str, object]:
data: dict[str, object] = json.loads(sti.read_text(encoding="utf-8"))
return data
def _skriv_inngang(mappe: Path, data: object, navn: str = "inngang.json") -> str:
sti = mappe / navn
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
return str(sti)
# ------------------------------------------------------------------ the main run
def test_hovedkjoringen_skriver_seks_filer_med_innholdsliste(hoved: Path, liten: Path) -> None:
assert sorted(p.name for p in hoved.iterdir()) == sorted(df.ALLE_FILER)
innhold = _les(hoved / "innhold.json")
assert innhold == {
"grunnlag": {
"merke": "oppdiktet",
"sjekksummer": {"grunnlagsfil": hashlib.sha256(liten.read_bytes()).hexdigest()},
},
"antall_trekninger": 1,
"stige": [1, 2],
"scenarioer": [s.navn for s in kj.SCENARIOER],
"losninger": [a.value for a in Losning],
"filer": {
navn: hashlib.sha256((hoved / navn).read_bytes()).hexdigest() for navn in df.FILER
},
}
for navn in df.FILER:
data = _les(hoved / navn)
assert {k: data[k] for k in list(innhold)[:5]} == {k: innhold[k] for k in list(innhold)[:5]}
def test_filene_har_formatet_og_ingen_avrunding(hoved: Path) -> None:
"""Every float reads back to the same float, and writing what was read gives the bytes."""
for navn in df.ALLE_FILER:
raa = (hoved / navn).read_bytes()
assert raa.endswith(b"\n")
assert not raa.endswith(b"\n\n")
assert b"\r" not in raa
assert b"\\u" not in raa
assert df.json_tekst(json.loads(raa)).encode("utf-8") == raa
def test_tallene_er_de_de_eksisterende_funksjonene_gir(hoved: Path, liten: Path) -> None:
g = gl.fra_fil(liten)
kjoring = kj.kjor(g.trekninger, stige=STIGE)
dommer = kj.sett_dommer(kjoring, g.M5, storrelser=g.storrelser, status=g.status)
lest = _les(hoved / "dommer.json")
assert (lest["trinn"], lest["grunnlag_for_trinnet"]) == (
dommer.valg.trinn,
dommer.valg.grunnlag.value,
)
assert lest == df.rein(
df.lag_dommer(df.hode(g, STIGE, kj.SCENARIOER, tuple(Losning)), kjoring, dommer)
)
per_scenario = lest["per_scenario"]
assert isinstance(per_scenario, list)
for blokk in per_scenario:
sd = dommer.scenarioer[blokk["navn"]]
for t in blokk["trinn"]:
for a in Losning:
for m in kj.MAAL_PER_LOSNING:
md = sd.per_trinn[t["trinn"]][a].maal[m]
assert t["losninger"][a.value][m]["dom"] == md.dom.value
assert t["losninger"][a.value][m]["andel_holder"] == md.andel_holder
assert dommer.valg.trinn is not None
trinn = dommer.valg.trinn
# the timeline
tidslinje = _les(hoved / "tidslinje.json")
per_losning = tidslinje["per_losning"]
assert isinstance(per_losning, dict)
alle = kj.tidslinje_over_trekningene(kjoring, Losning.T_K, 2)["alle"]
assert [r["median"] for r in per_losning["T-K"][1]["typer"]["alle"]] == [x.median for x in alle]
# the sensitivity list: the main run's row and one row through kjor_rad
folsomheter = _les(hoved / "folsomheter.json")
hovedkjoringen = folsomheter["hovedkjoringen"]
assert isinstance(hovedkjoringen, dict)
assert list(hovedkjoringen) == [s.navn for s in kj.SCENARIOER if s.navn != "overkapasitet"]
assert hovedkjoringen["normalisering"] == df.rein(
df.radtabell(fs.hovedtabell(kjoring, g.M5, dommer.valg, NORM))
)
rad = fs.RADER["14"]
radkjoring = fs.kjor_rad(g.trekninger, rad, dommer.valg, karbonbaner=g.karbonbaner)
rader = folsomheter["rader"]
assert isinstance(rader, dict)
assert list(rader) == list(fs.RADER)
assert rader["14"]["tabell"]["normalisering"] == df.rein(
df.radtabell(fs.tabell(kjoring, rad, radkjoring, g.M5, dommer.valg)["normalisering"])
)
assert rader["10"]["merknad"] == fs.MERKNAD_STANDARDVILKAAR
assert rader["24"]["tabell"] is None
assert set(rader["24"]["eierformer"]) == {"A", "B", "C", "T-F", "T-K"}
# the price threshold, its check and d*
terskler = _les(hoved / "terskler.json")
p = kj.pristerskel_for_losning(g.trekninger, Losning.C, trinn, NORM)
pris = terskler["pristerskler"]
assert isinstance(pris, dict)
assert pris["C"]["normalisering"]["k"] == p.k
assert list(pris["C"]) == ["knapphet varer", "normalisering", "overkapasitet"]
stjerne = terskler["d_stjerne"]
assert isinstance(stjerne, dict)
assert stjerne["C"]["k_a"] == p.k
assert [x["eps_d"] for x in stjerne["C"]["verdier"]] == [1.0, 0.5, 2.0]
# the ownership forms
eier = _les(hoved / "eierformer.json")
tabeller = kj.eierformer_paa_trinnet(g.trekninger, dommer.valg, g.eos)
per_losning = eier["per_losning"]
assert isinstance(per_losning, dict)
assert per_losning == {a.value: df.rein(df.eierformtabell(tabeller[a])) for a in tabeller}
def test_kontroll_med_to_prosesser_er_identisk(
hoved: Path, liten: Path, capsys: pytest.CaptureFixture[str]
) -> None:
"""Clarification 129 and 101: the same bytes on two processes as on one."""
kode = vt.main(
["kontroll", "--grunnlag", str(liten), "--fasit", str(hoved), "--prosesser", "2"]
)
ut = capsys.readouterr().out
assert kode == 0
for navn in df.ALLE_FILER:
assert f"{navn}: identisk\n" in ut
assert "Samlet: identisk (største relative avvik 0). Grunnlaget er merket «oppdiktet»." in ut
def test_kontroll_sier_endret_og_gir_feilkode(
hoved: Path,
liten: Path,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
capsys: pytest.CaptureFixture[str],
) -> None:
"""A changed verdict in a file made anew is «endret», with exit code 1."""
def kopier_og_endre(_: object, ny: Path, **__: object) -> tuple[str, ...]:
shutil.copytree(hoved, ny, dirs_exist_ok=True)
data = _les(ny / "dommer.json")
data["del_I"] = "holder"
df.skriv(ny / "dommer.json", data)
return df.ALLE_FILER
monkeypatch.setattr(df, "skriv_hovedkjoring", kopier_og_endre)
kode = vt.main(
["kontroll", "--grunnlag", str(liten), "--fasit", str(hoved), "--ut", str(tmp_path / "ny")]
)
ut = capsys.readouterr().out
assert kode == 1
assert "dommer.json: endret; første forskjell: $.del_I: 'holder' mot" in ut
assert "Samlet: endret" in ut
# ------------------------------------------------------------- the four tools
def _uten_verktoy(sti: Path) -> bytes:
data = _les(sti)
verktoy = data["verktoy"]
assert isinstance(verktoy, dict)
assert verktoy["setning"] == vt.SETNING
del data["verktoy"]
return df.json_tekst(data).encode("utf-8")
def test_et_scenario_uten_endringer_gir_hovedkjoringens_filer(
hoved: Path, liten: Path, tmp_path: Path
) -> None:
"""Clarification 130: byte for byte, apart from what the tool adds."""
inngang = _skriv_inngang(tmp_path, {"navn": "uendret", "stige": [2, 1]})
ut = tmp_path / "ut"
assert vt.main(["scenario", inngang, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
for navn in (df.DOMMER, df.TIDSLINJE):
assert _uten_verktoy(ut / navn) == (hoved / navn).read_bytes()
assert next(iter(_les(ut / navn))) == "verktoy"
assert _les(ut / df.DOMMER)["verktoy"] == {
"setning": "Egen kjøring: ingen dom her er rapportens dom",
"kommando": "scenario",
"inngang": {"navn": "uendret", "stige": [2, 1]},
}
def test_scenario_med_egne_verdier_og_sammenlign(hoved: Path, liten: Path, tmp_path: Path) -> None:
inngang = {
"navn": "dyr reaktor",
"verdier": {"c_N_ref": 150000},
"losninger": ["C", "A"],
"stige": [1],
"scenarioer": ["normalisering"],
"trekninger": 1,
}
ut = tmp_path / "ut"
sti = _skriv_inngang(tmp_path, inngang)
assert vt.main(["scenario", sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
dommer = _les(ut / df.DOMMER)
assert dommer["verktoy"] == {"setning": vt.SETNING, "kommando": "scenario", "inngang": inngang}
assert (dommer["antall_trekninger"], dommer["stige"], dommer["losninger"]) == (
1,
[1],
["A", "C"],
)
sammen = tmp_path / "sammen"
assert vt.main(["sammenlign", str(hoved), str(ut), "--ut", str(sammen)]) == 0
s = _les(sammen / "sammenligning.json")
assert list(s) == ["verktoy", "ulikt_grunnlag", "a", "b", "trinnet", "per_scenario"]
assert s["ulikt_grunnlag"] == []
# sammenlign computes nothing: a folder from another basis with more draws is said first
annen = tmp_path / "annen"
annen.mkdir()
dommer["antall_trekninger"] = 5
dommer["grunnlag"] = {"merke": "oppdiktet", "sjekksummer": {"grunnlagsfil": "0"}}
df.skriv(annen / df.DOMMER, dommer)
assert vt.main(["sammenlign", str(hoved), str(annen), "--ut", str(sammen)]) == 0
s = _les(sammen / "sammenligning.json")
assert s["ulikt_grunnlag"] == [
"De to er laget fra ulikt grunnlag.",
"De to har ulikt antall trekninger: 1 og 5.",
]
per_scenario = s["per_scenario"]
assert isinstance(per_scenario, dict)
assert list(per_scenario) == ["normalisering"]
trinn = per_scenario["normalisering"]["trinn"]
assert [t["trinn"] for t in trinn] == [1]
assert list(trinn[0]["losninger"]) == ["A", "C"]
m1 = trinn[0]["losninger"]["A"]["M1"]
assert list(m1) == ["a", "b", "endring_andel_holder"]
median = trinn[0]["losninger"]["A"]["median_M1"]
if median["a"] is not None and median["b"] is not None:
assert median["endring"] == median["b"] - median["a"]
a, b = s["a"], s["b"]
assert isinstance(a, dict)
assert isinstance(b, dict)
assert (a["egen_kjoring"], b["egen_kjoring"]) == (False, True)
def test_folsomhet_med_alle_rader_gir_hovedkjoringens_fil(
hoved: Path, liten: Path, tmp_path: Path
) -> None:
sti = _skriv_inngang(tmp_path, {})
ut = tmp_path / "ut"
kode = vt.main(
[
"folsomhet",
sti,
"--grunnlag",
str(liten),
"--ut",
str(ut),
"--stige",
"1,2",
"--prosesser",
"2",
]
)
assert kode == 0
assert _uten_verktoy(ut / df.FOLSOMHETER) == (hoved / df.FOLSOMHETER).read_bytes()
def test_terskel_for_en_losning(hoved: Path, liten: Path, tmp_path: Path) -> None:
terskler = _les(hoved / "terskler.json")
trinn = terskler["trinn"]
sti = _skriv_inngang(tmp_path, {"losning": "C", "trinn": trinn})
ut = tmp_path / "ut"
assert vt.main(["terskel", sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
t = _les(ut / "terskel.json")
pris = terskler["pristerskler"]
assert isinstance(pris, dict)
assert t["pristerskel"] == pris["C"]["normalisering"]
assert t["d_stjerne"] == terskler["d_stjerne"]["C"]["verdier"] # type: ignore[index]
assert t["median_lcoc_v_2025"] == terskler["median_lcoc_v_2025"]
sti = _skriv_inngang(tmp_path, {"losning": "C", "trinn": trinn, "scenario": "knapphet varer"})
assert vt.main(["terskel", sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 0
t = _les(ut / "terskel.json")
assert t["pristerskel"] == pris["C"]["knapphet varer"]
assert t["d_stjerne"] is None
# ------------------------------------------------------------- strict input files
@pytest.mark.parametrize(
("kommando", "inngang", "melding"),
[
("scenario", {"navn": "x", "ekstra": 1}, "inngangsfila: ukjent felt: ekstra"),
("scenario", {"stige": [1]}, "inngangsfila: feltet mangler: navn"),
("scenario", {"navn": "x", "stige": "1,2"}, "stige: skal være en liste"),
("scenario", {"navn": "x", "trekninger": 1.0}, "trekninger: skal være et heltall"),
("scenario", {"navn": "x", "losninger": ["D"]}, "losninger: ukjent løsning 'D'"),
(
"scenario",
{"navn": "x", "scenarioer": ["tørrår"]},
"scenarioer: ukjent scenario 'tørrår'",
),
("scenario", {"navn": "x", "scenarioer": ["overkapasitet"]}, "«normalisering» må være med"),
(
"scenario",
{"navn": "x", "verdier": {"c_N_reff": 1.0}},
"verdier: ukjent størrelse c_N_reff",
),
(
"scenario",
{"navn": "x", "verdier": {"c_N_ref": "1"}},
"verdier.c_N_ref: skal være et tall",
),
("scenario", {"navn": "x", "trekninger": 3}, "grunnlaget har 1 trekninger, ba om 3"),
("folsomhet", {"rader": ["38"]}, "rader: ukjent rad 38"),
("folsomhet", {"rader": ["14", "14"]}, "rader: står to ganger: 14"),
("terskel", {"losning": "C"}, "inngangsfila: feltet mangler: trinn"),
(
"terskel",
{"losning": "C", "trinn": 2, "scenario": "kildenes lave forlop"},
"ukjent scenario",
),
("terskel", {"losning": "Q", "trinn": 2}, "losning: ukjent løsning 'Q'"),
],
)
def test_inngangsfila_leses_strengt_og_stanser_foer_noe_regnes(
liten: Path,
tmp_path: Path,
capsys: pytest.CaptureFixture[str],
kommando: str,
inngang: object,
melding: str,
) -> None:
sti = _skriv_inngang(tmp_path, inngang)
ut = tmp_path / "ut"
assert vt.main([kommando, sti, "--grunnlag", str(liten), "--ut", str(ut)]) == 2
assert melding in capsys.readouterr().err
assert not ut.exists()
def test_frysen_stanser_ved_vakten(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
"""Clarification 127: until the EEA assessment is written down, --frys stops at once."""
sti = _skriv_inngang(tmp_path, {"navn": "x"})
for argumenter in (
["scenario", sti, "--frys", "--ut", str(tmp_path / "ut")],
["hovedkjoring", "--frys", "--ut", str(tmp_path / "ut")],
):
assert vt.main(argumenter) == 2
assert (
"EØS-vurderingen per eierform er ikke fastsatt (avklaring 127)"
in capsys.readouterr().err
)
assert not (tmp_path / "ut").exists()
def test_grunnlaget_maa_oppgis_paa_en_maate(tmp_path: Path, liten: Path) -> None:
sti = _skriv_inngang(tmp_path, {"navn": "x"})
for argumenter in (
["scenario", sti, "--ut", str(tmp_path)],
["scenario", sti, "--frys", "--grunnlag", str(liten), "--ut", str(tmp_path)],
):
with pytest.raises(SystemExit) as feil:
vt.main(argumenter)
assert feil.value.code == 2
def test_hovedkjoring_kjenner_bare_de_fem_filene(
liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str]
) -> None:
kode = vt.main(
[
"hovedkjoring",
"--grunnlag",
str(liten),
"--ut",
str(tmp_path),
"--filer",
"resultat.json",
]
)
assert kode == 2
assert "--filer: ukjent fil resultat.json" in capsys.readouterr().err
# ------------------------------------------------------------------ the working copy
def test_arbeidskopien(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
kopi = tmp_path / "kopi"
assert vt.main(["arbeidskopi", str(kopi)]) == 0
for sti in (
"src/tokenfabrikker/verktoy.py",
"tests/test_verktoy.py",
"tests/oppdiktet/grunnlag.json",
"modell/parametere.json",
"modell/spesifikasjon.md",
"data/trekninger.npy",
"data/aarshendelser.json",
"requirements.txt",
"requirements-dev.txt",
"pyproject.toml",
):
assert (kopi / sti).is_file(), sti
assert (kopi / sti).read_bytes() == (vt.ROT / sti).read_bytes()
assert not list(kopi.rglob("__pycache__"))
tekst = (kopi / "ARBEIDSKOPI.md").read_text(encoding="utf-8")
sjekksum = hashlib.sha256((vt.ROT / "modell" / "parametere.json").read_bytes()).hexdigest()
assert f"SHA-256 for parameterfila ved kopieringen: `{sjekksum}`" in tekst
assert "Ingenting i en arbeidskopi er rapportens tall." in tekst
assert "Parameterfila var den frosne." in tekst
capsys.readouterr()
assert vt.main(["arbeidskopi", str(kopi)]) == 2
assert "finnes og er ikke en tom mappe" in capsys.readouterr().err
# ------------------------------------------------------------ the stored reference
def test_den_oppdiktede_fasiten_har_sjekksummene_i_innholdslista() -> None:
fasit = OPPDIKTET / "fasit"
innhold = _les(fasit / "innhold.json")
assert innhold["filer"] == {
navn: hashlib.sha256((fasit / navn).read_bytes()).hexdigest() for navn in df.FILER
}
assert innhold["grunnlag"] == {
"merke": "oppdiktet",
"sjekksummer": {
"grunnlagsfil": hashlib.sha256((OPPDIKTET / "grunnlag.json").read_bytes()).hexdigest()
},
}