EcoVal Ändringslogg v0.5.0

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

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:

PV=∑t=0H−1pt⋅qt(1+r)tPV = \sum_{t=0}^{H-1} \frac{p_t \cdot q_t}{(1 + r)^{t}}

qtq_t är den fysiska mängden år tt (besök, kilogram, ton), ptp_t dess pris, rr diskonteringsräntan (3,5 %) och HH tidshorisonten (100 år). Avsnitten skiljer sig bara i hur de tar fram qtq_t. 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 wcw_c gånger ett antal besök ncn_c för klassen. Klassgränserna ger intervallet: det lägsta antalet i varje klass, enkätens eget indexvärde, och det högsta.

V=∑cwc ncV = \sum_c w_c \, n_c
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 gg (1,15 % per år) för varje år sedan enkäten, eftersom människor värderar sin tid högre när inkomsterna stiger.

vi dag=vstudie⋅KPIprisa˚rKPIstudiea˚r⋅(1+g) prisa˚r−enka¨ta˚rv_{\text{i dag}} = v_{\text{studie}} \cdot \frac{\text{KPI}_{\text{prisår}}}{\text{KPI}_{\text{studieår}}} \cdot (1 + g)^{\,\text{prisår} - \text{enkätår}}
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:

beso¨kP=ra¨kning⋅min⁡ ⁣(1, o¨verlapp haomra˚dets ha)\text{besök}_P = \text{räkning} \cdot \min\!\left(1,\ \frac{\text{överlapp ha}}{\text{områdets ha}}\right)
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 hh av de boendes besök som görs under vistelse i kommersiellt boende tas bort ur de boendes modeller:

h=min⁡ ⁣(1, ∑minhemska na¨tterm⋅qmV⋅vuxna)h = \min\!\left(1,\ \frac{\sum_m \text{inhemska nätter}_m \cdot q_m}{V \cdot \text{vuxna}}\right)

med qmq_m besöken per gästnatt för kommun mm: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 VV, polygonens andel av de närboende vuxnas besök S(d0)S(d_0) från avståndsmodellen (del 1, avsnitt 6.1), andelen besök som är vardagsbesök (1−s)(1−h)(1 - s)(1 - h), och den oräknade andelen uu.

beso¨k=V⋅S(d0)⋅(1−s)(1−h)⋅u\text{besök} = V \cdot S(d_0) \cdot (1 - s)(1 - h) \cdot u

Intervallet parar ihop de låga och de höga värdena. SS räknas för vart och ett av de tre avstånden d0d_0, 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 d0d_0 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 vv, resten till resvärdet vresav_{\text{resa}} (en längre utflykt är värd mer):

va¨rde=nna¨ra⋅v+(n−nna¨ra)⋅vresa\text{värde} = n_{\text{nära}} \cdot v + (n - n_{\text{nära}}) \cdot v_{\text{resa}}

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:

Hur attraktivt ett bestånd är för friluftsliv, efter å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 tt har det kvarstående beståndet åldern a0+ta_0 + t och det avverkade åldern sedan sin senaste avverkning, τ(t)\tau(t). Andelen av friluftsvärdet som går förlorad det året är hur långt det avverkade beståndets betyg ligger efter:

ℓ(t)=max⁡ ⁣(0, 1−betyg(τ(t))betyg(a0+t))\ell(t) = \max\!\left(0,\ 1 - \frac{\text{betyg}(\tau(t))}{\text{betyg}(a_0 + t)}\right)

och förlusten över tidshorisonten är nuvärdet av den andelen av det årliga friluftsvärdet YY:

fo¨rlust=∑t=0H−1Y⋅ℓ(t)(1+r)t\text{förlust} = \sum_{t=0}^{H-1} \frac{Y \cdot \ell(t)}{(1 + r)^{t}}
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:

cˉregion=medel⁡y(sko¨rdy)skogsmark\bar{c}_{\text{region}} = \frac{\operatorname{medel}_y(\text{skörd}_y)}{\text{skogsmark}}
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:

cˉla¨n=cˉregion⋅ta¨ckningla¨nta¨ckningregion\bar{c}_{\text{län}} = \bar{c}_{\text{region}} \cdot \frac{\text{täckning}_{\text{län}}}{\text{täckning}_{\text{region}}}

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 cc (i %) från en logistisk modell, där den linjära prediktorn η\eta är en summa av koefficienter gånger beståndets egenskaper:

