Så är beräkningarna byggda, del 3: friluftsliv, bär, vatten, torv och skyddad natur
Del 1 och 2 tog upp grunderna och skogens kärnkedja (förråd, virke, tillväxt, kol). Den här delen tar upp resten av skogssidan: vad skogen ger dem som besöker den, bären, vad en avverkning gör med vattnet, torven under träden, och den skyddade och värdefulla naturen innanför den ritade ytan.
docs/calculations.md förklarar vad varje tal betyder och var indata kommer ifrån. Det här dokumentet förklarar
koden. Alla sökvägar utgår från backend/EcoVal.Api/Features/Forest/. 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. Vad de här avsnitten har gemensamt
- 2. Friluftsliv
- 3. Bär
- 4. Näringsämnen till vatten efter avverkning
- 5. Dricksvatten nedströms
- 6. Blöt mark: organiskt kol och kvicksilver
- 7. Våtmark och dikad torv
- 8. Skyddad och värdefull natur
- 9. Sammanfattning
1. Vad de här avsnitten har gemensamt
De flesta avsnitten här prissätter en förändring över tid: en avverkning orsakar något (förlorade besök, färre bär, mer läckage) som varar några år och sedan klingar av. De delar en formel, nuvärdet av ett årligt flöde:
är den fysiska mängden år (besök, kilogram, ton), dess pris, diskonteringsräntan (3,5 %) och tidshorisonten (100 år). Avsnitten skiljer sig bara i hur de tar fram . De återanvänder också alla avverkningsåren från tillväxtmodellens två avverkade vägar (del 2, avsnitt 8), så att alla avsnitt är överens om när skogsbruksvägen avverkar igen.
flowchart LR
G["Tillväxtmodellen (del 2):<br/>avverkningsår, beståndets volym per år,<br/>den kvarstående skogens CO₂-förråd"] --> R["Friluftsliv efter avverkning"]
G --> B["Bär"]
G --> W["Näringsläckage"]
G --> P["Torv: återvätningsvägens förlorade upptag"]
PR["Prisfallen för koldioxid (del 2)"] --> P
Det andra de delar: flera avsnitt använder regressionsmodeller som andra har publicerat. EcoVal anpassar dem inte; den tar de publicerade koefficienterna och räknar ut formeln. Avsnitt 9 listar dem.
2. Friluftsliv
Filer: Recreation/RecreationCalculator.cs, Recreation/RecreationSection.cs,
Recreation/RecreationAfterFelling.cs.
Hur besök fördelas efter avstånd (vardagsbesök, utflykter, turism) och hur de modellerna kalibrerades står i del 1, avsnitt 6.1 till 6.4. Det här avsnittet tar upp det som omger den kärnan: hur många besök en vuxen gör, vad ett besök är värt, var räknade besök tar över, och vad en avverkning kostar.
2.1 Besök per vuxen: en viktad summa av enkätklasser
En nationell enkät ger andelen vuxna i varje frekvensklass ("1–5 gånger per år", "6–20 gånger" och så vidare). Besök per vuxen är summan av varje klass andel gånger ett antal besök för klassen. Klassgränserna ger intervallet: det lägsta antalet i varje klass, enkätens eget indexvärde, och det högsta.
public static ValueRange VisitsPerAdult(IReadOnlyList<VisitFrequencyClass> classes) => new(
Math.Round(classes.Sum(c => c.Share * c.Low), 1),
Math.Round(classes.Sum(c => c.Share * c.Central), 1),
Math.Round(classes.Sum(c => c.Share * c.High), 1));
Med de inställda klasserna är det centrala värdet 25,7 besök per år.
2.2 Värdet av ett besök, flyttat till dagens priser
Varje studies värde per besök är i priserna för det år den gjordes. Två justeringar för det till prisåret: konsumentprisindex, och en real inkomsttillväxt (1,15 % per år) för varje år sedan enkäten, eftersom människor värderar sin tid högre när inkomsterna stiger.
var indexed = Money.Indexed(value.Sek, options.ConsumerPriceIndex, value.PriceYear, options.PriceYear, "Valuation:Recreation");
var surveyYear = value.SurveyYear ?? value.PriceYear;
var growth = Math.Pow(1 + options.IncomeGrowthPerYear, Math.Max(0, options.PriceYear - surveyYear));
Svaret bär både det indexerade värdet och värdet efter tillväxt, så att sidan kan visa varje steg.
2.3 Räknade besök ersätter modellen
Där ett områdes besök faktiskt har räknats används räkningen i stället för modellen. Polygonen får områdets räkning i proportion till hur mycket av området den täcker:
var share = area.AreaHectares > 0 ? Math.Min(1, area.OverlapHectares / area.AreaHectares) : 0;
var whole = new ValueRange(area.VisitsLow, Math.Round((area.VisitsLow + area.VisitsHigh) / 2.0), area.VisitsHigh);
För att inte räkna samma mark två gånger skalas sedan de modellerade besöken med den andel av polygonen som ligger
utanför varje räknat område (uncountedShare), och utflykts- och turismmodellerna körs bara på den oräknade
delen:
// Counted visits replace all modelled terms where they apply.
var uncounted = measured.Count == 0 ? polygon : await lookups.FindUncountedPartAsync(polygon, cancellationToken);
var uncountedShare = polygon.Area > 0 ? Math.Clamp(uncounted.Area / polygon.Area, 0, 1) : 0;
2.4 Semesterandelen: att inte räkna ett besök två gånger
Enkätens besök per vuxen räknar med utflykter som görs på semestern. Modellerna lägger alla en vuxens besök nära hemmet, medan turismmodellen räknar gäster där de bor. Ett besök som görs på semestern skulle därför räknas två gånger. Andelen av de boendes besök som görs under vistelse i kommersiellt boende tas bort ur de boendes modeller:
med besöken per gästnatt för kommun :s klass.
double Holiday(Func<ParameterRange, double> pick) => data.Municipalities.Values
.Sum(municipality => municipality.DomesticNights * pick(tourism.VisitsPerNight(tourism.ClassOf(municipality.Code))));
double Share(double holiday, double visitsPerAdult) =>
visitsPerAdult > 0 ? Math.Min(1, holiday / (visitsPerAdult * data.Adults)) : 0;
Utländska gäster finns inte alls i enkäten, så deras besök läggs helt enkelt till.
2.5 Sätta ihop vardagsbesöken
Vardagsbesöken är produkten av fyra faktorer: besök per vuxen , polygonens andel av de närboende vuxnas besök från avståndsmodellen (del 1, avsnitt 6.1), andelen besök som är vardagsbesök , och den oräknade andelen .
Intervallet parar ihop de låga och de höga värdena. räknas för vart och ett av de tre avstånden , och det låga fallet tar det minsta av de tre och det höga det största, vilket avstånd det än råkar vara:
var shares = new[] { Share(decayKm.Low), Share(decayKm.Central), Share(decayKm.High) };
var visits = new ValueRange(
Math.Round(perAdult.Low * shares.Min() * everydayShare.Low * uncountedShare),
Math.Round(perAdult.Central * shares[1] * everydayShare.Central * uncountedShare),
Math.Round(perAdult.High * shares.Max() * everydayShare.High * uncountedShare));
Ett längre betyder inte alltid fler besök: det låter människor nå den här skogen längre ifrån, men det låter
dem också nå all annan skog. Det är därför koden tar Min() och Max() och inte shares[0] och shares[2].
Utflykter värderas i två delar: de från hem inom 10 km till vardagsvärdet , resten till resvärdet (en längre utflykt är värd mer):
2.6 Vad en avverkning kostar i friluftsliv
Ett hygge är mindre lockande att besöka än en uppvuxen skog. En expertpanel har betygsatt bestånd 0–10 efter utvecklingsfas, och betyget är en trappstegsfunktion av beståndets ålder:
public static double Score(double age, double[] scores, RecreationAfterFellingOptions options)
{
var phase = Array.FindIndex(options.PhaseUpperAges, upper => age < upper);
return scores[phase < 0 ? scores.Length - 1 : phase];
}
År har det kvarstående beståndet åldern och det avverkade åldern sedan sin senaste avverkning, . Andelen av friluftsvärdet som går förlorad det året är hur långt det avverkade beståndets betyg ligger efter:
och förlusten över tidshorisonten är nuvärdet av den andelen av det årliga friluftsvärdet :
double Loss(double sekPerYear, double[] scores, IReadOnlyList<int> fellingYears) =>
Enumerable.Range(0, horizon)
.Sum(year => sekPerYear * LostShare(standAgeYears.Value + year, AgeAfterFelling(year, fellingYears), scores, options)
/ Math.Pow(1 + discountRate, year));
public static int AgeAfterFelling(int year, IReadOnlyList<int> fellingYears) =>
year - fellingYears.Where(felling => felling <= year).DefaultIfEmpty(0).Max();
fellingYears kommer från tillväxtmodellen, så skogsbruksvägen förlorar värde på nytt varje gång den avverkas.
3. Bär
Fil: Berries/BerryCalculator.cs. Avsnittet svarar på: hur många kilo blåbär och lingon ger den här skogen per år,
och hur ändras det om den avverkas?
Det är byggt i tre lager:
flowchart TB
A["Nivå: regionens uppmätta skörd per hektar,<br/>skalad med länets bärtäckning"] --> D
B["Form: publicerade finska modeller av hur skörden<br/>beror på beståndets ålder och täthet"] --> C["Relativt index för det här beståndet<br/>mot ett genomsnittligt bestånd"]
C --> D["Skörd i det här beståndet, kg/ha/år"]
D --> E["Längs de tre vägarna, år för år:<br/>skörd kvar − skörd avverkad"]
E --> F["Plockad andel × pris, diskonterat"]
3.1 Nivån: uppmätta skördar
Riksskogstaxeringen publicerar varje regions totala bärskörd per år. Medelvärdet över åren, delat med regionens skogsmark, är skörden på en genomsnittlig hektar:
public static double RegionKgPerHectare(IReadOnlyList<double> thousandTonnes, double thousandHectares) =>
thousandTonnes.Average() * 1_000_000 / (thousandHectares * 1_000);
Skördar publiceras bara per region, men bärens täckning (andelen av marken som riset täcker) publiceras per län. Länets nivå är regionens skörd skalad med kvoten av täckningarna:
3.2 Formen: publicerade regressionsmodeller
Hur skiljer sig ett bestånd från genomsnittet? Två finska studier har anpassat modeller av bärens täckning och skörd till taxeringsytor. EcoVal använder deras publicerade koefficienter; den anpassar ingenting. Det här är "lånad regression": statistiken gjordes av artiklarnas författare på finska data.
Varje modell har två steg. Först växtens täckning (i %) från en logistisk modell, där den linjära prediktorn är en summa av koefficienter gånger beståndets egenskaper:
För blåbär (Miina m.fl. 2009), med beståndsålder , grundyta , tallandel , en term för planterade bestånd och en referenshöjd över havet:
Sedan skörden från täckningen, som en log-linjär modell (så skörden är exponentialfunktionen av en summa):
public static double BilberryIndex(StandYear stand, double pineShare, bool planted, BerryOptions options)
{
var m = options.BilberryCoverModel;
var logit = m.Intercept
+ m.Pine * pineShare
+ (planted ? m.ArtificialRegeneration : 0)
+ m.AltitudePerMetre * options.ReferenceAltitudeMetres
+ m.Age * stand.AgeYears
+ m.AgeSquaredPer100 * stand.AgeYears * stand.AgeYears / 100
+ m.BasalArea * stand.BasalArea
+ m.BasalAreaSquaredPer100 * stand.BasalArea * stand.BasalArea / 100;
return Yield(CoverPercent(logit), stand.BasalArea, options.BilberryYield);
}
private static double CoverPercent(double logit) => 100 / (1 + Math.Exp(-logit));
private static double Yield(double coverPercent, double basalArea, QuadraticYield model) =>
Math.Exp(model.Cover * coverPercent
+ model.CoverSquaredPer100 * coverPercent * coverPercent / 100
+ model.LnBasalAreaPlusOne * Math.Log(basalArea + 1));
Kvadrattermerna med negativa koefficienter är det som ger kurvorna en topp: blåbär trivs bäst i ett medeltätt bestånd, medan lingon ger mest bär i det öppna.
Koefficienterna ligger i BerryOptions som vanliga egenskaper, var och en med artikeln och tabellen den kommer
ifrån:
/// <summary>Miina et al. (2009) Table 2: logit of bilberry cover.</summary>
public sealed class BilberryCoverModel
{
public double Intercept { get; set; } = -3.8470;
public double Pine { get; set; } = 0.1209;
// …
public double BasalArea { get; set; } = 0.0947;
public double BasalAreaSquaredPer100 { get; set; } = -0.1916;
}
3.3 Bara kvoten används
De finska modellernas absoluta nivå är inte att lita på för Sverige, och skördeformeln ovan utelämnar modellens intercept. Bara kvoten mellan det här beståndet och ett genomsnittligt bestånd används. Det genomsnittliga beståndet är medelvärdet av indexet över en hel omloppstid i skogsbruksvägen, som står för ett landskap med alla åldrar i sig:
/// <summary>kg per hectare and year: the county's average stand × this stand's index ÷ the average stand's.</summary>
public double KgPerHectare(StandYear stand, bool planted) => LevelPerHectare * Index(stand, planted) / Mean;
Det här är ett vanligt och sunt sätt att kombinera två källor: en nivå från lokala mätningar och en form från en modell som anpassats någon annanstans.
3.4 Beståndet längs vägarna
Bärmodellerna behöver beståndets ålder och grundyta varje år. Tillväxtmodellen ger volym per år, inte grundyta, så beståndets formhöjd (volym ÷ grundyta i dag, se del 1, avsnitt 6.6) räknar om den och antas förbli densamma:
var formHeight = volumePerHectare / basalArea;
// …
double BasalArea(double volume) => volume / formHeight;
var keep = Enumerable.Range(0, horizonYears)
.Select(year => new StandYear(standAgeYears + year, BasalArea(paths.KeepVolume[year]), Regrown: false))
.ToList();
3.5 Förlusten och dess värde
De kilo som går förlorade år är den plockade andelen gånger ytan gånger skillnaden i skörd:
kan vara negativ: ett ungt öppet bestånd kan ge fler lingon än det gamla gjorde. Summan behåller tecknet, så en vinst väger upp en förlust.
double LostKg(Species species, Case c, List<StandYear> felled, int year) =>
c.Share * forestHectares * species.KgPerHectare(keep[year], false)
- c.Share * forestHectares * species.KgPerHectare(felled[year], c.Planted && felled[year].Regrown);
De tre fallen är små poster som buntar ihop en plockad andel, en prisväljare och om den återvuxna skogen är planterad, vilket håller de låga, centrala och höga varianterna i en tabell:
var cases = new[]
{
new Case(share.Low, Planted: false, species => species.Price.Low),
new Case(share.Central, Planted: true, species => species.Price.Central),
new Case(share.High, Planted: true, species => species.Price.High),
};
4. Näringsämnen till vatten efter avverkning
Fil: Water/WaterCalculator.cs. Ett hygge läcker mer kväve och fosfor till vattendragen än en stående skog under
några år.
4.1 Skogens egen belastning per hektar
SMHI modellerar hur mycket kväve och fosfor varje delavrinningsområdes skog skickar till vatten. En polygon kan överlappa flera delavrinningsområden, så dess belastning per hektar är medelvärdet av deras, viktat med hur mycket av polygonen som ligger i vart och ett:
med polygonens överlapp med delavrinningsområde .
var weight = loaded.Sum(row => row.OverlapHectares);
double PerHectare(Func<CatchmentLoadRow, double> kg) =>
loaded.Sum(row => kg(row) / row.ForestHectares * row.OverlapHectares) / weight;
4.2 Det extra läckaget: en multipel under några år
Ett hygges vatten bär gånger skogens halt (för kväve 1,25, 2 eller 2,1) med samma avrinning. Det extra, per år, över den avverkade ytan :
Det varar år efter varje avverkning (5 i söder, 10 i norr), och går sedan tillbaka till skogens nivå.
var perYear = new ValueRange(
(factor.Low - 1) * forestPerHectare * felledHectares,
(factor.Central - 1) * forestPerHectare * felledHectares,
(factor.High - 1) * forestPerHectare * felledHectares);
4.3 Värdet: pulser, diskonterade
Varje avverkningsår startar en puls. Eftersom det extra är detsamma varje pulsår kan nuvärdet delas upp i , priset och en summa av diskonteringsfaktorer över pulsåren:
var pulseYears = fellings
.SelectMany(start => Enumerable.Range(start, years))
.Where(year => year >= 0 && year < horizonYears)
.ToList();
var discount = pulseYears.Sum(year => Math.Pow(1 + discountRate, -year));
// …
CarbonValueCalculator.RoundToHundreds(nutrient.ExtraKgPerYear.Central * discount * nutrient.SekPerKg.Central),
SelectMany gör om "varje avverkningsår" till "varje år i varje puls" i ett uttryck. Skogsbruksvägen har flera
avverkningsår, vägen med fri utveckling bara år 0.
4.4 Priser från flera källor
Varje näringsämne har flera publicerade priser (kostnaden för att ta bort det i en våtmark, en skadekostnad, ett svenskt värde per vattendistrikt), i olika valutor och prisår. De räknas alla om på samma sätt som koldioxidpriserna i del 2:
return price.PerKg * exchange * Index(price.PriceYear, options);
och intervallet sätts ihop av dem. För fosfor är det låga värdet reningskostnaden, det centrala mitten av distriktets värdeband, och det höga det större av bandets topp och skadekostnaden:
var price = ValueRange.Spanning(removal, (band.Low + band.High) / 2 * index, Math.Max(band.High * index, damage), 0);
Spanning (del 1, avsnitt 3.1) garanterar lågt ≤ centralt ≤ högt även där källorna inte kommer i den ordningen.
5. Dricksvatten nedströms
Fil: Water/DrinkingWaterDownstreamCalculator.cs. En avverkning höjer det organiska kolet (den bruna färgen) i
vattendragen nedanför. Om en dricksvattentäkt ligger nedströms blir dess råvatten lite brunare, och vattenverket
betalar lite mer för att rena det.
5.1 Hitta den första täkten nedströms
Varje delavrinningsområde rinner ut i ett annat. Med start i varje delavrinningsområde som polygonen överlappar går uppslaget nedströms steg för steg och antecknar vilka delavrinningsområden som rymmer en utpekad dricksvattentäkt:
flowchart LR
P["Polygonen överlappar<br/>delavrinningsområde A och B"] --> A["A"]
P --> B["B"]
A --> C["C"]
B --> C
C --> D["D: rymmer en sjö som är<br/>dricksvattentäkt"]
D --> E["E … till havet"]
style D stroke-width:3px
Pick tar, för varje start, det första steget vars delavrinningsområde rymmer en täkt, och väljer sedan den täkt
som den största delen av polygonen rinner till:
var path = steps[start.AroUuid].OrderBy(step => step.Depth).ToList();
var first = path.FirstOrDefault(step => hits[step.AroUuid].Any());
// …
var chosen = reached
.GroupBy(entry => entry.Hit!.WaterId)
.OrderByDescending(group => group.Sum(entry => entry.Start.OverlapHectares))
.ThenBy(group => group.Key, StringComparer.Ordinal)
.First()
.ToList();
Den andra sorteringsnyckeln (ThenBy på vattnets id) gör valet bestämt när två täkter väger lika: samma polygon
ger alltid samma svar.
5.2 Blandningsmodellen
Den avverkade marken är en andel av allt som rinner till täkten:
De avverkade vattendragen bär mg/l mer organiskt kol och gånger så mycket vatten. Nedströms blandas de med vatten från resten av avrinningsområdet, så täkten ser ökningen utspädd med andelen:
Det här är en konservativ blandningsmodell: den antar att inget försvinner på vägen, så det är en övre skattning.
var felled = felledHectares * Math.Clamp(source.StartsHectares / polygonHectares, 0, 1);
var share = felled / (source.UpstreamAreaKm2 * 100); // km² → ha
// …
double Extra(double increase, double runoff) => share * increase * runoff;
Ökningen har två faser (de två första åren efter avverkningen, sedan två år efter markberedningen), var och en med sitt eget .
5.3 Kostnaden
Ett vattenverks kostnad för ytterligare ett mg/l organiskt kol är publicerad i öre per kubikmeter. Den extra kostnaden är
och, summerad över åren i varje fas, i kronor per miljon kubikmeter renat vatten (1 öre/m³ är 10 000 kr per miljon m³):
// kr per million m³ over a felling's years: öre per m³ × 10,000.
double Sek(Func<ValueRange, double> end) =>
Math.Round(phases.Sum(phase => end(phase.OrePerCubicMetre) * (phase.ToYear - phase.FromYear + 1)) * 10_000);
Resultatet är per miljon m³ eftersom volymen ett vattenverk tar ut inte är offentlig. Andelen klassas också mot två publicerade trösklar (0,11 och 0,23 av avrinningsområdet) och skickas som en kod, så att sidan kan säga om effekten alls skulle gå att upptäcka.
6. Blöt mark: organiskt kol och kvicksilver
Fil: Water/WetGroundWaterCalculator.cs. Det här är bara indikatorer; inget prissätts.
En svensk studie av 179 källflöden anpassade en regression av organiskt kol (TOC) mot andelen av avrinningsområdet som är skogbevuxen våtmark. Modellen är log-linjär: tiologaritmen av TOC stiger i en rät linje med andelen , med lutningen 1,3. EcoVal använder den enda publicerade koefficienten för att säga hur mycket högre TOC är med den här polygonens andel än utan någon:
Interceptet tar ut sig i kvoten, och därför behövs bara lutningen.
var beyondStudy = forestOnWetland > options.MaxForestOnWetlandShare;
var tocIncrease = forestOnWetland is { } share
? Math.Round(Math.Pow(10, options.TocWetlandCoefficient * Math.Min(share, options.MaxForestOnWetlandShare)) - 1, 2)
: (double?)null;
Math.Min är viktig. Studiens avrinningsområden hade som mest 41,2 % skogbevuxen våtmark. En regression säger
inget tillförlitligt utanför det dataintervall den anpassades på, så en större andel räknas vid 41,2 % och flaggas
med beyondStudy, och sidan visar den som "minst". Det är samma skydd mot extrapolering som klämningen i
kantarellmodellen (del 1, avsnitt 6.7).
7. Våtmark och dikad torv
Filer: Wetland/WetlandCalculator.cs, Wetland/PeatCalculator.cs, Wetland/DitchMask.cs.
7.1 Marktäcke och markfuktighet: klassytor, grupperade
Rastren för marktäcke och markfuktighet innehåller klasser. ClassAreas.Count (del 1, avsnitt 2.3) ger hektar per
klassvärde, och kalkylatorn viker ihop de många klassvärdena till några få grupper med en switch över mönster:
switch (LandCoverClasses.Group(value))
{
case LandCoverGroup.OpenWetland or LandCoverGroup.LowMountainForestOnWetland:
openWetland += hectares;
break;
case LandCoverGroup.ForestOnWetland:
forestOnWetland += hectares;
break;
// …
}
7.2 Vilken torv som är dikad: ett rumsligt index
Torv räknas som dikad när den ligger inom 25 m från ett dike. Sveriges dikeskarta har omkring 30 miljoner linjer,
så att pröva varje torvpixel mot varje dike är uteslutet. DitchMask delar dikena nära polygonen i raka segment och
lägger dem i ett R-träd (NetTopologySuites STRtree), ett rumsligt index som kan ge tillbaka "de segment vars
omslutande ruta rör den här rutan" utan att titta på resten:
public bool Near(double x, double y)
{
// …
var point = new Coordinate(x, y);
foreach (var segment in _index.Query(new Envelope(x - _distance, x + _distance, y - _distance, y + _distance)))
{
if (segment.Distance(point) <= _distance)
{
return true;
}
}
return false;
}
Frågerutan hittar kandidater billigt; det exakta avståndstestet avgör sedan. Det här tvåstegsmönstret (ett billigt filter, sedan ett exakt test) är samma tanke som gränspixlarna i del 1, avsnitt 2.2.
7.3 Utsläpp per hektar: tre gaser i en enhet
Dikad torv släpper ut koldioxid, lustgas och metan. För att kunna lägga ihop dem räknas var och en om till "koldioxidekvivalenter" (CO₂e) i två steg: från massan av det rapporterade grundämnet (kol eller kväve) till massan av gasen, med kvoten av molmassorna, och från gasen till CO₂e med dess globala uppvärmningspotential (GWP: hur många gånger mer uppvärmning ett ton av gasen orsakar än ett ton CO₂ över 100 år).
Indata är ton kol, kilogram kväve och kilogram metan per hektar och år; talet 1000 gör om kilogram till ton. GWP-värdena är 265 för lustgas och 28 för metan.
private const double Co2PerCarbon = 44.0 / 12.0;
private const double NitrousOxidePerNitrogen = 44.0 / 28.0;
private const double MethanePerCarbon = 16.0 / 12.0;
public static double DrainedTonnesPerHectare(DrainedPeatFactor factor, PeatOptions options) =>
(factor.Co2CarbonTonnes + factor.DocCarbonTonnes) * Co2PerCarbon
+ factor.NitrousOxideNitrogenKg * NitrousOxidePerNitrogen * options.NitrousOxideGwp / 1_000
+ (factor.MethaneKg + factor.DitchMethaneKg) * options.MethaneGwp / 1_000;
Återvätt torv slutar förlora kol (den kan till och med ta upp en del) men släpper ut mer metan:
Diagrammet visar varför återvätningens resultat har ett så brett intervall: det publicerade 95 %-intervallet för metan från återvätt torv är mycket brett, så återvätning kan spara mycket eller, i den olyckliga änden, kosta mer än att låta torven vara dikad. Koden håller det ärligt genom att räkna besparingen vid den låga änden, mitten och den höga änden av metanintervallet:
public double[] Savings => [DrainedTonnes - RewettedHighTonnes, SavingTonnes, DrainedTonnes - RewettedLowTonnes];
7.4 De tre fallen: efter torvens sort
Emissionsfaktorerna skiljer sig med torvens kol/kväve-kvot, och ingen karta visar den kvoten. Därför är klasserna själva intervallet: det låga fallet är den klass som släpper ut minst, det höga den som släpper ut mest, och det centrala klassernas medelvärde viktat med hur mycket Sverige har av var och en:
double Weighted(Func<PeatCase, double> value) => classes.Zip(each, (factor, peat) => value(peat) * factor.AreaKha).Sum() / area;
return
[
each.MinBy(peat => peat.DrainedTonnes)!,
new PeatCase(Weighted(peat => peat.DrainedTonnes), /* … */),
each.MaxBy(peat => peat.DrainedTonnes)!,
];
7.5 Torven tar slut
Dikad torv släpper ut genom att förlora sitt kol, så ett tunt lager är borta innan tidshorisonten är slut. De år ett lager med djupet meter räcker är dess kol delat med dess årliga förlust, där är kolet per kubikmeter (kg) och förlusten (ton kol per hektar och år):
Talet 10 000 är kvadratmetrarna på en hektar (så är torvens volym per hektar), och 1000 gör om kilogram till ton.
public static double YearsUntilGone(double depthMetres, double carbonKgPerCubicMetre, double carbonLossTonnes) =>
depthMetres * 10_000 * carbonKgPerCubicMetre / 1_000 / carbonLossTonnes;
Ingen karta ger torvens djup i en polygon, så regionens kända fördelning av djup används: en andel av torven ligger i djupklass . Andelen som fortfarande släpper ut år är
Klämningen gör att en klass räknas fullt medan den räcker, med den bråkdel av sitt sista år som återstår, och inte alls därefter.
public static double[] StillEmitting(IReadOnlyList<double> shares, IReadOnlyList<double> years, int horizonYears) =>
Enumerable.Range(0, horizonYears)
.Select(year => shares.Zip(years, (share, lasts) => share * Math.Clamp(lasts - year, 0, 1)).Sum())
.ToArray();
Fallen är parade så att intervallet vidgas som det ska: den torv som släpper ut mest får minst kol per kubikmeter, så det höga fallet både släpper ut mest och tar slut först.
7.6 Värdet: ett flöde prissatt år för år
Utsläppet från dikad torv är ett årligt flöde, prissatt med varje års koldioxidpris och diskonterat
(CarbonValueCalculator.PresentValueOfFlow, flödesmotsvarigheten till del 2:s nuvärde av ett gap):
double[] Flow(int i) => emitting[i].Select(share => share * emission[i]).ToArray();
var emissionSek = Range(
Enumerable.Range(0, 3).SelectMany(i => prices.All.Select(series =>
CarbonValueCalculator.PresentValueOfFlow(Flow(i), series, discountRate))),
CarbonValueCalculator.PresentValueOfFlow(Flow(1), prices.Central, discountRate));
Som för kolvärdet i del 2 är intervallet det minsta och största över varje kombination (tre torvfall gånger tre prisfall), med det centrala fallet räknat direkt.
Återvätningsvägen sparar skillnaden mellan utsläppen från dikad och återvätt torv, men träden på återvätt torv slutar växa, så upptaget de skulle ha haft går förlorat. Det årliga nettoflödet är
där det förlorade upptaget kommer från tillväxtmodellens förråd i den kvarstående skogen, som dess ökning från år till år:
double[] Lost(double[] stock, double hectares) =>
Enumerable.Range(0, horizonYears).Select(year => (stock[year + 1] - stock[year]) * hectares).ToArray();
double[] Net(int i, double savedTonnes, double[]? lost) =>
Enumerable.Range(0, horizonYears).Select(year => emitting[i][year] * (savedTonnes - (lost?[year] ?? 0))).ToArray();
Här löper intervallet över fyra dimensioner på en gång: tre torvfall, tre metanvärden, tre tillväxtkörningar och
tre prisfall, sammanlagt 81 kombinationer. Den nästlade SelectMany räknar upp dem och intervallet tar minimum och
maximum.
8. Skyddad och värdefull natur
De här avsnitten räknar och mäter; inget prissätts ("ett värde utan pris är inte noll"). De är mest geometri och gruppering, och det intressanta är att undvika dubbelräkning.
8.1 Hur mycket som får avverkas: ytor av unioner
Fil: Protection/ForestProtection.cs. En bit mark kan vara naturreservat och Natura 2000-område. Att lägga
ihop de två överlappen skulle räkna den två gånger. Databasen mäter därför ytan av unionen av varje grupp av
skydd innanför den ritade ytan, och kalkylatorn gör om de ytorna till uppdelningen:
flowchart LR
O["Ritad yta"] --> S["Ingen avverkning<br/>(reservat, nationalpark, biotopskydd, …)"]
O --> F["Avverkningsbar = ritad yta − ingen avverkning"]
F --> P["varav: tillstånd krävs (Natura 2000)"]
F --> A["varav: naturvårdsavtal"]
F --> K["varav: nyckelbiotoper"]
Värdena i den avverkade kolumnen på andra ställen på sidan skalas med den här andelen.
En regel tar hand om ett praktiskt besvär. En yta som ritas runt ett reservat följer aldrig gränsen exakt, vilket lämnar en smal remsa som ser avverkningsbar ut. Under 0,1 ha eller 1 % av den ritade ytan behandlas remsan som en flisa och ytan räknas som helt skyddad:
var fellable = Math.Max(outlineHectares - noFelling, 0);
if (noFelling > 0 && (fellable < SliverHectares || fellable < SliverShare * outlineHectares))
{
noFelling = outlineHectares;
fellable = 0;
}
8.2 Rennäring: unioner och differenser
Fil: Reindeer/ReindeerCalculator.cs. Samebyar delar vinterbetesmark, och åretruntmarken ligger tvärs över dem, så
även här är totalerna ytor av unioner. Marken som bara används på vintern är en mängddifferens:
var yearRound = Union(yearRoundPieces);
var herding = Union([.. villagePieces, .. yearRoundPieces]);
// …
var winterOnlyHectares = herding is null ? 0 : Hectares(yearRound is null ? herding : herding.Difference(yearRound));
UnaryUnionOp.Union och Difference är geometrioperationer i NetTopologySuite. Överlapp under 0,01 ha tas bort
som flisor längs delade kanter.
8.3 EU:s naturtyper och artfynd: gruppera och summera
Filer: Habitats/NaturaHabitatCalculator.cs, Species/SpeciesCalculator.cs. Båda tar rader från databasen (bitar
av karterad naturtyp; enskilda artfynd) och sammanfattar dem med LINQ:s GroupBy. Artavsnittet delar först fynden
efter hur nya de är:
var recent = records.Where(record => record.Year >= options.RecentFromYear).ToList();
var earlier = records.Where(record => record.Year < options.RecentFromYear).ToList();
var undated = records.Count - recent.Count - earlier.Count;
och grupperar sedan per art och sorterar efter hur hotad arten är, med lika lägen avgjorda av antalet fynd och sedan namnet, så att ordningen är stabil:
.OrderBy(found => CategoryRank(found.RedListCategory))
.ThenByDescending(found => found.Records)
.ThenBy(found => found.ScientificName, StringComparer.Ordinal)
8.4 Hur mycket någon har letat: en percentil
Fil: Species/RecordEffortCalculator.cs. En kort artlista kan betyda få arter eller få besök av rapportörer. Den
här kalkylatorn mäter det senare, så att sidan kan säga vilket.
Den arbetar på de 1 km-rutor som polygonen rör. Två tal beskriver insatsen:
- medianen av antalet fynd bland de berörda rutor som har något fynd, och var den medianen ligger bland alla Sveriges rutor med fynd, som en percentil;
- andelen av de berörda rutorna som har något fynd alls.
Sveriges fördelning är en sorterad lista, så "hur många ligger under det här värdet" är en binärsökning: halvera sökintervallet tills det sluter sig om positionen. Det tar omkring 17 steg för 100 000 värden i stället för 100 000 jämförelser.
private static int LowerCount(IReadOnlyList<int> sorted, double value)
{
int low = 0, high = sorted.Count;
while (low < high)
{
var middle = (low + high) / 2;
if (sorted[middle] < value)
{
low = middle + 1;
}
else
{
high = middle;
}
}
return low;
}
De två talen görs sedan om till en läsning med fasta gränser:
| Läsning | Villkor |
|---|---|
none |
Ingen berörd ruta har något fynd |
little |
Percentil under 25, eller fynd i färre än hälften av rutorna |
well |
Percentil minst 75, och fynd i minst tre fjärdedelar av rutorna |
typical |
Allt annat |
var reading = with == 0 ? EffortReadings.None
: percentile < options.LittleBelowPercentile || share < options.LittleBelowShare ? EffortReadings.Little
: percentile >= options.WellFromPercentile && share >= options.WellFromShare ? EffortReadings.Well
: EffortReadings.Typical;
Lägg märke till asymmetrin: en svag signal räcker för "little", men båda måste vara starka för "well". Tomma rutor hålls med flit utanför medianen och räknas genom andelen i stället, så att Sveriges många obesökta rutor inte drar ner den nationella referensen till noll.
8.5 Sannolikhet för höga naturvärden: läsa någon annans tränade modell
Fil: ValueCores/ValueCoreCalculator.cs. Rastret som används här är utdata från en prediktiv modell som tränats
av dess upphovspersoner (Naturvärdeskarta Skog, Jonsson m.fl. 2024): för varje hektar, sannolikheten att en
fältinventering skulle klassa den som värdekärna. Det är det enda stället där en tränad modells förutsägelser
kommer in på skogssidan. EcoVal tränar den inte, kör den inte och har inte dess parametrar; den läser det
publicerade rastret och sammanfattar det.
Sammanfattningen är den ytviktade medelsannolikheten och hektaren i tre band (rapportens egna yttre klasser, högst 0,3 och minst 0,7):
där är hektaren med rastervärdet (sannolikheten i procent).
var mean = modelled.Sum(entry => entry.Key * entry.Value) / hectares / 100;
// …
Math.Round(Sum(percent => percent <= options.LowAtMostPercent), 2),
Math.Round(Sum(percent => percent > options.LowAtMostPercent && percent < options.HighAtLeastPercent), 2),
Math.Round(Sum(percent => percent >= options.HighAtLeastPercent), 2),
Eftersom indata redan är hektar per värde (ett histogram från ClassAreas.Count) behöver medelvärdet inget andra
varv över pixlarna.
8.6 Äldre lövrik skog: två trösklar, tre fall
Fil: OldForest/DeciduousRichCalculator.cs. En pixel räknas när den både är gammal nog och har tillräckligt med
löv (en lövandel på minst 30 %). Båda indata är osäkra: åldern har två modeller (del 2, avsnitt 3.1) och
lövandelen har en lägre och en högre läsning. Det låga fallet kräver båda villkoren med den pessimistiska
läsningen av vartdera, det höga med den optimistiska:
area[0] += age.Reaches(younger, years) && Rich(share.Lower) ? pixel.Hectares : 0;
area[2] += age.Reaches(older, years) && Rich(share.Higher) ? pixel.Hectares : 0;
Rich jämför med en liten tolerans (value >= minimum - 1e-9), eftersom en andel som är exakt 0,3 i datat kan
komma fram som 0,29999999 efter flyttalsräkning, och definitionen säger "minst".
9. Sammanfattning
| Avsnitt | Sorts beräkning | Regression eller anpassad modell? |
|---|---|---|
| Besök per vuxen, värde per besök | Viktad summa; prisindexering | Nej |
| Fördelning av besök efter avstånd | Gravitationsmodell | Kalibrerad av EcoVal (del 1, avsnitt 6.1–6.4) |
| Friluftsliv efter avverkning | Trappstegsfunktion av ålder; diskonterad summa | Nej (expertbetyg) |
| Bär: nivå | Kvoter av publicerad statistik | Nej |
| Bär: form | Logistisk täckningsmodell och log-linjär skördemodell | Lånad regression: koefficienter från Miina m.fl. 2009 och Turtiainen m.fl. 2013, inte anpassade av EcoVal |
| Näringsläckage | Publicerad faktor på en modellerad belastning; diskonterade pulser | Nej (SMHI:s belastningar kommer från SMHI:s egen hydrologiska modell) |
| Dricksvatten nedströms | Vandring i nätet; blandning efter ytandel | Nej (publicerade ökningar) |
| Organiskt kol från blöt mark | En koefficient ur en log-linjär regression | Lånad regression: Löfgren m.fl. 2014, begränsad till studiens intervall |
| Torvens utsläpp | Emissionsfaktorer, gasomräkningar, uttömning; diskonterat flöde | Nej (inventeringens och IPCC:s faktorer) |
| Skydd, rennäring, naturtyper, arter | Unioner av geometrier och gruppering | Nej |
| Rapporteringsinsats | Median, percentil med binärsökning, gränser | Nej |
| Sannolikhet för höga naturvärden | Ytviktat medelvärde av ett raster | Någon annans tränade modell: EcoVal läser bara dess utdata |
| Lövrik skog | Räkna pixlar mot två trösklar | Nej |
Tre sätt som en modell utifrån kan komma in i appen förekommer i den här delen, och de är värda att hålla isär:
- Lånade koefficienter (bär, organiskt kol): EcoVal räknar ut en publicerad formel. Koefficienterna är inställningar med sin källa; ingenting tränas.
- Lånade modellutdata (sannolikheten för naturvärden, SMHI:s näringsbelastningar): EcoVal läser tal som en modell har tagit fram och har ingen tillgång till själva modellen.
- Lånade faktorer (torv, läckagemultiplar, expertbetyg): enskilda publicerade tal, inga modeller.
I varje fall är säkerhetsnivån borrowed eller modelled, aldrig measured, och det är så sidan talar om för
läsaren hur långt talet går att lita på.