/// <summary> /// Adds some biomass for a species to the WOODY pools at a site. /// </summary> public static void AddWoody(double woodyBiomass, ISpecies species, ActiveSite site) { SiteVars.WoodyDebris[site].AddMass(woodyBiomass, SpeciesData.WoodyDebrisDecay[species]); }
//--------------------------------------------------------------------- public void Do(ActiveSite site) { foreach (ISpecies species in Model.Species) { if (seedingAlgorithm.Seeds(species, site)) cohorts[site].AddNewCohort(species); } }
public static List<Location> DurationBasedSize(ActiveSite site, double ROS) { List<Location> newFireList = new List<Location>(0); newFireList.Add(site.Location); //Add ignition site first. return newFireList; }
//--------------------------------------------------------------------- public void AddNewCohort(ISpecies species, ActiveSite site) { cohorts[site].AddNewCohort(species, CohortBiomass.InitialBiomass(cohorts[site], site, species)); }
public static bool Algorithm(ISpecies species, ActiveSite site) { return Reproduction.SufficientLight(species, site) && Reproduction.Establish(species, site) && Reproduction.MaturePresent(species, site); }
//--------------------------------------------------------------------- /// <summary> /// Records a species that should be checked for resprouting during /// reproduction. /// </summary> /// <param name="cohort"> /// The cohort whose death triggered the current call to this method. /// </param> /// <param name="site"> /// The site where the cohort died. /// </param> /// <remarks> /// If the cohort's age is within the species' age range for /// resprouting, then the species will be have additional resprouting /// criteria (light, probability) checked during reproduction. /// </remarks> public static void CheckForResprouting(AgeCohort.ICohort cohort, ActiveSite site) { ISpecies species = cohort.Species; if (species.MinSproutAge <= cohort.Age && cohort.Age <= species.MaxSproutAge) resprout[site].Set(species.Index, true); }
//--------------------------------------------------------------------- /// <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(); }
//--------------------------------------------------------------------- public void AddNewCohort(ISpecies species, ActiveSite site) { SiteVars.Cohorts[site].AddNewCohort(species, CohortBiomass.InitialBiomass(species, SiteVars.Cohorts[site], site)); }
//--------------------------------------------------------------------- /// <summary> /// Grows all cohorts at a site for a specified number of years. The /// dead pools at the site also decompose for the given time period. /// </summary> public static void GrowCohorts(SiteCohorts cohorts, ActiveSite site, int years, bool isSuccessionTimestep) { if (SiteVars.Cohorts[site] == null) return; for (int y = 1; y <= years; ++y) { SpeciesData.ChangeDynamicParameters(Model.Core.CurrentTime + y - 1); SiteVars.ResetAnnualValues(site); CohortBiomass.SubYear = y - 1; CohortBiomass.CanopyLightExtinction = 0.0; // SiteVars.LAI[site] = 0.0; SiteVars.PercentShade[site] = 0.0; SiteVars.LightTrans[site] = 1.0; SiteVars.Cohorts[site].Grow(site, (y == years && isSuccessionTimestep)); SiteVars.WoodyDebris[site].Decompose(); SiteVars.Litter[site].Decompose(); } }
public static void Algorithm(//ISpecies species, ActiveSite site) { return;//Reproduction.SufficientLight(species, site) && //Reproduction.Establish(species, site) && //Reproduction.MaturePresent(species, site); }
//--------------------------------------------------------------------- /// <summary> /// Default seed dispersal method. /// </summary> public static float Default(ISpecies species, ActiveSite sourceSite, ActiveSite destinationSite) { // TODO - Based on Brendan Ward's thesis return 0.0f; }
//--------------------------------------------------------------------- /// <summary> /// Determines if there is sufficient light at a site for a species to /// germinate/resprout. /// </summary> public static bool SufficientLight(ISpecies species, ActiveSite site) { byte siteShade = SiteVars.Shade[site]; return (species.ShadeTolerance <= 4 && species.ShadeTolerance > siteShade) || (species.ShadeTolerance == 5 && siteShade > 1); // pg 14, Model description, this ----------------^ may be 2? }
//--------------------------------------------------------------------- /// <summary> /// Raises a Cohort.DeathEvent. /// </summary> public static void Died(object sender, ICohort cohort, ActiveSite site, PlugInType disturbanceType) { if (DeathEvent != null) DeathEvent(sender, new DeathEventArgs(cohort, site, disturbanceType)); }
/// <summary> /// Decomposes Sturctural Litter /// </summary> public static void Decompose(ActiveSite site) { SiteVars.SurfaceStructural[site].DecomposeStructural(site); SiteVars.SurfaceMetabolic[site].DecomposeMetabolic(site); SiteVars.SoilStructural[site].DecomposeStructural(site); SiteVars.SoilMetabolic[site].DecomposeMetabolic(site); }
//--------------------------------------------------------------------- public void Do(ActiveSite site) { for (int i = 0; i < Model.Species.Count; i++) { ISpecies species = Model.Species[i]; if (seedingAlgorithm(species, site)) Reproduction.AddNewCohort(species, site); } }
//--------------------------------------------------------------------- /// <summary> /// Grows all cohorts at a site for a number of years. /// </summary> public static void Grow(SiteCohorts cohorts, int years, ActiveSite site, bool isSuccessionTimestep) { for (int y = 1; y <= years; ++y) cohorts.Grow(site, (y == years && isSuccessionTimestep)); }
//--------------------------------------------------------------------- public int ComputeChange(ICohort cohort, ActiveSite site, int siteBiomass, int prevYearSiteMortality) { CountCalled++; return Change; }
//--------------------------------------------------------------------- /// <summary> /// Determines if a species resprouts when one of its cohorts dies. /// </summary> public static bool Resprout(AgeOnly.ICohort cohort, ActiveSite site) { ISpecies species = cohort.Species; return (species.MinSproutAge <= cohort.Age) && (cohort.Age <= species.MaxSproutAge) && SufficientLight(species, site) && Establish(species, site); }
//--------------------------------------------------------------------- public static double ComputeWoodBiomass(ActiveSite site) { double woodBiomass = 0; if (SiteVars.SiteCohorts[site] != null) foreach (ISpeciesCohorts speciesCohorts in SiteVars.SiteCohorts[site]) foreach (ICohort cohort in speciesCohorts) woodBiomass += cohort.WoodBiomass; return woodBiomass; }
public static void Algorithm(//ISpecies species, ActiveSite site) { foreach(ISpecies species in Model.Core.Species) if(Reproduction.SufficientLight(species, site) && Reproduction.Establish(species, site)) Reproduction.AddNewCohort(species, site); //return Reproduction.SufficientLight(species, site) && // Reproduction.Establish(species, site); }
//--------------------------------------------------------------------- public void AddNewCohort(ISpecies species, ActiveSite site) { float[] initialBiomass = CohortBiomass.InitialBiomass(SiteVars.Cohorts[site], site, species); float initialWoodMass = initialBiomass[0]; float initialLeafMass = initialBiomass[1]; SiteVars.Cohorts[site].AddNewCohort(species, initialWoodMass, initialLeafMass); }
//--------------------------------------------------------------------- public override byte ComputeShade(ActiveSite site) { byte shade = 0; foreach (SpeciesCohorts speciesCohorts in cohorts[site]) { ISpecies species = speciesCohorts.Species; if (species.ShadeTolerance > shade) shade = species.ShadeTolerance; } return shade; }
//--------------------------------------------------------------------- public double MyCompute(ICohort cohort, ActiveSite site, int siteBiomass) { Assert.AreEqual(myCohort, cohort); Assert.AreEqual(myActiveSite, site); Assert.AreEqual(mySiteBiomass, siteBiomass); myComputeCalled = true; return myComputeResult; }
//New method for calculating N limits, called from Century.cs Run method before calling Grow //Iterates through cohorts, assigning each a N gathering efficiency based on fine root biomass //and N tolerance. public static double CalculateNLimits(ActiveSite site) { // Iterate through the first time, assigning each cohort un un-normalized N multiplier double NMultTotal=0.0; foreach (ISpeciesCohorts speciesCohorts in SiteVars.SiteCohorts[site]) foreach (ICohort cohort in speciesCohorts) { int Ntolerance = SpeciesData.NTolerance[cohort.Species]; //NMultiplier is a measure of how much N a cohort can gather relative to other cohorts double NMultiplier = CalculateNMultiplier(cohort.Biomass,Ntolerance); NMultTotal += NMultiplier; Dictionary<int,double> newEntry = new Dictionary<int,double>(); newEntry.Add(cohort.Age,NMultiplier); if (CohortNlimits.ContainsKey(cohort.Species.Index)) { CohortNlimits[cohort.Species.Index].Add(cohort.Age,NMultiplier); } else { CohortNlimits.Add(cohort.Species.Index,newEntry); } } double availableN = SiteVars.MineralN[site]; // g/m2 //Console.WriteLine("NMultTotal="+NMultTotal); //Iterate through a second time now that we have total N multiplier //Divide through by total and multiply by total available N so each cohort has a max N value //and the sum of cohort max N values is the site available N double totalNUptake = 0.0; foreach (ISpeciesCohorts speciesCohorts in SiteVars.SiteCohorts[site]) foreach (ICohort cohort in speciesCohorts) { double NMultiplier=CohortNlimits[cohort.Species.Index][cohort.Age]; double Nfrac=NMultiplier/NMultTotal; CohortNlimits[cohort.Species.Index][cohort.Age] = Nfrac *availableN; totalNUptake += Nfrac * availableN; //Console.WriteLine("species={0} age={1} NMult={2:0.00} Nfrac={3:0.0000}",cohort.Species.Name,cohort.Age,NMultiplier,Nfrac); } //Console.WriteLine("Total max N uptake = {0:0.0000}, availableN = {1:0.0000}, availableN-uptake={2:0.0000}", totalNUptake,availableN,availableN-totalNUptake); if ((availableN - totalNUptake) < -0.001 * availableN) { UI.WriteLine(" ERROR: Total max N uptake = {0:0.000}, availableN = {1:0.000}.", totalNUptake, availableN); throw new ApplicationException("Error: Max N uptake > availableN. See AvailableN.cs"); } return 0.0; }
/// <summary> /// Grows all cohorts at a site for a specified number of years. The /// dead pools at the site also decompose for the given time period. /// </summary> public static void GrowCohorts(SiteCohorts cohorts, ActiveSite site, int years, bool isSuccessionTimestep) { for (int y = 1; y <= years; ++y) { cohorts.Grow(site, (y == years && isSuccessionTimestep)); Dead.Pools.Woody[site].Decompose(); Dead.Pools.NonWoody[site].Decompose(); } }
//--------------------------------------------------------------------- private static float ReduceInput(float poolInput, Percentage reductionPercentage, ActiveSite site) { float reduction = (poolInput * (float) reductionPercentage); SiteVars.SourceSink[site].Carbon += (double) reduction * 0.47; //SiteVars.FireEfflux[site] += (double) reduction * 0.47; return (poolInput - reduction); }
//--------------------------------------------------------------------- public void Do(ActiveSite site) { for (int i = 0; i < Model.Core.Species.Count; i++) { ISpecies species = Model.Core.Species[i]; if (seedingAlgorithm(species, site)) { Reproduction.AddNewCohort(species, site); if (isDebugEnabled) log.DebugFormat("site {0}: seeded {1}", site.Location, species.Name); } } }
//--------------------------------------------------------------------- /// <summary> /// Grows the current cohort for one year. /// </summary> /// <param name="site"> /// The site where the cohort is located. /// </param> /// <param name="siteBiomass"> /// The total biomass at the site. This parameter is changed by the /// same amount as the current cohort's biomass. /// </param> /// <param name="prevYearMortality"> /// The total mortality at the site during the previous year. /// </param> /// <returns> /// The total mortality (excluding annual leaf litter) for the current /// cohort. /// </returns> public int GrowCurrentCohort(ActiveSite site, ref int siteBiomass, int prevYearMortality) { if (currentCohortAge == 0) throw new InvalidOperationException("Iterator has no current cohort"); int cohortMortality; nextIndex = cohorts.GrowCohort(index, site, ref siteBiomass, prevYearMortality, out cohortMortality); return cohortMortality; }
//--------------------------------------------------------------------- /// <summary> /// Determines if a species has at least one mature cohort at a site. /// </summary> public static bool MaturePresent(ISpecies species, ActiveSite site) { ISiteCohorts<AgeOnly.ICohort> cohorts = Model.GetSuccession<AgeOnly.ICohort>().Cohorts[site]; ISpeciesCohorts<AgeOnly.ICohort> speciesCohorts = cohorts[species]; if (speciesCohorts == null) return false; foreach (ushort age in speciesCohorts.Ages) if (age >= species.Maturity) return true; return false; }
/// <summary> /// Adds some biomass for a species to the WOOD litter pools at a site. /// </summary> public static void AddWoodLitter(double woodBiomass, ISpecies species, ActiveSite site) { if(woodBiomass > 0) WoodLayer.PartitionResidue(woodBiomass, FunctionalType.Table[SpeciesData.FuncType[species]].WoodDecayRate, SpeciesData.WoodCN[species], SpeciesData.WoodLignin[species], LayerName.Wood, LayerType.Surface, site); }