c=1001+e−ηc = \frac{100}{1 + e^{-\eta}}

För blåbär (Miina m.fl. 2009), med beståndsålder aa, grundyta GG, tallandel qq, en term för planterade bestånd och en referenshöjd över havet:

ηbla˚=β0+β1q+β2 [planterad]+β3 ho¨jd+β4a+β5a2100+β6G+β7G2100\eta_{\text{blå}} = \beta_0 + \beta_1 q + \beta_2\,[\text{planterad}] + \beta_3\,\text{höjd} + \beta_4 a + \beta_5 \frac{a^2}{100} + \beta_6 G + \beta_7 \frac{G^2}{100}

Sedan skörden från täckningen, som en log-linjär modell (så skörden är exponentialfunktionen av en summa):

sko¨rd∝exp⁡ ⁣(γ1c+γ2c2100+γ3ln⁡(G+1))\text{skörd} \propto \exp\!\left(\gamma_1 c + \gamma_2 \frac{c^2}{100} + \gamma_3 \ln(G + 1)\right)
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.

Bärskörd efter hur tätt beståndet är

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:

cbesta˚nd=cˉla¨n⋅I(besta˚nd)medel⁡omloppstidIc_{\text{bestånd}} = \bar{c}_{\text{län}} \cdot \frac{I(\text{bestånd})}{\operatorname{medel}_{\text{omloppstid}} I}
/// <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:

Gt=VtF,F=V0G0G_t = \frac{V_t}{F}, \qquad F = \frac{V_0}{G_0}
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 tt är den plockade andelen π\pi gånger ytan AA gånger skillnaden i skörd:

Δt=π⋅A⋅[ckvar(t)−cavverkad(t)]va¨rde=∑t=0H−1p⋅Δt(1+r)t\Delta_t = \pi \cdot A \cdot \bigl[c_{\text{kvar}}(t) - c_{\text{avverkad}}(t)\bigr] \qquad \text{värde} = \sum_{t=0}^{H-1} \frac{p \cdot \Delta_t}{(1 + r)^{t}}

Δt\Delta_t 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:

L=∑ibelastningiskog hai⋅oi∑ioiL = \frac{\sum_i \dfrac{\text{belastning}_i}{\text{skog ha}_i} \cdot o_i}{\sum_i o_i}

med oio_i polygonens överlapp med delavrinningsområde ii.

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 ff 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 AA:

E=(f−1)⋅L⋅AE = (f - 1) \cdot L \cdot A

Det varar nn år efter varje avverkning (5 i söder, 10 i norr), och går sedan tillbaka till skogens nivå.

Extra kväveläckage efter avverkning
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 EE är detsamma varje pulsår kan nuvärdet delas upp i EE, priset pp och en summa av diskonteringsfaktorer över pulsåren:

PV=p⋅E⋅∑t ∈ pulsa˚r(1+r)−tPV = p \cdot E \cdot \sum_{t \,\in\, \text{pulsår}} (1 + r)^{-t}
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 ϕ\phi av allt som rinner till täkten:

ϕ=AavverkatAuppstro¨ms\phi = \frac{A_{\text{avverkat}}}{A_{\text{uppströms}}}

De avverkade vattendragen bär ΔC\Delta C mg/l mer organiskt kol och ρ\rho 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:

ΔCta¨kt=ϕ⋅ΔC⋅ρ\Delta C_{\text{täkt}} = \phi \cdot \Delta C \cdot \rho

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 ΔC\Delta C.

5.3 Kostnaden

Ett vattenverks kostnad för ytterligare ett mg/l organiskt kol är publicerad i öre per kubikmeter. Den extra kostnaden är

o¨re per m³=ΔCta¨kt⋅κ\text{öre per m³} = \Delta C_{\text{täkt}} \cdot \kappa

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 ϕ\phi 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 ww, 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:

log⁡10TOC=α+1,3 w⟹TOC(w)TOC(0)−1=10 1,3 w−1\log_{10}\text{TOC} = \alpha + 1{,}3\,w \quad\Longrightarrow\quad \frac{\text{TOC}(w)}{\text{TOC}(0)} - 1 = 10^{\,1{,}3\,w} - 1

Interceptet α\alpha 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).

