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

        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.
        /// </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 void OldestOfSelectedSpecies(ISpeciesCohorts         cohorts,
                                            ISpeciesCohortBoolArray isDamaged)
        {
            if (cohorts.Species == SelectedSpecies)
                //  Oldest is first cohort
                isDamaged[0] = 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 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);
    	}

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

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

 public static int ComputeBiomass(ISpeciesCohorts cohorts)
 {
     int total = 0;
     if (cohorts != null)
         foreach (ICohort cohort in cohorts)
             total += cohort.Biomass;
     return total;
 }

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

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

 //---------------------------------------------------------------------
 /// <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>
        /// 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)
         return 0;
     ushort max = 0;
     foreach (ICohort cohort in cohorts) {
         //  First cohort is the oldest
         max = cohort.Age;
         break;
     }
     return max;
 }

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

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