//---------------------------------------------------------------------
/// <summary>
/// Selects all of a species' cohorts for harvesting.
/// </summary>
public static void All(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
//loop through all cohorts and mark as harvested
for (int i = 0; i < isHarvested.Count; i++)
isHarvested[i] = true;
}
//---------------------------------------------------------------------
#region ISpeciesCohortsDisturbance members
/// <summary>
/// Mark which cohorts for a species are to be cut (harvested).
/// </summary>
public void MarkCohortsForDeath(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isKilled)
{
CohortSelector.Harvest(cohorts, isKilled);
int numKilled = 0;
for (int i = 0; i < isKilled.Count; i++)
{
if (isKilled[i])
{
cohortCounts.IncrementCount(cohorts.Species);
numKilled++;
}
}
if (isDebugEnabled)
{
if (numKilled > 0)
{
string ageList = "";
int i = 0;
foreach (ICohort cohort in cohorts)
{
if (isKilled[i])
ageList += string.Format(" {0}", cohort.Age);
i++;
}
log.DebugFormat(" Cut {0} :{1}", cohorts.Species.Name, ageList);
}
}
}
public void OneCohort_True()
{
ISpeciesCohorts cohorts = CreateCohorts(77);
SelectCohorts(cohorts, selector_2to99_250);
CheckIsHarvested(true);
}
public void FourCohorts_True()
{
ISpeciesCohorts cohorts = CreateCohorts(250, 99, 50, 2);
SelectCohorts(cohorts, selector_2to99_250);
CheckIsHarvested(true, true, true, true);
}
//---------------------------------------------------------------------
public void AllExceptYoungest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
// Youngest is the last cohort (at index Count - 1)
for (int i = 0; i < (isDamaged.Count - 1); i++)
isDamaged[i] = true;
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void Harvest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
SelectCohorts.Method selectionMethod;
if (selectionMethods.TryGetValue(cohorts.Species, out selectionMethod))
selectionMethod(cohorts, isHarvested);
}
//---------------------------------------------------------------------
public void OldestOfSelectedSpecies(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
if (cohorts.Species == SelectedSpecies)
// Oldest is first cohort
isDamaged[0] = true;
}
public void ManyCohorts()
{
ISpeciesCohorts cohorts = CreateCohorts(501, 500, 300, 299, 201, 200, 155, 99, 75, 56, 50, 20);
SelectCohorts(cohorts, selector_25_50_75_100to200_300to500);
CheckIsHarvested(false, true, true, false, false, true, true, false, true, false, true, false);
}
//---------------------------------------------------------------------
#region ISpeciesCohortsDisturbance members
/// <summary>
/// Mark which cohorts for a species are to be cut (harvested).
/// </summary>
public void MarkCohortsForDeath(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isKilled)
{
CohortSelector.Harvest(cohorts, isKilled);
int numKilled = 0;
for (int i = 0; i < isKilled.Count; i++)
{
if (isKilled[i])
{
cohortCounts.IncrementCount(cohorts.Species);
numKilled++;
}
}
if (isDebugEnabled)
{
if (numKilled > 0)
{
string ageList = "";
int i = 0;
foreach (ICohort cohort in cohorts)
{
if (isKilled[i])
{
ageList += string.Format(" {0}", cohort.Age);
}
i++;
}
log.DebugFormat(" Cut {0} :{1}", cohorts.Species.Name, ageList);
}
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects all of a species' cohorts for harvesting except the oldest.
/// </summary>
public static void AllExceptOldest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
// Oldest is first (so start at i = 1 instead of i = 0)
for (int i = 1; i < isHarvested.Count; i++)
isHarvested[i] = true;
}
public void OneCohort_False()
{
ISpeciesCohorts cohorts = CreateCohorts(1);
SelectCohorts(cohorts, selector_2to99_250);
CheckIsHarvested(false);
}
public void ThreeCohorts()
{
ISpeciesCohorts cohorts = CreateCohorts(110, 50, 30);
SelectCohorts(cohorts, selector_25_50_75_100to200_300to500);
CheckIsHarvested(true, true, false);
}
public void NoCohorts()
{
ISpeciesCohorts cohorts = CreateCohorts();
SelectCohorts(cohorts, selector_25_50_75_100to200_300to500);
CheckIsHarvested();
}
//---------------------------------------------------------------------
private void CheckCohorts(ISpeciesCohorts biomassCohorts,
List <ushort> cohortAges)
{
Assert.IsNotNull(biomassCohorts);
Assert.AreEqual(cohortAges.Count, biomassCohorts.Count);
int i = 0;
foreach (ICohort cohort in biomassCohorts)
{
ushort age = cohortAges[i];
Assert.AreEqual(age, cohort.Age);
// If the timestep is 1, then annual growth calculations
// are called one less time than usual.
int expectedBiomass;
if (isTimestep1)
{
expectedBiomass = initialBiomass + (age - 1) * annualBiomassChange;
}
else
{
expectedBiomass = initialBiomass + age * annualBiomassChange;
}
Assert.AreEqual(expectedBiomass, cohort.Biomass);
i++;
}
}
public void FourCohorts_False()
{
ISpeciesCohorts cohorts = CreateCohorts(251, 249, 100, 1);
SelectCohorts(cohorts, selector_2to99_250);
CheckIsHarvested(false, false, false, false);
}
/// <summary>
/// Checks that two sets of site cohorts are the same. Also checks the
/// site's total biomass.
/// </summary>
/// <param name="expected">
/// Keys are expected species. A species' value is an array of the
/// ages and biomasses of its expected cohorts from oldest to youngest.
/// Ages and biomasses are alternate:
///
/// <pre>
/// item 0 = expected age of oldest cohort
/// item 1 = " biomass " "
/// item 2 = " age of 2nd oldest cohort
/// item 3 = " biomass " " "
/// ...
/// </pre>
/// </param>
/// <param name="actual">
/// The actual site cohorts to verify.
/// </param>
public static void CheckCohorts(Dictionary <ISpecies, ushort[]> expected,
ISiteCohorts actual)
{
int expectedTotalBiomass = 0;
foreach (ISpecies species in expected.Keys)
{
ISpeciesCohorts speciesCohorts = actual[species];
Assert.IsNotNull(speciesCohorts);
// Assume cohorts are ordered from oldest to youngest
ushort[] expectedCohortData = expected[species];
Assert.AreEqual(expectedCohortData.Length, speciesCohorts.Count * 2);
int i = 0;
foreach (ICohort cohort in speciesCohorts)
{
Assert.AreEqual(expectedCohortData[i], cohort.Age);
Assert.AreEqual(expectedCohortData[i + 1], cohort.Biomass);
expectedTotalBiomass += expectedCohortData[i + 1];
i += 2;
}
}
// Check if any extra species beyond those that were expected
foreach (ISpeciesCohorts speciesCohorts in actual)
{
Assert.IsTrue(expected.ContainsKey(speciesCohorts.Species));
}
Assert.AreEqual(expectedTotalBiomass, actual.TotalBiomass);
}
//---------------------------------------------------------------------
public void AllOfSelectedSpecies(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
if (cohorts.Species == SelectedSpecies) {
for (int i = 0; i < isDamaged.Count; i++)
isDamaged[i] = true;
}
}
////---------------------------------------------------------------------
//public static string MakeSpeciesMapName(string species)
//{
// return SpeciesMapNames.ReplaceTemplateVars(speciesMapNameTemplate,
// species,
// ModelCore.CurrentTime);
//}
//--------------------------------------------------------------
public static double ComputeBiomass(ISpeciesCohorts cohorts)
{
double total = 0.0;
if (cohorts != null)
foreach (ICohort cohort in cohorts)
total += (double) (cohort.LeafBiomass + cohort.WoodBiomass);
return total;
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void SelectCohorts(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
for (int i = isHarvested.Count - N; i >= 0; i -= N)
{
isHarvested[i] = true;
}
}
//---------------------------------------------------------------------
public void ClearCut(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
for (int i = 0; i < isDamaged.Count; i++)
{
isDamaged[i] = true;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects all of a species' cohorts for harvesting except the
/// youngest.
/// </summary>
public static void AllExceptYoungest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
// Youngest is last.
int youngestIndex = isHarvested.Count - 1;
for (int i = 0; i < youngestIndex; i++)
isHarvested[i] = true;
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void Harvest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
for (int i = 0; i < isHarvested.Count; i++)
{
isHarvested[i] = true;
}
}
public static int ComputeBiomass(ISpeciesCohorts cohorts)
{
int total = 0;
if (cohorts != null)
foreach (ICohort cohort in cohorts)
total += cohort.Biomass;
return total;
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance by copying a set of species cohorts.
/// </summary>
public SpeciesCohorts(ISpeciesCohorts <ICohort> cohorts)
{
this.species = cohorts.Species;
this.ages = new List <ushort>();
foreach (ushort age in cohorts.Ages)
{
this.ages.Add(age);
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void Harvest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
SelectCohorts.Method selectionMethod;
if (selectionMethods.TryGetValue(cohorts.Species, out selectionMethod))
{
selectionMethod(cohorts, isHarvested);
}
}
//---------------------------------------------------------------------
public void OldestOfSelectedSpecies(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
if (cohorts.Species == SelectedSpecies)
{
// Oldest is first cohort
isDamaged[0] = true;
}
}
//---------------------------------------------------------------------
public void AllExceptYoungest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
// Youngest is the last cohort (at index Count - 1)
for (int i = 0; i < (isDamaged.Count - 1); i++)
{
isDamaged[i] = true;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects all of a species' cohorts for harvesting except the oldest.
/// </summary>
public static void AllExceptOldest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
// Oldest is first (so start at i = 1 instead of i = 0)
for (int i = 1; i < isHarvested.Count; i++)
{
isHarvested[i] = true;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects all of a species' cohorts for harvesting.
/// </summary>
public static void All(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
//loop through all cohorts and mark as harvested
for (int i = 0; i < isHarvested.Count; i++)
{
isHarvested[i] = true;
}
}
public static ushort GetStdDevAge(ISpeciesCohorts speciesCohorts)
{
if (speciesCohorts == null)
{
return(0);
}
ushort std_dev = (ushort)System.Math.Round(System.Math.Sqrt(GetVarAge(speciesCohorts)), 0);
return(std_dev);
}
/// <summary>
/// Gets the maximum age among a species' cohorts.
/// </summary>
/// <returns>
/// The age of the oldest cohort or 0 if there are no cohorts.
/// </returns>
public static ushort GetMaxAge(ISpeciesCohorts<ICohort> cohorts)
{
if (cohorts == null)
return 0;
ushort max = 0;
foreach (ushort age in cohorts.Ages)
if (age > max)
max = age;
return max;
}
//---------------------------------------------------------------------
private byte CalcForestType(ISiteCohorts <AgeCohort.ICohort> cohorts,
IForestType[] forestTypes)
{
double[] forTypValue = new double[forestTypes.Length];
int forTypeCnt = 0;
foreach (IForestType ftype in forestTypes)
{
ushort maxSpeciesAge = 0;
IDataset SpeciesDataset = Model.Species;
foreach (ISpecies species in SpeciesDataset)
{
double sppValue = 0.0;
ISpeciesCohorts <AgeCohort.ICohort> speciesCohorts =
cohorts[species];
maxSpeciesAge = MaxAge(speciesCohorts);
if (maxSpeciesAge > 0)
{
sppValue = (double)maxSpeciesAge /
(double)species.Longevity *
(double)reclassCoefs[species.Index];
}
if (ftype[species.Index] != 0)
{
if (ftype[species.Index] == -1)
{
forTypValue[forTypeCnt] -= sppValue;
}
if (ftype[species.Index] == 1)
{
forTypValue[forTypeCnt] += sppValue;
}
}
}
forTypeCnt++;
}
int finalForestType = 0;
double maxValue = 0.0;
forTypeCnt = 0;
foreach (IForestType ftype in forestTypes)
{
//System.Console.WriteLine("ForestTypeNum={0}, Value={1}.",forTypeCnt,forTypValue[forTypeCnt]);
if (forTypValue[forTypeCnt] > maxValue)
{
maxValue = forTypValue[forTypeCnt];
finalForestType = forTypeCnt + 1;
}
forTypeCnt++;
}
return((byte)finalForestType);
}
//---------------------------------------------------------------------
/// <summary>
/// Selects all of a species' cohorts for harvesting except the
/// youngest.
/// </summary>
public static void AllExceptYoungest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
// Youngest is last.
int youngestIndex = isHarvested.Count - 1;
for (int i = 0; i < youngestIndex; i++)
{
isHarvested[i] = true;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void SelectCohorts(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
int i = 0;
foreach (ICohort cohort in cohorts) {
AgeRange? notUsed;
if (agesAndRanges.Contains(cohort.Age, out notUsed))
isHarvested[i] = true;
i++;
}
}
//---------------------------------------------------------------------
public void AllOfSelectedSpecies(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
if (cohorts.Species == SelectedSpecies)
{
for (int i = 0; i < isDamaged.Count; i++)
{
isDamaged[i] = true;
}
}
}
/// <summary>
/// Gets the maximum age among a species' cohorts.
/// </summary>
/// <returns>
/// The age of the oldest cohort or 0 if there are no cohorts.
/// </returns>
public static ushort GetMaxAge(ISpeciesCohorts cohorts)
{
if (cohorts == null)
return 0;
ushort max = 0;
foreach (ICohort cohort in cohorts) {
// First cohort is the oldest
max = cohort.Age;
break;
}
return max;
}
//---------------------------------------------------------------------
public void Every2ndCohort(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
int N = 2;
// Every Nth cohort, working from youngest to oldest
int youngestIndex = isDamaged.Count - 1;
for (int i = youngestIndex - (N - 1); i >= 0; i -= N)
{
isDamaged[i] = true;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance by copying a set of species cohorts.
/// </summary>
public SpeciesCohorts(ISpeciesCohorts cohorts)
{
this.species = cohorts.Species;
this.ages = new List<ushort>(cohorts.Count);
this.isMaturePresent = false;
foreach (ICohort cohort in cohorts) {
ushort age = cohort.Age;
this.ages.Add(age);
if (age >= species.Maturity)
this.isMaturePresent = true;
}
}
/// <summary>
/// Gets the maximum age among a species' cohorts.
/// </summary>
/// <returns>
/// The age of the oldest cohort or 0 if there are no cohorts.
/// </returns>
public static ushort GetMaxAge(ISpeciesCohorts cohorts)
{
if (cohorts == null || !cohorts.Any())
{
return(0);
}
else
{
// First cohort is the oldest
return(cohorts.First().Age);
}
}
//---------------------------------------------------------------------
private static int ComputeSpeciesBiomass(ISpeciesCohorts cohorts)
{
int total = 0;
if (cohorts != null)
{
foreach (ICohort cohort in cohorts)
{
total += cohort.Biomass;
}
}
return(total);
}
private int CalcPercentDeadFir(ActiveSite site)
{
int numDeadFir = 0;
if (SiteVars.NumberDeadFirCohorts == null)
{
return(0);
}
int minimumStartTime = System.Math.Max(0, SiteVars.TimeOfLastFire[site]);
for (int i = minimumStartTime; i <= modelCore.CurrentTime; i++)
{
if (modelCore.CurrentTime - i <= deadFirMaxAge)
{
if (SiteVars.NumberDeadFirCohorts[site].ContainsKey(i))
{
numDeadFir += SiteVars.NumberDeadFirCohorts[site][i];
}
}
}
int numSiteCohorts = 0;
int percentDeadFir = 0;
//ISpeciesDataset SpeciesDataset = modelCore.Species;
foreach (ISpecies species in modelCore.Species)
{
ISpeciesCohorts speciesCohorts = (Landis.Library.BiomassCohorts.ISpeciesCohorts)SiteVars.Cohorts[site][species];
if (speciesCohorts == null)
{
continue;
}
foreach (ICohort cohort in speciesCohorts)
{
numSiteCohorts++;
}
}
//foreach (ISpeciesCohorts speciesCohorts in (Landis.Library.BiomassCohorts.ISpeciesCohorts) SiteVars.Cohorts[site])
//foreach (ICohort cohort in speciesCohorts)
// numSiteCohorts++;
percentDeadFir = (int)(((double)numDeadFir / (double)(numSiteCohorts + numDeadFir)) * 100.0 + 0.5);
return(System.Math.Min(percentDeadFir, 100));
}
public static int ComputeBiomass(Site site, ISpecies species)
{
ISpeciesCohorts cohorts = (Landis.Library.BiomassCohorts.ISpeciesCohorts)SiteVars.Cohorts[site][species];
int total = 0;
if (cohorts != null)
{
foreach (ICohort cohort in cohorts)
{
total += cohort.Biomass;
}
}
return(total);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance by copying a set of species cohorts.
/// </summary>
public SpeciesCohorts(ISpeciesCohorts cohorts)
{
this.species = cohorts.Species;
this.ages = new List <ushort>(cohorts.Count);
this.isMaturePresent = false;
foreach (ICohort cohort in cohorts)
{
ushort age = cohort.Age;
this.ages.Add(age);
if (age >= species.Maturity)
{
this.isMaturePresent = true;
}
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void SelectCohorts(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
int i = 0;
foreach (ICohort cohort in cohorts)
{
AgeRange?notUsed;
if (agesAndRanges.Contains(cohort.Age, out notUsed))
{
isHarvested[i] = true;
}
i++;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void SelectCohorts(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
int i = 0;
foreach (ICohort cohort in cohorts) {
if (ages.Contains(cohort.Age))
isHarvested[i] = true;
else {
foreach (AgeRange range in ranges) {
if (range.Contains(cohort.Age)) {
isHarvested[i] = true;
break;
}
}
}
i++;
}
}
public static ushort GetStdDevAge(ISpeciesCohorts speciesCohorts)
{
if (speciesCohorts == null)
return 0;
ushort std_dev = (ushort)System.Math.Round(System.Math.Sqrt(GetVarAge(speciesCohorts)),0);
return std_dev;
}
public static ushort GetMinAge(ISpeciesCohorts speciesCohorts)
{
if (speciesCohorts == null)
return 0;
ushort min = 65535;//maxof ushort
foreach (ICohort cohort in speciesCohorts)
{
if(cohort.Age<min)
min = cohort.Age;
}
return min;
}
public static ushort GetMedianAge(ISpeciesCohorts speciesCohorts)
{
if (speciesCohorts == null)
return 0;
ushort median = 0;
double dbl_median = 0.0;
List<ushort> cohort_ages = new List<ushort>();
foreach (ICohort cohort in speciesCohorts)
{
cohort_ages.Add(cohort.Age);
}
int count = cohort_ages.Count;
if (count == 0)
{
return 0;
}
else if (count == 1)
{
return cohort_ages[0];
}
cohort_ages.Sort();//sorts in ascending order
if (count % 2 == 0)
{
dbl_median = (cohort_ages[count / 2] + cohort_ages[(count / 2) - 1]) / 2.0;
median = (ushort)dbl_median;
}
else
{
median = cohort_ages[count / 2];
}
return median;
}
public static ushort GetAvgAge(ISpeciesCohorts speciesCohorts)
{
if (speciesCohorts == null)
return 0;
ushort avg = 0;
uint sum = 0;
ushort count = 0;
foreach (ICohort cohort in speciesCohorts)
{
sum += cohort.Age;
count++;
}
if (count == 0)
{
return 0;
}
avg = (ushort)(sum / count);
return avg;
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void Harvest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
for (int i = 0; i < isHarvested.Count; i++)
isHarvested[i] = true;
}
//---------------------------------------------------------------------
/// <summary>
/// Selects the youngest of a species' cohorts for harvesting.
/// </summary>
public static void Youngest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
// Youngest is last.
isHarvested[isHarvested.Count - 1] = true;
}
//---------------------------------------------------------------------
private void CheckCohorts(ISpeciesCohorts speciesCohorts,
params int[] agesAsInts)
{
ushort[] expectedAges = ToUShorts(agesAsInts);
if (expectedAges.Length == 0) {
Assert.IsNull(speciesCohorts);
}
else {
Assert.IsNotNull(speciesCohorts);
List<ushort> ages = new List<ushort>();
foreach (ICohort cohort in speciesCohorts)
ages.Add(cohort.Age);
AssertAreEqual(expectedAges, ages);
}
}
//---------------------------------------------------------------------
void ISpeciesCohortsDisturbance.MarkCohortsForDeath(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
cohortSelector.Harvest(cohorts, isDamaged);
int cohortsDamaged = 0;
for (int i = 0; i < isDamaged.Count; i++) {
if (isDamaged[i]) {
//if this cohort is killed, update the damage table (for the stand of this site) with this species name
SiteVars.Stand[currentSite].UpdateDamageTable(cohorts.Species.Name);
//PlugIn.ModelCore.UI.WriteLine("Damaged: {0}.", cohorts.Species.Name);
//and increment the cohortsDamaged
cohortsDamaged++;
}
}
SiteVars.CohortsDamaged[currentSite] += cohortsDamaged;
}
//---------------------------------------------------------------------
/// <summary>
/// Selects which of a species' cohorts are harvested.
/// </summary>
public void SelectCohorts(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
for (int i = isHarvested.Count - N; i >= 0; i -= N)
isHarvested[i] = true;
}
//---------------------------------------------------------------------
public void Every2ndCohort(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
int N = 2;
// Every Nth cohort, working from youngest to oldest
int youngestIndex = isDamaged.Count - 1;
for (int i = youngestIndex - (N - 1); i >= 0; i -= N)
isDamaged[i] = true;
}
public static uint GetVarAge(ISpeciesCohorts speciesCohorts)
{
if (speciesCohorts == null)
return 0;
ushort avg = GetAvgAge(speciesCohorts);
double sum = 0;
ushort count = 0;
foreach (ICohort cohort in speciesCohorts)
{
sum += System.Math.Pow(cohort.Age - avg, 2);
count++;
}
if (count <= 1)
return 0;
return (uint)System.Math.Round((sum / (count - 1)));
}
//---------------------------------------------------------------------
void ISpeciesCohortsDisturbance.MarkCohortsForDeath(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isKilled)
{
cohortSelector.Harvest(cohorts, isKilled);
}
//---------------------------------------------------------------------
void ISpeciesCohortsDisturbance.Damage(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isDamaged)
{
cohortSelector.Harvest(cohorts, isDamaged);
int cohortsKilled = 0;
for (int i = 0; i < isDamaged.Count; i++)
if (isDamaged[i])
cohortsKilled++;
SiteVars.CohortsKilled[currentSite] = cohortsKilled;
}
//---------------------------------------------------------------------
private void CheckCohorts(ISpeciesCohorts biomassCohorts,
List<ushort> cohortAges)
{
Assert.IsNotNull(biomassCohorts);
Assert.AreEqual(cohortAges.Count, biomassCohorts.Count);
int i = 0;
foreach (ICohort cohort in biomassCohorts) {
ushort age = cohortAges[i];
Assert.AreEqual(age, cohort.Age);
// If the timestep is 1, then annual growth calculations
// are called one less time than usual.
int expectedBiomass;
if (isTimestep1)
expectedBiomass = initialBiomass + (age-1) * annualBiomassChange;
else
expectedBiomass = initialBiomass + age * annualBiomassChange;
Assert.AreEqual(expectedBiomass, cohort.Biomass);
i++;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Selects the oldest of a species' cohorts for harvesting.
/// </summary>
public static void Oldest(ISpeciesCohorts cohorts,
ISpeciesCohortBoolArray isHarvested)
{
// Oldest is first.
isHarvested[0] = true;
}
