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
- 2. Nätet som datastruktur
- 3. Vilka hinder som stoppar fisk
- 4. Vandra i nätet
- 5. Hur mycket mark som avvattnas genom en punkt
- 6. Dammens tre scenarier
- 7. El
- 8. Lax
- 9. Havsöring
- 10. Ål
- 11. Kostnader, nettot och betalningsvilja
- 12. Den nationella planen
- 13. Sammanfattning
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.
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
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 ytan uppströms utloppet, delavrinningsområdets egen yta, och den andel av delavrinningsområdets vattendragslängd som ligger uppströms punkten:
Vid utloppet är och formeln ger ; 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:
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å megawatt som går motsvarande timmar per år på full effekt ger
Från fysiken: vatten med densiteten som faller höjden med flödet avger effekten . En turbin gör om en andel av den till el, och bara en andel av medelflödet går att använda (högflöden spills förbi). Över årets 8 760 timmar:
med kg/m³ och m/s². Produkten är i watt; gånger timmar ger wattimmar, och 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.
med elområdets vattenkraftsproduktion och priset timme . 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.
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 , aldrig under noll (ett kraftverk som inte kan täcka sina driftkostnader skulle stå still). är i GWh, så är kWh, och priser i öre delas med 100 för att ge kronor:
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 ( år, ) summerar årsvärdet från år 1:
// 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:
| Symbol | Betydelse |
|---|---|
| Laxens livsmiljö ovanför dammen, km (vandringen i avsnitt 4.3) | |
| Smolt per km (kalibrerat, del 1, avsnitt 5.3) | |
| Andel lekvandrande vuxna som tar sig upp förbi den här dammen | |
| Andel smolt som tar sig ner förbi den här dammen | |
| En fiskvägs effektivitet (0,20, 0,37, 0,60) | |
| Fiskvägar mellan dammen och havet | |
| En smolts överlevnad förbi en kraftverksdamm (0,75, 0,88, 0,95) | |
| Kraftverksdammar mellan dammen och havet |
Scenariot ändrar bara och :
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:
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"]
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 till scenariots värde i en rät linje över år:
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);
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.
med de öringungar sträckan rymmer och den kalibrerade smolten per öringunge. Fångsten är sedan
där är andelen odlad smolt som rapporteras fångad (2,9 %, från märkningsstudier) och 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 (0,31, 0,70 eller 0,90). Förbi kraftverk:
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:
Sedan följer vikten längden som en potenslag, den vanliga formen för ett längd–vikt-samband i fiskbiologin:
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:
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
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.
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 |
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:
(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.