public void SingleCohort_ZeroBiomass() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 100; cohorts.AddNewCohort(poputrem, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = -2; expectedSender = cohorts[poputrem]; expectedDistType = null; // death during growth phase expectedSite = activeSite; deadCohorts.Clear(); for (int time = 1; time <= 60; time++) { if (time % successionTimestep == 0) { Util.Grow(cohorts, successionTimestep, activeSite, true); } } expectedCohorts.Clear(); Util.CheckCohorts(expectedCohorts, cohorts); Assert.AreEqual(1, deadCohorts.Count); ICohort deadCohort = deadCohorts[0]; Assert.AreEqual(poputrem, deadCohort.Species); Assert.AreEqual(initialBiomass / -mockCalculator.Change, deadCohort.Age); Assert.AreEqual(0, deadCohort.Biomass); }
public void SingleCohort() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 300; cohorts.AddNewCohort(abiebals, initialBiomass); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { 1, initialBiomass }; Util.CheckCohorts(expectedCohorts, cohorts); }
public void SingleCohort() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 300; cohorts.AddNewCohort(abiebals, initialBiomass); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { 1, initialBiomass }; Util.CheckCohorts(expectedCohorts, cohorts); }
public void CombineYoungCohorts() { SiteCohorts cohorts = new SiteCohorts(); int[] initialBiomass = new int[] { 300, 700 }; cohorts.AddNewCohort(abiebals, initialBiomass[0]); Assert.AreEqual(initialBiomass[0], cohorts.TotalBiomass); // Grow 1st cohort for 4 years, adding 10 to its biomass per year mockCalculator.CountCalled = 0; mockCalculator.Change = 10; Util.Grow(cohorts, 4, activeSite, false); Assert.AreEqual(4, mockCalculator.CountCalled); expectedCohorts.Clear(); expectedCohorts[abiebals] = new int[] { 5, (int)(300 + 4 * mockCalculator.Change) }; Util.CheckCohorts(expectedCohorts, cohorts); // Add 2nd cohort and then grow both cohorts 6 more years up to // a succession timestep cohorts.AddNewCohort(abiebals, initialBiomass[1]); mockCalculator.CountCalled = 0; Util.Grow(cohorts, 6, activeSite, true); // ComputeChange for both cohorts for 5 years, then combine them, // and then one time for the combined cohort Assert.AreEqual(5 * 2 + 1, mockCalculator.CountCalled); expectedCohorts.Clear(); expectedCohorts[abiebals] = new int[] { successionTimestep, (int) (300 + (4 + 5) * mockCalculator.Change // first cohort before combining + 700 + 5 * mockCalculator.Change // 2nd cohort before combining + mockCalculator.Change) // growth after combining }; Util.CheckCohorts(expectedCohorts, cohorts); }
public void SingleCohort_LongevityReached() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 300; cohorts.AddNewCohort(poputrem, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = 1; expectedSender = cohorts[poputrem]; expectedDistType = null; // death during growth phase expectedSite = activeSite; deadCohorts.Clear(); // Repeatedly grow for succession timesteps until longevity // reached. int time = 0; do { time += successionTimestep; Util.Grow(cohorts, successionTimestep, activeSite, true); } while (time <= poputrem.Longevity); expectedCohorts.Clear(); Util.CheckCohorts(expectedCohorts, cohorts); // Calculator called L times where L is longevity. Inituitively, // one would think since initial cohort's age is 1, it'd only take // L-1 times to get to the max age (= L). So the calculator // should be called L-1 times. But the combining of young cohorts // at the first succession timestep (t_succ = 20) results in the // calculator being called twice with cohort age = t_succ-1 (19). // At the end of year 19, the cohort's age is 20 and the // calculator has been called 19 times. But at the start of year // 20, the combine-young-cohorts operation is done because it's a // succession timestep. The combine operation takes all the young // cohorts (age <= t_succ = 20) and replaces them with one cohort // with age = t_succ-1 (= 19). This ensures that after the growth // phase, the cohort's age will be t_succ (20). So the growth // phase of year 20 calls the calculator for the 20th time with // cohort age 19. Assert.AreEqual(poputrem.Longevity, mockCalculator.CountCalled); Assert.AreEqual(1, deadCohorts.Count); ICohort deadCohort = deadCohorts[0]; Assert.AreEqual(poputrem, deadCohort.Species); Assert.AreEqual(poputrem.Longevity, deadCohort.Age); Assert.AreEqual(initialBiomass + (poputrem.Longevity * mockCalculator.Change), deadCohort.Biomass); }
//--------------------------------------------------------------------- private void CreateInitialCohorts() { ushort[] abiebalsAges = new ushort[] { 30, 40, 50, 150, 170 }; ushort[] betualleAges = new ushort[] { 100, 120, 280, 300 }; // Work with ages from oldest to youngest System.Array.Sort(abiebalsAges, Landis.AgeCohort.Util.WhichIsOlder); System.Array.Sort(betualleAges, Landis.AgeCohort.Util.WhichIsOlder); // Loop through succession timesteps from the time when the // oldest cohort would have been added to site (= -{its age}) to // the present (time = 0). Each cohort is added to the site // when time = -{its age}. initialSiteCohorts = new SiteCohorts(); const int initialBiomass = 55; List <ushort> abiebalsAgesLeft = new List <ushort>(abiebalsAges); List <ushort> betualleAgesLeft = new List <ushort>(betualleAges); ushort maxAge = System.Math.Max(abiebalsAgesLeft[0], betualleAgesLeft[0]); for (int time = -maxAge; time <= 0; time += successionTimestep) { Util.Grow(initialSiteCohorts, successionTimestep, activeSite, true); if (abiebalsAgesLeft.Count > 0) { if (time == -(abiebalsAgesLeft[0])) { initialSiteCohorts.AddNewCohort(abiebals, initialBiomass); abiebalsAgesLeft.RemoveAt(0); } } if (betualleAgesLeft.Count > 0) { if (time == -(betualleAgesLeft[0])) { initialSiteCohorts.AddNewCohort(betualle, initialBiomass); betualleAgesLeft.RemoveAt(0); } } } }
//--------------------------------------------------------------------- public static SiteCohorts Clone(ISiteCohorts site_cohorts) { SiteCohorts clone = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in site_cohorts) { foreach (ICohort cohort in speciesCohorts) { clone.AddNewCohort(cohort.Species, cohort.Age, cohort.WoodBiomass, cohort.LeafBiomass); } } return(clone); }
//--------------------------------------------------------------------- public static ISiteCohorts Clone(ActiveSite site, ISiteCohorts site_cohorts) { ISiteCohorts clone = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in site_cohorts) { foreach (Cohort cohort in speciesCohorts) { clone.AddNewCohort(cohort); } } return(clone); }
//--------------------------------------------------------------------- public static SiteCohorts Clone(SiteCohorts site_cohorts) { SiteCohorts clone = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in site_cohorts) { foreach (ICohort cohort in speciesCohorts) { clone.AddNewCohort(cohort.Species, cohort.Age, cohort.Biomass); //species.cohorts.Add(speciesCohorts.Clone()); } } return(clone); }
public void CombineYoungCohorts() { SiteCohorts cohorts = new SiteCohorts(); ushort[] initialBiomass = new ushort[] { 300, 700 }; cohorts.AddNewCohort(abiebals, initialBiomass[0]); // Grow 1st cohort for 4 years, adding 10 to its biomass per year mockCalculator.CountCalled = 0; mockCalculator.Change = 10; cohorts.Grow(4, activeSite, false); Assert.AreEqual(4, mockCalculator.CountCalled); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { 5, (ushort) (300 + 4 * mockCalculator.Change) }; Util.CheckCohorts(expectedCohorts, cohorts); // Add 2nd cohort and then grow both cohorts 6 more years up to // a succession timestep cohorts.AddNewCohort(abiebals, initialBiomass[1]); mockCalculator.CountCalled = 0; cohorts.Grow(6, activeSite, true); // ComputeChange for both cohorts for 5 years, then combine them, // and then one time for the combined cohort Assert.AreEqual(5 * 2 + 1, mockCalculator.CountCalled); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { successionTimestep, (ushort) (300 + (4 + 5) * mockCalculator.Change // first cohort before combining + 700 + 5 * mockCalculator.Change // 2nd cohort before combining + mockCalculator.Change) // growth after combining }; Util.CheckCohorts(expectedCohorts, cohorts); }
public void SingleCohort() { SiteCohorts cohorts = new SiteCohorts(); Assert.AreEqual(0, cohorts.TotalBiomass); const int initialBiomass = 300; cohorts.AddNewCohort(abiebals, initialBiomass); Assert.AreEqual(initialBiomass, cohorts.TotalBiomass); expectedCohorts.Clear(); expectedCohorts[abiebals] = new int [] { 1, initialBiomass }; Util.CheckCohorts(expectedCohorts, cohorts); }
public void SingleCohort() { SiteCohorts cohorts = new SiteCohorts(); Assert.AreEqual(0, cohorts.TotalBiomass); const int initialBiomass = 300; cohorts.AddNewCohort(abiebals, initialBiomass); Assert.AreEqual(initialBiomass, cohorts.TotalBiomass); expectedCohorts.Clear(); expectedCohorts[abiebals] = new int [] { 1, initialBiomass }; Util.CheckCohorts(expectedCohorts, cohorts); }
public void SingleCohort_LongevityReached() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 300; cohorts.AddNewCohort(poputrem, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = 1; expectedSite = activeSite; deadCohorts.Clear(); // Repeatedly grow for succession timesteps until longevity // reached. int time = 0; do { time += successionTimestep; cohorts.Grow(successionTimestep, activeSite, true); } while (time <= poputrem.Longevity); expectedCohorts.Clear(); Util.CheckCohorts(expectedCohorts, cohorts); // Calculator called L times where L is longevity. Inituitively, // one would think since initial cohort's age is 1, it'd only take // L-1 times to get to the max age (= L). So the calculator // should be called L-1 times. But the combining of young cohorts // at the first succession timestep (t_succ = 20) results in the // calculator being called twice with cohort age = t_succ-1 (19). // At the end of year 19, the cohort's age is 20 and the // calculator has been called 19 times. But at the start of year // 20, the combine-young-cohorts operation is done because it's a // succession timestep. The combine operation takes all the young // cohorts (age <= t_succ = 20) and replaces them with one cohort // with age = t_succ-1 (= 19). This ensures that after the growth // phase, the cohort's age will be t_succ (20). So the growth // phase of year 20 calls the calculator for the 20th time with // cohort age 19. Assert.AreEqual(poputrem.Longevity, mockCalculator.CountCalled); Assert.AreEqual(1, deadCohorts.Count); ICohort deadCohort = deadCohorts[0]; Assert.AreEqual(poputrem, deadCohort.Species); Assert.AreEqual(poputrem.Longevity, deadCohort.Age); Assert.AreEqual(initialBiomass + (poputrem.Longevity * mockCalculator.Change), deadCohort.Biomass); }
public void Grow() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 35; cohorts.AddNewCohort(abiebals, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = 8; cohorts.Grow(activeSite, true); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { // age biomass 2, (ushort) (initialBiomass + mockCalculator.Change) }; Util.CheckCohorts(expectedCohorts, cohorts); }
public void Grow() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 35; cohorts.AddNewCohort(abiebals, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = 8; cohorts.Grow(activeSite, true); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { // age biomass 2, (ushort)(initialBiomass + mockCalculator.Change) }; Util.CheckCohorts(expectedCohorts, cohorts); }
public SiteConditions GetFromKey(uint key) { SiteConditions s = null; if (initialSites.TryGetValue(key, out s) && siteoutput == null) { hydrology = s.hydrology; establishment = s.Establishment; cohorts = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in s.cohorts) { foreach (Cohort cohort in speciesCohorts) { Cohort newcohort = new Cohort(cohort); cohorts.AddNewCohort(newcohort, PlugIn.TStep); } } forestfloor = s.forestfloor; canopylaimax = s.CanopyLAImax; } return(s); }
//--------------------------------------------------------------------- private void CreateInitialCohorts() { ushort[] abiebalsAges = new ushort[]{30, 40, 50, 150, 170}; ushort[] betualleAges = new ushort[]{100, 120, 280, 300}; // Work with ages from oldest to youngest System.Array.Sort(abiebalsAges, Landis.AgeCohort.Util.WhichIsOlder); System.Array.Sort(betualleAges, Landis.AgeCohort.Util.WhichIsOlder); // Loop through succession timesteps from the time when the // oldest cohort would have been added to site (= -{its age}) to // the present (time = 0). Each cohort is added to the site // when time = -{its age}. initialSiteCohorts = new SiteCohorts(); const int initialBiomass = 55; List<ushort> abiebalsAgesLeft = new List<ushort>(abiebalsAges); List<ushort> betualleAgesLeft = new List<ushort>(betualleAges); ushort maxAge = System.Math.Max(abiebalsAgesLeft[0], betualleAgesLeft[0]); for (int time = -maxAge; time <= 0; time += successionTimestep) { Util.Grow(initialSiteCohorts, successionTimestep, activeSite, true); if (abiebalsAgesLeft.Count > 0) { if (time == -(abiebalsAgesLeft[0])) { initialSiteCohorts.AddNewCohort(abiebals, initialBiomass); abiebalsAgesLeft.RemoveAt(0); } } if (betualleAgesLeft.Count > 0) { if (time == -(betualleAgesLeft[0])) { initialSiteCohorts.AddNewCohort(betualle, initialBiomass); betualleAgesLeft.RemoveAt(0); } } } }
public void AddNewCohort(Cohort cohort, int SuccessionTimeStep) { cohorts.AddNewCohort(cohort, SuccessionTimeStep); }
public SiteConditions GetFromKey(uint key) { SiteConditions s=null; if (initialSites.TryGetValue(key, out s) && siteoutput == null) { hydrology = s.hydrology; establishment = s.Establishment; cohorts = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in s.cohorts) { foreach (Cohort cohort in speciesCohorts) { Cohort newcohort = new Cohort(cohort); cohorts.AddNewCohort(newcohort, PlugIn.TStep); } } forestfloor = s.forestfloor; canopylaimax = s.CanopyLAImax; } return s; }
//--------------------------------------------------------------------- private void CohortsRemoved(object disturbance) { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 40; mockCalculator.CountCalled = 0; mockCalculator.Change = 1; int timeOfLastSucc = 0; for (int time = 1; time <= 50; time++) { // Simulate the site being disturbed every 8 years which // results in a new cohort being added. bool siteDisturbed = (time % 8 == 0); bool isSuccTimestep = (time % successionTimestep == 0); if (siteDisturbed || isSuccTimestep) { Util.Grow(cohorts, (ushort)(time - timeOfLastSucc), activeSite, isSuccTimestep); timeOfLastSucc = time; } if (siteDisturbed) { cohorts.AddNewCohort(poputrem, initialBiomass); } } // Expected sequence of cohort changes: // // Time Grow_________ // Last Cohorts New // Time Succ years afterwards Cohort // ---- ---- ----- --------------- ------ // 8 0 8 1(40) // 16 8 8 9(48) 1(40) // 20 16 4 20(95*) * = 48+3 + 40+3 + 1 // 24 20 4 24(99) 1(40) // 32 24 8 32(107),9(48) 1(40) // 40 32 8 40(115),20(103*) 1(40) * = 48+7 + 40+7 + 1 // 48 40 8 48(123),28(111),9(48) 1(40) expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 28, 111, 9, 48, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); // Remove cohorts whose ages are between 10 and 30 expectedSender = cohorts[poputrem]; deadCohorts.Clear(); if (disturbance is IDisturbance) { cohorts.DamageBy((IDisturbance)disturbance); } else if (disturbance is AgeCohort.ICohortDisturbance) { ((AgeCohort.ISiteCohorts)cohorts).DamageBy((AgeCohort.ICohortDisturbance)disturbance); } expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); CheckDeadCohorts(deadCohorts); }
//--------------------------------------------------------------------- /// <summary> /// Makes the set of biomass cohorts at a site based on the age cohorts /// at the site, using a specified method for computing a cohort's /// initial biomass. /// </summary> /// <param name="ageCohorts"> /// A sorted list of age cohorts, from oldest to youngest. /// </param> /// <param name="site"> /// Site where cohorts are located. /// </param> /// <param name="initialBiomassMethod"> /// The method for computing the initial biomass for a new cohort. /// </param> public static SiteCohorts MakeBiomassCohorts(List<AgeCohort.ICohort> ageCohorts, ActiveSite site, ComputeMethod initialBiomassMethod) { SiteCohorts biomassCohorts = new SiteCohorts(); if (ageCohorts.Count == 0) return biomassCohorts; int indexNextAgeCohort = 0; // The index in the list of sorted age cohorts of the next // cohort to be considered // Loop through time from -N to 0 where N is the oldest cohort. // So we're going from the time when the oldest cohort was "born" // to the present time (= 0). Because the age of any age cohort // is a multiple of the succession timestep, we go from -N to 0 // by that timestep. NOTE: the case where timestep = 1 requires // special treatment because if we start at time = -N with a // cohort with age = 1, then at time = 0, its age will N+1 not N. // Therefore, when timestep = 1, the ending time is -1. int endTime = (successionTimestep == 1) ? -1 : 0; for (int time = -(ageCohorts[0].Age); time <= endTime; time += successionTimestep) { // Grow current biomass cohorts. Util.GrowCohorts(biomassCohorts, site, successionTimestep, true); // Add those cohorts that were born at the current year while (indexNextAgeCohort < ageCohorts.Count && ageCohorts[indexNextAgeCohort].Age == -time) { ushort initialBiomass = initialBiomassMethod(biomassCohorts, site, ageCohorts[indexNextAgeCohort].Species); biomassCohorts.AddNewCohort(ageCohorts[indexNextAgeCohort].Species, initialBiomass); indexNextAgeCohort++; } } return biomassCohorts; }
public void CohortsRemoved() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 40; mockCalculator.CountCalled = 0; mockCalculator.Change = 1; int timeOfLastSucc = 0; for (int time = 1; time <= 50; time++) { // Simulate the site being disturbed every 8 years which // results in a new cohort being added. bool siteDisturbed = (time % 8 == 0); bool isSuccTimestep = (time % successionTimestep == 0); if (siteDisturbed || isSuccTimestep) { cohorts.Grow((ushort) (time - timeOfLastSucc), activeSite, isSuccTimestep); timeOfLastSucc = time; } if (siteDisturbed) cohorts.AddNewCohort(poputrem, initialBiomass); } // Expected sequence of cohort changes: // // Time Grow_________ // Last Cohorts New // Time Succ years afterwards Cohort // ---- ---- ----- --------------- ------ // 8 0 8 1(40) // 16 8 8 9(48) 1(40) // 20 16 4 20(95*) * = 48+3 + 40+3 + 1 // 24 20 4 24(99) 1(40) // 32 24 8 32(107),9(48) 1(40) // 40 32 8 40(115),20(103*) 1(40) * = 48+7 + 40+7 + 1 // 48 40 8 48(123),28(111),9(48) 1(40) expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 28, 111, 9, 48, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); // Remove cohorts whose ages are between 10 and 30 expectedSite = null; deadCohorts.Clear(); cohorts.Remove(AgeBetween5And30); expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); Assert.AreEqual(2, deadCohorts.Count); ushort[] cohortData = new ushort[] { // age biomass (in young to old order because Remove goes // from back to front) 9, 48, 28, 111 }; for (int i = 0; i < deadCohorts.Count; i++) { ICohort deadCohort = deadCohorts[i]; Assert.AreEqual(poputrem, deadCohort.Species); Assert.AreEqual(cohortData[i*2], deadCohort.Age); Assert.AreEqual(cohortData[i*2+1], deadCohort.Biomass); } }
public void SingleCohort_ZeroBiomass() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 100; cohorts.AddNewCohort(poputrem, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = -2; expectedSender = cohorts[poputrem]; expectedDistType = null; // death during growth phase expectedSite = activeSite; deadCohorts.Clear(); for (int time = 1; time <= 60; time++) { if (time % successionTimestep == 0) Util.Grow(cohorts, successionTimestep, activeSite, true); } expectedCohorts.Clear(); Util.CheckCohorts(expectedCohorts, cohorts); Assert.AreEqual(1, deadCohorts.Count); ICohort deadCohort = deadCohorts[0]; Assert.AreEqual(poputrem, deadCohort.Species); Assert.AreEqual(initialBiomass / -mockCalculator.Change, deadCohort.Age); Assert.AreEqual(0, deadCohort.Biomass); }
public void Clone() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 55; cohorts.AddNewCohort(abiebals, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = 1; for (int time = successionTimestep; time <= 70; time += successionTimestep) { Util.Grow(cohorts, successionTimestep, activeSite, true); if (time % 20 == 0) cohorts.AddNewCohort(abiebals, initialBiomass); if (time % 30 == 0) cohorts.AddNewCohort(betualle, initialBiomass); } // Expected cohort changes: // // Time Cohorts // ---- ------- // 0 abiebals 1(55) // 10 abiebals 10(65) // 20 abiebals 20(75) 1(55) // 30 abiebals 30(85) 10(65) // betualle 1(55) // 40 abiebals 40(95) 20(75) 1(55) // betualle 10(65) // 50 abiebals 50(105) 30(85) 10(65) // betualle 20(75) // 60 abiebals 60(115) 40(95) 20(75) 1(55) // betualle 30(85) 1(55) // 70 abiebals 70(125) 50(105) 30(85) 10(65) // betualle 40(95) 10(65) expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { // age biomass 70, 125, 50, 105, 30, 85, 10, 65 }; expectedCohorts[betualle] = new ushort[] { // age biomass 40, 95, 10, 65 }; Util.CheckCohorts(expectedCohorts, cohorts); SiteCohorts clone = cohorts.Clone(); Util.CheckCohorts(expectedCohorts, clone); // Modify the original set of cohorts by growing them for 2 more // succession timesteps. Check that clone doesn't change. for (int time = 80; time <= 90; time += successionTimestep) { Util.Grow(cohorts, successionTimestep, activeSite, true); } Util.CheckCohorts(expectedCohorts, clone); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { // age biomass 90, 145, 70, 125, 50, 105, 30, 85 }; expectedCohorts[betualle] = new ushort[] { // age biomass 60, 115, 30, 85 }; Util.CheckCohorts(expectedCohorts, cohorts); }
//--------------------------------------------------------------------- public static ISiteCohorts Clone(ActiveSite site, ISiteCohorts site_cohorts) { ISiteCohorts clone = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in site_cohorts) foreach (Cohort cohort in speciesCohorts) { clone.AddNewCohort(cohort); } return clone; }
//--------------------------------------------------------------------- public static SiteCohorts Clone(SiteCohorts site_cohorts) { SiteCohorts clone = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in site_cohorts) foreach (ICohort cohort in speciesCohorts) //clone.AddNewCohort(cohort.Species, cohort.Age, cohort.Biomass); clone.AddNewCohort(cohort.Species, cohort.Age, cohort.Biomass, cohort.ANPP); //species.cohorts.Add(speciesCohorts.Clone()); return clone; }
public void Clone() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 55; cohorts.AddNewCohort(abiebals, initialBiomass); mockCalculator.CountCalled = 0; mockCalculator.Change = 1; for (int time = successionTimestep; time <= 70; time += successionTimestep) { Util.Grow(cohorts, successionTimestep, activeSite, true); if (time % 20 == 0) { cohorts.AddNewCohort(abiebals, initialBiomass); } if (time % 30 == 0) { cohorts.AddNewCohort(betualle, initialBiomass); } } // Expected cohort changes: // // Time Cohorts // ---- ------- // 0 abiebals 1(55) // 10 abiebals 10(65) // 20 abiebals 20(75) 1(55) // 30 abiebals 30(85) 10(65) // betualle 1(55) // 40 abiebals 40(95) 20(75) 1(55) // betualle 10(65) // 50 abiebals 50(105) 30(85) 10(65) // betualle 20(75) // 60 abiebals 60(115) 40(95) 20(75) 1(55) // betualle 30(85) 1(55) // 70 abiebals 70(125) 50(105) 30(85) 10(65) // betualle 40(95) 10(65) expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { // age biomass 70, 125, 50, 105, 30, 85, 10, 65 }; expectedCohorts[betualle] = new ushort[] { // age biomass 40, 95, 10, 65 }; Util.CheckCohorts(expectedCohorts, cohorts); SiteCohorts clone = cohorts.Clone(); Util.CheckCohorts(expectedCohorts, clone); // Modify the original set of cohorts by growing them for 2 more // succession timesteps. Check that clone doesn't change. for (int time = 80; time <= 90; time += successionTimestep) { Util.Grow(cohorts, successionTimestep, activeSite, true); } Util.CheckCohorts(expectedCohorts, clone); expectedCohorts.Clear(); expectedCohorts[abiebals] = new ushort[] { // age biomass 90, 145, 70, 125, 50, 105, 30, 85 }; expectedCohorts[betualle] = new ushort[] { // age biomass 60, 115, 30, 85 }; Util.CheckCohorts(expectedCohorts, cohorts); }
//--------------------------------------------------------------------- public static ISiteCohorts Clone(ISiteCohorts site_cohorts) { ISiteCohorts clone = new SiteCohorts(); foreach (ISpeciesCohorts speciesCohorts in site_cohorts) foreach (ICohort cohort in speciesCohorts) clone.AddNewCohort(cohort.Species, cohort.Age, cohort.WoodBiomass, cohort.LeafBiomass); //species.cohorts.Add(speciesCohorts.Clone()); return clone; }
public void CohortsRemoved() { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 40; mockCalculator.CountCalled = 0; mockCalculator.Change = 1; int timeOfLastSucc = 0; for (int time = 1; time <= 50; time++) { // Simulate the site being disturbed every 8 years which // results in a new cohort being added. bool siteDisturbed = (time % 8 == 0); bool isSuccTimestep = (time % successionTimestep == 0); if (siteDisturbed || isSuccTimestep) { Util.Grow(cohorts, (ushort)(time - timeOfLastSucc), activeSite, isSuccTimestep); timeOfLastSucc = time; } if (siteDisturbed) { cohorts.AddNewCohort(poputrem, initialBiomass); } } // Expected sequence of cohort changes: // // Time Grow_________ // Last Cohorts New // Time Succ years afterwards Cohort // ---- ---- ----- --------------- ------ // 8 0 8 1(40) // 16 8 8 9(48) 1(40) // 20 16 4 20(95*) * = 48+3 + 40+3 + 1 // 24 20 4 24(99) 1(40) // 32 24 8 32(107),9(48) 1(40) // 40 32 8 40(115),20(103*) 1(40) * = 48+7 + 40+7 + 1 // 48 40 8 48(123),28(111),9(48) 1(40) expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 28, 111, 9, 48, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); // Remove cohorts whose ages are between 10 and 30 expectedSite = null; deadCohorts.Clear(); cohorts.DamageBy(new RemoveAgeBetween5And30(expectedSite)); expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); Assert.AreEqual(2, deadCohorts.Count); ushort[] cohortData = new ushort[] { // age biomass (in young to old order because Remove goes // from back to front) 9, 48, 28, 111 }; for (int i = 0; i < deadCohorts.Count; i++) { ICohort deadCohort = deadCohorts[i]; Assert.AreEqual(poputrem, deadCohort.Species); Assert.AreEqual(cohortData[i * 2], deadCohort.Age); Assert.AreEqual(cohortData[i * 2 + 1], deadCohort.Biomass); } }
//--------------------------------------------------------------------- private void CohortsRemoved(object disturbance) { SiteCohorts cohorts = new SiteCohorts(); const ushort initialBiomass = 40; mockCalculator.CountCalled = 0; mockCalculator.Change = 1; int timeOfLastSucc = 0; for (int time = 1; time <= 50; time++) { // Simulate the site being disturbed every 8 years which // results in a new cohort being added. bool siteDisturbed = (time % 8 == 0); bool isSuccTimestep = (time % successionTimestep == 0); if (siteDisturbed || isSuccTimestep) { Util.Grow(cohorts, (ushort) (time - timeOfLastSucc), activeSite, isSuccTimestep); timeOfLastSucc = time; } if (siteDisturbed) cohorts.AddNewCohort(poputrem, initialBiomass); } // Expected sequence of cohort changes: // // Time Grow_________ // Last Cohorts New // Time Succ years afterwards Cohort // ---- ---- ----- --------------- ------ // 8 0 8 1(40) // 16 8 8 9(48) 1(40) // 20 16 4 20(95*) * = 48+3 + 40+3 + 1 // 24 20 4 24(99) 1(40) // 32 24 8 32(107),9(48) 1(40) // 40 32 8 40(115),20(103*) 1(40) * = 48+7 + 40+7 + 1 // 48 40 8 48(123),28(111),9(48) 1(40) expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 28, 111, 9, 48, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); // Remove cohorts whose ages are between 10 and 30 expectedSender = cohorts[poputrem]; deadCohorts.Clear(); if (disturbance is IDisturbance) cohorts.DamageBy((IDisturbance) disturbance); else if (disturbance is AgeCohort.IDisturbance) ((AgeCohort.ISiteCohorts) cohorts).DamageBy((AgeCohort.IDisturbance) disturbance); expectedCohorts.Clear(); expectedCohorts[poputrem] = new ushort[] { // age biomass 48, 123, 1, 40 }; Util.CheckCohorts(expectedCohorts, cohorts); CheckDeadCohorts(deadCohorts); }
//--------------------------------------------------------------------- /// <summary> /// Makes the set of biomass cohorts at a site based on the age cohorts /// at the site, using a specified method for computing a cohort's /// initial biomass. /// </summary> /// <param name="ageCohorts"> /// A sorted list of age cohorts, from oldest to youngest. /// </param> /// <param name="site"> /// Site where cohorts are located. /// </param> /// <param name="initialBiomassMethod"> /// The method for computing the initial biomass for a new cohort. /// </param> public static SiteCohorts MakeBiomassCohorts(List<AgeCohort.ICohort> ageCohorts, ActiveSite site, ComputeMethod initialBiomassMethod) { // Fix to keep initial mineral N and P as paramterized for year 1. double minN = SiteVars.MineralSoil[site].ContentN; double minP = SiteVars.MineralSoil[site].ContentP; SiteCohorts biomassCohorts = new SiteCohorts(); if (ageCohorts.Count == 0) return biomassCohorts; int indexNextAgeCohort = 0; //The index in the list of sorted age cohorts of the next // cohort to be considered. //Loop through time from -N to 0 where N is the oldest cohort. // So we're going from the time when the oldest cohort was "born" // to the present time (= 0). Because the age of any age cohort // is a multiple of the succession timestep, we go from -N to 0 // by that timestep. NOTE: the case where timestep = 1 requires // special treatment because if we start at time = -N with a // cohort with age = 1, then at time = 0, its age will N+1 not N. // Therefore, when timestep = 1, the ending time is -1. int endTime = (successionTimestep == 1) ? -1 : 0; for (int time = -(ageCohorts[0].Age); time <= endTime; time += successionTimestep) { //Grow current biomass cohorts. NutrientSuccession.InitGrowCohorts(biomassCohorts, site, successionTimestep, true); //Add those cohorts that were born at the current year while (indexNextAgeCohort < ageCohorts.Count && ageCohorts[indexNextAgeCohort].Age == -time) { float[] initialBiomass = initialBiomassMethod(biomassCohorts, site, ageCohorts[indexNextAgeCohort].Species); float initialWoodBiomass = initialBiomass[0]; float initialLeafBiomass = initialBiomass[1]; biomassCohorts.AddNewCohort(ageCohorts[indexNextAgeCohort].Species, initialWoodBiomass, initialLeafBiomass); indexNextAgeCohort++; } } // Reset mineral nutrients SiteVars.MineralSoil[site].ContentN = minN; SiteVars.MineralSoil[site].ContentP = minP; return biomassCohorts; }