EcoVal Ändringslogg v0.5.0

Så är beräkningarna byggda, del 4: vattendragsnätet och dammen

Den här delen går från skogssidan till vattensidan. En användare väljer ett hinder eller en damm i ett vattendrag, och sidan visar vad som ligger uppströms, vilken el dammen ger, och vilken lax, havsöring och ål den kostar eller skulle ge med en fiskväg eller utan dammen.

docs/calculations-water.md förklarar vad varje tal betyder och var indata kommer ifrån. Det här dokumentet förklarar koden. Om inget annat sägs utgår sökvägarna från backend/EcoVal.Api/Features/Water/. Kodutdragen är kopierade från källkoden och förkortade; // … visar var något är utelämnat. Koden och dess kommentarer står kvar på engelska.

Innehåll


1. En annan sorts beräkning

Skogssidan arbetar på pixlar: summor över ett raster innanför en polygon. Vattensidan arbetar på en graf: vattendragssegment som sitter ihop ände mot ände, med hinder på sig. Frågorna är graffrågor ("vad kan en fisk nå härifrån?"), och svaren kommer av att vandra i grafen.

flowchart LR
    DB["Databasen: vattendragssegment,<br/>hinder, delavrinningsområden"] --> N["RiverNetwork<br/>(i minnet, byggs en gång)"]
    N --> W["Vandringar: sträckan uppströms, vägen till havet,<br/>laxens livsmiljö"]
    W --> D["DamValuationCalculator<br/>(ren): tre scenarier"]
    O["Options: överlevnader, priser, kostnader"] --> D
    C["Kalibreringar (del 1, avsnitt 5):<br/>smolt per km, havsöringsmodellen"] --> D

Nätet läses in en gång och hålls som en singleton, som de anpassade modellerna i del 1, avsnitt 5. Alla Sveriges vattendrag ryms i minnet, och en vandring tar sedan millisekunder.


2. Nätet som datastruktur

Fil: Network/RiverNetwork.cs.

Ett segment är en sträcka vattendrag, ritad i flödesriktningen från en FromNode till en ToNode. Två segment hänger ihop när det enas ToNode är det andras FromNode. Ett hinder sitter på ett segment vid en bråkdel av dess längd: 0 i den övre änden, 1 i den nedre.

public sealed record NetworkSegment(int Id, int FromNode, int ToNode, double LengthMetres, /* … */);

public sealed record NetworkBarrier(int Id, int SegmentId, double Fraction, bool Blocks, /* … */);

/// <summary>A point on the network: a segment and the fraction of its length from its upstream start.</summary>
public sealed record NetworkPosition(int SegmentId, double Fraction);

/// <summary>Part of a segment, from one fraction of its length to another (0 upstream, 1 downstream).</summary>
public sealed record SegmentPiece(int SegmentId, double From, double To);

Att beskriva lägen som "segment plus bråkdel" har en nyttig följd: längden av vilken bit som helst är enkel aritmetik, utan någon geometri.

en bits la¨ngd=(till−fra˚n)⋅Lsegment\text{en bits längd} = (\text{till} - \text{från}) \cdot L_{\text{segment}}

Konstruktorn bygger uppslagstabeller en gång så att vandringarna aldrig behöver söka:

this.segments = segments.Where(segment => !segment.IsSea).ToDictionary(segment => segment.Id);
endingAt = this.segments.Values.ToLookup(segment => segment.ToNode);       // who flows INTO this node
startingAt = this.segments.Values.ToLookup(segment => segment.FromNode);   // who flows OUT of this node

endingAt[node] svarar på "vilka segment ligger uppströms den här noden?" och startingAt[node] på "vart går vattnet härnäst?". Båda är ILookup, en ordbok från en nyckel till många värden, så varje fråga är ett hashuppslag. Hindren lagras per segment, sorterade efter bråkdel, så "det första hindret ovanför den här punkten" är en genomgång av en kort sorterad array.


3. Vilka hinder som stoppar fisk

Källregistren beskriver varje hinder med en sort (damm, trumma, naturligt fall), ibland en inventerares bedömning av om öring kan passera, och ibland en uppgift om en fiskväg. BarrierRules gör om dem till beslut. De är regler, inte modeller: var och en är en liten ren funktion av några fält, skriven som ett switch-uttryck.

3.1 Öringregeln

public static bool BlocksTrout(string? passabilityTrout, string kind, bool salmonidFishway, string? status) =>
    passabilityTrout switch
    {
        "Impassable" => true,
        "Partial" or "Passable" => false,
        _ => kind == "Dam" && status != "Former" && !salmonidFishway,
    };

Läs uppifrån och ner: en inventerares bedömning vinner när det finns en. Utan den stoppar en stående damm öring om ingen fiskväg är noterad, och allt annat (en trumma, ett naturligt fall som ingen bedömt) gör det inte.

3.2 Laxregeln: fem utfall, inte två

För lax räcker inte ja eller nej, eftersom en fiskväg släpper igenom en del vuxna och ett naturligt vattenfall betyder att älven ovanför aldrig var laxvatten. Regeln ger ett av fem värden:

