/// <summary>
        /// Adds some biomass for a species to the coarse roots pools at a site.
        /// </summary>
        public static void AddLiveCoarseRoots(double abovegroundWoodyBiomass,
            //double leafLongevity,
            ISpecies species,
            ActiveSite site,
            Pool coarseRoots)
        {
            double leafLongevity = SpeciesData.LeafLongevity[species];
            double coarseRootBiomass = CalculateCoarseRoot(abovegroundWoodyBiomass, leafLongevity);
            double inputPercentC = SpeciesData.WoodFractionC[species];
            double inputPercentN = SpeciesData.WoodFractionN[species];
            double inputPercentP = SpeciesData.WoodFractionP[species];

            coarseRoots.AddMass(coarseRootBiomass, inputPercentC, inputPercentN, inputPercentP);
        }
        //---------------------------------------------------------------------
        /// <summary>
        /// Adds some biomass for a species to the fine roots pools at a site.
        /// </summary>
        public static void AddLiveFineRoots(double abovegroundLeafBiomass,
            //double leafLongevity,
            ISpecies species,
            ActiveSite site,
            Pool fineRoots)
        {
            double leafLongevity = SpeciesData.LeafLongevity[species];
            double fineRootBiomass = CalculateFineRoot(abovegroundLeafBiomass, leafLongevity);
            double inputPercentC = SpeciesData.FRootFractionC[species];
            double inputPercentN = SpeciesData.FRootFractionN[species];
            double inputPercentP = SpeciesData.FRootFractionP[species];

            fineRoots.AddMass(fineRootBiomass, inputPercentC,
                inputPercentN, inputPercentP);
        }
 //---------------------------------------------------------------------
 private InitialBiomass(SiteCohorts cohorts,
                        List<PoolD> litterPool,
                        PoolD woodyDebrisPool,
                        List<PoolD> deadFRootsPool,
                        Pool fineRootsPool,
                        Pool coarseRootsPool,
                        Charcoal charcoalPool)
 {
     this.cohorts = cohorts;
     this.litterPool = litterPool;
     this.woodyDebrisPool = woodyDebrisPool;
     this.deadFRootsPool = deadFRootsPool;
     this.fineRootsPool = fineRootsPool;
     this.coarseRootsPool = coarseRootsPool;
     this.charcoalPool = charcoalPool;
 }
        //---------------------------------------------------------------------
        /// <summary>
        /// Initializes the module.
        /// </summary>
        public static void Initialize()
        {
            cohorts             = Model.Core.Landscape.NewSiteVar<SiteCohorts>();
            availableN          = Model.Core.Landscape.NewSiteVar<double>();
            unavailable         = Model.Core.Landscape.NewSiteVar<Pool>();
            fineRoots           = Model.Core.Landscape.NewSiteVar<Pool>();
            coarseRoots         = Model.Core.Landscape.NewSiteVar<Pool>();
            woodyDebris         = Model.Core.Landscape.NewSiteVar<PoolD>();
            litter              = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
            deadFineRoots       = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
            litterAdd           = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
            deadFineRootsAdd    = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
            removeLitter        = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
            removeDeadFineRoots = Model.Core.Landscape.NewSiteVar<List<PoolD>>();
            soilOrganicMatter   = Model.Core.Landscape.NewSiteVar<SoilOrganicMatter>();
            mineralSoil         = Model.Core.Landscape.NewSiteVar<MineralSoil>();
            charcoal            = Model.Core.Landscape.NewSiteVar<Charcoal>();
            rock                = Model.Core.Landscape.NewSiteVar<Rock>();
            //fireSeverity        = Model.Core.Landscape.NewSiteVar<int>();

            TotalWoodBiomass    = Model.Core.Landscape.NewSiteVar<double>();
            CurrentYearMortality = Model.Core.Landscape.NewSiteVar<double>();
            PrevYearMortality = Model.Core.Landscape.NewSiteVar<double>();
            //fireSeverity = Model.Core.GetSiteVar<byte>("Fire.Severity");

            // Enable interactions with (almost) any fire extension:
            /*if (Model.Core.GetSiteVar<int>("Fire.Severity") == null)
            {
                Console.Write("Fire Severity not cu");
            }
            else
            {
                Console.Write("Real value");
                fireSeverity = Model.Core.GetSiteVar<int>("Fire.SeverityX");
            }*/

            foreach (ActiveSite site in Model.Core.Landscape)
            {
                //  site cohorts are initialized by the PlugIn.InitializeSite method
                availableN[site]            = new double();
                unavailable[site]           = new Pool();
                fineRoots[site]             = new Pool();
                coarseRoots[site]           = new Pool();
                woodyDebris[site]           = new PoolD();
                litter[site]                = new List<PoolD>();
                deadFineRoots[site]         = new List<PoolD>();
                litterAdd[site]             = new List<PoolD>();
                deadFineRootsAdd[site]      = new List<PoolD>();
                removeLitter[site]          = new List<PoolD>();
                removeDeadFineRoots[site]   = new List<PoolD>();
                soilOrganicMatter[site]     = new SoilOrganicMatter();
                mineralSoil[site]           = new MineralSoil();
                charcoal[site]              = new Charcoal();
                rock[site]                  = new Rock();
            }
        }
 //---------------------------------------------------------------------
 /// <summary>
 /// Reduces the fine root's biomass and nutrients by a specified amount.
 /// </summary>
 public static void ReduceFineRoots(double amount,
     ISpecies species,
     Pool fineRoots)
 {
     fineRoots.Mass -= amount;
     fineRoots.ContentC -= (amount * SpeciesData.FRootFractionC[species]);
     fineRoots.ContentN -= (amount * SpeciesData.FRootFractionN[species]);
     fineRoots.ContentP -= (amount * SpeciesData.FRootFractionP[species]);
 }
 //---------------------------------------------------------------------
 /// <summary>
 /// Reduces the coarse root's biomass and nutrients by a specified amount.
 /// </summary>
 public static void ReduceCoarseRoots(double amount,
     ISpecies species,
     Pool coarseRoots)
 {
     coarseRoots.Mass -= amount;
     coarseRoots.ContentC -= (amount * SpeciesData.WoodFractionC[species]);
     coarseRoots.ContentN -= (amount * SpeciesData.WoodFractionN[species]);
     coarseRoots.ContentP -= (amount * SpeciesData.WoodFractionP[species]);
 }