C# SiteCohorts.AddNewCohort方法代码示例

        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();
            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 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_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);
        }

        //---------------------------------------------------------------------

        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);
        }

        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 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 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;
        }

        //---------------------------------------------------------------------
        /// <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);
            }
        }

        //---------------------------------------------------------------------
        /// <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;
        }

        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);
        }

        //---------------------------------------------------------------------

        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 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;
 }