SalmonPassage Betydelse Effekt på en vandring
Open Passerar fritt Vandras igenom
Fishway En fiskväg, eller bedömd som delvis passerbar Vandras igenom; vuxna passerar med fiskvägens effektivitet
ImpassableSurvey Bedömd som opasserbar, av människan byggd Stoppar vandringen
DamWithoutFishway En damm som ingen bedömt, ingen fiskväg noterad Stoppar vandringen
Natural Bedömd som opasserbar och naturlig Stoppar vandringen; inget ovanför värderas
return passabilityTrout switch
{
    "Impassable" when kind == "Dam" && salmonidFishway => SalmonPassage.Fishway,
    "Impassable" => natural == true || kind == "NaturalBarrier" ? SalmonPassage.Natural : SalmonPassage.ImpassableSurvey,
    "Partial" => SalmonPassage.Fishway,
    "Passable" => kind == "Dam" && salmonidFishway ? SalmonPassage.Fishway : SalmonPassage.Open,
    _ when kind == "Dam" => salmonidFishway ? SalmonPassage.Fishway : SalmonPassage.DamWithoutFishway,
    _ => SalmonPassage.Open,
};

Armarnas ordning spelar roll: den första armen ("Impassable" when …) fångar en damm som bedömts som opasserbar men har en fiskväg, före den allmänna "Impassable"-armen. Ett switch-uttryck tar den första arm som passar.

3.3 En dammanläggning, en bedömning

Ett kraftverk står i registren som flera byggnadsverk: en intagsdamm, ett utskov, ibland fler. En fisk behöver bara en väg förbi. Inläsningen grupperar sådana byggnadsverk till en dammanläggning (EcoVal.Ingest/Water/DamSites.cs: dammar inom 250 m på sammanhängande segment, eller med namn som "Granö A" och "Granö B"), och AsSites ger varje damm i en anläggning anläggningens bästa bedömning:

var blocks = dams.All(dam => dam.Blocks);                    // stopped only if EVERY dam stops them
SalmonPassage? salmon =
    dams.Any(dam => dam.Fishway) ? SalmonPassage.Fishway
    : dams.Any(dam => dam.Salmon == SalmonPassage.Open) ? SalmonPassage.Open
    : dams.Any(dam => dam.Salmon == SalmonPassage.Fishway) ? SalmonPassage.Fishway
    : null;
var hydropower = dams.Any(dam => dam.Hydropower);            // turbines if ANY dam is for power

Lägg märke till asymmetrin mellan All och Any: för att stoppa måste varje byggnadsverk stoppa, men en turbin räcker för att anläggningen ska ha turbiner. Vandringarna räknar sedan en anläggning en gång, hur många av dess dammar de än möter, genom att samla anläggnings-id i en HashSet<int>.

3.4 En trumma som egentligen inte ligger i ån

Inläsningen fäster varje hinder vid närmaste vattendragslinje inom 150 m. Många inventerade trummor ligger i bäckar som är för små för att finnas i nätet, och där en sådan bäck möter en å fästs dess trumma vid ån och skulle stoppa varje vandring där. En regel tar bort dem: en trumma eller vägpassage som ligger mer än 30 m från linjen för ett vattendrag där minst 100 km² rinner igenom antas ligga i en sidobäck.

public static bool BesideARiver(string kind, double snapDistanceMetres, double throughAreaKm2, double snapMetres, double riverKm2) =>
    kind is "Culvert" or "RoadCrossing" && snapDistanceMetres > snapMetres && throughAreaKm2 >= riverKm2;

Kommentaren på den här metoden räknar upp de verkliga älvar där problemet hittades. Det är ett bra exempel på en datakvalitetsregel som finns på grund av bestämda observerade fel, och som säger det.


4. Vandra i nätet

Vandra uppströms från en damm

4.1 Uppströms: bredden-först-sökning

Uppströms grenar sig ån, så vandringen måste utforska varje gren. Upstream är en bredden-först-sökning: en kö håller de segment som återstår att besöka, och en mängd av besökta id ser till att inget besöks två gånger.

var visited = new HashSet<int> { start.SegmentId };
var queue = new Queue<NetworkSegment>();
// … the first segment, from the start point up …

while (queue.TryDequeue(out var segment))
{
    var onSegment = BarriersOn(segment.Id, ignore).ToList();
    // Coming from downstream, the first barrier met is the one furthest down the segment.
    var blocker = onSegment.LastOrDefault(stops);
    var top = blocker?.Fraction ?? 0;
    pieces.Add(new SegmentPiece(segment.Id, top, 1));
    length += (1 - top) * segment.LengthMetres;
    // …
    if (blocker is not null)
    {
        ends.Add(blocker);        // the walk stops on this branch
    }
    else
    {
        Enqueue(segment);         // carry on to the segments flowing into this one
    }
}

En detalj som är lätt att få fel: hindren är sorterade från den övre änden (bråkdel 0) till den nedre (bråkdel 1), men vandringen kommer nedströmsifrån. Det första hindret den möter är därför det sista i den sorterade listan som stoppar fisk, därav LastOrDefault. Den vandrade biten går från det hindrets bråkdel till 1.

Enqueue lägger till de segment som slutar i det här segmentets startnod, och räknar en källa när det inte finns några:

void Enqueue(NetworkSegment segment)
{
    var upstream = endingAt[segment.FromNode].ToList();
    if (upstream.Count == 0)
    {
        headwaters++;
    }
    foreach (var next in upstream.Where(next => visited.Add(next.Id)))
    {
        queue.Enqueue(next);
    }
}

