C# ActiveSite类代码示例

 public static bool Algorithm(ISpecies   species,
                              ActiveSite site)
 {
     return Reproduction.SufficientLight(species, site) &&
            Reproduction.Establish(species, site) &&
            Reproduction.MaturePresent(species, site);
 }

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

        //---------------------------------------------------------------------
        /// <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(Landis.Library.BiomassCohorts.SiteCohorts cohorts,
                                       ActiveSite site,
                                       int years,
                                       bool isSuccessionTimestep)
        {
            if (SiteVars.Cohorts[site] == null)
                return;

            for (int y = 1; y <= years; ++y)
            {

                SpeciesData.ChangeDynamicParameters(PlugIn.ModelCore.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 void AddNewCohort(ISpecies   species,
     ActiveSite site)
 {
     cohorts[site].AddNewCohort(species,
                                CohortBiomass.InitialBiomass(cohorts[site],
                                                             site, species));
 }

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

        public static void MyAddNewCohort(ISpecies   species,
                                          ActiveSite site)
        {
            Assert.IsTrue(speciesThatReproduce.Contains(species));
            Assert.AreEqual(expectedSite, site);
            actualSpecies_AddNewCohort.Add(species);
        }

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

        /// <summary>
        /// Assigns an active site to a particular stand.
        /// </summary>
        /// <param name="activeSite">
        /// The active site that is being assigned to a stand.
        /// </param>
        /// <param name="mapCode">
        /// The map code of the stand that the site is being assigned to.
        /// </param>
        public static void AssignSiteToStand(ActiveSite activeSite,
                                             ushort     mapCode)
        {
            double blockArea = (activeSite.SharesData ? Model.BlockArea : Model.Core.CellArea)
            
            //  Skip the site if its management area is not active.
            if (SiteVars.ManagementArea[activeSite] == null)
                return;

            Stand stand;
            //check if this stand is already in the dictionary
            if (stands.TryGetValue(mapCode, out stand)) {
                //if the stand is already in the dictionary, check if it is in the same management area.
                //if it's not in the same MA, throw exception.
                if (SiteVars.ManagementArea[activeSite] != stand.ManagementArea) {
                    throw new PixelException(activeSite.Location,
                                             "Stand {0} is in management areas {1} and {2}",
                                             stand.MapCode,
                                             stand.ManagementArea.MapCode,
                                             SiteVars.ManagementArea[activeSite].MapCode);
                }

            }
            //valid site location which has not been keyed by the dictionary.
            else {
                //assign stand (trygetvalue set it to null when it wasn't found in the dictionary)
                stand = new Stand(mapCode, blockArea);
                //add this stand to the correct management area (pointed to by the site)
                SiteVars.ManagementArea[activeSite].Add(stand);
                stands[mapCode] = stand;
            }                        

            //add this site to this stand
            stand.Add(activeSite);
        }

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

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

 public static bool Algorithm(ISpecies   species,
     ActiveSite site)
 {
     return Reproduction.SufficientResources(species, site) &&
            Reproduction.Establish(species, site) &&
            //Reproduction.MaturePresent(species, site);
            SiteVars.Cohorts[site].IsMaturePresent(species);
 }

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

        public static bool MySeedingAlgorithm(ISpecies   species,
                                              ActiveSite site)
        {
            Assert.IsTrue(expectedSpecies.Contains(species));
            Assert.AreEqual(expectedSite, site);
            actualSpecies_SeedingAlg.Add(species);
            return speciesThatReproduce.Contains(species);
        }

        //public static bool Establish(double[,] establishment)
        //---------------------------------------------------------------------
        /// <summary>
        /// Determines if a species can establish on a site.
        /// </summary>
        public static bool Establish(ISpecies species, ActiveSite site)
        {
            double establishProbability = 0; // Reproduction.GetEstablishProbability(species, site);

            //return Landis.Model.GenerateUniform() < establishment;

            return Model.Core.GenerateUniform() < establishProbability;
        }

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

 /// <summary>
 /// The default method for determining if there is sufficient light at
 /// a site for a species to germinate/resprout.
 /// </summary>
 public static bool SufficientResources(ISpecies   species,
     ActiveSite site)
 {
     byte siteShade = SiteVars.Shade[site];
     bool sufficientLight;
     sufficientLight = (species.ShadeTolerance <= 4 && species.ShadeTolerance > siteShade) ||
            (species.ShadeTolerance == 5 && siteShade > 1);
     //  pg 14, Model description, this ----------------^ may be 2?
     return sufficientLight;
 }

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

        /// <summary>
        /// Assigns an active site to a particular management area.
        /// </summary>
        /// <param name="activeSite">
        /// The active site that is being assigned to a management area.
        /// </param>
        /// <param name="mapCode">
        /// The map code of the management area that the site is being assigned
        /// to.
        /// </param>
        public static void AssignSiteToMgmtArea(ActiveSite activeSite,
                                                ushort     mapCode)
        {
            ManagementArea mgmtArea = mgmtAreas.Find(mapCode);
            if (mgmtArea == null) {
                if (! inactiveMgmtAreas.Contains(mapCode))
                    inactiveMgmtAreas.Add(mapCode);
            }
            else {
                mgmtArea.OnMap = true;
                SiteVars.ManagementArea[activeSite] = mgmtArea;
            }
        }

        //---------------------------------------------------------------------
        /// <summary>
        /// Computes the actual biomass at a site.  The biomass is the total
        /// of all the site's cohorts except young ones.  The total is limited
        /// to being no more than the site's maximum biomass less the previous
        /// year's mortality at the site.
        /// </summary>
        public static double ActualSiteBiomass(SiteCohorts    siteCohorts,
            ActiveSite     site,
            out IEcoregion ecoregion)
        {
            int youngBiomass;
            int totalBiomass = Cohorts.ComputeBiomass(siteCohorts, out youngBiomass);
            double B_ACT = totalBiomass - youngBiomass;

            int lastMortality = siteCohorts.PrevYearMortality;
            ecoregion = Model.Core.Ecoregion[site];
            B_ACT = Math.Min( B_MAX[ecoregion] - lastMortality, B_ACT);

            return B_ACT;
        }

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

        bool IFormOfReproduction.TryAt(ActiveSite site)
        {
            bool success = false;
            BitArray selectedSpeciesAtSite = selectedSpecies[site];

            for (int index = 0; index < speciesDataset.Count; ++index) {
                if (selectedSpeciesAtSite.Get(index)) {
                    ISpecies species = speciesDataset[index];
                    if (PreconditionsSatisfied(species, site)) {
                        Reproduction.AddNewCohort(species, site);
                        success = true;
                    }
                }
            }

            return success;
        }