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

        //public Species.AuxParm<Ecoregions.AuxParm<double>> EstablishProbabilities
        //{
        //    get {
        //        return establishProbs;
        //    }
        //}

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

        public InputParameters()
        {
            ecoregionDataset = PlugIn.ModelCore.Ecoregions;
            speciesDataset   = PlugIn.ModelCore.Species;

            //establishProbs = CreateSpeciesEcoregionParm<double>();
        }
Example #2
0
        //---------------------------------------------------------------------
        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        /// <param name="path">
        /// Path to the raster file that represents the map.
        /// </param>
        /// <param name="ecoregions">
        /// The dataset of ecoregions that are in the map.
        /// </param>
        /// <param name="rasterFactory">
        /// The raster factory to use to read the map.
        /// </param>
        public Map(string         path,
            IEcoregionDataset       ecoregions,
            IRasterFactory rasterFactory)
        {
            this.path = path;
            this.ecoregions = ecoregions;
            this.rasterFactory = rasterFactory;

            try
            {
                IInputRaster<EcoregionPixel> map = rasterFactory.OpenRaster<EcoregionPixel>(path);
                using (map)
                {
                    //this.metadata = map.Metadata;
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine("#### Internal error occurred within the program:");
                Console.WriteLine("  {0}", exc.Message);
                for (Exception innerException = exc.InnerException; innerException != null; innerException = innerException.InnerException)
                {
                    Console.WriteLine("  {0}", innerException.Message);
                }
            }
        }
Example #3
0
        //---------------------------------------------------------------------

        public ParametersParser()
        //: base(ecoregionDataset,
        //       speciesDataset)
        {
            this.ecoregionDataset = PlugIn.ModelCore.Ecoregions;
            this.speciesDataset   = PlugIn.ModelCore.Species;
        }
Example #4
0
        //---------------------------------------------------------------------
        ///<summary>
        ///Initialize an Epidemic - defined as an agent outbreak for an entire landscape
        ///at a single BDA timestep.  One epidemic per agent per BDA timestep
        ///</summary>

        public static void Initialize(IAgent agent)
        {
            PlugIn.ModelCore.Log.WriteLine("   Initializing agent {0}.", agent.AgentName);

            ecoregions = PlugIn.ModelCore.Ecoregions;


            //.ActiveSiteValues allows you to reset all active site at once.
            SiteVars.NeighborResourceDom.ActiveSiteValues = 0;
            SiteVars.Vulnerability.ActiveSiteValues       = 0;
            SiteVars.SiteResourceDomMod.ActiveSiteValues  = 0;
            SiteVars.SiteResourceDom.ActiveSiteValues     = 0;

            foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
            {
                if (agent.OutbreakZone[site] == Zone.Newzone)
                {
                    agent.OutbreakZone[site] = Zone.Lastzone;
                }
                else
                {
                    agent.OutbreakZone[site] = Zone.Nozone;
                }
            }
        }
        //---------------------------------------------------------------------
        //public Species.AuxParm<Ecoregions.AuxParm<double>> EstablishProbabilities
        //{
        //    get {
        //        return establishProbs;
        //    }
        //}
        //---------------------------------------------------------------------
        public InputParameters()
        {
            ecoregionDataset = PlugIn.ModelCore.Ecoregions;
            speciesDataset = PlugIn.ModelCore.Species;

            //establishProbs = CreateSpeciesEcoregionParm<double>();
        }
Example #6
0
        //---------------------------------------------------------------------

        private void TryParse(string filename,
                              int errorLineNum)
        {
            try {
                reader = OpenFile(filename);
                // This method is only called on bad files, so we expect the
                // statement below to throw an exception.  Since we knowingly
                // ignore the variable "dataset", disable the CS0219 warning
                // "The variable '...' is assigned but its value is never used'.
#pragma warning disable 0219
                IEcoregionDataset dataset = parser.Parse(reader);
#pragma warning restore 0219
            }
            catch (System.Exception e) {
                Data.Output.WriteLine(e.Message.Replace(Data.Directory, Data.DirPlaceholder));
                LineReaderException lrExc = e as LineReaderException;
                if (lrExc != null)
                {
                    Assert.AreEqual(errorLineNum, lrExc.LineNumber);
                }
                Data.Output.WriteLine();
                throw;
            }
            finally {
                reader.Close();
            }
        }
Example #7
0
        public void FullTable()
        {
            string            filename = "FullTable.txt";
            IEcoregionDataset dataset  = ParseFile(filename);

            CompareDatasetAndFile(dataset, filename);
        }
Example #8
0
        //---------------------------------------------------------------------

        private void CompareDatasetAndFile(IEcoregionDataset dataset,
                                           string filename)
        {
            FileLineReader file      = OpenFile(filename);
            InputLine      inputLine = new InputLine(file);

            InputVar <string> LandisData = new InputVar <string>(Landis.Data.InputVarName);

            inputLine.ReadVar(LandisData);

            int expectedIndex = 0;

            foreach (IEcoregion ecoregion in dataset)
            {
                Assert.AreEqual(expectedIndex, ecoregion.Index);
                expectedIndex++;

                Assert.IsTrue(inputLine.GetNext());
                currentLine = new StringReader(inputLine.ToString());

                Assert.AreEqual(ReadValue <bool>(), ecoregion.Active);
                Assert.AreEqual(ReadValue <byte>(), ecoregion.MapCode);
                Assert.AreEqual(ReadValue <string>(), ecoregion.Name);
                Assert.AreEqual(ReadValue <string>(), ecoregion.Description);
            }
            Assert.IsFalse(inputLine.GetNext());
            file.Close();
        }
Example #9
0
        //---------------------------------------------------------------------

        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        /// <param name="path">
        /// Path to the raster file that represents the map.
        /// </param>
        /// <param name="ecoregions">
        /// The dataset of ecoregions that are in the map.
        /// </param>
        /// <param name="rasterFactory">
        /// The raster factory to use to read the map.
        /// </param>
        public Map(string path,
                   IEcoregionDataset ecoregions,
                   IRasterFactory rasterFactory)
        {
            this.path          = path;
            this.ecoregions    = ecoregions;
            this.rasterFactory = rasterFactory;


            try
            {
                IInputRaster <EcoregionPixel> map = rasterFactory.OpenRaster <EcoregionPixel>(path);
                using (map)
                {
                    //this.metadata = map.Metadata;
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine("#### Internal error occurred within the program:");
                Console.WriteLine("  {0}", exc.Message);
                for (Exception innerException = exc.InnerException; innerException != null; innerException = innerException.InnerException)
                {
                    Console.WriteLine("  {0}", innerException.Message);
                }
            }
        }
        //---------------------------------------------------------------------

        public InputParametersParser()
        {
            this.ecoregionDataset = PlugIn.ModelCore.Ecoregions;
            this.speciesDataset   = PlugIn.ModelCore.Species;
            this.speciesLineNums  = new Dictionary <string, int>();
            this.speciesName      = new InputVar <string>("Species");
        }
 ///<Summary>
 /// Initializes a species and ecoregion specific parameter
 ///</Summary>
 public SpeciesEcoregionAuxParm(ISpeciesDataset speciesDataset, IEcoregionDataset ecoregionDataset)
 {
     values = new Parameters.Species.AuxParm <Parameters.Ecoregions.AuxParm <T> >(speciesDataset);
     foreach (ISpecies species in speciesDataset)
     {
         values[species] = new Parameters.Ecoregions.AuxParm <T>(ecoregionDataset);
     }
 }
Example #12
0
        //---------------------------------------------------------------------

        private IEcoregionDataset ParseFile(string filename)
        {
            reader = OpenFile(filename);
            IEcoregionDataset dataset = parser.Parse(reader);

            reader.Close();
            return(dataset);
        }
Example #13
0
        //---------------------------------------------------------------------

        public Parameters(IEcoregionDataset ecoregionDataset,
                          ISpeciesDataset speciesDataset)
        {
            this.ecoregionDataset = ecoregionDataset;
            this.speciesDataset   = speciesDataset;
            maxANPP    = CreateSpeciesEcoregionParm <int>();
            maxBiomass = CreateSpeciesEcoregionParm <int>();
        }
Example #14
0
        //---------------------------------------------------------------------
        ///<summary>
        ///Initialize an Epidemic - defined as an agent outbreak for an entire landscape
        ///at a single EDA timestep.  One epidemic per agent per EDA timestep
        ///</summary>

        public static void Initialize(IAgent agent)
        {
            PlugIn.ModelCore.UI.WriteLine("   Initializing agent {0}.", agent.AgentName);

            ecoregions = PlugIn.ModelCore.Ecoregions;

            //.ActiveSiteValues allows you to reset all active site at once.
            SiteVars.SiteHostIndexMod.ActiveSiteValues = 0;
            SiteVars.SiteHostIndex.ActiveSiteValues    = 0;
            SiteVars.FOI.ActiveSiteValues = 0;
        }
Example #15
0
        //---------------------------------------------------------------------

        /// <summary>
        /// Initializes a new instance using an input raster with ecoregion
        /// pixels.
        /// </summary>
        public InputGrid(IInputRaster <EcoregionPixel> raster,
                         IEcoregionDataset ecoregions)
            : base(raster.Dimensions.Rows,
                   raster.Dimensions.Columns)
        {
            this.raster     = raster;
            this.ecoregions = ecoregions;

            // Initialize pixel location so the next call to RowMajor.Next
            // will return upper-left location (1,1)
            this.pixelLocation = new Location(1, 0);
        }
Example #16
0
        //---------------------------------------------------------------------

        private void LoadEcoregions(string path)
        {
            ui.WriteLine("Loading ecoregions from file \"{0}\" ...", path);
            Ecoregions.DatasetParser parser = new Ecoregions.DatasetParser();
            ecoregions = Load <IEcoregionDataset>(path, parser);
        }
Example #17
0
        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        public Parameters(IEcoregionDataset ecoregionDataset,
                          ISpeciesDataset speciesDataset,
                          int litterCnt, int functionalCnt)
            : base(ecoregionDataset,
                   speciesDataset)
        {
            this.speciesDataset   = speciesDataset;
            this.ecoregionDataset = ecoregionDataset;

            functionalTypes        = new FunctionalTypeTable(functionalCnt);
            fireReductionsTable    = new FireReductions[6];
            harvestReductionsTable = new List <HarvestReductions>();

            sppFunctionalType = new Species.AuxParm <int>(speciesDataset);
            nFixer            = new Species.AuxParm <bool>(speciesDataset);
            gddMin            = new Species.AuxParm <int>(speciesDataset);
            gddMax            = new Species.AuxParm <int>(speciesDataset);
            minJanTemp        = new Species.AuxParm <int>(speciesDataset);
            maxDrought        = new Species.AuxParm <double>(speciesDataset);
            leafLongevity     = new Species.AuxParm <double>(speciesDataset);
            epicormic         = new Species.AuxParm <bool>(speciesDataset);
            leafLignin        = new Species.AuxParm <double>(speciesDataset);
            woodLignin        = new Species.AuxParm <double>(speciesDataset);
            coarseRootLignin  = new Species.AuxParm <double>(speciesDataset);
            fineRootLignin    = new Species.AuxParm <double>(speciesDataset);
            leafCN            = new Species.AuxParm <double>(speciesDataset);
            woodCN            = new Species.AuxParm <double>(speciesDataset);
            coarseRootCN      = new Species.AuxParm <double>(speciesDataset);
            foliageLitterCN   = new Species.AuxParm <double>(speciesDataset);
            fineRootCN        = new Species.AuxParm <double>(speciesDataset);

            minRelativeBiomass = new Ecoregions.AuxParm <Percentage> [6];
            for (byte shadeClass = 1; shadeClass <= 5; shadeClass++)
            {
                minRelativeBiomass[shadeClass] = new Ecoregions.AuxParm <Percentage>(ecoregionDataset);
            }
            sufficientLight = new List <ISufficientLight>();

            percentClay       = new Ecoregions.AuxParm <double>(ecoregionDataset);
            percentSand       = new Ecoregions.AuxParm <double>(ecoregionDataset);
            soilDepth         = new Ecoregions.AuxParm <int>(ecoregionDataset);
            fieldCapacity     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            wiltingPoint      = new Ecoregions.AuxParm <double>(ecoregionDataset);
            stormFlowFraction = new Ecoregions.AuxParm <double>(ecoregionDataset);
            baseFlowFraction  = new Ecoregions.AuxParm <double>(ecoregionDataset);
            drain             = new Ecoregions.AuxParm <double>(ecoregionDataset);
            atmosNslope       = new Ecoregions.AuxParm <double>(ecoregionDataset);
            atmosNintercept   = new Ecoregions.AuxParm <double>(ecoregionDataset);
            latitude          = new Ecoregions.AuxParm <double>(ecoregionDataset);
            decayRateSurf     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            decayRateSOM1     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            decayRateSOM2     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            decayRateSOM3     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            denitrif          = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM1surfC     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM1surfN     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM1soilC     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM1soilN     = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM2C         = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM2N         = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM3C         = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initSOM3N         = new Ecoregions.AuxParm <double>(ecoregionDataset);
            initMineralN      = new Ecoregions.AuxParm <double>(ecoregionDataset);


            this.dynamicUpdates = new List <Dynamic.ParametersUpdate>();
        }
        //---------------------------------------------------------------------
        ///<summary>
        ///Initialize an Epidemic - defined as an agent outbreak for an entire landscape
        ///at a single BDA timestep.  One epidemic per agent per BDA timestep
        ///</summary>

        public static void Initialize(IAgent agent)
        {
            PlugIn.ModelCore.Log.WriteLine("   Initializing agent {0}.", agent.AgentName);

            ecoregions = PlugIn.ModelCore.Ecoregions;


            //.ActiveSiteValues allows you to reset all active site at once.
            SiteVars.NeighborResourceDom.ActiveSiteValues = 0;
            SiteVars.Vulnerability.ActiveSiteValues = 0;
            SiteVars.SiteResourceDomMod.ActiveSiteValues = 0;
            SiteVars.SiteResourceDom.ActiveSiteValues = 0;

            foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
            {
                if(agent.OutbreakZone[site] == Zone.Newzone)
                    agent.OutbreakZone[site] = Zone.Lastzone;
                else
                    agent.OutbreakZone[site] = Zone.Nozone;
            }

        }
Example #19
0
        //---------------------------------------------------------------------

        public static Landis.Library.Biomass.Species.AuxParm <Landis.Library.Biomass.Ecoregions.AuxParm <T> > CreateSpeciesEcoregionParm <T>(ISpeciesDataset speciesDataset, IEcoregionDataset ecoregionDataset)
        {
            Landis.Library.Biomass.Species.AuxParm <Landis.Library.Biomass.Ecoregions.AuxParm <T> > newParm;
            newParm = new Landis.Library.Biomass.Species.AuxParm <Landis.Library.Biomass.Ecoregions.AuxParm <T> >(speciesDataset);
            foreach (ISpecies species in speciesDataset)
            {
                newParm[species] = new Landis.Library.Biomass.Ecoregions.AuxParm <T>(ecoregionDataset);
            }
            return(newParm);
        }
Example #20
0
 public static Species.AuxParm <Ecoregions.AuxParm <T> > CreateSpeciesEcoregionParm <T>(ISpeciesDataset speciesDataset, IEcoregionDataset ecoregionDataset)
 {
     Species.AuxParm <Ecoregions.AuxParm <T> > newParm;
     newParm = new Species.AuxParm <Ecoregions.AuxParm <T> >(speciesDataset);
     foreach (ISpecies species in speciesDataset)
     {
         newParm[species] = new Ecoregions.AuxParm <T>(ecoregionDataset);
     }
     return(newParm);
 }
Example #21
0
        //---------------------------------------------------------------------

        public AuxParm(IEcoregionDataset ecoregions)
        {
            values = new T[ecoregions.Count];
        }
Example #22
0
        public void EmptyTable()
        {
            IEcoregionDataset dataset = ParseFile("EmptyTable.txt");

            Assert.AreEqual(0, dataset.Count);
        }