visited.Add(id) ger false om id:t redan fanns, så att använda den inne i Where både prövar och märker i ett steg. Det skyddar mot slingor i datat (en å som delar sig runt en ö och går ihop igen).

Metoden tar stoppregeln som en funktion, Func<NetworkBarrier, bool> stops, så samma vandring tjänar öring (barrier => barrier.Blocks) och ung ål (barrier => barrier.BlocksYoungEel). Den valda dammen själv skickas med i ignore, så vandringen börjar vid den utan att stoppas av den.

4.2 Nedströms: följ vattnet

Nedströms finns ingen förgrening: vattnet från ett segment går till ett nästa segment. Vandringen är en enkel loop som följer Next tills nätet slutar vid havet:

while (visited.Add(segment.Id))
{
    var onSegment = BarriersOn(segment.Id, ignore).Where(barrier => barrier.Fraction > from).ToList();
    barriers.UnionWith(onSegment.Select(barrier => barrier.Site));
    blocking.UnionWith(onSegment.Where(barrier => barrier.Blocks).Select(barrier => barrier.Site));
    lengthToSea += (1 - from) * segment.LengthMetres;
    // …
    if (Next(segment) is not { } next)
    {
        break;
    }
    (segment, from) = next;
}

SalmonToSea är samma loop med en annan räkning: hur många fiskvägar, kraftverksdammar, stoppande hinder och naturliga hinder som ligger mellan punkten och havet. De fyra talen styr laxformeln i avsnitt 8.

4.3 Laxens livsmiljö: en vandring med en storleksgräns

Lax växer upp i älvar, inte i bäckar. Habitat är vandringen uppströms med ytterligare en stoppregel: en gren vandras inte in i när mindre än 100 km² avvattnas genom den.

foreach (var next in upstream.Where(next => visited.Add(next.Id)))
{
    if (AreaAtOutlet(next.Id) is { } area && area < minUpstreamAreaKm2)
    {
        ends.Add(new HabitatEnd(StretchEndReasons.HabitatLimit, null));
    }
    else
    {
        queue.Enqueue(next);
    }
}

Varje slut på vandringen antecknas med en orsakskod (natural_barrier, impassable_survey, dam_without_fishway, habitat_limit), så att sidan kan visa exakt varför livsmiljön slutar där den gör.


5. Hur mycket mark som avvattnas genom en punkt

Flera regler behöver avrinningsområdets yta i en punkt: laxens storleksgräns, breddmodellen (del 1, avsnitt 5.1), elmodellens flöde. De publicerade data ger ytan uppströms varje delavrinningsområdes utlopp, inte i godtyckliga punkter.

5.1 En punkt inne i ett delavrinningsområde

För en punkt en bit in i ett delavrinningsområde fördelas delavrinningsområdets egen yta i proportion till vattendragslängd. Med AutA_{\text{ut}} ytan uppströms utloppet, AcA_c delavrinningsområdets egen yta, och σ\sigma den andel av delavrinningsområdets vattendragslängd som ligger uppströms punkten:

A(punkt)=Aut−Ac⋅(1−σ)σ=vattendragsla¨ngd i delavrinningsomra˚det ovanfo¨r punktenall vattendragsla¨ngd i delavrinningsomra˚detA(\text{punkt}) = A_{\text{ut}} - A_c \cdot (1 - \sigma) \qquad \sigma = \frac{\text{vattendragslängd i delavrinningsområdet ovanför punkten}}{\text{all vattendragslängd i delavrinningsområdet}}

Vid utloppet är σ=1\sigma = 1 och formeln ger AutA_{\text{ut}}; högst upp ger den det som rinner in från andra delavrinningsområden.

var share = Math.Clamp(above / total, 0, 1);
return Math.Max(0, upstreamArea - catchment.AreaKm2 * (1 - share));

5.2 Ytan vid varje segments ände: rekursion utan rekursion

Ett segments yta ska vara minst lika stor som ytan hos de segment som rinner in i det. Det gör att ett segments yta beror på ytorna hos allt uppströms, vilket är rekursivt till sin natur:

Aa¨nde(s)=max⁡(Aegen(s), max⁡u ∈ uppstro¨ms sAa¨nde(u))A_{\text{ände}}(s) = \max\Bigl(A_{\text{egen}}(s),\ \max_{u \,\in\, \text{uppströms } s} A_{\text{ände}}(u)\Bigr)

En rekursiv C#-metod skulle spränga anropsstacken: en lång älv är tusentals segment djup. Koden gör samma arbete med en uttrycklig stack och besöker varje segment två gånger: en gång för att lägga upp dess uppströmssegment, och en gång, när de är klara, för att räkna dess eget värde. Det här är en genomgång i efterordning (post-order).

// Post-order over the segments upstream, without recursion: rivers can be thousands of segments long.
var stack = new Stack<(int Id, bool Expanded)>([(segmentId, false)]);
// …
while (stack.TryPop(out var item))
{
    // …
    if (!item.Expanded)
    {
        stack.Push((item.Id, true));                 // come back to this one later
        foreach (var next in upstream.Where(/* not yet known */))
        {
            stack.Push((next.Id, false));            // but do its upstream segments first
        }
        continue;
    }
    var own = UpstreamAreaKm2(new NetworkPosition(item.Id, 1));
    var above = upstream.Select(next => areaAtOutlet.GetValueOrDefault(next.Id)).Where(area => area is not null).Max();
    areaAtOutlet[item.Id] = own is null ? above : above is null ? own : Math.Max(own.Value, above.Value);
}

