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
- 2. Skogens förråd
- 3. Beståndsåldern och reglerna som beror på den
- 4. Beståndsfaser
- 5. Trädslagsblandning
- 6. Virkesvärde
- 7. Tillväxtmodellen
- 8. De tre kolvägarna
- 9. Kolvärde
- 10. Vardagliga jämförelser
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 tarZonalResult-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:
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 , torrsubstansen görs om till kol med kolandelen , och kol till CO₂ med kvoten mellan deras molmassor (en CO₂-molekyl väger 44, kolatomen i den 12):
ä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:
där är det viktade antalet giltiga pixlar och 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 (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 centimeter:
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):
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:
är 1 när villkoret gäller och 0 annars, pixelns hektar innanför polygonen och 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:
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 skalas först så att de summerar till 1.
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
| Symbol | Betydelse | Enhet |
|---|---|---|
| Stående volym | m³sk | |
| Andel av ytan som lämnas som hänsynsytor | 0–1 | |
| Omräkning från stående volym till såld volym (bark och toppar borttagna) | m³fub per m³sk | |
| Nettopris per såld kubikmeter, efter avverkningskostnad | kr/m³fub | |
| Skogsmark i polygonen | ha | |
| Kostnad för att föryngra en avverkad hektar | kr/ha |
Nettopriset blandar tre sortiment. Med lövandelen, timmerandelen av barrvolymen, de tre priserna och avverkningskostnaden :
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 : inget under cm, stigande i en rät linje till vid cm.
med . håller 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));
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:
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: , 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 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 av ett bestånds volym, med sitt eget och sin egen kostnad , och föryngrar ingenting:
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 (nettot före föryngring), för avtalets år. Ett negativt netto ger ingen betalning:
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):
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 (m³sk per hektar och år, i medeltal över en
omloppstid) och en omloppstid (å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 multipliceras därför med en nivå som beror på polygonens nordkoordinat : räta linjer mellan fyra regioners mittpunkter, plant utanför dem, och ±10 % för lågt och högt.
// 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));
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:
är volymen där kurvan planar ut, anger hur fort den når dit och anger formen. (Koden
kallar takten Rate och formen Shape; används här för att hålla den isär från omräkningstalet i
avsnitt 6.)
Kalibrera kurvan mot B och R. Kurvan har två obekanta, och , och produktionstabellen ger två fakta som låser dem:
- Medeltillväxten når sin topp vid omloppstiden . Det är vad en omloppstid är: åldern då avverkning ger mest virke per år.
- Vid den toppen är medeltillväxten lika med , så .
Medeltillväxten når sin topp där derivatan är noll, vilket är där . Deriverar man kurvan och skriver blir detta
som saknar sluten lösning, så den löses numeriskt (för är ). De två parametrarna följer sedan:
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å , negativt för stora .
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.
Årets tillväxt är kurvans skillnad över ett år, inte dess derivata, eftersom simuleringen stegar i hela år:
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 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 (0,5), och stannar vid kurvans tillväxt över den:
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 som faller i en rät linje från 1 vid till (0,5) vid och stannar där:
3. Naturlig avgång. En del av bruttotillväxten dör. Andelen är en liten bakgrund plus en trängselterm som växer brant när den stående volymen närmar sig ett tak (en andel av kurvans maximum):
med . Vid taket är : beståndet slutar öka i volym.
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.
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 , bakgrundsavgången , trängselexponenten och golvet för gammal skog .
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 ( och ). 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:
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 () och nivån (). Båda anpassas på tillväxten per åldersklass, genom att minimera den kvadrerade logkvoten mellan modellens nettotillväxt och den uppmätta (logkvoten ser "20 % för högt" och "20 % för lågt" som lika fel, som i del 1):
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 , och så vidare.
- Fri utveckling: allt avverkas nu; det nya beståndet lämnas sedan i fred.
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
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 (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 () gånger virkets torrdensitet gånger kolandelen, omräknat till CO₂:
En leverans på ton delas efter timmerandelen och sågverkets utbyte (den andel av en timmerstock som blir sågat virke):
Det som återstår, (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 betyder att hälften finns kvar efter år, så andelen som finns kvar från ett år till nästa är
Med IPCC:s standardvärden behåller sågat virke ( år) 98,0 % per år och papper ( å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.
En avverkad vägs total år är dess träd plus dess produkter:
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):
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.
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 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 vara gapet år : 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).
Värdet prissätter varje års förändring av gapet med det årets pris, och diskonterar den till i dag med räntan (3,5 %):
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, , ä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 ä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:
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:
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:
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 |