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