Resultaten sparas i en ConcurrentDictionary, så varje segment räknas en gång under processens livstid. Det här mönstret (en rekursiv definition, en uttrycklig stack, en cache) kallas memoisering, och är standardsättet att räkna något över ett djupt träd.


6. Dammens tre scenarier

Fil: Dam/DamValuationCalculator.cs. Allt om en damm räknas för tre scenarier, i en loop:

Scenario El Fisk på väg upp Fisk på väg ner
Kvar (som den är) Full Som dammen är i dag Genom turbinerna
Fiskväg Förlorar vattnet som fiskvägen tar Med fiskvägens effektivitet Genom turbinerna
Riven Ingen Fritt Fritt
foreach (var kind in new[] { DamScenarioKinds.Kept, DamScenarioKinds.Fishway, DamScenarioKinds.Removed })
{
    var sameAsKept = kind == DamScenarioKinds.Fishway && fishwayExists;
    // … power, salmon, sea trout, eel, cost and net for this scenario …
}

Om dammen redan har en fiskväg är fiskvägsscenariot lika med det kvarstående och flaggas sameAsKept.

6.1 En liten verktygslåda för lågt, centralt och högt

Den här kalkylatorn har dussintals formler som var och en behöver tre fall, och vissa parametrar verkar åt motsatt håll (en högre kostnad ger ett lägre netto). Den löser det med en liten uppsättning hjälpfunktioner byggda på en enum:

private enum Case { Low, Central, High }

private static double Pick(ParameterRange range, Case c) => c switch
{
    Case.Low => range.Low,
    Case.High => range.High,
    _ => range.Central,
};

/// <summary>The opposite case, for a parameter that lowers the result when it rises.</summary>
private static Case Flip(Case c) => c switch
{
    Case.Low => Case.High,
    Case.High => Case.Low,
    _ => Case.Central,
};

private static ValueRange Range(Func<Case, double> compute, int digits) =>
    ValueRange.Spanning(compute(Case.Low), compute(Case.Central), compute(Case.High), digits);

En formel skrivs sedan en gång, som en funktion av fallet, och Range kör den tre gånger:

smolts = Range(c => Smolts(inputs, salmon, kind, c), 0);

och en parameter som verkar åt motsatt håll väljs med Flip(c):

Math.Max(0, Pick(price, c) - Pick(power.OperatingCostOrePerKwh, Flip(c)))   // the low case pays the high cost

Det här gör samma jobb som den handskrivna parningen i virkesvärdet (del 2, avsnitt 6.4), men klarar många formler utan att upprepa var och en tre gånger.


7. El

7.1 Produktion: tre källor, den bästa först

Hur mycket el ett kraftverk ger per år tas från den bästa källan som finns, i den här ordningen:

flowchart TD
    A{"Årsproduktion<br/>publicerad?"} -->|ja| P["Använd den"]
    A -->|nej| B{"Effekt (MW)<br/>publicerad?"}
    B -->|ja| C["effekt × fullasttimmar"]
    B -->|nej| D{"Kraftverksdamm med<br/>känd fallhöjd och flöde?"}
    D -->|ja| M["Modellera den från fysiken"]
    D -->|nej| N["Inget värde, med en statuskod som säger varför"]

Från effekt: ett kraftverk på PP megawatt som går motsvarande hh timmar per år på full effekt ger

E=P⋅h1000GWh per a˚rE = \frac{P \cdot h}{1000} \quad \text{GWh per år}

Från fysiken: vatten med densiteten ρ\rho som faller höjden HH med flödet QQ avger effekten ρgHQ\rho g H Q. En turbin gör om en andel η\eta av den till el, och bara en andel cc av medelflödet går att använda (högflöden spills förbi). Över årets 8 760 timmar:

E=η⋅ρ⋅g⋅H⋅Q⋅c⋅8760109GWh per a˚rE = \frac{\eta \cdot \rho \cdot g \cdot H \cdot Q \cdot c \cdot 8760}{10^{9}} \quad \text{GWh per år}

med ρ=1000\rho = 1000 kg/m³ och g=9,81g = 9{,}81 m/s². Produkten ρgHQ\rho g H Q är i watt; gånger timmar ger wattimmar, och 10910^9 sådana är en gigawattimme.

private const double WaterDensity = 1000, Gravity = 9.81, HoursPerYear = 8760;

/// <summary>E = η ρ g H Q c × 8,760 h, in GWh a year.</summary>
public static double ModelledGigawattHours(double headMetres, double meanFlowM3s, double efficiency, double usableShare) =>
    efficiency * WaterDensity * Gravity * headMetres * meanFlowM3s * usableShare * HoursPerYear / 1e9;

Metoden Production ger en statuskod tillsammans med värdet (Published, FromCapacity, Modelled, NoHead, NoFlow, NotHydropower), så att sidan kan säga vilken källa den visar.

7.2 Priset: medel eller fångstpris

Årsmedelpriset per elområde är utgångsvärdet. Ett kraftverk med vatten lagrat bakom sig kan välja när det kör, och kör när priset är högt. Ett sådant kraftverk prissätts till vattenkraftens fångstpris: priset viktat med hur mycket vattenkraften faktiskt producerade varje timme.

