Så är beräkningarna byggda, del 6: stadssidan och startsidans kalkylator
Det här är den sista delen. Den tar upp stadssidan (trädkronor, skugga och svalka i tätorter) och startsidans kalkylator, som visar vad en typisk skog, myr, ålgräsäng, sjö eller rullstensås är värd utan en karta.
docs/calculations-city.md förklarar stadssidans tal, och avsnitten om startsidans kalkylator i
docs/calculations.md och docs/calculations-water.md förklarar kalkylatorns. Det här dokumentet förklarar koden.
Sökvägarna utgår från backend/EcoVal.Api/Features/ om inget annat sägs. 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. Stad: vad marken är
- 3. Stad: skugga från träd
- 4. Stad: svalka under varma dagar
- 5. Startsidans kalkylator
- 6. Sammanfattning av den här delen
- 7. Alla sex delar: var statistik och modeller förekommer
1. Översikt
De två halvorna av den här delen har motsatt karaktär.
Stadssidan är den mest rastertunga delen av EcoVal: den läser 1 m-pixlar, och det tunga arbetet (att hitta trädkronor och kasta deras skuggor) görs en gång, i förväg, av Python-skript som skriver nya raster. API:et räknar sedan bara pixlar.
flowchart LR
subgraph offline ["I förväg, en gång per datauppdatering (Python + GDAL)"]
S1["Trädtäckning och laserhöjder"] --> P1["city-canopy.py"]
P1 --> R1["Kronraster, 1 m"]
R1 --> P2["city-shade.py<br/>solens läge, skuggkastning"]
P2 --> R2["Skuggraster, 1 m<br/>en bit per timme"]
end
subgraph api ["Per förfrågan (C#)"]
R1 --> C1["CityCoverCalculator:<br/>vad varje kvadratmeter är"]
R2 --> C2["CityShadeCalculator:<br/>kvadratmeter i skugga"]
H["Raster med yttemperatur, 30 m"] --> C3["CityCoolingCalculator"]
C1 --> C3
end
Startsidans kalkylator har inga egna data alls. Den matar typiska indata (ett bestånd av en viss ålder, en myr av ett visst djup) till samma kalkylatorer som skogs- och vattensidorna använder.
2. Stad: vad marken är
Filer: City/Cover/CityCoverCalculator.cs, City/Cover/CityCoverReader.cs.
2.1 Tre raster lästa i samma punkter
För varje provtagen kvadratmeter slår läsaren upp tre värden: kronrastret (finns något högt här, och hur högt?),
marktäckeklassen, och avståndet till närmaste byggnadskontur. Provtagningen är ClassAreas.Sample från del 1,
avsnitt 2.3: pixelmittpunkter innanför den ritade ytan, utglesade på stora ytor så att varje prov står för flera
kvadratmeter.
Eftersom proven räknas efter pixelns mittpunkt skiljer sig deras total lite från ytans verkliga area. Summorna skalas därför så att delarna summerar exakt till den ritade ytan:
var sampled = _kinds.Sum();
var scale = sampled > 0 ? areaSquareMetres / sampled : 0;
2.2 Två källor packade i ett rastervärde
Kronorna kommer från två källor av olika kvalitet: Boverkets trädtäckning (som redan har skilt träd från tak) och en laserhöjdmodell (där ett tak är lika högt som ett träd). Båda lagras i ett 8-bitarsraster med en förskjutning: en Boverket-pixel innehåller 100 plus höjden i meter, en laserpixel innehåller höjden som den är.
public const short BoverketOffset = 100;
private static bool IsBoverket(short canopy) => canopy >= BoverketOffset;
Värdet 112 betyder alltså "Boverket, 12 m" och 12 betyder "laser, 12 m". Att packa en flagga i talet sparar ett andra raster och en andra läsning per pixel.
2.3 Klassningen: ett beslutsträd
Varje prov sorteras in i en sorts mark med en fast följd av regler. Det är en regelbaserad klassificerare skriven för hand, inte en tränad:
flowchart TD
A{"Saknar något av<br/>rastren data?"} -->|ja| U["Ej karterat"]
A -->|nej| B{"Boverkets källa?"}
B -->|"ja, och minst 3 m"| C["Trädkrona"]
B -->|"ja, lägre"| D{"Inne i en byggnad?"}
D -->|ja| BU["Byggnad"]
D -->|nej| G["Efter marktäcke:<br/>väg, övrigt bebyggt, grönt, bart, vatten"]
B -->|"nej: laserhöjd"| E{"Inne i en byggnad?"}
E -->|ja| BU
E -->|nej| F{"Vatten i marktäcket?"}
F -->|ja| W["Vatten"]
F -->|nej| H{"Minst 3 m?"}
H -->|"ja, men inom 2 m<br/>från en byggnadskontur"| BU
H -->|"ja, längre bort"| C
H -->|nej| G
if (IsBoverket(canopy))
{
if (IsTall(canopy - BoverketOffset))
{
return GroundKind.Canopy;
}
return IsBuilding(landClass, buildingMetres) ? GroundKind.Building : Ground(landClass);
}
if (IsBuilding(landClass, buildingMetres))
{
return GroundKind.Building;
}
if (landClass is Lake or Sea)
{
return GroundKind.Water;
}
if (IsTall(canopy))
{
return NearerThan(buildingMetres, options.BuildingEdgeMetres) ? GroundKind.Building : GroundKind.Canopy;
}
return Ground(landClass);
Testernas ordning bär betydelsen. Vatten prövas före höjd eftersom en bro eller en förtöjd båt är hög i laserdatat men inte är ett träd. Kantregeln finns eftersom lasern ser en takkant som "högt och precis utanför byggnadskonturen".
2.4 Låg och hög krontäckning i ett svep
Osäkerheten i laserkällan sitter precis intill byggnader, där en krona och en takkant ser likadana ut. Intervallet byggs genom att räkna samma prov med en smalare och en bredare marginal runt konturerna:
- Högt: varje hög pixel utanför en kontur räknas som krona, även takkantspixlarna.
- Centralt: höga pixlar inom 2 m från en kontur räknas som byggnad.
- Lågt: höga pixlar inom 3 m från en kontur lämnas utanför.
if (kind == GroundKind.Canopy)
{
// …
_canopyHigh += squareMetres;
// The low reading keeps a wider margin to the outlines, where a crown and a roof are hardest to tell
// apart in laser heights. Boverket's canopy has no such doubt.
if (boverket || !NearerThan(buildingMetres, options.BuildingEdgeWideMetres))
{
_canopyLow += squareMetres;
}
}
Alla tre samlas i ett svep över proven. Kalkylatorn är en liten klass med tillstånd (Add per prov, Result i
slutet), vilket passar en strömmande läsning av miljontals pixlar bättre än att först bygga en lista.
3. Stad: skugga från träd
3.1 Förhandsdelen: var står solen?
Fil: scripts/city-shade.py (Python, körs av scripts/prepare-rasters.sh). För att veta var skuggorna faller
behöver skriptet först solens läge vid fyra tider på dagen den 21 juni. Det använder de vanliga astronomiska
formlerna (NOAA:s solkalkylator, efter Meeus). Kärnsambandet ger solhöjden över horisonten från
breddgraden , solens deklination (hur långt norr om ekvatorn den står den dagen) och timvinkeln
(hur långt jorden har vridit sig sedan sann middag):
cos_zenith = math.sin(phi) * math.sin(declination) + math.cos(phi) * math.cos(declination) * math.cos(hour_angle)
zenith = math.acos(max(-1, min(1, cos_zenith)))
# …
return 90 - math.degrees(zenith), azimuth % 360
Resten av sun_position räknar ut och från datum och tid. En praktisk detalj följer efter: kartans
rutnät (SWEREF 99 TM) pekar inte exakt mot sann norr annat än längs sin medelmeridian, så solens kompassriktning
vrids med den lokala skillnaden innan den används på rutnätet.
3.2 Förhandsdelen: kasta skuggorna
En solstråle som når marken i en punkt har, på det vågräta avståndet mot solen, passerat på höjden
Punkten ligger i skugga om den höjden på något avstånd ligger inne i ett träds krona. Ett träd med höjden antas ha sin krona från en fjärdedel av höjden till toppen (stammen nedanför släpper igenom solen):
där är trädhöjden i pixeln meter mot solen.
Att pröva varje pixel mot varje avstånd i en Python-loop skulle ta dagar. Skriptet vänder på frågan. För varje steg längs strålen räknar det ut vilka trädhöjder som skulle kasta en skugga från den förskjutningen, och prövar sedan hela rastret mot det höjdintervallet i en vektoriserad operation:
while distance * rise <= tallest + 0.5:
z = distance * rise
lowest = max(CANOPY_MIN, math.ceil(z - 0.5))
highest = min(tallest, math.floor(z / TRUNK_SHARE - 0.5))
if highest >= lowest:
offset = (round(-distance * math.cos(bearing)), round(distance * math.sin(bearing))) # rows run south
# …
distance += STEP
view = trees[margin + row:margin + row + rows, margin + column:margin + column + columns]
# low <= view <= high in one comparison: the subtraction wraps below low.
np.subtract(view, low, out=scratch)
np.less_equal(scratch, high - low, out=scratch.view(bool))
np.logical_or(shaded, scratch.view(bool), out=shaded)
view är trädhöjdsrastret förskjutet med förskjutningen, så "trädet row, column pixlar mot solen" läses för alla
pixlar på en gång. Kommentaren pekar ut ett snyggt knep: med teckenlösa 8-bitarstal får subtraktionen av low
varje värde under low att slå runt till ett stort tal, så det tvåsidiga testet low <= x <= high blir en enda
jämförelse.
3.3 En bit per timme
Resultatet för varje pixel är fyra ja/nej-svar (skuggad kl. 11.30, 12.30, 13.30, 14.30). De lagras i en byte som bitar:
| Bit | Värde | Betydelse |
|---|---|---|
| 0 | 1 | I skugga kl. 11.30 |
| 1 | 2 | I skugga kl. 12.30 |
| 2 | 4 | I skugga kl. 13.30 |
| 3 | 8 | I skugga kl. 14.30 |
En pixel som är skuggad kl. 12.30 och 13.30 innehåller . I Python:
bits |= shaded.astype(np.uint8) << index.
3.4 API-delen: räkna bitar
Fil: City/Shade/CityShadeCalculator.cs. C#-sidan läser tillbaka bitarna. Att pröva en timme är ett skift och en
mask; att räkna hur många timmar en pixel är skuggad är en "population count" (antalet satta bitar), som
processorn har en enda instruktion för:
private const int HourBits = (1 << Hours) - 1; // 0b1111
public static int ShadedHours(short shade) => BitOperations.PopCount((uint)(shade & HourBits));
for (var hour = 0; hour < Hours; hour++)
{
if ((shade >> hour & 1) == 1)
{
_hours[hour] += squareMetres;
}
}
var shaded = ShadedHours(shade);
if (shaded >= mostHours)
{
_most += squareMetres;
}
Bara mark som en människa kan stå på räknas: en skugga på ett tak eller på vatten svalkar ingen.
public static bool IsGround(GroundKind kind) => kind is not (GroundKind.Building or GroundKind.Water or GroundKind.Unmapped);
Uppdelningen mellan skriptet och API:et har en kostnad som skriptets huvud säger rakt ut: båda måste vara överens
om vad som räknas som ett träd, så skriptet upprepar klassningsreglerna i avsnitt 2.3 och konstanterna i
CityOptions. En ändring i det ena måste göras i det andra.
4. Stad: svalka under varma dagar
Fil: City/Cooling/CityCoolingCalculator.cs. Ett satellitbaserat raster ger yttemperaturen under de varmaste
sommardagarna i 30 m-celler. Sidan jämför en ritad yta med tätortens hårdgjorda mark (tak, vägar, gårdar).
4.1 Vad en 30 m-cell är: en majoritetsomröstning
En 30 m-värmecell rymmer 900 kvadratmeter blandad mark. För att märka den provtar läsaren ett rutnät på 3 × 3 punkter i den, klassar var och en med markklassificeraren i avsnitt 2, och tar den sort som mer än hälften av dem har:
var half = points.Length / 2.0;
return off > half ? null
: sealedGround > half ? HeatCellKind.Sealed
: canopy > half ? HeatCellKind.Trees
: green > half ? HeatCellKind.Green
: HeatCellKind.Mixed;
En cell utan majoritet är Mixed och räknas inte till någon grupp, vilket håller grupperna rena.
4.2 Statistik från ett histogram
En tätort har hundratusentals celler. Deras temperaturer är hela grader, så i stället för att spara varje värde
håller läsaren ett histogram: en array med 256 räknare per sort, där counts[t] är antalet celler vid
grader.
private readonly long[][] _counts = Enum.GetValues<HeatCellKind>().Select(_ => new long[256]).ToArray();
public void Add(HeatCellKind kind, short celsius) => _counts[(int)kind][celsius]++;
Medelvärdet och percentilerna kommer sedan ur räknarna. Med celler vid temperaturen :
Percentilen är den lägsta temperatur där den löpande summan når andelen av alla celler:
private static double Percentile(long[] counts, double share)
{
var target = counts.Sum() * share;
long seen = 0;
for (var value = 0; value < counts.Length; value++)
{
seen += counts[value];
if (seen >= target && seen > 0)
{
return value;
}
}
return 0;
}
Minnet stannar vid några kilobyte hur stor tätorten än är, och ingen sortering behövs. Tätortens tal sparas efter
första läsningen (TownHeatCache), eftersom de bara ändras när ett raster byts ut.
4.3 Svalare än hårdgjord mark
Resultatet är en skillnad, med tätortens hårdgjorda mark vid sitt medelvärde som det centrala fallet och vid sin svalare och varmare fjärdedel (25:e och 75:e percentilen) som lågt och högt:
public static ValueRange CoolerThanSealed(double areaCelsius, TownHeat town) => new(
Math.Round(town.SealedLowCelsius - areaCelsius, 1),
Math.Round(town.SealedCelsius - areaCelsius, 1),
Math.Round(town.SealedHighCelsius - areaCelsius, 1));
Det är en jämförelse av uppmätta yttemperaturer, inte en modell av hur mycket träden svalkar luften.
4.4 Människorna i närheten: klippa polygoner för hand
Sidan räknar de som bor inom 300 m från området. Området vidgas med 300 m (en buffert), och varje 1 km-befolkningsruta räknas med den andel av den som ligger inne i det vidgade området:
Ett biblioteksanrop (zone.Intersection(square).Area) skulle göra detta, men en hel tätorts zon har tiotusentals
punkter och hundratals rutor på sin kant, och att skära hela polygonen med varje ruta är långsamt. Koden gör det
för hand med två klassiska algoritmer.
Sutherland–Hodgman-klippning skär en polygon längs en rät linje och behåller ena sidan. Den går igenom ringens kanter; en punkt på den behållna sidan behålls, och där en kant korsar linjen läggs korsningspunkten till:
if (fromInside)
{
kept.Add(from);
}
if (fromInside != toInside)
{
var along = (at - fromValue) / (toValue - fromValue);
kept.Add(vertical
? new Coordinate(from.X + along * (to.X - from.X), at)
: new Coordinate(at, from.Y + along * (to.Y - from.Y)));
}
En ruta är fyra sådana snitt. Tidsvinsten ligger i ordningen: zonen skärs först till en vågrät remsa som är en rad rutor hög, och varje ruta i den raden skär sedan bara remsan, som har en bråkdel av zonens punkter.
Skosnöreformeln ger en polygons yta från dess hörnkoordinater:
double twice = 0;
for (var i = 1; i + 1 < ring.Count; i++)
{
twice += (ring[i].X - ring[0].X) * (ring[i + 1].Y - ring[0].Y) - (ring[i + 1].X - ring[0].X) * (ring[i].Y - ring[0].Y);
}
return twice / 2;
Koden mäter från ringens första punkt (ring[0]) och inte från origo. Matematiskt ändrar det ingenting, men
SWEREF-koordinater är i miljontals meter, och att multiplicera två sådana tal och sedan subtrahera tappar
precision. Små tal håller aritmetiken tillräckligt exakt. Hål hanteras med ett tecken: ett skals yta läggs till,
ett håls dras ifrån.
5. Startsidans kalkylator
Filer: Calculator/. Startsidan låter en besökare dra i reglage (storlek, ålder, mark, hur många som bor i
närheten) och se vad en typisk bit natur är värd. Den har ingen karta och läser inga raster.
5.1 Tanken: samma modeller med typiska indata
flowchart LR
S["Reglage:<br/>hektar, ålder, mark, människor i närheten, region"] --> T["Typiska indata<br/>från nationell statistik<br/>(CalculatorOptions)"]
T --> M["Sidornas egna kalkylatorer:<br/>RecreationCalculator, BerryCalculator,<br/>PeatCalculator, CoastCalculator,<br/>GroundwaterCalculator, …"]
M --> R["En svarsform för alla fem typer:<br/>rader med en sort, en nivå, ett intervall"]
Det här är det viktigaste designbeslutet i den här mappen. Kalkylatorn har inte egna förenklade formler.
ForestStandCalculator anropar RecreationCalculator.Visits, BerryCalculator.BilberryIndex och
YieldCurve.Calibrate, just de metoder som skogssidan använder. En rättning i en modell når därför båda, och de
två kan inte glida isär.
Det kalkylatorn lägger till är översättningen från ett reglage till de indata som metoderna behöver.
5.2 En typisk skog: tabeller från taxeringen
I stället för raster läser det typiska beståndet två publicerade tabeller: den stående volymen och den bruttotillväxt som Riksskogstaxeringen finner vid varje ålder, per region.
Båda läses med samma regel "räta linjer mellan punkterna, plant utanför ändarna" som varje annan tabell (del 2, avsnitt 3.3), och skalas med markreglaget. Markfaktorn är produktionen för det valda marksteget delad med den för det genomsnittliga steget, ur produktionstabellen:
public static double SoilFactor(ForestInputs inputs, ForestSliders sliders) =>
MeanProduction(inputs.Soil, inputs.Region, sliders) / MeanProduction(ForestSoils.Average, inputs.Region, sliders);
Det årliga CO₂-upptaget multiplicerar ytan , den uppmätta bruttotillväxten , markfaktorn, andelen som överlever den naturliga avgången och CO₂ per kubikmeter :
Avgången är exakt skogssidans (del 2, avsnitt 7.4), med samma inställningar:
double Surviving(double capShare, double background) =>
Math.Max(0, 1 - (background + (1 - background) * Math.Pow(volume / (capShare * curve.MaxVolume), options.CrowdingExponent)));
// …
var tonnes = surviving.Select((share, c) => inputs.Hectares * gross * soil * share * co2[c]).ToArray();
5.3 Besök utan karta: ett påhittat landskap
Besöksmodellen (del 1, avsnitt 6.1) behöver människorna runt skogen och den andra skog de kunde besöka i stället. Utan karta bygger kalkylatorn ett syntetiskt landskap av 1 km-rutor och kör den riktiga modellen på det:
- Skogen ligger i mitten.
- Reglagets antal vuxna (500, 5 000, 50 000 eller 250 000) sprids jämnt över rutorna inom 10 km.
- Annan skog täcker 68 % av varje ruta ut till 20 km, Sveriges andel skogsmark.
var homes = squares.Where(square => Distance(square) > 0 && Distance(square) <= options.ReachKm * SquareMetres).ToList();
var total = sliders.AdultsWithin10Km[inputs.People];
var population = homes
.Select((square, i) =>
{
var adults = total / homes.Count + (i < total % homes.Count ? 1 : 0);
return new PopulationNear(square.X, square.Y, adults, adults, Distance(square));
})
.ToList();
Uttrycket för adults fördelar hela människor rättvist: varje ruta får heltalsandelen, och de första
total % homes.Count rutorna får en till, så totalen blir exakt. (Heltalsdivision är avsedd här, till skillnad
från de två fallen i del 4 och 5 där den måste undvikas.)
Anropet i slutet är skogssidans egen metod:
return RecreationCalculator.Visits(
inputs.Hectares, own, forest, population, everydayShare, 1, new ValueRange(0, 0, 0), options);
Kommentaren på den här metoden antecknar två tidigare versioner som gav fel svar (en stor skog kom ut som värd upp till dubbelt så mycket per hektar som en liten) och varför den nuvarande avståndsregeln valdes. Ett syntetiskt landskap är lätt att få subtilt fel, och kommentaren bevarar den historien.
Sjökalkylatorn gör samma sak för fiskedagar: ett påhittat landskap med sjön i mitten, de vuxna runt den och annat vatten på en fast andel av varje ruta, som matas till fiskemodellen i del 1, avsnitt 6.5. Eftersom vikten mellan två rutor bara beror på hur långt ifrån varandra de ligger räknar den i förväg ut en tabell av vikter per förskjutning i stället för att anropa exponentialfunktionen för varje par:
// The weight between two squares depends only on their offset, so it is looked up rather than computed.
var span = 2 * waterReach;
var weights = new double[2 * span + 1, 2 * span + 1];
5.4 En typisk myr
MireCalculator använder torvfaktorerna från del 3, avsnitt 7. Myrens eget årliga flöde är faktorn för återvätt
torv om den är orörd och faktorn för dikad torv om den är dikad. Kolet den håller är dess volym gånger kolet per
kubikmeter, som CO₂:
var cubicMetres = inputs.DepthMetres * 10_000 * hectares;
var stock = new[] { density.Low, density.Central, density.High }
.Select(kg => cubicMetres * kg / 1_000 * Co2PerCarbon)
.ToArray();
Det som prissätts är inte myrens eget flöde (en naturlig myrs metan är ingens utsläpp) utan skillnaden mot det andra tillståndet. Ett tecken låter en formel tjäna båda riktningarna:
// Intact compared with drained keeps the saving out of the air; drained compared with intact lets it out.
var sign = drained ? -1 : 1;
var savings = each.SelectMany(kind => kind.Savings).Select(saving => sign * saving * hectares).ToList();
5.5 En typisk ålgräsäng: ett reglage mellan två publicerade fall
Ängskalkylatorn har ett reglage för hur mycket sediment som eroderas när ängen går förlorad, från 0 till 35 cm. Källstudien ger förrådet bara för de två ändarna. Reglaget rör sig mellan dem i en rät linje:
public static double Interpolated(ParameterRange stock, double share) => stock.Low + (stock.Central - stock.Low) * share;
Kommentaren på inställningen kallar den räta linjen ett antagande, vilket den är: studien mätte de två ändarna, inte vägen mellan dem.
5.6 En typisk rullstensås
EskerCalculator är den kortaste: den bygger ett grundvattenmagasin av den valda uttagsklassen och anropar
vattensidans GroundwaterCalculator.Capacity (del 5, avsnitt 6). Dess enda beslut är radens sort. Om ett
vattenverk tar vatten ur åsen är vattnet Valued och går in i totalen. Om inte är samma tal en Capacity: visad,
inte adderad.
inputs.Source ? CalculatorRowKinds.Valued : CalculatorRowKinds.Capacity,
5.7 Ett svar för fem sorters natur
Alla fem kalkylatorerna ger samma CalculatorResponse: en lista av rader, var och en med en kod, en sort, en nivå
och ett intervall. Sorterna säger hur en rad får användas:
| Sort | Betydelse | Går in i totalen? |
|---|---|---|
Valued |
Prissatt och räknad | Ja |
Climate |
Ett årligt klimatflöde, prissatt | I totalen med klimat |
Stored |
Ett förråd, med vad det skulle kosta om det släpptes ut | Nej |
Indicator |
Mätt mot en tröskel | Nej |
Capacity, Example |
Visas som jämförelse | Nej |
NotYet |
En tjänst som EcoVal inte värderar än | Nej |
Raderna med NotYet spelar lika stor roll som de värderade: de talar om för besökaren vilka tjänster som saknas i
totalen, så att ett lågt tal inte läses som "det här är allt den är värd".
6. Sammanfattning av den här delen
| Avsnitt | Sorts beräkning | Regression eller anpassad modell? |
|---|---|---|
| Marktäckning | Regelbaserad klassning av provtagna pixlar; ett intervall från två marginaler | Nej |
| Solens läge | Astronomiska formler | Nej |
| Skuggkastning | Geometri längs solstrålen, vektoriserad; bitmasker | Nej |
| Svalka | Majoritetsomröstning per cell; medelvärde och percentiler ur ett histogram; skillnader | Nej |
| Människor i närheten | Polygonklippning och skosnöreformeln | Nej |
| Typisk skog | Taxeringens tabeller, skogssidans tillväxt-, besöks- och bärmodeller | Återanvänder EcoVals kalibrerade modeller och de lånade bärmodellerna |
| Typisk sjö | Fiskemodellen på ett påhittat landskap | Återanvänder EcoVals kalibrerade fiskeparametrar |
| Typisk myr, äng, ås | Sidornas egna faktorer; linjär interpolation för erosionsreglaget | Nej |
Ingenting i den här delen är anpassat till data. Stadssidan är geometri och räkning; startsidans kalkylator är återanvändning.
7. Alla sex delar: var statistik och modeller förekommer
Det här avslutar serien, så här är svaret på "använder EcoVal statistisk regression, maskininlärning eller något annat?" samlat på ett ställe.
Ingen maskininlärning tränas eller körs av EcoVal. Inget maskininlärningsbibliotek refereras, och ingen modellfil skickas med.
| Vad | Sort | Tränad av | När | Var det är dokumenterat |
|---|---|---|---|---|
| Vattendragets bredd från avrinningsområdets yta | Minsta kvadrat-regression (log–log) | EcoVal | När API:et startar, från databasen | Del 1, 5.1 |
| Havsöringens tätheter, smoltkvoter, laxsmolt per km | Kvantiler och kalibreringskvoter | EcoVal | När API:et startar | Del 1, 5.2–5.3 |
| Råvattnets trend | Sens lutning med Mann–Kendalls test | EcoVal | Vid varje förfrågan | Del 5, 5 |
| Besök efter avstånd: utflykter, turism | Gravitationsmodell, kalibrerad med rutnätssökning | EcoVal | I förväg (EcoVal.Calibration) |
Del 1, 6.1–6.4 |
| Fiskedagar efter människor | Gravitationsmodell, kalibrerad med viktad minsta kvadrat på ett rutnät | EcoVal | I förväg (EcoVal.Calibration) |
Del 1, 6.5 |
| Tillväxtmodellen: produktionsnivå, avgång, golv för gammal skog | Kalibrerad med rutnätssökning, minsta kvadrat | EcoVal | I förväg (ett Python-skript) | Del 2, 7.7 |
| Formhöjd efter ålder | Klassvis kvot | EcoVal | I förväg (EcoVal.Calibration) |
Del 1, 6.6 |
| Kantarellens habitat | Logistisk regression med ridge-straff, korsvaliderad i block | EcoVal | I förväg; används inte av appen | Del 1, 6.7 |
| Bärens täckning och skörd | Publicerade logistiska och log-linjära regressioner | Artiklarnas författare | Lånade koefficienter | Del 3, 3.2 |
| Organiskt kol från skogbevuxen våtmark | En koefficient ur en publicerad log-linjär regression | Artikelns författare | Lånad koefficient | Del 3, 6 |
| Ålens längd och vikt | Publicerade linjära samband och potenslagar | SLU | Lånade koefficienter | Del 4, 10.2 |
| Sannolikhet för höga naturvärden | En prediktiv modells utdataraster | Dess upphovspersoner | Lånade utdata | Del 3, 8.5 |
| Näringsbelastningar | En hydrologisk modells utdata | SMHI | Lånade utdata | Del 3, 4.1 |
Allt annat (det mesta av appen) är deterministisk aritmetik på uppmätta data och publicerade faktorer: summor över pixlar, tabelluppslag, produkter av andelar, diskonterade summor, grafvandringar och geometri.
Tre vanor återkommer i allt detta, och de är vad man ska behålla när man lägger till kod:
- Formler är rena funktioner, skilda från koden som läser data, så att de kan testas för hand och återanvändas av kalibreringarna.
- Varje tal är ett intervall, byggt med avsikt: tre sammanhängande parameteruppsättningar, varje kombination, spridningen mellan observerade år, eller hörnprodukter, vilket som nu passar formeln.
- Ett tal sträcks inte utanför sin källa. Indata hålls inom det intervall en modell anpassades på, kostnader avvisas utanför de dammar en studie täckte, och ett saknat värde skickas som en kod som säger varför, aldrig som en gissning.