Edikad=(CCO2+CDOC)⋅4412  +  NN2O⋅4428⋅GWPN2O1000  +  (MCH4+Mdike)⋅GWPCH41000E_{\text{dikad}} = \bigl(C_{\text{CO}_2} + C_{\text{DOC}}\bigr)\cdot\frac{44}{12} \;+\; N_{\text{N}_2\text{O}}\cdot\frac{44}{28}\cdot\frac{\text{GWP}_{\text{N}_2\text{O}}}{1000} \;+\; \bigl(M_{\text{CH}_4} + M_{\text{dike}}\bigr)\cdot\frac{\text{GWP}_{\text{CH}_4}}{1000}

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:

Ea˚terva¨tt=(CCO2+CDOC)⋅4412  +  CCH4⋅1612⋅GWPCH41000E_{\text{återvätt}} = \bigl(C_{\text{CO}_2} + C_{\text{DOC}}\bigr)\cdot\frac{44}{12} \;+\; C_{\text{CH}_4}\cdot\frac{16}{12}\cdot\frac{\text{GWP}_{\text{CH}_4}}{1000}
Torvens utsläpp dikad och återvätt

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:

Ecentral=∑kEk⋅ytak∑kytakE_{\text{central}} = \frac{\sum_k E_k \cdot \text{yta}_k}{\sum_k \text{yta}_k}
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 dd meter räcker är dess kol delat med dess årliga förlust, där ρC\rho_C är kolet per kubikmeter (kg) och λ\lambda förlusten (ton kol per hektar och år):

T(d)=d⋅10 000⋅ρC/1000λT(d) = \frac{d \cdot 10\,000 \cdot \rho_C / 1000}{\lambda}

Talet 10 000 är kvadratmetrarna på en hektar (så d⋅10 000d \cdot 10\,000 ä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 wjw_j av torven ligger i djupklass jj. Andelen som fortfarande släpper ut år tt är

S(t)=∑jwj⋅clamp⁡(Tj−t, 0, 1)S(t) = \sum_j w_j \cdot \operatorname{clamp}\bigl(T_j - t,\ 0,\ 1\bigr)

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();
Dikad torv tar slut

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

PV=∑t=0H−1P(t)⋅S(t)⋅E⋅A(1+r)tPV = \sum_{t=0}^{H-1} \frac{P(t) \cdot S(t) \cdot E \cdot A}{(1 + r)^{t}}
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

netto(t)=S(t)⋅[besparing−fo¨rlorat upptag(t)]\text{netto}(t) = S(t) \cdot \bigl[\text{besparing} - \text{förlorat upptag}(t)\bigr]

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"]
Aavverkningsbar=max⁡(0, Aritad−Aingen avverkning)avverkningsbar andel=AavverkningsbarAritadA_{\text{avverkningsbar}} = \max\bigl(0,\ A_{\text{ritad}} - A_{\text{ingen avverkning}}\bigr) \qquad \text{avverkningsbar andel} = \frac{A_{\text{avverkningsbar}}}{A_{\text{ritad}}}

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:

Arensko¨tsel=yta⁡(⋃samebyar∪a˚retrunt)Abara vinter=yta⁡(rensko¨tsel∖a˚retrunt)A_{\text{renskötsel}} = \operatorname{yta}\Bigl(\bigcup \text{samebyar} \cup \text{åretrunt}\Bigr) \qquad A_{\text{bara vinter}} = \operatorname{yta}\bigl(\text{renskötsel} \setminus \text{åretrunt}\bigr)
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.
percentil=100⋅∣{Sveriges rutor med fa¨rre fynd a¨n medianen}∣∣{Sveriges rutor med fynd}∣\text{percentil} = 100 \cdot \frac{\bigl|\{\text{Sveriges rutor med färre fynd än medianen}\}\bigr|}{\bigl|\{\text{Sveriges rutor med fynd}\}\bigr|}

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

πˉ=∑vv⋅hv100⋅∑vhv\bar{\pi} = \frac{\sum_v v \cdot h_v}{100 \cdot \sum_v h_v}

där hvh_v är hektaren med rastervärdet vv (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:

Hla˚g=∑php⋅1[ap,yngre≥τ]⋅1[bp,la¨gre≥0,3]H_{\text{låg}} = \sum_p h_p \cdot \mathbb{1}\bigl[a_{p,\text{yngre}} \ge \tau\bigr] \cdot \mathbb{1}\bigl[b_{p,\text{lägre}} \ge 0{,}3\bigr]
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:

  1. 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.
  2. 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.
  3. 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å.