EcoVal Ändringslogg v0.5.0

Så är beräkningarna byggda, del 2: skogens bestånd, virke, tillväxt och kol

Del 1 (01-foundations-and-fitted-models.sv.md) tog upp hur en ritad yta blir pixlar och hur resultat bärs. Den här delen följer skogssidans kärnkedja: vad som står i polygonen, hur gammalt det är, vad virket är värt, hur fort det växer, och vad en avverkning skulle kosta klimatet.

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/. 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. Kedjan i en blick

flowchart TB
    R["Raster, 10 m-pixlar:<br/>volym, biomassa, höjd, diameter, grundyta,<br/>ålder (två modeller), ståndortsindex (två trädslag)"]
    R --> S["Skogens förråd<br/>m³sk, ton biomassa, ton CO₂"]
    R --> A["Beståndsålder per pixel<br/>låg, central, hög"]
    A --> P["Beståndsfaser<br/>ung, gallring, växande, slutavverkning"]
    R --> M["Trädslagsblandning<br/>tall, gran, löv"]
    S --> T["Virkesvärde<br/>kr, efter avverkning och föryngring"]
    P --> T
    M --> T
    DB["Databasen: priser, kostnader,<br/>hänsynsytor, föryngringskostnader"] --> T
    S --> G["Tillväxtmodell<br/>tillväxtkurva från ståndortsindex"]
    A --> G
    G --> C["Kolvägar över 100 år<br/>behåll, skogsbruk, fri utveckling"]
    C --> V["Kolvärde<br/>kr, prissatt och diskonterat"]

Två mönster från del 1 återkommer i varje avsnitt:

  • Varje klass har en tunn instansmetod som läser raster och en static-metod med formlerna. Den statiska tar ZonalResult-värden eller vanliga tal, så testerna behöver inga filer.
  • Lågt, centralt och högt tas fram genom att köra samma formel tre gånger med tre parameteruppsättningar, inte genom att vidga ett enda resultat i efterhand.

2. Skogens förråd

Fil: Features/Forest/Timber/ForestStockCalculator.cs.

2.1 Volym och biomassa

Volym och biomassa är raster per hektar, så deras totaler är zonsummorna från del 1, avsnitt 2.2:

V=ℓ210 000∑psp vp(m³sk)M=ℓ210 000∑psp mp(ton torrsubstans ovan mark)V = \frac{\ell^2}{10\,000}\sum_p s_p\,v_p \quad \text{(m³sk)} \qquad M = \frac{\ell^2}{10\,000}\sum_p s_p\,m_p \quad \text{(ton torrsubstans ovan mark)}

I koden är det en egenskap på zonresultatet: biomass.TotalOfPerHectareValue.

2.2 CO₂-förrådet

Biomassarastret räknar det som finns ovan mark. Rötterna läggs till med en rot/skott-kvot RR, torrsubstansen görs om till kol med kolandelen fCf_C, och kol till CO₂ med kvoten mellan deras molmassor (en CO₂-molekyl väger 44, kolatomen i den 12):

CO2=M⋅(1+R)⋅fC⋅4412\text{CO}_2 = M \cdot (1 + R) \cdot f_C \cdot \frac{44}{12}

RR är den osäkra faktorn (0,2, 0,25, 0,3), så formeln är en lokal funktion som anropas tre gånger:

private const double Co2PerCarbon = 44.0 / 12.0;
// …
var biomassTonnes = biomass.TotalOfPerHectareValue;
var r = parameters.RootToShootRatio;
double Co2(double rootToShoot) => biomassTonnes * (1 + rootToShoot) * parameters.CarbonFraction * Co2PerCarbon;
// …
Co2StockTonnes: new ValueRange(Math.Round(Co2(r.Low), 1), Math.Round(Co2(r.Central), 1), Math.Round(Co2(r.High), 1)),

2.3 Medelvärden över träd, och stammar per hektar

Rastren för höjd, diameter och grundyta är 0 där träden är under 3 m. Ett vanligt medelvärde skulle dras ner av hyggen, så medelvärdet tas över de pixlar som har träd:

xˉtra¨d=∑psp xpN−N0\bar{x}_{\text{träd}} = \frac{\sum_p s_p\,x_p}{N - N_0}

där NN är det viktade antalet giltiga pixlar och N0N_0 de av dem som är noll.

private static double? MeanOverTrees(ZonalResult? result) =>
    result is { ValidPixels: > 0 } && result.ValidPixels > result.ZeroPixels
        ? result.Sum / (result.ValidPixels - result.ZeroPixels)
        : null;

Stammar per hektar följer av geometrin. Grundytan GG (m²/ha) är den summerade tvärsnittsytan av alla stammar i brösthöjd. Dela den med en genomsnittlig stams tvärsnitt, en cirkel med diametern dd centimeter:

Nstammar=Gπ(d200)2N_{\text{stammar}} = \frac{G}{\pi \left(\dfrac{d}{200}\right)^2}

Talet 200 gör om en diameter i centimeter till en radie i meter.

var radiusMetres = d / 200;
return Math.Round(g / (Math.PI * radiusMetres * radiusMetres) / 10) * 10;   // rounded to tens

2.4 Skogsmark: läsa två raster pixel för pixel

"Hur mycket av polygonen är skogsmark, och hur mycket volym står på den?" kräver två raster på en gång: marktäckekartan säger vilka pixlar som är skog, volymrastret vad som står där. RasterStack.Read går igenom flera lager på samma rutnät och lämnar varje pixels värden till en callback som en ReadOnlySpan<short>:

RasterStack.Read<bool>(
    [volumeTiles, landTiles],
    [RasterLayer.Volume.NoData, RasterLayer.LandCover.NoData],
    polygon,
    (StackedCell cell, ReadOnlySpan<short> values, out bool kept) =>
    {
        kept = false;
        // …
        mapped += cell.Hectares;
        if (!LandCoverClasses.IsForest(values[1]))
        {
            return false;
        }
        forest += cell.Hectares;
        // …
            volume += values[0] * cell.Hectares;
        return false;
    });

cell.Hectares är redan pixelns yta gånger dess andel innanför polygonen, så summorna är de viktade summorna från del 1. Tillväxtmodellen nedan arbetar på den här skogsmarken och dess volym, inte på hela polygonen.


3. Beståndsåldern och reglerna som beror på den

Filer: Forestry/StandAgeRules.cs, Forestry/StandRasters.cs, Features/Forest/OldForest/OldForestCalculator.cs.

3.1 Två åldersmodeller blir ett intervall

Skogsstyrelsen publicerar beståndsåldern två gånger: en gång modellerad som om beståndet vore gran, en gång som om det vore tall. De två kan skilja sig med årtionden. EcoVal väljer inte en av dem. De två blir intervallet, och det centrala värdet är åldern för det trädslag som växer bäst i pixeln (det högre ståndortsindexet):