pfa˚ngst=∑hqh⋅ph∑hqhp_{\text{fångst}} = \frac{\sum_h q_h \cdot p_h}{\sum_h q_h}

med qhq_h elområdets vattenkraftsproduktion och php_h priset timme hh. Det här är ett produktionsviktat medelvärde, samma konstruktion som den volymviktade trädslagsblandningen i del 2, avsnitt 5.

Det räknas i förväg av scripts/power-market.py från öppna timdata och klistras in i PowerOptions som en tabell per elområde och år. Det är en beräknad statistik, inte en anpassad modell: ingenting skattas, bara medelvärdesbildas.

Medelpris och fångstpris per elområde
var storage = inputs.RegulationDegreePercent >= options.StorageMinRegulationPercent;
// …
var price = captureYears is null ? mean : YearRange(captureYears, 1);

Intervallet över åren är det billigaste året, medelvärdet och det dyraste året:

private static ValueRange YearRange(IReadOnlyDictionary<int, double> byYear, int digits) =>
    new(Math.Round(byYear.Values.Min(), digits), Math.Round(byYear.Values.Average(), digits), Math.Round(byYear.Values.Max(), digits));

7.3 Intäkten och dess nuvärde

Årsintäkten är energin gånger priset minus driftkostnaden oo, aldrig under noll (ett kraftverk som inte kan täcka sina driftkostnader skulle stå still). EE är i GWh, så E⋅106E \cdot 10^6 är kWh, och priser i öre delas med 100 för att ge kronor:

R=E⋅106⋅max⁡(0, p−o)100R = E \cdot 10^{6} \cdot \frac{\max(0,\ p - o)}{100}
var revenue = energy is not null && powerValuation.PriceOrePerKwh is { } price
    ? Range(c => Pick(energy, c) * 1e6 * Math.Max(0, Pick(price, c) - Pick(power.OperatingCostOrePerKwh, Flip(c))) / 100, digits: 0)
    : null;

Nuvärdet över tidshorisonten (H=30H = 30 år, r=3,5 %r = 3{,}5\,\%) summerar årsvärdet från år 1:

PV=∑t=1HR(1+r)tPV = \sum_{t=1}^{H} \frac{R}{(1 + r)^{t}}
// Money.cs
public static double PresentValue(Func<int, double> valueInYear, double discountRate, int horizonYears, int fromYear = 1)
{
    var total = 0.0;
    for (var year = Math.Max(1, fromYear); year <= horizonYears; year++)
    {
        total += valueInYear(year) / Math.Pow(1 + discountRate, year);
    }
    return total;
}

Värdet ett visst år skickas in som en funktion, så samma metod klarar ett konstant flöde (_ => value) och ett som ändras över tid (fiskrampen i avsnitt 8.3).

I fiskvägsscenariot minskas energin med den andel av flödet som fiskvägen tar; i scenariot med riven damm är den noll. Ett kraftverk med magasin får också betalt för att hålla effekt i reserv, värderat per megawatt och avslutat av en rivning.


8. Lax

8.1 Smolt som når havet

En smolt är en ung lax på väg mot havet. Antalet som når det från livsmiljön ovanför dammen är en kedja av multiplikationer:

S=L⋅d⋅u⋅w⋅ε nf⋅μ nhS = L \cdot d \cdot u \cdot w \cdot \varepsilon^{\,n_f} \cdot \mu^{\,n_h}
Symbol Betydelse
LL Laxens livsmiljö ovanför dammen, km (vandringen i avsnitt 4.3)
dd Smolt per km (kalibrerat, del 1, avsnitt 5.3)
uu Andel lekvandrande vuxna som tar sig upp förbi den här dammen
ww Andel smolt som tar sig ner förbi den här dammen
ε\varepsilon En fiskvägs effektivitet (0,20, 0,37, 0,60)
nfn_f Fiskvägar mellan dammen och havet
μ\mu En smolts överlevnad förbi en kraftverksdamm (0,75, 0,88, 0,95)
nhn_h Kraftverksdammar mellan dammen och havet

Scenariot ändrar bara uu och ww:

var up = kind == DamScenarioKinds.Removed ? 1 : inputs.Passage switch
{
    SalmonPassage.Open => 1,
    SalmonPassage.Fishway => fishway,
    _ => kind == DamScenarioKinds.Fishway ? fishway : 0,       // blocked today: 0 kept, the efficiency with a fishway
};
var down = kind != DamScenarioKinds.Removed && inputs.Hydropower ? damSurvival : 1;
var toSea = inputs.ToSea!;
var below = Math.Pow(fishway, toSea.FishwayBarriers) * Math.Pow(damSurvival, toSea.HydropowerDams);
return habitatKm * density * up * down * below;

Exponenterna är skälet till att dammar längre ner i älven spelar så stor roll. Var och en multiplicerar andelen en gång till:

Andelen som tar sig förbi flera dammar

8.2 Från smolt till fångad fisk

Därifrån fortsätter kedjan med överlevnad i havet och andelarna som fångas:

