Så är beräkningarna byggda, del 5: kust, sjö, dricksvatten och grundvatten
Del 4 tog upp vattendragsnätet och dammen. Den här delen tar upp resten av vattensidan: ett ritat kustområde med sitt ålgräs, en sjö med sitt fiske och sin status, råvattnet i en dricksvattentäkt, och grundvattnet under en ritad yta.
docs/calculations-water.md förklarar vad varje tal betyder och var indata kommer ifrån. Det här dokumentet
förklarar koden. Sökvägarna utgår 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. Översikt
- 2. Kusten: ålgräs
- 3. Kusten: hamnens sida, havsbottnen och stranden
- 4. En sjö
- 5. Dricksvatten: en trend med ett statistiskt test
- 6. Grundvatten
- 7. Sammanfattning
1. Översikt
De här fyra avsnitten arbetar på polygoner igen, som skogssidan, men de flesta av deras indata är vektordata i PostGIS (ängar, sjöar, vattenförekomster, grundvattenmagasin), inte raster. Uppslagen mäter överlapp i databasen, och kalkylatorerna gör om hektar till värden.
flowchart LR
P["Ritad yta eller vald sjö"] --> L["Uppslag (PostGIS):<br/>överlapp i hektar, rader av data"]
L --> C1["CoastCalculator"]
L --> C2["LakeCalculator"]
L --> C3["DrinkingWaterCalculator"]
L --> C4["GroundwaterCalculator"]
R["Ett raster: vågexponering"] --> C1
G["Fiskerutnätet (del 1, avsnitt 6.5)"] --> C2
Två byggstenar återkommer och är värda att säga en gång.
Annuiteten. Många värden här är "så många kronor per år, varje år". Nuvärdet av 1 kr per år från år till tidshorisonten kallas en annuitetsfaktor:
så ett konstant årsvärde är värt i dag. Med och år är : trettio år med 1 kr är värda omkring 18 kr i dag.
// Money.cs
public static double Annuity(double discountRate, int horizonYears, int fromYear = 1) =>
PresentValue(_ => 1, discountRate, horizonYears, fromYear);
Indexering. Varje publicerat belopp flyttas till prisåret med konsumentprisindex, som i del 2 till 4
(Money.Indexed).
2. Kusten: ålgräs
Filer: Coast/CoastCalculator.cs, Coast/WaveExposure.cs. Ålgräsängar är barnkammare för fisk och begraver kol
och kväve i sitt sediment. Avsnittet värderar en äng i tre scenarier: kvar, överbyggd av en hamn, och (där en äng
har gått förlorad) återställd.
2.1 Skyddad eller exponerad: klassa efter pixlarnas mittpunkter
Hur mycket kol en äng håller beror på hur skyddad den ligger. Ett raster över vågexponering lägger varje ängsbit i den skyddade eller den exponerade gruppen. En bit kan ligga på båda sidor om gränsen, så den delas efter andelen av dess pixelmittpunkter på vardera sidan:
if (value >= cutoff)
{
high[owners[p]]++;
}
else
{
low[owners[p]]++;
}
// …
sheltered += hectares * l / (l + h);
exposed += hectares * h / (l + h);
Två detaljer gör det robust:
- En reserv för små bitar. En bit som är mindre än en pixel kanske inte innehåller någon pixelmittpunkt alls. Den tar då värdet i sin inre punkt (en punkt som garanterat ligger inuti den), och lämnas oklassad bara om inte heller den har något värde.
- En läsning för alla bitar. Alla punkter i alla bitar samlas i en lista och läses ur rastret i ett svep, med
en
owners-array som minns vilken bit varje punkt hör till. Att läsa bit för bit skulle packa upp samma rasterblock om och om igen.
2.2 Förrådet per hektar: ett viktat medelvärde av tre grupper
En ängs skyddade, exponerade och oklassade hektar tar var sitt grupps publicerade förråd, och ängens förråd per hektar är deras ytviktade medelvärde:
var unclassed = Math.Max(0, hectares - shelteredHectares - exposedHectares);
double Mean(Func<ParameterRange, double> pick) =>
(shelteredHectares * pick(sheltered) + exposedHectares * pick(exposed) + unclassed * pick(pooled)) / hectares;
return new ParameterRange(Mean(range => range.Low), Mean(range => range.Central), Mean(range => range.High));
Det låga fallet antar att sedimentet ligger kvar när ängen dör; det centrala och det höga antar att de översta 35 cm eroderas, vilket studiens borrkärnor tyder på att det gjorde.
2.3 En äng som står kvar: tre årliga tjänster
Per hektar och år ger en äng fisk (ett årsvärde i kronor), begraver kol och begraver kväve. Över tidshorisonten:
är fiskvärdet, det begravda kolet (som ton CO₂), koldioxidpriset år (samma prisbanor som skogens kolvärde, del 2, avsnitt 9.1), det begravda kvävet och dess pris.
Fisk och kväve har ett konstant pris, så de använder annuiteten. Kolets pris ändras per år, så det behöver hela summan:
double FishPv(int case_, int from) => fishCases[case_] * Annuity(from, options);
double CarbonPv(int case_, int from) => Discounted(year => carbonBurial * carbonPaths[case_][Math.Min(year, carbonPaths[case_].Length - 1)], from, options);
double NitrogenPv(int case_, int from) => nitrogenBurial * nitrogen[case_] * Annuity(from, options);
Var och en tar ett första år from, som återställningsscenariot använder nedan.
2.4 Överbyggd: förrådet släpps ut, plus allt en kvarstående äng skulle ha gett
En hamn på ängen släpper ut sedimentets förråd på en gång och avslutar de årliga tjänsterna. Kostnaden per hektar är
(talet 1000 gör om ton kväve till kilogram, prisets enhet).
double CarbonRelease(int c) => stockCases[c].Item1 * carbonPaths[c][0];
double NitrogenRelease(int c) => stockCases[c].Item2 * 1000 * nitrogen[c];
// …
double HarbourCost(int c) =>
(CarbonRelease(c) + NitrogenRelease(c) + FishPv(c, 1) + CarbonPv(c, 1) + NitrogenPv(c, 1)) * currentHectares + HaloLost(c);
Utsläppet prissätts år 0 och diskonteras inte, som för en avverkning i del 2.
2.5 Ringen runt en hamn: integrera en kurva
En hamn glesar också ut ålgräset runt sig. En fältstudie mätte ålgräsets täckning 0, 2, 4 och 6 m från en bryggas kant, med full täckning tillbaka vid 7,5 m. Andelen täckning som går förlorad i den ringen är ett minus medeltäckningen över ringen, och medelvärdet av en kurva är dess yta delad med dess bredd.
Med de inventerade punkterna förbundna med räta linjer är ytan under kurvan en summa av trapetser. För punkterna :
var points = distancesMetres.Zip(coverPercent).Where(point => point.First < haloMetres).Append((haloMetres, 100.0)).ToList();
// …
var area = 0.0;
for (var i = 1; i < points.Count; i++)
{
area += (points[i].Item1 - points[i - 1].Item1) * (points[i].Item2 + points[i - 1].Item2) / 2;
}
return 1 - area / (haloMetres - points[0].Item1) / 100;
Det här är trapetsregeln, den enklaste formen av numerisk integration. För flytbryggor ger den en förlust på 60 %, för bryggor på pålar 36 %. De är det centrala och det låga fallet; det höga fallet är studiens eget övergripande tal.
Värdet som går förlorat i ringen är sedan dess hektar gånger förlustandelen gånger vad en kvarstående hektar ger.
2.6 Återställd: en kostnad nu mot en nytta senare, om det lyckas
Att plantera om en förlorad äng kostar pengar nu. Nyttan kommer senare (en planterad äng tar år att mogna) och bara om planteringen lyckas (med sannolikheten : 0,39, 0,44 eller 0,64). Den förväntade nyttan är
var grownFrom = options.RestorationMaturityYears + 1;
double Benefit(int c) =>
restorableHectares * success[c] * (FishPv(c, grownFrom) + CarbonPv(c, grownFrom) + NitrogenPv(c, grownFrom));
Det är här parametern from gör rätt för sig: samma tre funktioner ger värdena från år 1 för en kvarstående äng
och från år 4 för en återställd.
Nettot parar den låga nyttan med den höga kostnaden, som varje netto i EcoVal gör:
ValueRange.Spanning(benefit.Low - cost.High, benefit.Central - cost.Central, benefit.High - cost.Low, 0)
3. Kusten: hamnens sida, havsbottnen och stranden
3.1 Vad en hamn tjänar
Sidan visar också den andra vågskålen: vad en småbåtshamn på den ritade ytan skulle dra in. Antalet båtplatser är de räknade platserna i befintliga hamnar plus en uppskattning för resten av vattnet, med en täthet av platser per hektar (106, 132 eller 152, kvartilerna över 14 svenska småbåtshamnar):
var berths = new[]
{
countedBerths + density.Low * estimated,
countedBerths + density.Central * estimated,
countedBerths + density.High * estimated,
};
var fees = new[] { berths[0] * fee.Low, berths[1] * fee.Central, berths[2] * fee.High };
En hamn som bara delvis ligger innanför ytan bidrar med sina platser i proportion:
marina.Berths * Math.Min(1, marina.InsideHectares / marina.Hectares).
Om en ny hamn alls är möjlig avgörs av hur mycket av ytan som är vatten och om det finns strand att bygga från, som en kedja av villkor som ger en kod:
var newMarina = waterHectares is null ? HarbourNewMarinaStatuses.Possible
: Math.Round(waterHectares.Value, 2) <= 0 ? HarbourNewMarinaStatuses.NoWater
: Math.Round(landHectares!.Value, 2) <= 0 && Math.Round(marinaHectares, 2) <= 0 ? HarbourNewMarinaStatuses.NoShore
: Math.Round(extensionHectares, 2) <= 0 ? HarbourNewMarinaStatuses.NoRoom
: HarbourNewMarinaStatuses.Possible;
Kommentaren ovanför förklarar avrundningen: villkoren prövas på värdena som de kommer att skickas, så att koden och talen användaren ser aldrig kan säga emot varandra (0,004 ha vatten som visas som "0,00 ha" måste också räknas som inget vatten).
3.2 Havsbottnen: från "minst" till "exakt"
Data om bottenstörningar ger, för varje riskklass, ytan med den klassen eller högre. Sidan vill ha ytan med exakt varje klass, så att klasserna summerar. Det är en skillnad mellan grannar:
double Only(SeabedMapping mapping, int riskClass, bool eelgrass) =>
Math.Round(Math.Max(0, AtLeast(mapping, riskClass, eelgrass) - AtLeast(mapping, riskClass + 1, eelgrass)), 2);
3.3 Stranden: en täthet mot en tröskel
Hur bebyggd en strand är uttrycks som anläggningar (bryggor, pirar, kajer) per 100 m strandlinje, som visas bredvid en publicerad tröskel över vilken en strand räknas som påverkad:
4. En sjö
Fil: Lake/LakeCalculator.cs.
4.1 Fiskedagar: tre grunder
En nationell enkät ger fiskedagar per fiskeområde, med en felmarginal. Dagarna blir ett intervall genom att dra ifrån och lägga till marginalen, aldrig under noll:
public static ValueRange Spread(double thousand, double margin) =>
new(Math.Max(0, thousand - margin) * 1000, thousand * 1000, (thousand + margin) * 1000);
Hur en sjö får sin andel beror på vad som är känt, och resultatet bär en kod som säger vilken grund som användes:
| Grundkod | När | Formel |
|---|---|---|
OwnLake |
En stor sjö med egna dagar i enkäten | Sjöns dagar × andelen av sjön i urvalet |
RegionByPeople |
Alla andra sjöar, när fiskerutnätet är inläst | Efter människorna inom räckhåll (del 1, avsnitt 6.5) |
RegionPerHectare |
Reserven | Regionens dagar per hektar × sjöns hektar |
NotPublished |
Enkäten ger inga dagar för området | Inget värde |
Grunden efter människor är modellen vars kalibrering del 1 beskrev i sin helhet; det är här den används.
4.2 Dagarnas värde
En fiskedag är värd ett konsumentöverskott som skiljer sig mellan fiskeområden. Ett urval som spänner över flera områden lägger ihop dem område för område:
var byArea = lakes
.Where(lake => lake.FishingDays is not null)
.GroupBy(lake => lake.FishingArea)
.Select(group => (PerDay: SekPerDay(group.Key, options), Days: Sum(group.Select(lake => lake.FishingDays))))
.ToList();
// …
RoundTo(byArea.Sum(area => area.Days.Central * area.PerDay.Central), 0),
När flera områden är inblandade är "värdet per dag" som visas det totala värdet delat med de totala dagarna (ett viktat medelvärde), så att de tre talen på sidan (dagar, värde per dag, värde per år) går ihop:
var perDay = byArea.Count switch
{
0 => SekPerDay(null, options),
1 => byArea[0].PerDay,
_ => new ValueRange(
dayTotals.Low > 0 ? Math.Round(perYear.Low / dayTotals.Low) : byArea.Min(area => area.PerDay.Low),
// …
4.3 Yrkesfisket: intervallet är åren
De stora sjöarnas yrkesfångst publiceras per år. Med bara ett par år är intervallet helt enkelt det lägsta året, medelvärdet och det högsta året, vart och ett skalat med andelen av sjön i urvalet:
low += values.Min() * share;
central += values.Average() * share;
high += values.Max() * share;
Det här är det tredje sättet ett intervall byggs på i EcoVal, efter "tre parameteruppsättningar" och "varje kombination": spridningen mellan observerade år.
4.4 Status: hur långt från målet
Vattenmyndigheterna klassar varje vattenförekomsts ekologiska status på en femgradig skala och sätter ett mål. Sidan visar hur många steg förekomsten ligger under sitt mål. Klasserna blir rangtal och gapet är en subtraktion, aldrig negativ:
private static int Rank(string code) => code switch
{
FishStatusClasses.High => 5,
FishStatusClasses.Good => 4,
FishStatusClasses.Moderate => 3,
FishStatusClasses.Poor => 2,
_ => 1,
};
// …
ecological is null || target is null ? null : Math.Max(0, Rank(target) - Rank(ecological)),
Det mesta av statuskoden är översättning: källans bokstäver och svenska fraser görs om till stabila koder med
switch-uttryck ("Vatten" => ChemicalMedia.Water), så att ingen visningstext lämnar API:et. Enhetsomräkning görs
på samma sätt, med ett tupelmönster som ger null för varje kombination det inte känner till:
public static double? Background(double? value, string? unit, string limitUnit) => (value, unit, limitUnit) switch
{
(null, _, _) => null,
(var v, "µg/l", ChemicalLimitUnits.MicrogramsPerLitre) => v,
(var v, "µg/kg TS", ChemicalLimitUnits.MicrogramsPerKgDryWeight) => v,
(var v, "mg/kg TS", ChemicalLimitUnits.MicrogramsPerKgDryWeight) => v * 1000,
_ => null,
};
Att ge null för en okänd enhet är avsiktligt: att inte visa någon bakgrundshalt är bättre än att visa en i fel
enhet.
5. Dricksvatten: en trend med ett statistiskt test
Fil: Lake/DrinkingWaterCalculator.cs. För en sjö som är dricksvattentäkt visar sidan råvattnets organiska kol
(som gör vattnet brunt och dyrt att rena): dess senaste nivå, dess klass, och om det stiger eller faller över
åren.
Den sista frågan är statistisk, och det här är det enda stället i EcoVal där ett statistiskt test körs vid förfrågan på data från den plats användaren valt.
Sorts metod: icke-parametrisk trendskattning och trendtest (Sens lutning med Mann–Kendalls test). Det är statistik, inte maskininlärning, och det är inte heller minsta kvadrat-regression. Ingenting tränas eller sparas: varje förfrågan räknar om det från den sjöns årsmedelvärden.
5.1 Nivån och dess klass
Den senaste nivån är medelvärdet av de tre senast mätta åren. Dess klass kommer från en lista av publicerade gränser: klassen är antalet gränser som värdet har nått.
public static string ClassOf(double value, double[] bounds, string[] codes)
{
var index = 0;
while (index < bounds.Length && value >= bounds[index])
{
index++;
}
return codes[index];
}
Ett värde som ligger exakt på en gräns hör till klassen ovanför (>=), vilket kommentaren knyter till hur
källrapporten skriver sina klasser ("4–8").
5.2 Varför inte en vanlig regressionslinje?
Att anpassa en minsta kvadrat-linje genom årsmedelvärdena (som för vattendragets bredd i del 1) vore det självklara valet, men vattenkemi bryter mot dess antaganden: ett enda översvämningsår kan ligga långt från resten, och en minsta kvadrat-linje dras hårt av en sådan punkt eftersom den kvadrerar avstånden. Metoderna som används här arbetar i stället med tecken och medianer, som ett enda extremt år knappast kan rubba.
5.3 Sens lutning: medianen av alla parvisa lutningar
Ta varje par av år och räkna lutningen mellan dem. Med år finns par. Sens lutning är medianen av de lutningarna:
5.4 Mann–Kendalls test: är trenden verklig?
Testet frågar: om det inte fanns någon trend, hur överraskande vore då den här serien? Det räknar, över alla par, hur många gånger det senare värdet är högre minus hur många gånger det är lägre:
Utan trend är uppgångar och nedgångar lika sannolika och ligger nära noll. Dess varians under "ingen trend" är känd, med en korrigering för lika värden (grupper av lika värden):
och teststatistikan är
Om kallas trenden stigande eller fallande (ett test på 5 %-nivån); annars är utslaget "ingen tydlig trend".
Både lutningarna och kommer ur samma dubbla loop:
var slopes = new List<double>(n * (n - 1) / 2);
var s = 0;
for (var i = 0; i < n; i++)
{
for (var j = i + 1; j < n; j++)
{
var difference = rows[j].Mean - rows[i].Mean;
slopes.Add(difference / (rows[j].Year - rows[i].Year)); // for Sen's slope
s += Math.Sign(difference); // for Mann–Kendall's S
}
}
slopes.Sort();
var ties = rows.GroupBy(row => row.Mean).Select(group => group.Count()).Where(count => count > 1);
var variance = (n * (n - 1.0) * (2 * n + 5) - ties.Sum(t => t * (t - 1.0) * (2 * t + 5))) / 18;
// …
var z = s == 0 ? 0 : (s - Math.Sign(s)) / Math.Sqrt(variance);
var code = Math.Abs(z) <= options.TrendZ ? TrendCodes.NoClearTrend : z > 0 ? TrendCodes.Rising : TrendCodes.Falling;
Lägg märke till n - 1.0 och t - 1.0: .0 gör aritmetiken till flyttal, av samma skäl som typomvandlingen i
uppbyggnaden i del 4.
En serie kortare än tio år får ingen trend alls (TooShort): med få år har testet för lite styrka för att säga
något.
5.5 Lutningens intervall
95 %-intervallet för Sens lutning kommer också ur den sorterade listan av parvisa lutningar. Med är den nedre och övre gränsen lutningarna på platserna
i den sorterade listan. En större varians skjuter isär de två platserna och vidgar intervallet.
var count = slopes.Count;
var c = options.TrendZ * Math.Sqrt(variance);
var lower = (int)Math.Round((count - c) / 2);
var upper = (int)Math.Round((count + c) / 2) + 1;
return (Median(slopes), slopes[Math.Clamp(lower - 1, 0, count - 1)], slopes[Math.Clamp(upper - 1, 0, count - 1)], code);
5.6 Ett år följer det förra: korrigeringen för seriekorrelation
Testet antar att varje år är oberoende av året innan. En sjös vatten stannar i sjön i flera år, så ett högt år följs gärna av ännu ett högt år. Då innehåller serien mindre oberoende information än dess längd antyder, och det enkla testet ropar trend för ofta.
Korrigeringen (Hamed och Rao 1998) blåser upp variansen med en faktor , där är det "effektiva" antalet oberoende år. Serien avtrendas först med Sens lutning och görs om till rangtal; med rangtalens korrelation med sig själva år senare:
Bara de fördröjningar vars själv är signifikant tas med ().
var ranks = Ranks(rows.Select(row => row.Mean - slopePerYear * row.Year).ToArray()); // detrend, then rank
// …
for (var lag = 1; lag < n; lag++)
{
var product = 0.0;
for (var t = 0; t + lag < n; t++)
{
product += (ranks[t] - mean) * (ranks[t + lag] - mean);
}
var correlation = product / spread;
if (Math.Abs(correlation) > bound)
{
sum += (n - lag) * (n - lag - 1.0) * (n - lag - 2.0) * correlation;
}
}
return Math.Max(1, 1 + 2 / (n * (n - 1.0) * (n - 2.0)) * sum);
Ett avsiktligt avsteg från den publicerade formeln. Sista raden låter aldrig faktorn hamna under 1. Som den är publicerad kan faktorn bli mindre än 1 när värdena växlar upp och ner, vilket skulle krympa variansen och få testet att ropa trend lättare. Kommentaren i källkoden antecknar vad som hittades när detta kontrollerades på de verkliga sjöarna: i korta serier hamnade faktorn under 1 av en slump för 19 av 90 sjöar och gjorde om tre utslag från "ingen tydlig trend" till trend, tvärtemot korrigeringens syfte. Därför används bara den vidgande riktningen, och kommentaren säger det, tillsammans med skriptet som kontrollerade det. Det är en bra förebild för hur man dokumenterar ett avvägt beslut i statistisk kod.
5.7 Från en trend till en kostnad
En stigande trend på mg/l per årtionde kostar ett vattenverk öre per kubikmeter och årtionde, med kostnaden för ytterligare ett mg/l. Båda har ett intervall, och lutningen kan vara negativ, så produktens låga och höga värde hittas genom att pröva alla fyra hörnkombinationer:
var products = new[] { slope.Low * orePerMg.Low, slope.Low * orePerMg.High, slope.High * orePerMg.Low, slope.High * orePerMg.High };
cost = new ValueRange(Math.Round(products.Min(), 2), Math.Round(slope.Central * orePerMg.Central, 2), Math.Round(products.Max(), 2));
Att multiplicera lågt med lågt och högt med högt är bara rätt när båda faktorerna är positiva. För en fallande trend (en negativ lutning) är den mest negativa produkten den låga lutningen gånger den höga kostnaden. Att ta minimum och maximum av alla fyra hörn är den allmänna regeln för intervallet av en produkt, och den används här eftersom tecknet inte är känt i förväg.
6. Grundvatten
Fil: Lake/GroundwaterCalculator.cs. Grundvatten som går att pumpa upp rent behandlas som ett naturligt
vattenverk: dess värde är den reningskostnad som ytvatten skulle ha krävt.
6.1 Från en uttagsklass till kubikmeter per år
SGU klassar varje grundvattenmagasin efter hur mycket vatten det kan ge, i liter per sekund: 1–5, 5–25, 25–125 och så vidare. Varje klass är fem gånger den föregående. För en sådan skala är den naturliga mittpunkten det geometriska medelvärdet, inte det aritmetiska:
För klassen 5–25 l/s ger det 11,2 l/s; det aritmetiska medelvärdet (15) skulle ligga för nära toppen av en skala som växer genom multiplikation.
var (low, high) = AquiferYieldClasses.SoilBounds(zone.YieldCode)!.Value;
var top = high ?? low;
var central = low == 0 ? top / 2 : Math.Sqrt(low * top);
De två specialfallen hanteras uttryckligen: den lägsta klassen börjar på 0, där ett geometriskt medelvärde skulle bli 0, så den tar hälften av sin övre gräns; den öppna toppklassen ("över 125") har ingen övre gräns, så dess nedre gräns används och resultatet flaggas som ett minimum.
En liter per sekund under ett år är
/// <summary>m³ in a year of one litre a second.</summary>
public const double CubicMetresPerYearPerLitreSecond = 365 * 86_400 / 1_000.0;
och sidan visar det också som antal försörjda personer, vid 180 liter per person och dag.
6.2 Priset: mitten av fyra tal
Fyra publicerade tal ger den sparade reningskostnaden per kubikmeter (två från nederländska räkenskaper, två från en svensk kommun), vart och ett indexerat från sitt eget år. Intervallet är deras lägsta och högsta, och det centrala värdet är mitten av de fyra, vilket för ett jämnt antal är medelvärdet av de två i mitten (medianen):
Array.Sort(figures);
return ValueRange.Spanning(figures[0], (figures[1] + figures[2]) / 2, figures[3], 2);
Med bara fyra tal från två källor är en median ett bättre centralt värde än ett medelvärde, eftersom ett avvikande tal inte kan dra den med sig.
Värdet är sedan volym gånger pris, avrundat till tusental kronor:
7. Sammanfattning
| Avsnitt | Sorts beräkning | Regression eller anpassad modell? |
|---|---|---|
| Ålgräs: skyddad eller exponerad | Andel pixelmittpunkter på vardera sidan om en gräns | Nej |
| Ålgräs: förråd per hektar | Ytviktat medelvärde av publicerade förråd | Nej |
| Ålgräs: kvar, överbyggd, återställd | Annuiteter och en diskonterad summa; förväntat värde med en lyckandegrad | Nej |
| Ringen runt en hamn | Trapetsregeln på inventerad täckning | Nej |
| Hamnens intäkter | Båtplatser × avgift; en täthet från observerade hamnar | Nej (kvartiler av 14 hamnar) |
| Havsbotten, strand | Skillnader mellan kumulativa ytor; en täthet | Nej |
| Sjö: fiskedagar efter människor | Gravitationsmodell | Kalibrerad av EcoVal (del 1, avsnitt 6.5) |
| Sjö: värde, yrkesfiske, status | Summor, min/medel/max över år, rangskillnader | Nej |
| Råvattnets trend | Sens lutning och Mann–Kendalls test, med korrigering för seriekorrelation | En statistisk skattning och ett test, räknade per förfrågan; inget sparas |
| Grundvatten | Geometriskt medelvärde av klassgränser; median av fyra priser | Nej |
Råvattnets trend gör bilden komplett av var statistik förekommer i EcoVal:
- Anpassat i förväg, sparat som inställningar: gravitationsmodellerna, tillväxtmodellens parametrar (del 1 och 2).
- Anpassat när API:et startar, hålls i minnet: breddregressionen, fisktätheterna (del 1).
- Räknat per förfrågan från platsens egna data: råvattnets trend (den här delen).
- Lånat från publikationer: bärmodellerna, koefficienten för organiskt kol, ålsambanden (del 3 och 4).