ala˚g=min⁡(agran,atall)aho¨g=max⁡(agran,atall)a_{\text{låg}} = \min(a_{\text{gran}}, a_{\text{tall}}) \qquad a_{\text{hög}} = \max(a_{\text{gran}}, a_{\text{tall}}) acentral={agranom SIgran>SItallatallom SItall>SIgran12(agran+atall)om de a¨r lika eller saknasa_{\text{central}} = \begin{cases} a_{\text{gran}} & \text{om } SI_{\text{gran}} > SI_{\text{tall}} \\ a_{\text{tall}} & \text{om } SI_{\text{tall}} > SI_{\text{gran}} \\ \tfrac{1}{2}(a_{\text{gran}} + a_{\text{tall}}) & \text{om de är lika eller saknas} \end{cases}

Implementationen är en egenskap som ger en tupel, med en switch över en nullbar bool:

public bool? SpruceLeads => SiteIndexSpruce is { } spruce && SiteIndexPine is { } pine && spruce != pine ? spruce > pine : null;

public (double Low, double Central, double High) Age => (
    Math.Min(AgeSpruce, AgePine),
    SpruceLeads switch { true => AgeSpruce, false => AgePine, null => (AgeSpruce + AgePine) / 2 },
    Math.Max(AgeSpruce, AgePine));

3.2 Hektar över en åldersgräns

"Hur många hektar är gammal skog?" är en räkning, gjord tre gånger, en gång per åldersfall:

Hfall=∑php⋅1[ap,fall≥τ]H_{\text{fall}} = \sum_p h_p \cdot \mathbb{1}\bigl[a_{p,\text{fall}} \ge \tau\bigr]

1[⋅]\mathbb{1}[\cdot] är 1 när villkoret gäller och 0 annars, hph_p pixelns hektar innanför polygonen och τ\tau gränsen (som skiljer sig mellan en nordlig grupp av län och resten).

ValueRange Hectares(Func<AgedPixel, bool> where, AgeThreshold threshold, int years)
{
    double low = 0, central = 0, high = 0;
    foreach (var pixel in pixels.Where(where))
    {
        var (younger, best, older) = pixel.Stand.Age;
        low += threshold.Reaches(younger, years) ? pixel.Hectares : 0;
        central += threshold.Reaches(best, years) ? pixel.Hectares : 0;
        high += threshold.Reaches(older, years) ? pixel.Hectares : 0;
    }
    return ValueRange.Spanning(low, central, high, digits: 2);
}

Reaches döljer om gränsen räknas med ("minst 180 år") eller inte ("äldre än 140 år"), vilket skiljer sig mellan definitionerna som inställningarna hänvisar till.

3.3 Lägsta slutavverkningsålder: interpolera i en lagtabell

Föreskrifterna till skogsvårdslagen anger den lägsta åldern för föryngringsavverkning som en tabell efter ståndortsindex. Mellan tabellens rader interpoleras värdet linjärt, och utanför dem hålls det vid första och sista raden:

τ(SI)=τi+SI−SIiSIi+1−SIi (τi+1−τi)fo¨r SIi≤SI≤SIi+1\tau(SI) = \tau_i + \frac{SI - SI_i}{SI_{i+1} - SI_i}\,(\tau_{i+1} - \tau_i) \qquad \text{för } SI_i \le SI \le SI_{i+1}
public static double Interpolate(IReadOnlyList<SiteIndexAge> table, double siteIndex)
{
    var rows = table.OrderBy(row => row.SiteIndex).ToList();
    if (siteIndex <= rows[0].SiteIndex)
    {
        return rows[0].Years;
    }
    for (var i = 1; i < rows.Count; i++)
    {
        if (siteIndex <= rows[i].SiteIndex)
        {
            var (from, to) = (rows[i - 1], rows[i]);
            return from.Years + (siteIndex - from.SiteIndex) / (to.SiteIndex - from.SiteIndex) * (to.Years - from.Years);
        }
    }
    return rows[^1].Years;
}

Den här "tabellen med räta linjer mellan raderna, plant utanför ändarna" är EcoVals standardsätt att läsa en publicerad tabell. Den återkommer för produktionstabellen, prisbanorna för koldioxid och produktionsnivån.

Ett intervall som går baklänges. Kontrollen av slutavverkningsåldern räknar hektar som är yngre än gränsen. En yngre ålder lägger mer yta under gränsen, så det låga åldersfallet ger det höga resultatet. Koden säger det uttryckligen i stället för att lita på att Spanning reder ut det:

// Younger ages put more of the area below the limit: the low case of the age is the high case here.
low += older < minimum ? pixel.Hectares : 0;
central += best < minimum ? pixel.Hectares : 0;
high += younger < minimum ? pixel.Hectares : 0;

4. Beståndsfaser

Fil: Features/Forest/Timber/StandPhaseCalculator.cs.

Varje pixel sorteras in i en av fyra faser med tre jämförelser. Det är ett beslutsträd, inte en formel:

flowchart TD
    A{"Medelhöjd<br/>under 10 m?"} -->|ja| Y["ung"]
    A -->|nej| B{"Ålder minst den lägsta<br/>slutavverkningsåldern?"}
    B -->|ja| F["slutavverkning"]
    B -->|nej| C{"Grundyta<br/>minst 20 m²/ha?"}
    C -->|ja| T["gallring"]
    C -->|nej| G["växande"]
public static string Phase(PhasePixel pixel, double age, double minimumFellingAge, HarvestOptions harvest)
{
    if (pixel.HeightMetres < harvest.ThinningFromHeightMetres)
    {
        return StandPhaseCodes.Young;
    }
    if (age >= minimumFellingAge)
    {
        return StandPhaseCodes.FinalFelling;
    }
    return pixel.BasalArea >= harvest.ThinningBasalArea ? StandPhaseCodes.Thinning : StandPhaseCodes.Growing;
}

Åldern är osäker (avsnitt 3.1), så varje pixel klassas tre gånger, och varje fas hektar blir ett intervall. Volymen per fas summeras bara för den centrala åldern:

var (younger, best, older) = pixel.Stand.Age;
double[] ages = [younger, best, older];
for (var i = 0; i < ages.Length; i++)
{
    var phase = Phase(pixel, ages[i], minimumAge, harvest);
    hectares[phase][i] += pixel.Hectares;
    if (i == 1)
    {
        volume[phase] += pixel.VolumePerHectare * pixel.Hectares;
    }
}

Fasen med flest hektar i det centrala fallet blir den föreslagna åtgärden, och volymen i gallringsfasen går vidare till gallringens värde i avsnitt 6.5.


5. Trädslagsblandning

Fil: Features/Forest/Timber/SpeciesMixReader.cs.

Trädslagskartorna ger varje pixels andelar per trädslag. Polygonens blandning är ett viktat medelvärde av pixlarnas andelar, där vikten är hur mycket virke pixeln rymmer: dess hektar gånger den lasermätta volymen i dess mittpunkt. Varje pixels andelar qp,kq_{p,k} skalas först så att de summerar till 1.

andelk=∑pwp qp,k∑pwpwp=hp⋅vp\text{andel}_k = \frac{\sum_p w_p\,q_{p,k}}{\sum_p w_p} \qquad w_p = h_p \cdot v_p

Att väga med volymen spelar roll: en pixel med tät gammal gran ska räknas mer än en pixel med gles ung björk när resultatet används för att prissätta virke. Om ingen pixel har volym faller vikten tillbaka på enbart hektar.

var volumeWeighted = valid.Any(pixel => pixel.Hectares * pixel.VolumePerHectare > 0);
double[]? sums = null;
var weights = 0.0;
foreach (var pixel in valid)
{
    var weight = volumeWeighted ? pixel.Hectares * pixel.VolumePerHectare : pixel.Hectares;
    var shares = fractions(pixel.Shares);
    sums ??= new double[shares.Length];
    for (var i = 0; i < sums.Length; i++)
    {
        sums[i] += weight * shares[i];
    }
    weights += weight;
}
return (sums!.Select(sum => sum / weights).ToArray(), volumeWeighted);

Trädslagskartan och volymrastret har olika pixelstorlek (12,5 m och 10 m), så volymen läses inte som ett rutnät utan provtas i varje trädslagspixels mittpunkt (tile.Sample(xs, ys, …)).


6. Virkesvärde

Fil: Features/Forest/Timber/TimberValueCalculator.cs. Värdet är ett engångsnetto: vad en slutavverkning i dag skulle ge, minus vad den kostar.

flowchart LR
    V["Stående volym V<br/>m³sk"] -->|"× (1 − r)<br/>hänsynsytor står kvar"| F["Avverkat<br/>m³sk"]
    F -->|"× k<br/>bark och toppar bort"| S["Sålt<br/>m³fub"]
    S -->|"× p<br/>nettopris per m³fub"| I["Intäkt minus avverkning<br/>kr"]
    I -->|"− A·(1 − r)·G<br/>föryngring"| N["Virkesnetto T<br/>kr"]

6.1 Formeln

T=V⋅(1−r)⋅k⋅p  −  A⋅(1−r)⋅GT = V \cdot (1 - r) \cdot k \cdot p \;-\; A \cdot (1 - r) \cdot G
Symbol Betydelse Enhet
VV Stående volym m³sk
rr Andel av ytan som lämnas som hänsynsytor 0–1
kk Omräkning från stående volym till såld volym (bark och toppar borttagna) m³fub per m³sk
pp Nettopris per såld kubikmeter, efter avverkningskostnad kr/m³fub
AA Skogsmark i polygonen ha
GG Kostnad för att föryngra en avverkad hektar kr/ha

Nettopriset blandar tre sortiment. Med bb lövandelen, ss timmerandelen av barrvolymen, de tre priserna PP och avverkningskostnaden CC:

p=(1−b) [s Ptimmer+(1−s) Pmassa]+b Plo¨v−Cp = (1 - b)\,\bigl[s\,P_{\text{timmer}} + (1 - s)\,P_{\text{massa}}\bigr] + b\,P_{\text{löv}} - C

Lövvolymen prissätts enbart som massaved, eftersom prisstatistiken saknar ett pris på lövtimmer.

private static double PerM3fub(PriceMix prices, double sawlogShare, decimal cost) =>
    (1 - prices.BroadleafShare) * (sawlogShare * (double)prices.Sawlog + (1 - sawlogShare) * (double)prices.ConiferPulpwood)
    + prices.BroadleafShare * (double)prices.BroadleafPulpwood
    - (double)cost;
private static FellingCase Felling(/* … */)
{
    var felledVolume = volumeM3sk * (1 - retention);
    var felledHectares = forestHectares * (1 - retention);
    var sold = felledVolume * k;
    var regeneration = felledHectares * regenerationPerHectare;
    return new FellingCase(felledVolume, felledHectares, sold, regeneration, sold * PerM3fub(prices, sawlogShare, harvestingCost) - regeneration);
}

Priserna är decimal i databasen och i kontraktet (de är publicerade tal, och decimal håller dem exakta), och görs om till double först inne i aritmetiken.

6.2 Timmerandelen: en ramp över diametern

Hur mycket av ett bestånd som blir timmer beror på hur grova träden är. EcoVal använder en enkel ramp över medeldiametern dd: inget under d0=12d_0 = 12 cm, stigande i en rät linje till smax⁡=0,7s_{\max} = 0{,}7 vid d1=32d_1 = 32 cm.

s(d)=smax⁡⋅clamp⁡ ⁣(d−d0d1−d0, 0, 1)sla˚g,ho¨g=clamp⁡(s(d)∓u, 0, 1)s(d) = s_{\max} \cdot \operatorname{clamp}\!\left(\frac{d - d_0}{d_1 - d_0},\ 0,\ 1\right) \qquad s_{\text{låg,hög}} = \operatorname{clamp}\bigl(s(d) \mp u,\ 0,\ 1\bigr)

med u=0,1u = 0{,}1. clamp⁡(x,0,1)\operatorname{clamp}(x, 0, 1) håller xx mellan 0 och 1.

var ramp = Math.Clamp((diameter - options.NoSawlogsBelowCm) / (options.FullShareFromCm - options.NoSawlogsBelowCm), 0, 1);
var central = ramp * options.MaxShare;
return new ParameterRange(
    Math.Clamp(central - options.Uncertainty, 0, 1),
    central,
    Math.Clamp(central + options.Uncertainty, 0, 1));
Timmerandel från beståndets medeldiameter

Options-klassen kallar det här en platshållare, som ska ersättas med en sortimentstabell. Det är ett modellantagande, inte något som anpassats till data.

6.3 Timmerpriset efter trädslag

När trädslagsblandningen är känd och statistiken publicerar tall- och grantimmerpriser var för sig, är timmerpriset deras medelvärde viktat med varje trädslags andel av barrvolymen:

Ptimmer=qtall Ptall+qgran Pgranqtall+qgranP_{\text{timmer}} = \frac{q_{\text{tall}}\,P_{\text{tall}} + q_{\text{gran}}\,P_{\text{gran}}}{q_{\text{tall}} + q_{\text{gran}}}
var conifer = species.PineShare + species.SpruceShare;
var bySpecies = conifer > 0 && market.PineSawlogPrice is not null && market.SpruceSawlogPrice is not null;
var sawlog = bySpecies
    ? (decimal)Math.Round(
        (species.PineShare * (double)market.PineSawlogPrice!.Value
            + species.SpruceShare * (double)market.SpruceSawlogPrice!.Value) / conifer)
    : market.SawlogPrice;

Varje steg har en reserv (??, eller priset för alla trädslag), eftersom statistiken lämnar celler tomma för vissa regioner och kvartal.

6.4 Para ihop fallen: vilket lågt hör till vilket

Fyra indata är osäkra: kk, timmerandelen, andelen hänsynsytor och föryngringskostnaden. De trycker inte alla åt samma håll. Ett lågt nettovärde kommer av ett lågt kk och en låg timmerandel men en hög andel hänsynsytor och en hög föryngringskostnad. Parningen är utskriven, med en kommentar, så att ingen behöver räkna ut den igen:

// The low net pairs the low k and sawlog share with the most left standing and the dearest regeneration
// (cleaning too); the high net the opposite, with scarification only.
var low = Felling(volumeM3sk, forestHectares, k.Low, s.Low, retention.High, regeneration.High, prices, market.HarvestingCost);
var central = Felling(volumeM3sk, forestHectares, k.Central, s.Central, retention.Central, regeneration.Central, prices, market.HarvestingCost);
var high = Felling(volumeM3sk, forestHectares, k.High, s.High, retention.Low, regeneration.Low, prices, market.HarvestingCost);

Intervallet för föryngringskostnaden byggs av vilka åtgärder som antas: enbart markberedning (låg kostnad), plus plantering (central), plus röjning (hög kostnad).

Resultaten avrundas till hundratal kronor. Uppdelningen som visas för användaren byggs från det avrundade nettot, så dess rader summerar exakt:

// Rounded to hundreds like the net, so the lines add up to it.
net.Central + harvestingSek + regenerationSek,

6.5 Gallring och hyggesfria uttag

Ett deluttag tar en andel θ\theta av ett bestånds volym, med sitt eget kk och sin egen kostnad CmC_m, och föryngrar ingenting:

Tdel=Vbesta˚nd⋅θ⋅km⋅p(sm,Cm)T_{\text{del}} = V_{\text{bestånd}} \cdot \theta \cdot k_m \cdot p(s_m, C_m)

En gallring tar de klenare träden, så dess timmerandel läses från samma ramp vid 0,8 av beståndets diameter (ThinningDiameterRatio), och den gäller bara volymen i gallringsfasen (avsnitt 4).

double Net(double share, double conversion, double sawlogs) =>
    standVolume * share * conversion * PerM3fub(prices, sawlogs, cost.SekPerM3fub);

6.6 Vad staten skulle betala för att skydda den

ProtectionPaymentCalculator lägger två referensbelopp bredvid virkesvärdet. De är inga värden på skogen och läggs inte till något.

Ett naturvårdsavtal betalar en fast andel per år av beståndets rotnetto TrotT_{\text{rot}} (nettot före föryngring), för avtalets år. Ett negativt netto ger ingen betalning:

avtal=max⁡(0, Trot)⋅(andel per a˚r×a˚r)\text{avtal} = \max(0,\ T_{\text{rot}}) \cdot (\text{andel per år} \times \text{år})

Biotopskydd tas som regionens genomsnittliga ersättning per hektar, sammanslagen över de publicerade åren som total ersättning delat med totala hektar (inte som ett medelvärde av årens medelvärden, vilket skulle låta ett år med få hektar räknas lika mycket som ett år med många):

per hektar=∑yersa¨ttningy∑yhektary\text{per hektar} = \frac{\sum_y \text{ersättning}_y}{\sum_y \text{hektar}_y}
var pooled = region.Sum(year => year.CompensationThousandSek) * 1000 / region.Sum(year => year.LandHectares);
var perHectare = new ValueRange(
    Thousands(region.Min(year => year.SekPerHectare)), Thousands(pooled), Thousands(region.Max(year => year.SekPerHectare)));

7. Tillväxtmodellen

Fil: Features/Forest/Growth/GrowthCalculator.cs. Det här är den mest modelltunga delen av skogssidan. Den svarar på: hur mycket växer den här skogen per år, och hur skulle den växa de närmaste hundra åren om den står kvar, eller om den avverkas och växer upp igen?

Polygonen behandlas som ett genomsnittligt bestånd. Modellen har fem steg:

flowchart LR
    A["Ståndortsindex<br/>(raster)"] --> B["Produktion B och omloppstid R<br/>(publicerad tabell)"]
    B --> C["× produktionsnivå<br/>(efter breddgrad, anpassad)"]
    C --> D["Tillväxtkurva V(t)<br/>kalibrerad mot B och R"]
    D --> E["Simulering år för år:<br/>slutenhet, golv för gammal skog, avgång"]

7.1 Produktion och omloppstid från ståndortsindex

Ståndortsindexet (H100: hur höga de härskande träden är vid 100 år) säger hur bra marken är. SiteProductivityTable.Lookup gör om det till en produktion BB (m³sk per hektar och år, i medeltal över en omloppstid) och en omloppstid RR (år), med linjär interpolation mellan tabellens jämna ståndortsindex:

var upper = Array.FindIndex(rows, row => row.SiteIndex >= siteIndex);
var (below, above) = (rows[upper - 1], rows[upper]);
var t = (siteIndex - below.SiteIndex) / (above.SiteIndex - below.SiteIndex);
return new SiteProduction(
    Lerp(below.Production[column], above.Production[column], t),
    Lerp(below.Rotation[column], above.Rotation[column], t));

Tabellen är en static readonly-array i källkoden, inte en inställning: det är en publicerad tabell, avskriven en gång, med anteckningarna om avskriften i klassens kommentar.

7.2 Produktionsnivån efter breddgrad

Riksskogstaxeringen mäter mer tillväxt i norr än produktionstabellen förutsäger. Tabellens BB multipliceras därför med en nivå λ\lambda som beror på polygonens nordkoordinat yy: räta linjer mellan fyra regioners mittpunkter, plant utanför dem, och ±10 % för lågt och högt.

B′=λ(y)⋅BB' = \lambda(y) \cdot B
// ProductionLevelOptions.At, in Features/Forest/ValuationOptions.cs
var share = (km - points[i - 1].NorthingKm) / (points[i].NorthingKm - points[i - 1].NorthingKm);
level = points[i - 1].Level + share * (points[i].Level - points[i - 1].Level);
// …
return new ParameterRange(level * (1 - Uncertainty), level, level * (1 + Uncertainty));
Produktionsnivå efter breddgrad

De fyra värdena är anpassade till taxeringens data; avsnitt 7.7 förklarar hur.

7.3 Tillväxtkurvan: Chapman–Richards

Ett bestånds volym efter ålder följer en S-formad kurva: långsamt i början, snabbast i medelåldern, sedan avplanande. EcoVal använder Chapman–Richards-funktionen, en standardkurva för tillväxt inom skogsbruket:

V(t)=Vmax⁡ (1−e−κt)pV(t) = V_{\max}\,\bigl(1 - e^{-\kappa t}\bigr)^{p}

Vmax⁡V_{\max} är volymen där kurvan planar ut, κ\kappa anger hur fort den når dit och p=3p = 3 anger formen. (Koden kallar takten Rate och formen Shape; κ\kappa används här för att hålla den isär från omräkningstalet kk i avsnitt 6.)

Kalibrera kurvan mot B och R. Kurvan har två obekanta, Vmax⁡V_{\max} och κ\kappa, och produktionstabellen ger två fakta som låser dem:

  1. Medeltillväxten V(t)/tV(t)/t når sin topp vid omloppstiden RR. Det är vad en omloppstid är: åldern då avverkning ger mest virke per år.
  2. Vid den toppen är medeltillväxten lika med BB, så V(R)=B⋅RV(R) = B \cdot R.

Medeltillväxten V(t)/tV(t)/t når sin topp där derivatan är noll, vilket är där t V′(t)=V(t)t\,V'(t) = V(t). Deriverar man kurvan och skriver x=κtx = \kappa t blir detta

p x e−x=1−e−xp\,x\,e^{-x} = 1 - e^{-x}

som saknar sluten lösning, så den löses numeriskt (för p=3p = 3 är x∗≈1,90x^{*} \approx 1{,}90). De två parametrarna följer sedan:

κ=x∗RVmax⁡=B⋅R(1−e−x∗)p\kappa = \frac{x^{*}}{R} \qquad V_{\max} = \frac{B \cdot R}{\bigl(1 - e^{-x^{*}}\bigr)^{p}}
public static YieldCurve Calibrate(double production, double rotationYears, double shape)
{
    var x = PeakOfMeanGrowth(shape);
    return new YieldCurve(production * rotationYears / Math.Pow(1 - Math.Exp(-x), shape), x / rotationYears, shape);
}

Lösa ut x* med intervallhalvering. Intervallhalvering (bisektion) hittar var en funktion korsar noll genom att halvera ett intervall som man vet innehåller korsningen. Balance(x) är vänsterledet minus högerledet i ekvationen ovan: positivt för små xx, negativt för stora xx.

double Balance(double x) => shape * x * Math.Exp(-x) - (1 - Math.Exp(-x));
var (low, high) = (1e-9, 50.0);
for (var i = 0; i < 200; i++)
{
    var middle = (low + high) / 2;
    if (Balance(middle) > 0)
    {
        low = middle;      // still on the positive side: the crossing is further right
    }
    else
    {
        high = middle;     // on the negative side: the crossing is to the left
    }
}
return (low + high) / 2;

Varje steg halverar intervallet, så 200 steg är långt mer än en double kan upplösa; loopen går helt enkelt till maskinprecision. Det är samma tanke som gyllene snittet-sökningen i del 1, avsnitt 6.3: en robust endimensionell metod utan derivator.

Tillväxtkurvan för en ståndort

Årets tillväxt är kurvans skillnad över ett år, inte dess derivata, eftersom simuleringen stegar i hela år:

ΔV(t)=V(t+1)−V(t)\Delta V(t) = V(t + 1) - V(t)
public double Volume(double age) => age <= 0 ? 0 : MaxVolume * Math.Pow(1 - Math.Exp(-Rate * age), Shape);
public double Growth(double age) => Volume(age + 1) - Volume(Math.Max(age, 0));

7.4 Hur den stående skogen växer

Ett verkligt bestånd ligger inte på kurvan. Det kan vara glesare än kurvan säger, eller långt äldre än omloppstiden, och en del av det som växer dör. Tre korrigeringar görs i tur och ordning, varje år.

1. Slutenhet. Om beståndets uppmätta volym VV ligger under kurvans volym vid dess ålder har det färre träd att växa på. Tillväxten faller i proportion under en tröskel σ\sigma (0,5), och stannar vid kurvans tillväxt över den:

g1=min⁡ ⁣(1, V/Vkurva(a)σ)⋅ΔV(a)g_1 = \min\!\left(1,\ \frac{V / V_{\text{kurva}}(a)}{\sigma}\right) \cdot \Delta V(a)

2. Golvet för gammal skog. Kurvan ensam skulle låta ett mycket gammalt bestånd sluta växa, vilket taxeringen inte visar. Efter omloppstiden är tillväxten minst en andel av B′B' som faller i en rät linje från 1 vid RR till φ\varphi (0,5) vid 2R2R och stannar där:

g2=max⁡(g1, f(a))f(a)={0a<RB′[1−(1−φ) min⁡ ⁣(1, aR−1)]a≥Rg_2 = \max\bigl(g_1,\ f(a)\bigr) \qquad f(a) = \begin{cases} 0 & a < R \\ B'\left[1 - (1 - \varphi)\,\min\!\left(1,\ \dfrac{a}{R} - 1\right)\right] & a \ge R \end{cases}

3. Naturlig avgång. En del av bruttotillväxten dör. Andelen ss är en liten bakgrund s0s_0 plus en trängselterm som växer brant när den stående volymen närmar sig ett tak (en andel cc av kurvans maximum):

s=s0+(1−s0)(Vc⋅Vmax⁡)qg=g2⋅max⁡(0, 1−s)s = s_0 + (1 - s_0)\left(\frac{V}{c \cdot V_{\max}}\right)^{q} \qquad g = g_2 \cdot \max(0,\ 1 - s)

med q=4q = 4. Vid taket är s=1s = 1: beståndet slutar öka i volym.

Naturlig avgång efter hur fullt beståndet är

I koden är de tre korrigeringarna tre rader i simuleringsloopen:

var age = standAge + year;
var curveVolume = curve.Volume(age);
var stocking = curveVolume < 1 ? 1 : keepVolume / curveVolume;
var keepGrowth = Math.Min(1, stocking / p.FullGrowthStocking) * curve.Growth(age);   // 1. stocking
keepGrowth = Math.Max(keepGrowth, FloorGrowth(age, p));                              // 2. old-forest floor
keepGrowth = mortality.Net(keepGrowth, keepVolume);                                  // 3. mortality
private static double FloorGrowth(double age, PathParameters p) =>
    age < p.Rotation ? 0 : p.Production * (1 - (1 - p.GrowthFloor) * Math.Min(1, age / p.Rotation - 1));

private sealed record Mortality(double Cap, double Background, double Exponent)
{
    public double Net(double grossGrowth, double volume)
    {
        var lost = Background + (1 - Background) * Math.Pow(Math.Max(0, volume / Cap), Exponent);
        return grossGrowth * Math.Max(0, 1 - lost);
    }
}

Första årets värde på keepGrowth är sidans "tillväxt i år".

7.5 Från kubikmeter till ton CO₂

Tillväxt i m³sk blir CO₂ med polygonens egen kvot: dess CO₂-förråd (avsnitt 2.2) delat med dess volym.

γ=CO2-fo¨rra˚dV(ton CO₂ per m³sk)upptag=g⋅A⋅γ\gamma = \frac{\text{CO}_2\text{-förråd}}{V} \quad \text{(ton CO₂ per m³sk)} \qquad \text{upptag} = g \cdot A \cdot \gamma

Att använda polygonens egen kvot håller förrådet och upptaget förenliga med varandra. Bara när polygonen saknar stående volym tar ett nationellt standardvärde (1,375 ton/m³sk) över:

var co2PerM3sk = ownRatio
    ? new ParameterRange(co2.Low / forest.VolumeM3sk, co2.Central / forest.VolumeM3sk, co2.High / forest.VolumeM3sk)
    : growth.Co2PerM3sk;

7.6 Tre sammanhängande parameteruppsättningar

Tillväxtmodellen har ett tiotal osäkra parametrar. Att ta var och ens låga och höga värde oberoende av varandra skulle inte ge ett meningsfullt intervall, så modellen körs tre gånger med tre uppsättningar som var och en hänger ihop: en långsamt växande skog, en central och en snabbt växande. Den låga uppsättningen tar det långsammare trädslaget, den äldre åldersmodellen och de låga parametrarna, utom för de två parametrar som bromsar tillväxten när de stiger, där den tar den höga änden.

// Low is the slower-growing case throughout: the less productive species, the older age, the low parameters,
// and the high stocking threshold and background mortality (the two that slow growth as they rise).
PathParameters Set(SiteProduction production, double age, Func<ParameterRange, double> pick, Func<ParameterRange, double> opposite) => new(
    production.M3skPerHectareYear * pick(productionLevel),
    production.RotationYears,
    age,
    opposite(growth.FullGrowthStocking),
    pick(growth.SelfThinningCap),
    opposite(growth.BackgroundMortality),
    // …
var low = Simulate(Set(slower, Math.Max(site.SpruceAgeYears, site.PineAgeYears), range => range.Low, range => range.High), /* … */);
var central = Simulate(Set(mean, (site.SpruceAgeYears + site.PineAgeYears) / 2, range => range.Central, range => range.Central), /* … */);
var high = Simulate(Set(faster, Math.Min(site.SpruceAgeYears, site.PineAgeYears), range => range.High, range => range.Low), /* … */);

Att skicka pick och opposite som funktioner är ett snyggt sätt att säga "samma konstruktion, tre gånger, med olika ände av varje intervall" utan tre nästan likadana block. Varje utdata läses sedan tvärs över de tre körningarna:

ValueRange Across(Func<PathResult, double> value, int digits = 1) =>
    ValueRange.Spanning(value(low), value(central), value(high), digits);

7.7 Var tillväxtparametrarna kommer ifrån: anpassade till Riksskogstaxeringen

Fyra av modellens parametrar är anpassade till data: produktionsnivån λ\lambda, bakgrundsavgången s0s_0, trängselexponenten qq och golvet för gammal skog φ\varphi.

Sorts anpassning: kalibrering med rutnätssökning och ett minsta kvadrat-fel, samma sort som utflykts- och fiskeanpassningarna i del 1. Den skiljer sig på ett praktiskt sätt: anpassningen ligger inte i EcoVal.Calibration utan i ett Python-skript, scripts/review/growth/fit-mortality.py, skrivet under granskningen i november 2026. Skriptet återimplementerar tillväxtmodellen (samma kurva, slutenhet, golv och avgång som i avsnitt 7.4) och har taxeringens publicerade tabeller som konstanter. Dess resultat kopierades till GrowthOptions för hand.

Datat är SLU:s Skogsdata 2026: tillväxt, stående volym och naturlig avgång per region och åldersklass.

Avgången (s0s_0 och qq). För varje kandidatpar räknar skriptet ut vilken andel av tillväxten modellen säger dör i var och en av de fyra regionernas brukade skog, och i skyddad skog i hela landet, och jämför med de uppmätta andelarna:

E(s0,q)=∑r=14[m^r(s0,q)−mr]2+4 [m^skydd(s0,q)−mskydd]2E(s_0, q) = \sum_{r=1}^{4} \bigl[\hat{m}_r(s_0, q) - m_r\bigr]^2 + 4\,\bigl[\hat{m}_{\text{skydd}}(s_0, q) - m_{\text{skydd}}\bigr]^2

Talet för skyddad skog får vikten 4 så att det räknas lika mycket som de fyra regionala talen tillsammans.

def fit_mortality():
    """s0 and p by least squares on the four managed shares and the national protected share (weighted as four)."""
    managed, national = targets()
    best = None
    for s0 in [i / 200 for i in range(0, 41)]:
        for p in [1 + i / 20 for i in range(0, 81)]:
            err = sum((managed_share(r, s0, p) - managed[r]) ** 2 for r in REGIONS)
            err += 4 * (protected_national(s0, p) - national) ** 2
            if best is None or err < best[0]:
                best = (err, s0, p)
    return best[1], best[2]

Golvet (φ\varphi) och nivån (λ\lambda). Båda anpassas på tillväxten per åldersklass, genom att minimera den kvadrerade logkvoten mellan modellens nettotillväxt n^\hat{n} och den uppmätta nn (logkvoten ser "20 % för högt" och "20 % för lågt" som lika fel, som i del 1):

E=∑klasser[ln⁡n^n]2E = \sum_{\text{klasser}} \left[\ln\frac{\hat{n}}{n}\right]^2

Golvet använder åldersklasserna efter omloppstiden, alla regioner tillsammans. Nivån anpassas per region, på klasserna från 21 år. De fyra regionala nivåerna görs sedan om till en funktion av breddgraden: värdena i regionernas mittpunkter justeras, genom upprepad korrigering, tills varje regions skogsviktade medelvärde är lika med dess anpassade nivå.

Spara resultatet. De sparade värdena är avrundade, och intervallet runt dem är en bedömning som kommentaren på inställningen förklarar (till exempel täcker den höga bakgrundsavgången barkborreår):

public ParameterRange BackgroundMortality { get; set; } = new(0.06, 0.10, 0.18);
public double CrowdingExponent { get; set; } = 4;
public ParameterRange OldForestGrowthFloor { get; set; } = new(0.4, 0.5, 0.6);

De övriga tillväxtparametrarna (slutenhetströskeln, självgallringstaket, kurvans form, gallringsåldrarna) är satta från litteraturen eller genom resonemang, och flera är märkta "to verify" i sina kommentarer.

Eftersom anpassningen ligger i ett skript med datat inskrivet betyder en ny anpassning efter en ny taxering att man uppdaterar skriptets tabeller, kör det och ändrar inställningarna. Om C#-modellen ändras måste skriptets kopia av den ändras också, annars stämmer anpassningen inte längre med vad appen räknar.


8. De tre kolvägarna

Fortfarande i GrowthCalculator.cs. Simuleringen följer tre framtider för samma mark, år för år i 100 år:

  • Behåll: skogen står kvar och växer som i avsnitt 7.4.
  • Skogsbruk: allt avverkas nu; ett nytt bestånd planteras, gallras, avverkas igen vid RR, och så vidare.
  • Fri utveckling: allt avverkas nu; det nya beståndet lämnas sedan i fred.
CO₂ som hålls över 100 år i de tre vägarna

8.1 Simuleringsloopen

Loopen är en vanlig tidsstegande simulering: för varje år, anteckna tillståndet och stega sedan fram det. Två Regrowth-objekt bär de avverkade vägarnas tillstånd.

var forestry = new Regrowth(curve, p, growth, hectares, fellAgain: true, mortality);
var leftToGrow = new Regrowth(curve, p, growth, hectares, fellAgain: false, mortality);
forestry.Fell(0, volumePerHectare, p.SawlogShareNow);
leftToGrow.Fell(0, volumePerHectare, p.SawlogShareNow);
// …
for (var year = 0; year <= horizon; year++)
{
    // … the standing forest's growth, section 7.4 …
    keepStock[year] = keepVolume * co2PerHectareM3;
    keepUptake[year] = keepGrowth * co2PerHectareM3;
    keepVolume += keepGrowth;
    forestry.Step(year, co2PerHectareM3);
    leftToGrow.Step(year, co2PerHectareM3);
}

I formler är den kvarstående skogens förråd år tt

K(t)=Vt⋅A⋅γVt+1=Vt+gtK(t) = V_t \cdot A \cdot \gamma \qquad V_{t+1} = V_t + g_t

8.2 Beståndet som växer upp igen

Regrowth är en liten tillståndsmaskin. Dess ålder börjar negativ, på minus föryngringstiden (10 år), så ingenting växer förrän åldern når 0:

private double _age = -growth.RegenerationDelayYears;
// …
public void Step(int year, double co2PerHectareM3)
{
    var grown = _age >= 0 ? curve.Growth(_age) : 0;
    if (!fellAgain)
    {
        grown = Math.Max(grown, FloorGrowth(_age, p));
    }
    grown = mortality.Net(grown, _volume);

    _trees[year] = _volume * co2PerHectareM3;
    _products[year] = _sawnwood + _paper;
    _uptake[year] = grown * co2PerHectareM3;

    _volume += grown;
    _age++;
    _sawnwood *= _sawnwoodRetained;
    _paper *= _paperRetained;
    // … forestry only: thin at the thinning ages, fell at the rotation and start over …
}

I skogsbruksvägen tar en gallring bort en andel θ\theta (0,30) av volymen, och vid omloppstiden avverkas allt och åldern nollställs:

if (_age >= p.Rotation)
{
    Fell(year + 1, _volume, p.RotationSawlogShare);
    _volume = 0;
    _age = -growth.RegenerationDelayYears;
}
else if (p.Thinnings.FirstOrDefault(thinning => thinning.AgeYears == _age) is { } thinning)
{
    var taken = _volume * p.ThinningRemoval;
    Deliver(taken, thinning.SawlogShare, p.ThinningProductCo2PerM3sk);
    _volume -= taken;
}

8.3 Träprodukter: vad de avverkade stammarna fortfarande håller

Avverkat virke släpps inte ut på en gång. Stammarna som säljs blir sågat virke och papper, som håller sitt kol en tid. Grenar, toppar, stubbar och rötter räknas som utsläppta vid avverkningen.

CO₂ i det levererade virket per avverkad m³sk är den sålda volymen (kk) gånger virkets torrdensitet ρ\rho gånger kolandelen, omräknat till CO₂:

π=k⋅ρ⋅0,5⋅4412(ton CO₂ per avverkad m³sk)\pi = k \cdot \rho \cdot 0{,}5 \cdot \frac{44}{12} \quad \text{(ton CO₂ per avverkad m³sk)}

En leverans på D=Vavverkat⋅A⋅πD = V_{\text{avverkat}} \cdot A \cdot \pi ton delas efter timmerandelen ss och sågverkets utbyte yy (den andel av en timmerstock som blir sågat virke):

sa˚gat virke+=D⋅s⋅ypapper+=D⋅(1−s)\text{sågat virke} \mathrel{+}= D \cdot s \cdot y \qquad \text{papper} \mathrel{+}= D \cdot (1 - s)

Det som återstår, D⋅s⋅(1−y)D \cdot s \cdot (1 - y) (flis och sågspån, som mest eldas för energi), räknas som utsläppt.

private void Deliver(double volume, double sawlogShare, double co2PerM3sk)
{
    var delivered = volume * hectares * co2PerM3sk;
    _sawnwood += delivered * sawlogShare * p.SawnwoodYield;
    _paper += delivered * (1 - sawlogShare);
}

Nedbrytning med halveringstid. Varje pool bryts ner exponentiellt. En halveringstid hh betyder att hälften finns kvar efter hh år, så andelen som finns kvar från ett år till nästa är

δ=(12)1/hpoolt+1=δ⋅poolt\delta = \left(\tfrac{1}{2}\right)^{1/h} \qquad \text{pool}_{t+1} = \delta \cdot \text{pool}_t

Med IPCC:s standardvärden behåller sågat virke (h=35h = 35 år) 98,0 % per år och papper (h=2h = 2 år) 70,7 %.

private readonly double _sawnwoodRetained = Math.Pow(0.5, 1 / growth.SawnwoodHalfLifeYears);
private readonly double _paperRetained = Math.Pow(0.5, 1 / growth.PaperHalfLifeYears);

Faktorn räknas en gång i fältets initiering och multipliceras in varje år, vilket är billigare och tydligare än att räkna om en exponentialfunktion av förfluten tid för varje leverans.

Skogsbruksvägen isärplockad i träd och träprodukter

En avverkad vägs total år tt är dess träd plus dess produkter:

F(t)=tra¨d(t)+sa˚gat virke(t)+papper(t)F(t) = \text{träd}(t) + \text{sågat virke}(t) + \text{papper}(t)

8.4 Vad som läses av från vägarna

Två sammanfattande årtal kommer från den centrala körningen genom att söka efter det första året ett villkor gäller:

UptakeCrossoverYear: FirstYear(horizon, year => path(central).Uptake[year] > central.KeepUptake[year]),
ParityYear: FirstYear(horizon, year => year > 0 && path(central).Total(year) >= central.KeepStock[year]),

Korsningsåret är när den nya skogen börjar ta upp mer CO₂ per år än den gamla skulle ha gjort. Paritetsåret är när den avverkade vägen har hunnit ikapp den kvarstående skogen totalt, om den alls gör det inom tidshorisonten (annars null).


9. Kolvärde

Fil: Features/Forest/Growth/CarbonValueCalculator.cs. Den här sätter ett pris på gapet mellan att behålla och att avverka.

9.1 Prisbanorna

Tre publicerade priser per ton CO₂ används, vart och ett en serie punkter per kalenderår. Ett pris för vilket år som helst läses med den vanliga regeln (räta linjer mellan punkterna, plant utanför dem):

P(y)=Pi+(Pi+1−Pi) y−yiyi+1−yiP(y) = P_i + (P_{i+1} - P_i)\,\frac{y - y_i}{y_{i+1} - y_i}
public static double At(IReadOnlyList<CarbonPricePoint> points, int year)
{
    // …
    for (var i = 1; i < sorted.Count; i++)
    {
        var (before, after) = (sorted[i - 1], sorted[i]);
        if (year <= after.Year)
        {
            return before.PerTonne + (after.PerTonne - before.PerTonne) * (year - before.Year) / (after.Year - before.Year);
        }
    }
    return sorted[^1].PerTonne;
}

Banorna är publicerade i olika valutor och prisår, så var och en får en omräkningsfaktor till kronor i det gemensamma prisåret (2025): växelkursen om den är i euro, gånger kvoten av konsumentprisindex från dess eget prisår.

faktor=va¨xelkurs⋅KPI2025KPIprisa˚r\text{faktor} = \text{växelkurs} \cdot \frac{\text{KPI}_{2025}}{\text{KPI}_{\text{prisår}}}
return Money.Indexed(exchange, options.ConsumerPriceIndex, path.PriceYear, options.PriceYear, "Valuation:CarbonPrice");

Money.Indexed kastar ett undantag med konfigurationsavsnittets namn om indexet saknar ett år, så ett saknat tal fallerar högljutt i stället för att tyst prissätta med 1.

De tre prisbanorna för koldioxid

De tre prisfallen byggs sedan år för år: lågt är den lägsta av de tre banorna det året, centralt är ASEK:s, högt är den högsta. Ett fall är inte en bana: i diagrammet ovan följer det höga fallet Umweltbundesamt de första åren och ASEK därefter.

return new PriceCases(
    Enumerable.Range(0, horizonYears + 1).Select(year => series.Min(prices => prices[year])).ToArray(),
    Prices(options.Asek, startYear, horizonYears, options),
    Enumerable.Range(0, horizonYears + 1).Select(year => series.Max(prices => prices[year])).ToArray());

9.2 Nuvärdet av gapet

Låt D(t)D(t) vara gapet år tt: den CO₂ som hålls om skogen står kvar minus den CO₂ som hålls på den avverkade vägen (träd och träprodukter).

D(t)=K(t)−F(t),D(−1)=0D(t) = K(t) - F(t), \qquad D(-1) = 0

Värdet prissätter varje års förändring av gapet med det årets pris, och diskonterar den till i dag med räntan rr (3,5 %):

PV=∑t=0HP(t) [D(t)−D(t−1)](1+r)tPV = \sum_{t=0}^{H} \frac{P(t)\,\bigl[D(t) - D(t-1)\bigr]}{(1 + r)^{t}}

Varför förändringen och inte gapet självt? För att CO₂ spelar roll när den släpps ut eller tas upp. Den första termen, D(0)−0D(0) - 0, är utsläppet vid avverkningen, prissatt i dag och inte diskonterat. Senare termer är varje års skillnad i upptag och nedbrytning mellan de två vägarna: negativa när den avverkade vägen hinner ikapp. Ett gap som fortfarande är öppet vid tidshorisonten står helt enkelt kvar i summan, vilket betyder att det räknas som behållet för gott.

public static double PresentValue(double[] keepStock, double[] pathStock, double[] prices, double discountRate)
{
    var total = 0.0;
    var previous = 0.0;
    for (var year = 0; year < keepStock.Length; year++)
    {
        var difference = keepStock[year] - pathStock[year];
        total += prices[year] * (difference - previous) / Math.Pow(1 + discountRate, year);
        previous = difference;
    }
    return total;
}

Diskonteringsfaktorn 1/(1+r)t1 / (1 + r)^t är det som gör att avlägsna år räknas lite: vid 3,5 % räknas ett ton om 50 år som 18 % av ett ton i dag, och om 100 år som 3 %. Det är därför värdet domineras av utsläppet vid avverkningen och de första årtiondena.

9.3 Intervallet: varje kombination av tillväxt och pris

Det finns tre tillväxtkörningar (långsam, central, snabb) och tre prisfall. Vilken kombination som ger det lägsta värdet är inte självklart i förväg: en snabbt växande skog sluter gapet fortare, men har också mer att förlora. Därför räknas alla nio, och intervallet är deras minsta och största:

PVla˚g=min⁡g, c PV(g,c)PVcentral=PV(central tillva¨xt, ASEK)PVho¨g=max⁡g, c PV(g,c)PV_{\text{låg}} = \min_{g,\,c}\ PV(g, c) \qquad PV_{\text{central}} = PV(\text{central tillväxt},\ \text{ASEK}) \qquad PV_{\text{hög}} = \max_{g,\,c}\ PV(g, c)
ValueRange Value(Func<Stocks, double[]> path)
{
    var all = runs
        .SelectMany(run => new[] { low, central, high }.Select(prices => PresentValue(run.Keep, path(run), prices, rate)))
        .ToList();
    return new ValueRange(
        RoundToHundreds(all.Min()),
        RoundToHundreds(PresentValue(runs[1].Keep, path(runs[1]), central, rate)),
        RoundToHundreds(all.Max()));
}

Det här är ett annat sätt att bygga ett intervall än i avsnitt 7.6. Där är de tre fallen konstruerade för att vara långsamt, centralt och snabbt. Här hittas ytterligheterna genom att pröva allt, eftersom ingen enskild parning är "den låga".

9.4 Dela upp värdet per period

Sidan visar hur mycket av värdet som kommer från själva avverkningen, från år 1–20, 21–50 och 51 och framåt. Eftersom nuvärdet är en summa över år är varje periods del helt enkelt termerna för dess år, och delarna summerar till helheten per konstruktion:

PV=∑perioder j ∑t∈jP(t) [D(t)−D(t−1)](1+r)tPV = \sum_{\text{perioder } j}\ \sum_{t \in j} \frac{P(t)\,\bigl[D(t) - D(t-1)\bigr]}{(1 + r)^{t}}
private static readonly int[] PartStarts = [0, 1, 21, 51];
// …
for (var year = from; year <= to; year++)
{
    var previous = year == 0 ? 0 : keepStock[year - 1] - pathStock[year - 1];
    sek += prices[year] * (keepStock[year] - pathStock[year] - previous) / Math.Pow(1 + discountRate, year);
}

10. Vardagliga jämförelser

Fil: Features/Forest/Growth/CarbonComparisonCalculator.cs. Ton CO₂ säger inte mycket för de flesta, så API:et skickar några omräkningsfaktorer och frontenden delar tonnen med dem. De är rena kvoter av publicerade nationella tal, vart och ett med sitt år och sin källa i ComparisonOptions:

en bils utsla¨pp per a˚r=utsla¨pp fra˚n alla personbilarbilar i trafikkostnad fo¨r infa˚ngning per ton=beviljat statssto¨dton som ska lagras\text{en bils utsläpp per år} = \frac{\text{utsläpp från alla personbilar}}{\text{bilar i trafik}} \qquad \text{kostnad för infångning per ton} = \frac{\text{beviljat statsstöd}}{\text{ton som ska lagras}}
CarTonnesPerYear: Math.Round(options.CarEmissionsTonnes / options.CarsInTraffic, 3),
// …
var auctions = options.BeccsAuctions
    .Select(auction => (Auction: auction, PerTonne: auction.AidSek / auction.StoredTonnes))
    .OrderBy(entry => entry.PerTonne)
    .ToList();
var (cheapest, dearest) = (auctions[0], auctions[^1]);

Jämförelserna uttrycker samma ton på ett annat sätt. De är aldrig ett eget värde och läggs aldrig till kolvärdet.


Sammanfattning: vilken sorts beräkning varje avsnitt är

Avsnitt Sort Anpassad till data?
Skogens förråd Zonsummor och enhetsomräkningar Nej
Beståndsålder, gammal skog, slutavverkningsålder Räkna pixlar mot gränser; interpolation i tabell Nej (lagtabeller och publicerade tabeller)
Beståndsfaser Beslutsträd per pixel Nej (trösklar från handledningar)
Trädslagsblandning Volymviktat medelvärde Nej
Virkesvärde Algebraisk formel med publicerade priser Nej (timmerrampen är ett antagande)
Tillväxtmodell Kalibrerad tillväxtkurva plus en årlig simulering Ja: nivå, avgång och golv, med rutnätssökning i ett Python-skript
Kolvägar Tidsstegande simulering med exponentiell nedbrytning Använder tillväxtmodellens parametrar
Kolvärde Diskonterad summa över år; intervall över nio kombinationer Nej (publicerade priser och diskonteringsränta)
Jämförelser Kvoter av publicerade tal Nej