flowchart LR
    S["Smolt<br/>som når havet"] -->|"× postsmoltöverlevnad (0,10)<br/>× vuxenöverlevnad (0,92)"| A["Vuxna<br/>som återvänder"]
    A -->|"× kustfiskets uttag (0,15)"| C["Kustfångst<br/>(antal)"]
    C -->|"× medelvikt × pris per kg"| K["Kustfångst<br/>(kr per år)"]
    A -->|"× (fångstandel i älven + trolling)"| G["Sportfiskarnas fångst"]
    G -->|"× utgifter per fisk"| P["Sportfiskarnas utgifter"]
vuxna=S⋅spost⋅svuxenkustfa˚ngst (kr)=vuxna⋅hc⋅m⋅p\text{vuxna} = S \cdot s_{\text{post}} \cdot s_{\text{vuxen}} \qquad \text{kustfångst (kr)} = \text{vuxna} \cdot h_c \cdot m \cdot p
private static double CoastalSek(DamInputs inputs, SalmonOptions options, string kind, Case c) =>
    Smolts(inputs, options, kind, c) * Pick(options.PostSmoltSurvival, c) * options.AdultSurvival
    * Pick(options.CoastalHarvestRate, c) * options.MeanWeightKg * options.PricePerKg;

Varje faktor är en inställning med sin källa. Hela laxsidan är en produkt av publicerade andelar och en kalibrerad täthet; det finns ingen anpassad modell i den utöver den tätheten.

8.3 Uppbyggnaden: fisken kommer inte på en gång

En ny fiskväg fyller inte älven med lax året därpå: de första lekfiskarnas avkomma måste växa upp, gå till havs och komma tillbaka. Den årliga fångsten går därför från dagens värde KK till scenariots värde NN i en rät linje över T=10T = 10 år:

v(t)=K+(N−K)⋅min⁡ ⁣(1, tT)PV=∑t=1Hv(t)(1+r)tv(t) = K + (N - K) \cdot \min\!\left(1,\ \frac{t}{T}\right) \qquad PV = \sum_{t=1}^{H} \frac{v(t)}{(1 + r)^{t}}
fishPv = Range(c =>
{
    var kept = CoastalSek(inputs, salmon, DamScenarioKinds.Kept, c);
    var now = CoastalSek(inputs, salmon, kind, c);
    return PresentValue(year => kept + (now - kept) * Math.Min(1, year / (double)salmon.RampUpYears), power);
}, 0);
Uppbyggnaden och diskonteringens effekt

Typomvandlingen (double)salmon.RampUpYears är inte pynt. year och RampUpYears är båda int, och year / 10 i heltalsaritmetik är 0 de första nio åren. Utan omvandlingen skulle rampen bli ett trappsteg.

8.4 Ett resultat som beror på något annat

Om ett hinder längre ner i älven stoppar laxen helt når ingen fisk den här dammen, vad som än görs här. Kalkylatorn räknar ändå scenariot, med hindren nedanför behandlade som passerbara, och sätter en flagga (inputs.ToSea is { BlockingBarriers: > 0 }) så att sidan kan säga att resultatet bara gäller om även de öppnas. Ett naturligt hinder nedanför är något annat: älven ovanför var aldrig laxvatten, så statusen är NaturalBarrierBelow och ingenting värderas.

Statusarna bestäms med en switch över egenskapsmönster, som läses som en tabell av villkor:

var status = inputs switch
{
    { River: null } => SalmonStatuses.NotSalmonRiver,
    { OnNetwork: false } or { Habitat: null } or { ToSea: null } => SalmonStatuses.OffNetwork,
    { ToSea.NaturalBarriers: > 0 } => SalmonStatuses.NaturalBarrierBelow,
    { Density: null } => SalmonStatuses.NotSalmonRiver,
    _ => SalmonStatuses.Valued,
};

9. Havsöring

Havsöring använder samma passagefaktorer som lax men en annan utgångspunkt. Dess livsmiljö har ingen storleksgräns (den leker i små vattendrag), och antalet ungar kommer från havsöringsmodellen i del 1, avsnitt 5: vattendragets modellerade bredd gånger täthetsklassen i dess distrikt.

So¨ring=Y⋅k⋅u⋅w⋅ε nf⋅μ nhS_{\text{öring}} = Y \cdot k \cdot u \cdot w \cdot \varepsilon^{\,n_f} \cdot \mu^{\,n_h}

med YY de öringungar sträckan rymmer och kk den kalibrerade smolten per öringunge. Fångsten är sedan

fa˚ngade=So¨ring⋅codlad⋅fvild\text{fångade} = S_{\text{öring}} \cdot c_{\text{odlad}} \cdot f_{\text{vild}}

där codladc_{\text{odlad}} är andelen odlad smolt som rapporteras fångad (2,9 %, från märkningsstudier) och fvildf_{\text{vild}} en faktor för hur mycket bättre vild smolt klarar sig i havet (1, 3,7 eller 4,5).

private static double SeaTroutCatchSek(DamInputs inputs, SalmonOptions salmon, SeaTroutOptions trout, string kind, Case c) =>
    SeaTroutSmolts(inputs, salmon, kind, c) * trout.ReportedCatchRate * Pick(trout.WildFactor, c) * trout.MeanWeightKg
    * Pick(trout.PricePerKg, c);

Vildfaktorn visar hur en lucka i datat hanteras: det finns inget svenskt tal för vild havsöring, så intervallet går från "inte bättre än odlad" till talet som mätts för lax, och kommentaren på inställningen säger just det.


10. Ål

