EcoVal Ändringslogg v0.5.0

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

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 ff till tidshorisonten HH kallas en annuitetsfaktor:

a(f)=∑t=fH1(1+r)ta(f) = \sum_{t=f}^{H} \frac{1}{(1 + r)^{t}}

så ett konstant årsvärde yy är värt y⋅a(1)y \cdot a(1) i dag. Med r=3,5 %r = 3{,}5\,\% och H=30H = 30 år är a(1)≈18,4a(1) \approx 18{,}4: 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:

skyddade ha=ha⋅nundernunder+no¨verexponerade ha=ha⋅no¨vernunder+no¨ver\text{skyddade ha} = \text{ha} \cdot \frac{n_{\text{under}}}{n_{\text{under}} + n_{\text{över}}} \qquad \text{exponerade ha} = \text{ha} \cdot \frac{n_{\text{över}}}{n_{\text{under}} + n_{\text{över}}}
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:

sˉ=hsk ssk+hex sex+hokl sallah\bar{s} = \frac{h_{\text{sk}}\,s_{\text{sk}} + h_{\text{ex}}\,s_{\text{ex}} + h_{\text{okl}}\,s_{\text{alla}}}{h}
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));
Kol som en förlorad ålgräsäng släpper ut

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:

kvar per ha=F⋅a(1)  +  ∑t=1HbC⋅P(t)(1+r)t  +  bN⋅pN⋅a(1)\text{kvar per ha} = F \cdot a(1) \;+\; \sum_{t=1}^{H} \frac{b_C \cdot P(t)}{(1 + r)^{t}} \;+\; b_N \cdot p_N \cdot a(1)

FF är fiskvärdet, bCb_C det begravda kolet (som ton CO₂), P(t)P(t) koldioxidpriset år tt (samma prisbanor som skogens kolvärde, del 2, avsnitt 9.1), bNb_N det begravda kvävet och pNp_N 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

kostnad per ha=sC⋅P(0)⏟kol som sla¨pps ut nu+sN⋅1000⋅pN⏟kva¨ve som sla¨pps ut nu+kvar per ha\text{kostnad per ha} = \underbrace{s_C \cdot P(0)}_{\text{kol som släpps ut nu}} + \underbrace{s_N \cdot 1000 \cdot p_N}_{\text{kväve som släpps ut nu}} + \text{kvar per ha}

(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.

Ålgräsets täckning intill en brygga

Med de inventerade punkterna förbundna med räta linjer är ytan under kurvan en summa av trapetser. För punkterna (di,ci)(d_i, c_i):

yta=∑i=1n(di−di−1)⋅ci+ci−12fo¨rlust=1−yta(dn−d0)⋅100\text{yta} = \sum_{i=1}^{n} (d_i - d_{i-1}) \cdot \frac{c_i + c_{i-1}}{2} \qquad \text{förlust} = 1 - \frac{\text{yta}}{(d_n - d_0) \cdot 100}
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 m=3m = 3 år att mogna) och bara om planteringen lyckas (med sannolikheten qq: 0,39, 0,44 eller 0,64). Den förväntade nyttan är

nytta=h⋅q⋅[kvar per ha, ra¨knat fra˚n a˚r m+1]\text{nytta} = h \cdot q \cdot \bigl[\text{kvar per ha, räknat från år } m + 1\bigr]
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 δ\delta av platser per hektar (106, 132 eller 152, kvartilerna över 14 svenska småbåtshamnar):

B=Bra¨knade+δ⋅hora¨knatavgifter o¨ver tidshorisonten=B⋅avgift⋅a(1)B = B_{\text{räknade}} + \delta \cdot h_{\text{oräknat}} \qquad \text{avgifter över tidshorisonten} = B \cdot \text{avgift} \cdot a(1)
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:

A=k=A≥k−A≥k+1A_{=k} = A_{\ge k} - A_{\ge k+1}
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:

per 100 m=anla¨ggningarstrandmeter⋅100\text{per 100 m} = \frac{\text{anläggningar}}{\text{strandmeter}} \cdot 100

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
dagaregen=Dsjo¨⋅ha i urvalethadagarper ha=Dregionharegion⋅ha i urvalet\text{dagar}_{\text{egen}} = D_{\text{sjö}} \cdot \frac{\text{ha i urvalet}}{\text{ha}} \qquad \text{dagar}_{\text{per ha}} = \frac{D_{\text{region}}}{\text{ha}_{\text{region}}} \cdot \text{ha i urvalet}

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:

va¨rde per a˚r=∑omra˚den AdagarA⋅vAva¨rde o¨ver tidshorisonten=va¨rde per a˚r⋅a(1)\text{värde per år} = \sum_{\text{områden } A} \text{dagar}_A \cdot v_A \qquad \text{värde över tidshorisonten} = \text{värde per år} \cdot a(1)
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:

gap=max⁡(0, rang(ma˚l)−rang(status))\text{gap} = \max\bigl(0,\ \text{rang}(\text{mål}) - \text{rang}(\text{status})\bigr)
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.

Sens lutning på en påhittad serie

5.3 Sens lutning: medianen av alla parvisa lutningar

Ta varje par av år i<ji < j och räkna lutningen mellan dem. Med nn år finns N=n(n−1)/2N = n(n-1)/2 par. Sens lutning är medianen av de lutningarna:

β^=median⁡{xj−xitj−ti : i<j}\hat{\beta} = \operatorname{median}\left\{ \frac{x_j - x_i}{t_j - t_i} \ :\ i < j \right\}

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:

S=∑i<jsign⁡(xj−xi)S = \sum_{i < j} \operatorname{sign}(x_j - x_i)

Utan trend är uppgångar och nedgångar lika sannolika och SS ligger nära noll. Dess varians under "ingen trend" är känd, med en korrigering för lika värden (grupper av tgt_g lika värden):

Var⁡(S)=n(n−1)(2n+5)−∑gtg(tg−1)(2tg+5)18\operatorname{Var}(S) = \frac{n(n-1)(2n+5) - \sum_g t_g(t_g - 1)(2t_g + 5)}{18}

och teststatistikan är

Z=S−sign⁡(S)Var⁡(S)Z = \frac{S - \operatorname{sign}(S)}{\sqrt{\operatorname{Var}(S)}}

Om ∣Z∣>1,96|Z| > 1{,}96 kallas trenden stigande eller fallande (ett test på 5 %-nivån); annars är utslaget "ingen tydlig trend".

Både lutningarna och SS 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 C=zVar⁡(S)C = z\sqrt{\operatorname{Var}(S)} är den nedre och övre gränsen lutningarna på platserna

M1=N−C2M2=N+C2+1M_1 = \frac{N - C}{2} \qquad M_2 = \frac{N + C}{2} + 1

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 n/n∗n / n^{*}, där n∗n^{*} är det "effektiva" antalet oberoende år. Serien avtrendas först med Sens lutning och görs om till rangtal; med ρ(i)\rho(i) rangtalens korrelation med sig själva ii år senare:

nn∗=1+2n(n−1)(n−2)∑i=1n−1(n−i)(n−i−1)(n−i−2) ρ(i)\frac{n}{n^{*}} = 1 + \frac{2}{n(n-1)(n-2)} \sum_{i=1}^{n-1} (n - i)(n - i - 1)(n - i - 2)\,\rho(i)

Bara de fördröjningar vars ρ(i)\rho(i) själv är signifikant tas med (∣ρ(i)∣>z/n|\rho(i)| > z/\sqrt{n}).

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å β^\hat\beta mg/l per årtionde kostar ett vattenverk β^⋅κ\hat\beta \cdot \kappa öre per kubikmeter och årtionde, med κ\kappa 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:

Qcentral=Qla˚g⋅Qho¨gQ_{\text{central}} = \sqrt{Q_{\text{låg}} \cdot Q_{\text{hög}}}

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

365⋅86 4001000=31 536 m3\frac{365 \cdot 86\,400}{1000} = 31\,536 \ \text{m}^3
/// <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:

va¨rde per a˚r=Q⋅31 536⋅p\text{värde per år} = Q \cdot 31\,536 \cdot p

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).