//---------------------------------------------------------------------
private InitialBiomass(SiteCohorts cohorts,
List<PoolD> litterPool,
PoolD woodyDebrisPool,
List<PoolD> deadFRootsPool,
Pool fineRootsPool,
Pool coarseRootsPool,
Charcoal charcoalPool)
{
this.cohorts = cohorts;
this.litterPool = litterPool;
this.woodyDebrisPool = woodyDebrisPool;
this.deadFRootsPool = deadFRootsPool;
this.fineRootsPool = fineRootsPool;
this.coarseRootsPool = coarseRootsPool;
this.charcoalPool = charcoalPool;
}
//---------------------------------------------------------------------
/// <summary>
/// Adds biomass for a species to the annual litter pool at a site.
/// </summary>
public static void AddLitter(double leafBiomass,
ISpecies species,
ActiveSite site,
List<PoolD> litterAdd)
{
IEcoregion ecoregion = Model.Core.Ecoregion[site];
double siteAET = (double)(EcoregionData.AET[ecoregion]);
PoolD litterAddition = new PoolD();
litterAddition.Mass = leafBiomass;
litterAddition.InitialMass = leafBiomass;
litterAddition.ContentC = SpeciesData.LitterFractionC[species] *
litterAddition.Mass;
litterAddition.ContentN = SpeciesData.LitterFractionN[species] *
litterAddition.Mass;
litterAddition.ContentP = SpeciesData.LitterFractionP[species] *
litterAddition.Mass;
//Calculate decomposition rate (Fan et al. 1998)
double leafKReg = ((0.10015 * siteAET - 3.44618) - (0.01341 + 0.00147 * siteAET) *
SpeciesData.LeafLignin[species]) / 100;
double leafKStd = ((0.10015 * 551 - 3.44618) - (0.01341 + 0.00147 * 551) *
SpeciesData.LeafLignin[species]) / 100;
double leafKAdj = 8.35 * Math.Pow((SpeciesData.LeafLignin[species] /
SpeciesData.LitterFractionN[species]), -0.784) * (leafKReg / leafKStd);
litterAddition.DecayValue = leafKAdj;
//Calculate mass loss limit (Berg et al. 1996). Average is 7% to
// soil organic matter (Verburg and Johnson 2001, other models).
// Use ceiling of 95% to ensure litter is removed.
double limitValue = 0.01 * (91.241 - (1.744 *
(SpeciesData.LitterFractionN[species] * 1000)));
litterAddition.LimitValue = Math.Min(limitValue, 0.95);
litterAdd.Add(litterAddition);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes the module.
/// </summary>
public static void Initialize()
{
cohorts = Model.Core.Landscape.NewSiteVar<SiteCohorts>();
availableN = Model.Core.Landscape.NewSiteVar<double>();
unavailable = Model.Core.Landscape.NewSiteVar<Pool>();
fineRoots = Model.Core.Landscape.NewSiteVar<Pool>();
coarseRoots = Model.Core.Landscape.NewSiteVar<Pool>();
woodyDebris = Model.Core.Landscape.NewSiteVar<PoolD>();
litter = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
deadFineRoots = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
litterAdd = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
deadFineRootsAdd = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
removeLitter = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
removeDeadFineRoots = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
soilOrganicMatter = Model.Core.Landscape.NewSiteVar<SoilOrganicMatter>();
mineralSoil = Model.Core.Landscape.NewSiteVar<MineralSoil>();
charcoal = Model.Core.Landscape.NewSiteVar<Charcoal>();
rock = Model.Core.Landscape.NewSiteVar<Rock>();
//fireSeverity = Model.Core.Landscape.NewSiteVar<int>();
TotalWoodBiomass = Model.Core.Landscape.NewSiteVar<double>();
CurrentYearMortality = Model.Core.Landscape.NewSiteVar<double>();
PrevYearMortality = Model.Core.Landscape.NewSiteVar<double>();
//fireSeverity = Model.Core.GetSiteVar<byte>("Fire.Severity");
// Enable interactions with (almost) any fire extension:
/*if (Model.Core.GetSiteVar<int>("Fire.Severity") == null)
{
Console.Write("Fire Severity not cu");
}
else
{
Console.Write("Real value");
fireSeverity = Model.Core.GetSiteVar<int>("Fire.SeverityX");
}*/
foreach (ActiveSite site in Model.Core.Landscape)
{
// site cohorts are initialized by the PlugIn.InitializeSite method
availableN[site] = new double();
unavailable[site] = new Pool();
fineRoots[site] = new Pool();
coarseRoots[site] = new Pool();
woodyDebris[site] = new PoolD();
litter[site] = new List<PoolD>();
deadFineRoots[site] = new List<PoolD>();
litterAdd[site] = new List<PoolD>();
deadFineRootsAdd[site] = new List<PoolD>();
removeLitter[site] = new List<PoolD>();
removeDeadFineRoots[site] = new List<PoolD>();
soilOrganicMatter[site] = new SoilOrganicMatter();
mineralSoil[site] = new MineralSoil();
charcoal[site] = new Charcoal();
rock[site] = new Rock();
}
}
//---------------------------------------------------------------------
protected override void InitializeSite(ActiveSite site,
ICommunity initialCommunity)
{
InitialBiomass initialBiomass = InitialBiomass.Compute(site, initialCommunity);
//Clone initial cohorts
SiteVars.Cohorts[site] = initialBiomass.InitialCohorts.Clone();
//Clone initial coarse roots to all sites
SiteVars.CoarseRoots[site].Mass = initialBiomass.CoarseRootsPool.Mass;
SiteVars.CoarseRoots[site].ContentC = initialBiomass.CoarseRootsPool.ContentC;
SiteVars.CoarseRoots[site].ContentN = initialBiomass.CoarseRootsPool.ContentN;
SiteVars.CoarseRoots[site].ContentP = initialBiomass.CoarseRootsPool.ContentP;
//Clone initial fine roots to all sites
SiteVars.FineRoots[site].Mass = initialBiomass.FineRootsPool.Mass;
SiteVars.FineRoots[site].ContentC = initialBiomass.FineRootsPool.ContentC;
SiteVars.FineRoots[site].ContentN = initialBiomass.FineRootsPool.ContentN;
SiteVars.FineRoots[site].ContentP = initialBiomass.FineRootsPool.ContentP;
//Clone initial woody debris to all sites
SiteVars.WoodyDebris[site].Mass = initialBiomass.WoodyDebrisPool.Mass;
SiteVars.WoodyDebris[site].ContentC = initialBiomass.WoodyDebrisPool.ContentC;
SiteVars.WoodyDebris[site].ContentN = initialBiomass.WoodyDebrisPool.ContentN;
SiteVars.WoodyDebris[site].ContentP = initialBiomass.WoodyDebrisPool.ContentP;
SiteVars.WoodyDebris[site].DecayValue = initialBiomass.WoodyDebrisPool.DecayValue;
//Clone initial litter to all sites
if (SiteVars.Litter[site].Count == 0)
{
foreach (PoolD litter in initialBiomass.LitterPool)
{
PoolD litterAdd = new PoolD();
litterAdd.Mass = litter.Mass;
litterAdd.ContentC = litter.ContentC;
litterAdd.ContentN = litter.ContentN;
litterAdd.ContentP = litter.ContentP;
litterAdd.DecayValue = litter.DecayValue;
litterAdd.InitialMass = litter.InitialMass;
litterAdd.LimitValue = litter.LimitValue;
SiteVars.Litter[site].Add(litterAdd);
}
}
//Clone initial dead fine roots to all sites
if (SiteVars.DeadFineRoots[site].Count == 0)
{
foreach (PoolD litter in initialBiomass.DeadFRootsPool)
{
PoolD litterAdd = new PoolD();
litterAdd.Mass = litter.Mass;
litterAdd.ContentC = litter.ContentC;
litterAdd.ContentN = litter.ContentN;
litterAdd.ContentP = litter.ContentP;
litterAdd.DecayValue = litter.DecayValue;
litterAdd.InitialMass = litter.InitialMass;
litterAdd.LimitValue = litter.LimitValue;
SiteVars.DeadFineRoots[site].Add(litterAdd);
}
}
//Clone initial charcoal to all sites
SiteVars.Charcoal[site].ContentC = initialBiomass.CharcoalPool.ContentC;
SiteVars.Charcoal[site].ContentN = initialBiomass.CharcoalPool.ContentN;
SiteVars.Charcoal[site].ContentP = initialBiomass.CharcoalPool.ContentP;
}
//---------------------------------------------------------------------
/// <summary>
/// Adds yearly biomass addition to dead fine roots at a site.
/// Sums all species-cohort additions and adds as a single cohort.
/// </summary>
public static void AddYearDeadFineRoots(ActiveSite site)
{
double addMass = 0.0;
double addC = 0.0;
double addN = 0.0;
double addP = 0.0;
double addDecay = 0.0;
double addLimit = 0.0;
foreach (PoolD litter in SiteVars.DeadFineRootsAdd[site])
{
addMass += litter.Mass;
addC += litter.ContentC;
addN += litter.ContentN;
addP += litter.ContentP;
addDecay += (litter.DecayValue * litter.Mass); //weighted avg
addLimit += (litter.LimitValue * litter.Mass); //weighted avg
}
PoolD LitterAddition = new PoolD();
LitterAddition.Mass = addMass;
LitterAddition.ContentC = addC;
LitterAddition.ContentN = addN;
LitterAddition.ContentP = addP;
LitterAddition.DecayValue = addDecay / addMass;
LitterAddition.LimitValue = addLimit / addMass;
LitterAddition.InitialMass = addMass;
SiteVars.DeadFineRoots[site].Add(LitterAddition);
SiteVars.DeadFineRootsAdd[site].Clear();
SiteVars.DeadFineRootsAdd[site].TrimExcess();
}
//---------------------------------------------------------------------
/// <summary>
/// Kills fine roots and add the biomass to the Dead Fine Roots pool.
/// </summary>
public static void KillFineRoots(double litterMass,
ISpecies species,
List<PoolD> deadFRootsAdd)
{
PoolD deadFRootsAddition = new PoolD();
deadFRootsAddition.Mass = litterMass; //litterMass is result of CalculateFineRoots
deadFRootsAddition.ContentC = SpeciesData.FRootFractionC[species] *
deadFRootsAddition.Mass;
deadFRootsAddition.ContentN = SpeciesData.FRootFractionN[species] *
deadFRootsAddition.Mass;
deadFRootsAddition.ContentP = SpeciesData.FRootFractionP[species] *
deadFRootsAddition.Mass;
//Calculate decomposition rate (Silver and Miya 2001, Fig. 3,
// with substituted (-) for (+) to match figure).
deadFRootsAddition.DecayValue = Math.Exp(3.92 - (1.12 *
(Math.Log(SpeciesData.FRootFractionC[species] /
SpeciesData.FRootFractionN[species]))));
//Calculate mass loss limit (Berg et al. 1996). Lower limit
// than for litter (Verburg and Johnson 2001 and others).
// Use ceiling of 0.95 to ensure litter is removed.
double limitValue = 0.01 * (91.241 - (1.744 *
(SpeciesData.FRootFractionN[species] * 1000)));
deadFRootsAddition.LimitValue = Math.Min(limitValue, 0.95);
deadFRootsAdd.Add(deadFRootsAddition);
}
//---------------------------------------------------------------------
/// <summary>
/// Phase 3 of decomposition: Matter is transferred to soil organic
/// matter. If C:P > 450, additional P is released prior to
/// humification (Moore et al. 2006).
/// </summary>
public static void DecompPhase3(PoolD litter,
ActiveSite site)
{
double CPratio = litter.ContentC / litter.ContentP;
if (CPratio > 450)
{
double mineralizedP = litter.ContentC / 450;
litter.ContentP -= mineralizedP;
SiteVars.MineralSoil[site].ContentP += mineralizedP;
}
SiteVars.SoilOrganicMatter[site].Mass += litter.Mass;
SiteVars.SoilOrganicMatter[site].ContentC += litter.ContentC;
SiteVars.SoilOrganicMatter[site].ContentN += litter.ContentN;
SiteVars.SoilOrganicMatter[site].ContentP += litter.ContentP;
SiteVars.RemoveDeadFineRoots[site].Add(litter);
}
//---------------------------------------------------------------------
/// <summary>
/// Phase 2 of decomposition: Nitrogen and phosphorus mineralized
/// proportionally to decomposition rate (Berg and Staaf 1981,
/// Moore et al. 2006).
/// </summary>
public static void DecompPhase2(PoolD litter,
ActiveSite site)
{
litter.Mass = litter.Mass * Math.Exp(-1 * litter.DecayValue);
litter.ContentC = litter.ContentC * Math.Exp(-1 * litter.DecayValue);
//Net N mineralization proportional to mass loss.
double mineralizedN = litter.ContentN - (litter.ContentN *
Math.Exp(-1 * litter.DecayValue));
litter.ContentN -= mineralizedN;
SiteVars.MineralSoil[site].ContentN += mineralizedN;
//Net P mineralization proportional to mass loss.
double mineralizedP = litter.ContentP - (litter.ContentP *
Math.Exp(-1 * litter.DecayValue));
litter.ContentP -= mineralizedP;
SiteVars.MineralSoil[site].ContentP += mineralizedP;
}
//---------------------------------------------------------------------
/// <summary>
/// Phase 1 of decomposition: Rapid decomposition with net nitrogen
/// immobilization and either no change or mineralization in
/// phosphorus.
/// </summary>
public static void DecompPhase1(PoolD litter,
ActiveSite site)
{
litter.Mass = litter.Mass * Math.Exp(-1 * litter.DecayValue);
litter.ContentC = litter.ContentC * Math.Exp(-1 * litter.DecayValue);
//Net immobilization of nitrogen (Jannsen 1996 with application
// described in Noij et al. 1996).
//Microbe CUE and C:N ratios set to default values.
double microbeCUE = 0.5;
double microbeCN = 20;
double mineralizedN = litter.ContentC * (litter.DecayValue /
(litter.ContentC / litter.ContentN)) - microbeCUE *
litter.ContentC * (litter.DecayValue / microbeCN);
litter.ContentN -= mineralizedN;
SiteVars.MineralSoil[site].ContentN += mineralizedN;
//Critical C:P < 900 used as cut-off of net P mineralization
// (Prescott et al. 2000 upperbound). If C:P > 900, conserve
// P; else, mineralization occurs at decomposition rate.
double CPratio = litter.ContentC / litter.ContentP;
if (CPratio < 900)
{
double mineralizedP = litter.ContentP - (litter.ContentP *
Math.Exp(-1 * litter.DecayValue));
litter.ContentP -= mineralizedP;
SiteVars.MineralSoil[site].ContentP += mineralizedP;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Decomposition of fine roots. Follows Berg's 3-part model (generally
/// higher limit values, but same dynamics as ForestFloor.DecomposeLitter)
/// (McClaugherty et al. 1984).
/// </summary>
public static void DecomposeDeadFineRoots(PoolD litter,
ActiveSite site)
{
double CNratio = litter.ContentC / litter.ContentN;
double massLoss = (litter.InitialMass - litter.Mass) / litter.InitialMass;
if (litter.Mass < 1.0)
{
SiteVars.RemoveDeadFineRoots[site].Add(litter);
return;
}
//Limit to mass loss determines cut-off betweeen phases 2 and 3.
//Phase 3.
else if (massLoss > litter.LimitValue)
{
Roots.DecompPhase3(litter, site);
return;
}
//Critical C:N < 40 used as cut-off between phases 1 and 2.
// (Upper bound in Prescott et al. 2000 and empirical finding
// in Janssen 1996).
//Phase 1.
else if (CNratio > 40)
{
Roots.DecompPhase1(litter, site);
return;
}
//Phase 2.
else
{
Roots.DecompPhase2(litter, site);
return;
}
}
/// <summary>
/// Adds biomass for a species to the woody debris pool at a site.
/// </summary>
public static void AddWoodyDebris(double woodBiomass,
ISpecies species,
PoolD woodyDebris)
{
woodyDebris.AddMass(woodBiomass, SpeciesData.WoodFractionC[species],
SpeciesData.WoodFractionN[species], SpeciesData.WoodFractionP[species],
SpeciesData.WoodyDebrisDecay[species]);
}