Ål hanteras annorlunda, eftersom den nationella ålbedömningen redan skattar hur många ton blankål som dödas vid varje större kraftverk. EcoVal visar det talet för kraftverket och lägger till två egna saker.

10.1 Överlevnad till havet

En blankål på väg ner passerar varje kraftverks turbiner med dödligheten mm (0,31, 0,70 eller 0,90). Förbi nn kraftverk:

o¨verlevnad=(1−m) n\text{överlevnad} = (1 - m)^{\,n}
var survival = 1 - Pick(options.TurbineMortality, Flip(c));       // the low case takes the high mortality
var turbines = inputs.Hydropower || inputs.Eel?.Plant is not null;
var plants = (inputs.ToSea?.HydropowerDams ?? 0) + (turbines && kind != DamScenarioKinds.Removed ? 1 : 0);
return Math.Pow(survival, plants);

En fiskväg ändrar inte detta: fiskvägar hjälper fisk uppåt, och ålarna dödas på väg ner.

10.2 Från ton till ett antal ålar

"0,8 ton ål" är svårt att se framför sig; ett antal ålar är det inte. För att räkna om behövs ålens medelvikt, och den kommer från två publicerade samband, använda med sina koefficienter som de är (lånad regression, som i del 3).

Först stiger en blankåls medellängd med breddgraden, som en rät linje:

ℓ(φ)=70+5 (φ−56)cm, med φ breddgraden i grader nord\ell(\varphi) = 70 + 5\,(\varphi - 56) \quad \text{cm, med } \varphi \text{ breddgraden i grader nord}

Sedan följer vikten längden som en potenslag, den vanliga formen för ett längd–vikt-samband i fiskbiologin:

W=a⋅ℓ bg,a=0,000559, b=3,297W = a \cdot \ell^{\,b} \quad \text{g}, \qquad a = 0{,}000559,\ b = 3{,}297

Exponenten ligger nära 3 eftersom vikten växer med volymen, och volymen med längden i kubik.

public sealed record SilverEelLength(double Central, double PerDegree, double AtLatitude)
{
    public double At(double latitude) => Central + PerDegree * (latitude - AtLatitude);
}

public sealed record LengthWeight(double A, double B)
{
    public double Grams(double lengthCm) => A * Math.Pow(lengthCm, B);
}

Antalet ålar är sedan ton delat med gram, avrundat till två gällande siffror, eftersom vikten är ett nationellt medelvärde och fler siffror skulle påstå mer än vad som är känt:

n=ton⋅106Wn = \frac{\text{ton} \cdot 10^{6}}{W}
public static double EelCount(double tonnes, double grams)
{
    var count = tonnes * 1_000_000 / grams;
    if (count < 1) return Math.Round(count, 1);
    var scale = Math.Pow(10, Math.Floor(Math.Log10(count)) - 1);
    return Math.Round(count / scale) * scale;
}

Math.Floor(Math.Log10(count)) är antalet siffror före decimaltecknet, minus ett. Att dela med en tiopotens ett steg lägre lämnar två siffror att avrunda, och att multiplicera tillbaka återställer storleken: 6 843 blir 6 800.


11. Kostnader, nettot och betalningsvilja

11.1 Vad en fiskväg eller en rivning kostar

Publicerade kostnader anges per meter fallhöjd. Engångskostnaden för en fiskväg är

Cenga˚ng=H⋅cper meter⋅KPIprisa˚rKPIkostnadsa˚r+CutredningC_{\text{engång}} = H \cdot c_{\text{per meter}} \cdot \frac{\text{KPI}_{\text{prisår}}}{\text{KPI}_{\text{kostnadsår}}} + C_{\text{utredning}}

med olika kostnad per meter för stora och små kraftverk, och ett årligt underhåll ovanpå. Nuvärdet lägger underhållets nuvärde till engångskostnaden:

oneOff = Range(c => Index(head * Pick(perMetre, c), year, costs) + study, 0);
upkeep = Range(c => Index(Pick(costs.FishwayUpkeepSekPerYear, c), costs.FishwayStudyPriceYear, costs), 0);
// …
var presentValue = Combine(oneOff, upkeep, (once, yearly) => once + PresentValue(_ => yearly, power), 0);

Rivningskostnaden kommer från en studie av små dammar. För en damm utanför det som studien täckte (en fallhöjd över 7 m eller ett medelflöde över 30,2 m³/s) ger kalkylatorn statusen OutsideSourceRange och ingen kostnad, i stället för att använda talet per meter där det aldrig mättes:

if (removal && (head > costs.RemovalMaxHeadMetres || inputs.MeanFlowM3s > costs.RemovalMaxMeanFlowM3s))
{
    return new DamCost(DamCostStatuses.OutsideSourceRange, basis, Math.Round(head, 1), headSource, null, null, null, null);
}

Det är samma princip som begränsningarna i del 3: ett tal sträcks inte utanför de data som ligger bakom det.

11.2 Nettot

Nettot lägger ihop el, reserver och fiskfångst, och drar av kostnaden. Kostnaden paras åt motsatt håll: det låga nettot tar den höga kostnaden.

nettola˚g=PVla˚gel+PVla˚gfisk−Cho¨g\text{netto}_{\text{låg}} = PV^{\text{el}}_{\text{låg}} + PV^{\text{fisk}}_{\text{låg}} - C_{\text{hög}}
return ValueRange.Spanning(
    powerSide.Low + fish.Low - costSide.High,
    powerSide.Central + fish.Central - costSide.Central,
    powerSide.High + fish.High - costSide.Low,
    0);

Om elen inte går att avgöra (en kraftverksdamm utan känd fallhöjd, till exempel) finns inget netto alls (null). Ett netto som tyst utelämnade elen vore sämre än inget netto.

11.3 Betalningsvilja: ett värde som stannar vid enkätens kant

Två enkäter frågade svenskar vad de skulle betala för en bestämd ökning av vild lax: omkring 1 000 fler lekfiskar i en älv. Det ger en total för den ökningen, inte ett pris per fisk.

Kalkylatorn räknar scenariots extra lekfiskar och avgör sedan vilket av tre fall som gäller:

Extra lekfiskar Kod Värde
Färre än den efterfrågade ökningen (1 000) Below Inget
Inom det efterfrågade intervallet Within Enkätens total
Fler än den största efterfrågade (6 000) Above Enkätens total, inte mer
va¨rde=total⋅clamp⁡ ⁣(extraefterfra˚gad, 0, 1)fo¨r extra≥efterfra˚gad, annars inget\text{värde} = \text{total} \cdot \operatorname{clamp}\!\left(\frac{\text{extra}}{\text{efterfrågad}},\ 0,\ 1\right) \quad \text{för extra} \ge \text{efterfrågad}, \text{ annars inget}
var scope = extra.Central < survey.SurveyedIncrease
    ? WillingnessToPayScopes.Below
    : extra.Central > survey.MaxSurveyedIncrease ? WillingnessToPayScopes.Above : WillingnessToPayScopes.Within;
var value = scope == WillingnessToPayScopes.Below
    ? null
    : Combine(extra, survey.TotalSek, (fish, total) => total * Math.Clamp(fish / survey.SurveyedIncrease, 0, 1), 0);

Vilket fall som gäller avgörs på det centrala fallet. Det låga och det höga fallet använder sedan sitt eget antal extra lekfiskar, så ett lågt fall som hamnar under den efterfrågade ökningen skalas ner av klämningen.

Kommentaren i källkoden förklarar valet: att skala ner totalen för en mindre ökning skulle vara detsamma som ett värde per lax, vilket ingen av enkäterna ger stöd för. Så under den efterfrågade ökningen ger koden null, och sidan säger att värdet är okänt.


12. Den nationella planen

Fil: Dam/NationalPlanCalculator.cs. Sveriges nationella plan för vattenkraften anger, per älvsystem, hur mycket produktion som får avstås för miljöåtgärder (ett riktvärde i TWh per år). Kalkylatorn visar hur mycket av det ett scenario skulle ta i anspråk:

andel av riktva¨rdet=Ekvar−Escenarioriktva¨rde⋅1000\text{andel av riktvärdet} = \frac{E_{\text{kvar}} - E_{\text{scenario}}}{\text{riktvärde} \cdot 1000}

(GWh delat med GWh; talet 1000 gör om riktvärdets TWh till GWh.)

var gigawattHours = guideTerawattHours * 1000;
return ValueRange.Spanning(
    (kept.Low - now.Low) / gigawattHours,
    (kept.Central - now.Central) / gigawattHours,
    (kept.High - now.High) / gigawattHours,
    digits: 4);

Metoden tar dagens datum som parameter (DateOnly today) för att avgöra om dammens prövningsdatum har passerat. Endpointen hämtar det från TimeProvider, vilket håller kalkylatorn ren och låter ett test bestämma datumet.


13. Sammanfattning

Avsnitt Sorts beräkning Regression eller anpassad modell?
Nätet Graf av segment med uppslagstabeller Nej
Vilka hinder som stoppar fisk Beslutsregler (switch-uttryck) Nej
Uppströms, nedströms, livsmiljö Grafvandringar (bredden-först-sökning; en loop som följer flödet) Nej
Yta som avvattnas genom en punkt Proportionell fördelning; genomgång i efterordning med cache Nej
El: produktion Publicerat tal, effekt × timmar, eller fysikformeln Nej
El: fångstpris Produktionsviktat medelvärde, räknat i förväg av ett skript Nej (en beräknad statistik)
Lax Produkt av överlevnader och andelar Använder EcoVals kalibrerade smolt per km (del 1, avsnitt 5.3)
Havsöring Samma produkt från en annan utgångspunkt Använder EcoVals breddregression, täthetsklasser och smoltkvot (del 1, avsnitt 5.1–5.2)
Ålens överlevnad En överlevnad upphöjd till antalet kraftverk Nej
Antal ålar Längd från breddgrad, vikt från längd Lånad regression: SLU:s linjära längdsamband och potenslagen för längd–vikt
Kostnader Kostnad per meter fallhöjd, indexerad; avvisas utanför källans intervall Nej
Betalningsvilja En enkättotal som bara används inom det efterfrågade intervallet Nej
Nationell plan En kvot Nej

Vattensidans damm är det tydligaste exemplet i EcoVal på en processmodell: en kedja av fysiska och biologiska steg, vart och ett en enkel multiplikation med en publicerad andel. Dess osäkerhet kommer från andelarna, och det är därför nästan varje sådan är en ParameterRange, och därför koden lägger så mycket omsorg på vilket lågt som hör ihop med vilket högt.