public void Init()
        {
            intVar = new InputVar<int>("intVar");

            values = new int[] { -4, 78900, 0, 555 };
            string[] valsAsStrs = Array.ConvertAll(values,
                                                   new Converter<int, string>(Convert.ToString));
            valuesAsStr = string.Join(" ", valsAsStrs);
        }
        //---------------------------------------------------------------------

        protected override void ReadBiomassMaps()
        {
            // TO DO: Probably should be required in the final release but made
            // it optional for now so that CBI doesn't have to update every
            // scenario in the short term.
            InputVar<string> biomassMapNames = new InputVar<string>("BiomassMaps");
            string foo;
            if (ReadOptionalVar(biomassMapNames))
                foo /*parameters.BiomassMapNames*/ = biomassMapNames.Value;
        }
        //---------------------------------------------------------------------

        protected InputValue <ISiteSelector> ReadSiteSelector(StringReader reader,
                                                              out int index)
        {
            TextReader.SkipWhitespace(reader);
            index = reader.Index;
            string name = TextReader.ReadWord(reader);

            if (name == "")
            {
                throw new InputValueException();  // Missing value
            }
            ISiteSelector selector;
            StringBuilder valueAsStr = new StringBuilder(name);

            //  Site selection -- Complete stand
            if (name == SiteSelection.Complete)
            {
                selector = new CompleteStand();
            }
            //  Site selection -- Target size with partial or complete spread

            else if (name == SiteSelection.CompleteAndSpreading || name == SiteSelection.TargetAndSpreading)
            {
                InputVar <double> minTargetSize = new InputVar <double>("the minimum target harvest size");
                ReadValue(minTargetSize, reader);

                InputVar <double> maxTargetSize = new InputVar <double>("the maximum target harvest size");
                ReadValue(maxTargetSize, reader);


                //validate the target size for spreading algorithms
                StandSpreading.ValidateTargetSizes(minTargetSize.Value,
                                                   maxTargetSize.Value);

                if (name == SiteSelection.TargetAndSpreading)
                {
                    // Site selection -- partial spread
                    selector = new PartialStandSpreading(minTargetSize.Value.Actual,
                                                         maxTargetSize.Value.Actual);
                }
                else
                {
                    //  Site selection -- complete stand
                    selector = new CompleteStandSpreading(minTargetSize.Value.Actual,
                                                          maxTargetSize.Value.Actual);
                }
                valueAsStr.AppendFormat(" {0}", minTargetSize.Value.String);
                valueAsStr.AppendFormat(" {0}", maxTargetSize.Value.String);
            }

            //  Site selection -- Patch cutting
            else if (name == SiteSelection.Patch)
            {
                InputVar <Percentage> percentage = new InputVar <Percentage>("the site percentage for patch cutting");
                ReadValue(percentage, reader);
                PatchCutting.ValidatePercentage(percentage.Value);

                InputVar <double> size = new InputVar <double>("the target patch size");
                ReadValue(size, reader);
                PatchCutting.ValidateSize(size.Value);

                // priority is an optional value so we can't use ReadValue
                TextReader.SkipWhitespace(reader);
                index = reader.Index;
                string priority = TextReader.ReadWord(reader);

                selector = new PatchCutting(percentage.Value.Actual, size.Value.Actual, priority);
                valueAsStr.AppendFormat(" {0} {1} {2}", percentage.Value.String,
                                        size.Value.String,
                                        priority);
            }

            else
            {
                string[] methodList = new string[] { "Site selection methods:",
                                                     "  " + SiteSelection.Complete,
                                                     "  " + SiteSelection.CompleteAndSpreading,
                                                     "  " + SiteSelection.TargetAndSpreading,
                                                     "  " + SiteSelection.Patch };
                throw new InputValueException(name,
                                              name + " is not a valid site selection method",
                                              new MultiLineText(methodList));
            }
            return(new InputValue <ISiteSelector>(selector, valueAsStr.ToString()));
        }
        //---------------------------------------------------------------------

        protected IStandRankingMethod ReadRankingMethod()
        {
            //1. read which ranking method is chosen- eg. Random and MaxCohortAge
            //2. check for optional ranking requirements- eg. minimumAge and maximumAge
            //3. form rankingMethod and return it.

            InputVar <string> rankingName = new InputVar <string>("StandRanking");

            ReadVar(rankingName);

            IStandRankingMethod rankingMethod;

            if (rankingName.Value.Actual == "Economic")
            {
                rankingMethod = new EconomicRank(ReadEconomicRankTable());
            }
            else if (rankingName.Value.Actual == "MaxCohortAge")
            {
                rankingMethod = new MaxCohortAge();
            }
            else if (rankingName.Value.Actual == "Random")
            {
                rankingMethod = new RandomRank();
            }
            else if (rankingName.Value.Actual == "RegulateAges")
            {
                rankingMethod = new RegulateAgesRank();
            }
            else if (rankingName.Value.Actual == "FireHazard")
            {
                rankingMethod = new FireRiskRank(ReadFireRiskTable());
            }

            ////list of ranking methods which have not been implemented yet
            //else if ((rankingName.Value.Actual == "SpeciesBiomass") ||
            //        (rankingName.Value.Actual == "TotalBiomass")) {
            //    throw new InputValueException(rankingName.Value.String,
            //                                  rankingName.Value.String + " is not implemented yet");
            //}

            else
            {
                string[] methodList = new string[] { "Stand ranking methods:",
                                                     "  Economic",
                                                     "  MaxCohortAge",
                                                     "  Random",
                                                     "  RegulateAges",
                                                     "  FireRisk" };
                throw new InputValueException(rankingName.Value.String,
                                              rankingName.Value.String + " is not a valid stand ranking",
                                              new MultiLineText(methodList));
            }

            //  Read optional ranking requirements

            ushort?           minAge     = null;
            InputVar <ushort> minimumAge = new InputVar <ushort>("MinimumAge");

            if (ReadOptionalVar(minimumAge))
            {
                //get minAge
                minAge = minimumAge.Value.Actual;
                //add the minimumAge ranking requirement to this ranking method.
                rankingMethod.AddRequirement(new MinimumAge(minAge.Value));
            }

            InputVar <ushort> maximumAge = new InputVar <ushort>("MaximumAge");

            if (ReadOptionalVar(maximumAge))
            {
                //get maxAge
                ushort maxAge = maximumAge.Value.Actual;
                //throw exception if maxAge < minAge
                if (minAge.HasValue && maxAge < minAge)
                {
                    throw new InputValueException(maximumAge.Value.String,
                                                  "{0} is < minimum age ({1})",
                                                  maximumAge.Value.String,
                                                  minimumAge.Value.String);
                }
                //add the maximumAge ranking requirement to this ranking method.
                rankingMethod.AddRequirement(new MaximumAge(maxAge));
            }

            //stand adjacency variables and constraints
            InputVar <ushort> standAdjacency            = new InputVar <ushort>("StandAdjacency");
            InputVar <string> adjacencyType             = new InputVar <string>("AdjacencyType");
            InputVar <ushort> adjacencyNeighborSetAside = new InputVar <ushort>("AdjacencyNeighborSetAside");

            //if stand-adjacency is defined, check flags
            if (ReadOptionalVar(standAdjacency))
            {
                //get adjacency-type
                ushort adjacency = standAdjacency.Value.Actual;
                ReadVar(adjacencyType);

                if (adjacencyType.Value.String != "StandAge" && adjacencyType.Value.String != "MinimumTimeSinceLastHarvest")
                {
                    string[] methodList = new string[] { "AdjacencyType methods:",
                                                         "    StandAge",
                                                         "    TimeSinceLastHarvested" };
                    throw new InputValueException(adjacencyType.Value.String,
                                                  adjacencyType.Value.String + " is not a valid site selection method",
                                                  new MultiLineText(methodList));
                }
                string ad_type = adjacencyType.Value.String;

                //get set-aside var if defined
                ushort set_aside = 0;
                if (ReadOptionalVar(adjacencyNeighborSetAside))
                {
                    //Model.Core.UI.WriteLine("adjacencyNeighborSetAside = {0}", adjacencyNeighborSetAside.Value.Actual);
                    set_aside = adjacencyNeighborSetAside.Value.Actual;
                }
                //add stand-adjacency to list of ranking requirements
                rankingMethod.AddRequirement(new StandAdjacency(adjacency, ad_type, set_aside));
            }


            InputVar <ushort> spatialArrangement = new InputVar <ushort>("SpatialArrangement");

            if (ReadOptionalVar(spatialArrangement))
            {
                //get minimum age requirement
                ushort s_minAge = spatialArrangement.Value.Actual;
                //add ranking requirement for neighbor stands to be at least of minimum age (defined by s_minAge)
                rankingMethod.AddRequirement(new SpatialArrangement(s_minAge));
            }

            InputVar <ushort> minimumTimeSinceLastHarvest = new InputVar <ushort>("MinimumTimeSinceLastHarvest");

            if (ReadOptionalVar(minimumTimeSinceLastHarvest))
            {
                //get minimum time requirement
                ushort min_time = minimumTimeSinceLastHarvest.Value.Actual;
                //add requirement for this stand to have not been harvested within the minimum
                //time ranking requirement specified (defined by min_time)
                rankingMethod.AddRequirement(new MinTimeSinceLastHarvest(min_time));
            }

            return(rankingMethod);
        }
Exemple #5
0
        //---------------------------------------------------------------------

        protected override IInputParameters Parse()
        {
            InputVar <string> landisData = new InputVar <string>("LandisData");

            ReadVar(landisData);
            if (landisData.Value.Actual != PlugIn.PlugInName)
            {
                throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", PlugIn.PlugInName);
            }

            InputParameters parameters = new InputParameters(SpeciesDataset.Count);

            InputVar <int> timestep = new InputVar <int>("Timestep");

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            InputVar <int> outputTimestep = new InputVar <int>("OutputTimestep");

            ReadVar(outputTimestep);
            parameters.OutputTimestep = outputTimestep.Value;

            // Template for filenames of reclass maps

            InputVar <string> mapFileNames = new InputVar <string>("MapFileNames");

            ReadVar(mapFileNames);
            parameters.MapFileNames = mapFileNames.Value;


            InputVar <string> speciesName = new InputVar <string>("Species");

            Dictionary <string, int> lineNumbers = new Dictionary <string, int>();

            //  Read list of Suitability Files
            InputVar <string> suitabilityFile = new InputVar <string>("SuitabilityFiles");

            ReadVar(suitabilityFile);

            List <ISuitabilityParameters>   suitabilityParameterList = new List <ISuitabilityParameters>();
            SuitabilityFileParametersParser suitabilityParser        = new SuitabilityFileParametersParser();

            ISuitabilityParameters suitabilityParameters = Landis.Data.Load <ISuitabilityParameters>(suitabilityFile.Value, suitabilityParser);

            suitabilityParameterList.Add(suitabilityParameters);
            parameters.SuitabilityFiles.Add(suitabilityFile.Name);

            while (!AtEndOfInput)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(suitabilityFile, currentLine);
                CheckForRepeatedName(suitabilityFile.Value, "suitability file", lineNumbers);

                suitabilityParameters = Landis.Data.Load <ISuitabilityParameters>(suitabilityFile.Value, suitabilityParser);
                suitabilityParameterList.Add(suitabilityParameters);
                parameters.SuitabilityFiles.Add(suitabilityFile.Name);

                GetNextLine();
            }
            parameters.SuitabilityParameters = suitabilityParameterList;

            CheckNoDataAfter(string.Format("the {0} parameter", "SuitabilityFiles"));

            return(parameters); //.GetComplete();
        }
Exemple #6
0
        //---------------------------------------------------------------------

        protected override Dictionary <int, IDynamicInputRecord[, ]> Parse()
        {
            //InputVar<string> landisData = new InputVar<string>("LandisData");
            //ReadVar(landisData);
            //if (landisData.Value.Actual != FileName)
            //    throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", PlugIn.ExtensionName);
            ReadLandisDataVar();


            Dictionary <int, IDynamicInputRecord[, ]> allData = new Dictionary <int, IDynamicInputRecord[, ]>();

            //---------------------------------------------------------------------
            //Read in climate data:
            InputVar <int>    year          = new InputVar <int>("Time step for updating values");
            InputVar <string> ecoregionName = new InputVar <string>("Ecoregion Name");
            InputVar <string> speciesName   = new InputVar <string>("Species Name");
            InputVar <double> pest          = new InputVar <double>("Probability of Establishment");
            InputVar <int>    anpp          = new InputVar <int>("ANPP");
            InputVar <int>    bmax          = new InputVar <int>("Maximum Biomass");

            while (!AtEndOfInput)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(year, currentLine);
                int yr = year.Value.Actual;

                if (!allData.ContainsKey(yr))
                {
                    IDynamicInputRecord[,] inputTable = new IDynamicInputRecord[PlugIn.ModelCore.Species.Count, PlugIn.ModelCore.Ecoregions.Count];
                    allData.Add(yr, inputTable);
                    PlugIn.ModelCore.UI.WriteLine("  Dynamic Input Parser:  Add new year = {0}.", yr);
                }

                ReadValue(ecoregionName, currentLine);

                IEcoregion ecoregion = GetEcoregion(ecoregionName.Value);

                ReadValue(speciesName, currentLine);

                ISpecies species = GetSpecies(speciesName.Value);

                IDynamicInputRecord dynamicInputRecord = new DynamicInputRecord();

                ReadValue(pest, currentLine);
                dynamicInputRecord.ProbEst = pest.Value;

                ReadValue(anpp, currentLine);
                dynamicInputRecord.ANPP_MAX_Spp = anpp.Value;

                ReadValue(bmax, currentLine);
                dynamicInputRecord.B_MAX_Spp = bmax.Value;

                allData[yr][species.Index, ecoregion.Index] = dynamicInputRecord;

                CheckNoDataAfter("the " + bmax.Name + " column",
                                 currentLine);

                GetNextLine();
            }

            return(allData);
        }
        //---------------------------------------------------------------------

        new protected InputValue<ISiteSelector> ReadSiteSelector(StringReader reader,
                                                                 out int      index)
        {
            TextReader.SkipWhitespace(reader);
            index = reader.Index;
            string name = TextReader.ReadWord(reader);
            if (name == "")
                throw new InputValueException();  // Missing value

            ISiteSelector selector;
            StringBuilder valueAsStr = new StringBuilder(name);
            //  Site selection -- Complete stand
            if (name == SiteSelection.Complete) {
                selector = new CompleteStand();
            }
            //  Site selection -- Target size with partial or complete spread
            else if (name == SiteSelection.CompleteAndSpreading || name == SiteSelection.TargetAndSpreading) {
                
                InputVar<double> minTargetSize = new InputVar<double>("the minimum target harvest size");
                ReadValue(minTargetSize, reader);

                InputVar<double> maxTargetSize = new InputVar<double>("the maximum target harvest size");
                ReadValue(maxTargetSize, reader);


                //validate the target size for spreading algorithms
                StandSpreading.ValidateTargetSizes(minTargetSize.Value, maxTargetSize.Value);
                standSpreadMinTargetSize = minTargetSize.Value;
                standSpreadMaxTargetSize = maxTargetSize.Value;
                
                
                if (name == SiteSelection.TargetAndSpreading) {
                    // Site selection -- partial spread
                    selector = new PartialStandSpreading(minTargetSize.Value.Actual,
                        maxTargetSize.Value.Actual);
                }
                else {
                    //  Site selection -- complete stand
                    selector = new CompleteStandSpreading(minTargetSize.Value.Actual,
                    maxTargetSize.Value.Actual);

                }
                valueAsStr.AppendFormat(" {0}", minTargetSize.Value.String);
                valueAsStr.AppendFormat(" {0}", maxTargetSize.Value.String);


                //validate the target size for spreading algorithms
                //StandSpreading.ValidateTargetSize(targetSize.Value);
                //standSpreadTargetSize = targetSize.Value;

                //if (name == SiteSelection.TargetAndSpreading) {
                    //  Site selection -- partial spread
                //    selector = new PartialStandSpreading(targetSize.Value.Actual);
                //}
                //else {
                    //  Site selection -- complete stand
                //    selector = new CompleteStandSpreading(targetSize.Value.Actual);
                //}
                //valueAsStr.AppendFormat(" {0}", targetSize.Value.String);

            }
            
            //  Site selection -- Patch cutting
            else if (name == SiteSelection.Patch) {
                InputVar<Percentage> percentage = new InputVar<Percentage>("the site percentage for patch cutting");
                ReadValue(percentage, reader);
                PatchCutting.ValidatePercentage(percentage.Value);

                InputVar<double> size = new InputVar<double>("the target patch size");
                ReadValue(size, reader);
                PatchCutting.ValidateSize(size.Value);

                selector = new PatchCutting(percentage.Value.Actual, size.Value.Actual);
                valueAsStr.AppendFormat(" {0} {1}", percentage.Value.String,
                                                    size.Value.String);
            }
            
            else {
                string[] methodList = new string[]{"Site selection methods:",
                                                   "  " + SiteSelection.Complete,
                                                   "  " + SiteSelection.CompleteAndSpreading,
                                                   "  " + SiteSelection.TargetAndSpreading,
                                                   "  " + SiteSelection.Patch};
                throw new InputValueException(name,
                                              name + " is not a valid site selection method",
                                              new MultiLineText(methodList));
            }
            return new InputValue<ISiteSelector>(selector, valueAsStr.ToString());
        }
        //---------------------------------------------------------------------

        // Since this class derives from Base Harvest's parser, then the Parse
        // method below must return Base Harvest's interface to the parameters.
        // But the method uses Biomass Harvest's class for editable parameters,
        // so that the new BiomassMaps parameter can be read and validated.
        // The method returns an instance of Biomass Harvest's Parameters, so
        // the caller must cast the reference to Biomass Harvest's parameters
        // interface in order to access the new BiomassMaps parameter.
        protected override BaseHarvest.IInputParameters Parse()
        {
            RoundedRepeatIntervals.Clear();

            ReadLandisDataVar();

            Parameters parameters = new Parameters();

            InputVar<int> timestep = new InputVar<int>("Timestep");
            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            InputVar<string> mgmtAreaMap = new InputVar<string>("ManagementAreas");
            ReadVar(mgmtAreaMap);
            parameters.ManagementAreaMap = mgmtAreaMap.Value;
            
            InputVar<string> standMap = new InputVar<string>("Stands");
            ReadVar(standMap);
            parameters.StandMap = standMap.Value;

            ReadPrescriptions(parameters.Prescriptions, timestep.Value.Actual);

            ReadHarvestImplementations(parameters.ManagementAreas, parameters.Prescriptions);
                                       
                                       
            //  Output file parameters

            InputVar<string> prescriptionMapNames = new InputVar<string>(Names.PrescriptionMaps);
            ReadVar(prescriptionMapNames);
            parameters.PrescriptionMapNames = prescriptionMapNames.Value;

            // TO DO: Probably should be required in the final release but made
            // it optional for now so that CBI doesn't have to update every
            // scenario in the short term.
            InputVar<string> biomassMapNames = new InputVar<string>("BiomassMaps");
            if (ReadOptionalVar(biomassMapNames))
                parameters.BiomassMapNames = biomassMapNames.Value;

            InputVar<string> eventLogFile = new InputVar<string>("EventLog");
            ReadVar(eventLogFile);
            parameters.EventLog = eventLogFile.Value;

            InputVar<string> summaryLogFile = new InputVar<string>("SummaryLog");
            ReadVar(summaryLogFile);
            parameters.SummaryLog = summaryLogFile.Value;

            CheckNoDataAfter("the " + summaryLogFile.Name + " parameter");
            return parameters; 
        }
 //---------------------------------------------------------------------
 /// <summary>
 /// Puts filename for BiomassMaps into the parameters
 /// </summary>
 /// <remarks>
 /// This overrides the base method in harvest-mgmt-lib
 /// </remarks>
 protected override void ReadBiomassMaps(InputParameters baseParameters)
 {
     InputVar<string> biomassMapNames = new InputVar<string>("BiomassMaps");
     if (ReadOptionalVar(biomassMapNames))
     {
         // Get the biomass harvest implementation of the InputParameters so we can set the biomassMaps property
         Parameters parameters = baseParameters as Parameters;
         parameters.BiomassMapNames = biomassMapNames.Value;
     }
 }
        //---------------------------------------------------------------------

        protected override IInputParameters Parse()
        {
            InputVar <string> landisData = new InputVar <string>("LandisData");

            ReadVar(landisData);
            if (landisData.Value.Actual != PlugIn.ExtensionName)
            {
                throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", PlugIn.ExtensionName);
            }

            InputParameters parameters = new InputParameters();

            InputVar <int> timestep = new InputVar <int>("Timestep");

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            //----------------------------------------------------------
            // Read in Maps and Log file names.

            // - infection status (0=Susceptible;1=Infected;2=Diseased). -
            InputVar <string> statusMapNames = new InputVar <string>("MapNames");

            ReadVar(statusMapNames);
            parameters.StatusMapNames = statusMapNames.Value; //check why this is different from others below

            // - mortality -
            InputVar <string> mortMapNames = new InputVar <string>("MORTMapNames");

            try
            {
                ReadVar(mortMapNames);
                parameters.MortMapNames = mortMapNames.Value;
            }
            catch (LineReaderException errString)
            {
                if (!(errString.MultiLineMessage[1].Contains("Found the name \"EPDMapNames\" but expected \"MORTMapNames\"")))
                {
                    throw errString;
                }
            }

            // - logfile -
            InputVar <string> logFile = new InputVar <string>("LogFile");

            ReadVar(logFile);
            parameters.LogFileName = logFile.Value;

            //----------------------------------------------------------
            // Last, read in Agent File names,
            // then parse the data in those files into agent parameters.

            InputVar <string> agentFileName = new InputVar <string>("EDAInputFiles");

            ReadVar(agentFileName);

            List <IAgent>        agentParameterList = new List <IAgent>();
            AgentParameterParser agentParser        = new AgentParameterParser();

            IAgent agentParameters = Landis.Data.Load <IAgent>(agentFileName.Value, agentParser);

            agentParameterList.Add(agentParameters);

            while (!AtEndOfInput)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(agentFileName, currentLine);

                agentParameters = Landis.Data.Load <IAgent>(agentFileName.Value, agentParser);

                agentParameterList.Add(agentParameters);

                GetNextLine();
            }

            foreach (IAgent activeAgent in agentParameterList)
            {
                if (agentParameters == null)
                {
                    PlugIn.ModelCore.UI.WriteLine("PARSE:  Agent Parameters NOT loading correctly.");
                }
                else
                {
                    PlugIn.ModelCore.UI.WriteLine("Name of Agent = {0}", agentParameters.AgentName);
                }
            }
            parameters.ManyAgentParameters = agentParameterList;

            return(parameters); //.GetComplete();
        }
        //---------------------------------------------------------------------

        /// <summary>
        /// Reads a list of species and their cohorts that should be removed.
        /// </summary>
        protected ICohortSelector ReadSpeciesAndCohorts(params string[] names)
        {
            List <string> namesThatFollow;

            if (names == null)
            {
                namesThatFollow = new List <string>();
            }
            else
            {
                namesThatFollow = new List <string>(names);
            }

            cohortSelector = new MultiSpeciesCohortSelector();
            SpeciesLineNumbers.Clear();

            while (!AtEndOfInput && !namesThatFollow.Contains(CurrentName))
            {
                StringReader currentLine = new StringReader(CurrentLine);

                // Species name
                ISpecies species = ReadSpecies(currentLine);

                //  Cohort keyword, cohort age or cohort age range
                //  keyword = (All, Youngest, AllExceptYoungest, Oldest,
                //             AllExceptOldest, 1/{N})
                TextReader.SkipWhitespace(currentLine);
                int    indexOfDataAfterSpecies = currentLine.Index;
                string word = TextReader.ReadWord(currentLine);
                if (word == "")
                {
                    throw NewParseException("No cohort keyword, age or age range after the species name");
                }

                bool foundKeyword = false;
                if (keywordsEnabled)
                {
                    if (word == "All")
                    {
                        cohortSelector[species] = SelectCohorts.All;
                        foundKeyword            = true;
                    }
                    else if (word == "Youngest")
                    {
                        cohortSelector[species] = SelectCohorts.Youngest;
                        foundKeyword            = true;
                    }
                    else if (word == "AllExceptYoungest")
                    {
                        cohortSelector[species] = SelectCohorts.AllExceptYoungest;
                        foundKeyword            = true;
                    }
                    else if (word == "Oldest")
                    {
                        cohortSelector[species] = SelectCohorts.Oldest;
                        foundKeyword            = true;
                    }
                    else if (word == "AllExceptOldest")
                    {
                        cohortSelector[species] = SelectCohorts.AllExceptOldest;
                        foundKeyword            = true;
                    }
                    else if (word.StartsWith("1/"))
                    {
                        InputVar <ushort> N = new InputVar <ushort>("1/N");
                        N.ReadValue(new StringReader(word.Substring(2)));
                        if (N.Value.Actual == 0)
                        {
                            throw NewParseException("For \"1/N\", N must be > 0");
                        }
                        cohortSelector[species] = new EveryNthCohort(N.Value.Actual).SelectCohorts;
                        foundKeyword            = true;
                    }
                }

                if (foundKeyword)
                {
                    CheckNoDataAfter("the keyword \"" + word + "\"", currentLine);
                }
                else
                {
                    //  Read one or more ages or age ranges
                    List <ushort>   ages   = new List <ushort>();
                    List <AgeRange> ranges = new List <AgeRange>();
                    currentLine = new StringReader(CurrentLine.Substring(indexOfDataAfterSpecies));
                    InputVar <AgeRange> ageOrRange = new InputVar <AgeRange>("Age or Age Range");
                    while (currentLine.Peek() != -1)
                    {
                        ReadValue(ageOrRange, currentLine);
                        ValidateAgeOrRange(ageOrRange.Value, ages, ranges);
                        TextReader.SkipWhitespace(currentLine);
                    }
                    CreateCohortSelectionMethodFor(species, ages, ranges);
                }

                GetNextLine();
            }

            if (SpeciesLineNumbers.Count == 0)
            {
                throw NewParseException("Expected a line starting with a species name");
            }

            return(cohortSelector);
        }
Exemple #12
0
        //---------------------------------------------------------------------

        protected override IParameters Parse()
        {
            ReadLandisDataVar();

            EditableParameters parameters = new EditableParameters(SpeciesDataset.Count);

            InputVar <int> timestep = new InputVar <int>("Timestep");

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            // Table of reclass coefficients

            InputVar <string> speciesName  = new InputVar <string>("Species");
            InputVar <double> reclassCoeff = new InputVar <double>("Reclass Coefficient");

            Dictionary <string, int> lineNumbers = new Dictionary <string, int>();

            const string ReclassMaps = "ReclassMaps";

            while (!AtEndOfInput && CurrentName != ReclassMaps)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(speciesName, currentLine);
                ISpecies species = GetSpecies(speciesName.Value);
                CheckForRepeatedName(speciesName.Value, "species", lineNumbers);

                ReadValue(reclassCoeff, currentLine);
                parameters.ReclassCoefficients[species.Index] = reclassCoeff.Value;

                CheckNoDataAfter(string.Format("the {0} column", reclassCoeff.Name),
                                 currentLine);
                GetNextLine();
            }

            //  Read definitions of reclass maps

            ReadName(ReclassMaps);

            InputVar <string> mapName    = new InputVar <string>("Map Name");
            InputVar <string> forestType = new InputVar <string>("Forest Type");

            lineNumbers.Clear();
            Dictionary <string, int> forestTypeLineNumbers = new Dictionary <string, int>();

            const string MapFileNames  = "MapFileNames";
            const string nameDelimiter = "->";              // delimiter that separates map name and forest type

            IEditableMapDefinition mapDefn = null;

            while (!AtEndOfInput && CurrentName != MapFileNames)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                //	If the current line has the delimiter, then read the map
                //	name.
                if (CurrentLine.Contains(nameDelimiter))
                {
                    ReadValue(mapName, currentLine);
                    CheckForRepeatedName(mapName.Value, "map name", lineNumbers);

                    mapDefn      = new EditableMapDefinition();
                    mapDefn.Name = mapName.Value;
                    parameters.ReclassMaps.Add(mapDefn);

                    TextReader.SkipWhitespace(currentLine);
                    string word = TextReader.ReadWord(currentLine);
                    if (word != nameDelimiter)
                    {
                        throw NewParseException("Expected \"{0}\" after the map name {1}.",
                                                nameDelimiter, mapName.Value.String);
                    }

                    forestTypeLineNumbers.Clear();
                }
                else
                {
                    //	If there is no name delimiter and we don't have the
                    //	name for the first map yet, then it's an error.
                    if (mapDefn == null)
                    {
                        throw NewParseException("Expected a line with map name followed by \"{0}\"", nameDelimiter);
                    }
                }

                ReadValue(forestType, currentLine);
                CheckForRepeatedName(forestType.Value, "forest type",
                                     forestTypeLineNumbers);

                IEditableForestType currentForestType = new EditableForestType(SpeciesDataset.Count);
                currentForestType.Name = forestType.Value;
                mapDefn.ForestTypes.Add(currentForestType);

                //	Read species for forest types

                List <string> speciesNames = new List <string>();

                TextReader.SkipWhitespace(currentLine);
                while (currentLine.Peek() != -1)
                {
                    ReadValue(speciesName, currentLine);
                    string name = speciesName.Value.Actual;
                    bool   negativeMultiplier = name.StartsWith("-");
                    if (negativeMultiplier)
                    {
                        name = name.Substring(1);
                        if (name.Length == 0)
                        {
                            throw new InputValueException(speciesName.Value.String,
                                                          "No species name after \"-\"");
                        }
                    }
                    ISpecies species = GetSpecies(new InputValue <string>(name, speciesName.Value.String));
                    if (speciesNames.Contains(species.Name))
                    {
                        throw NewParseException("The species {0} appears more than once.", species.Name);
                    }
                    speciesNames.Add(species.Name);

                    currentForestType[species.Index] = negativeMultiplier ? -1 : 1;

                    TextReader.SkipWhitespace(currentLine);
                }
                if (speciesNames.Count == 0)
                {
                    throw NewParseException("At least one species is required.");
                }

                GetNextLine();
            }

            // Template for filenames of reclass maps

            InputVar <string> mapFileNames = new InputVar <string>(MapFileNames);

            ReadVar(mapFileNames);
            parameters.MapFileNames = mapFileNames.Value;

            CheckNoDataAfter(string.Format("the {0} parameter", MapFileNames));

            return(parameters.GetComplete());
        }
        //---------------------------------------------------------------------
        protected override Dictionary <string, Parameter <string> > Parse()
        {
            try
            {
                Dictionary <string, Parameter <string> > parameters = new Dictionary <string, Parameter <string> >(StringComparer.InvariantCultureIgnoreCase);

                InputVar <string> landisData = new InputVar <string>("LandisData");
                ReadVar(landisData);

                if (landisData.Value.Actual != this.KeyWord)
                {
                    throw new InputValueException(landisData.Value.String, "Landis Keyword expected " + this.KeyWord + " but read \"{0}\"" + this.FileName, landisData.Value.Actual);
                }

                string line = new StringReader(CurrentLine).ReadLine().Trim();

                while (line.Length == 0)
                {
                    GetNextLine();
                }

                List <string> ReadHeaderLabels = new List <string>(line.Split((char[])null, System.StringSplitOptions.RemoveEmptyEntries));
                if (line.ToLower().Contains(KeyWord.ToLower()) == false)
                {
                    throw new System.Exception("Expecting keyword " + KeyWord + " in headerline");
                }

                if (ExpectedColumnHeaders != null)
                {
                    ExpectedColumnHeaders.Add(KeyWord);

                    foreach (string label in ReadHeaderLabels)
                    {
                        if (ListContains(ExpectedColumnHeaders, label) == false)
                        {
                            throw new PnetSpeciesParameterFileFormatException("Unrecognized column header " + label + " in " + FileName + "./nExpected headers are: " + string.Join(",", ExpectedColumnHeaders.ToArray()));
                        }
                    }
                }

                GetNextLine();

                speciesLineNums.Clear();

                while (!AtEndOfInput)
                {
                    InputVar <string> RowLabel = new InputVar <string>("RowLabel");

                    StringReader s = new StringReader(CurrentLine);

                    CheckHeaderCount(new StringReader(CurrentLine), ReadHeaderLabels.Count);

                    for (int column = 0; column < ReadHeaderLabels.Count; column++)
                    {
                        Parameter <string> parameter      = null;
                        string             parameterlabel = null;

                        string valuekey = null;

                        InputVar <string> var = new InputVar <string>(ReadHeaderLabels[column]);
                        ReadValue(var, s);

                        if (column == 0)
                        {
                            RowLabel = var;
                            if (ExpectedRowLabels != null && ListContains(ExpectedRowLabels, RowLabel.Value) == false)
                            {
                                throw new PnetSpeciesParameterFileFormatException("Unknown parameter label [" + var.Value + "] in " + FileName + ".\nExpected labels are: [" + string.Join(" ,", ExpectedRowLabels.ToArray()) + "].");
                            }
                            continue;
                        }
                        switch (transposed)
                        {
                        case true:
                            parameterlabel = RowLabel.Value;
                            valuekey       = ReadHeaderLabels[column];
                            break;

                        case false:
                            parameterlabel = ReadHeaderLabels[column];
                            valuekey       = RowLabel.Value;
                            break;
                        }
                        if (parameters.TryGetValue(parameterlabel, out parameter) == false)
                        {
                            parameter = new Parameter <string>(parameterlabel);
                            parameters.Add(parameterlabel, parameter);
                        }
                        if (parameter.ContainsKey(valuekey))
                        {
                            throw new System.Exception("Duplicate parameter label [" + var.Value + "] for parameter " + parameterlabel);
                        }
                        parameter.Add(valuekey, var.Value);
                    }
                    GetNextLine();
                }
                return(parameters);
            }
            catch (System.Exception e)
            {
                if (e is PnetSpeciesParameterFileFormatException)
                {
                    throw e;
                }
                else
                {
                    throw new System.Exception("Unexpected file format (dir,file) (" +
                                               System.IO.Directory.GetCurrentDirectory() + "," +
                                               this.FileName + ")" +
                                               " " + e.Message + "\n\nNOTE header line is mandatory");
                }
            }
        }
Exemple #14
0
        //---------------------------------------------------------------------

        private void ParseTable(IPercentageTable table,
                                string tableName,
                                string nextTableName)
        {
            ReadName(tableName);

            PlugIn.ModelCore.UI.WriteLine("      Reading {0}.", tableName);

            InputVar <string>     disturbance      = new InputVar <string>("Disturbance");
            InputVar <Percentage> woodPercentage   = new InputVar <Percentage>("Woody");
            InputVar <Percentage> foliarPercentage = new InputVar <Percentage>("Non-Woody");
            string lastColumn = "the " + foliarPercentage.Name + " column";

            const string defaultName  = "(default)";
            bool         defaultFound = false;

            lineNums.Clear();
            while (!AtEndOfInput && CurrentName != nextTableName)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(disturbance, currentLine);
                int lineNum;
                if (lineNums.TryGetValue(disturbance.Value.Actual, out lineNum))
                {
                    throw new InputValueException(disturbance.Value.Actual,
                                                  "The value \"{0}\" was previously used on line {1}",
                                                  disturbance.Value.Actual,
                                                  lineNum);
                }
                lineNums[disturbance.Value.String] = LineNumber;

                PoolPercentages percentages;
                if (disturbance.Value.Actual == defaultName)
                {
                    defaultFound = true;
                    percentages  = table.Default;
                }
                else
                {
                    ExtensionType disturbanceType = new ExtensionType("disturbance:" + disturbance.Value.Actual);

                    //if(disturbance.Value.Actual == "Fire" || disturbance.Value.Actual == "fire")
                    //    throw new InputValueException(disturbance.Value.Actual,
                    //                              "\"{0}\" is not an allowable disturbance type, line {1}",
                    //                              disturbance.Value.Actual,
                    //                              lineNum);

                    //percentages = table[disturbanceType];
                    table[disturbanceType] = new PoolPercentages();
                    percentages            = table[disturbanceType];
                    PlugIn.ModelCore.UI.WriteLine("         Adding {0}...", disturbanceType);
                }

                ReadValue(woodPercentage, currentLine);
                percentages.Wood = woodPercentage.Value;

                ReadValue(foliarPercentage, currentLine);
                percentages.Foliar = foliarPercentage.Value;

                CheckNoDataAfter(lastColumn, currentLine);
                GetNextLine();
            }

            if (!defaultFound)
            {
                throw NewParseException("Missing the \"{0}\" row in the percentage table",
                                        defaultName);
            }
        }
        //---------------------------------------------------------------------

        protected override IAgent Parse()
        {
            //PlugIn.ModelCore.Log.WriteLine("Parsing 1; sppCnt={0}", Model.Species.Count);
            Agent agentParameters = new Agent(PlugIn.ModelCore.Species.Count, PlugIn.ModelCore.Ecoregions.Count, (int)DisturbanceType.Null);   //The last disturb Type is Null

            InputVar <string> agentName = new InputVar <string>("BDAAgentName");

            ReadVar(agentName);
            agentParameters.AgentName = agentName.Value;

            InputVar <int> bdpc = new InputVar <int>("BDPCalibrator");

            ReadVar(bdpc);
            agentParameters.BDPCalibrator = bdpc.Value;

            InputVar <SRDmode> srd = new InputVar <SRDmode>("SRDMode");

            ReadVar(srd);
            agentParameters.SRDmode = srd.Value;

            InputVar <int> tSLE = new InputVar <int>("TimeSinceLastEpidemic");

            ReadVar(tSLE);
            agentParameters.TimeSinceLastEpidemic = tSLE.Value;

            InputVar <TemporalType> tt = new InputVar <TemporalType>("TemporalType");

            ReadVar(tt);
            agentParameters.TempType = tt.Value;

            InputVar <RandomFunction> rf = new InputVar <RandomFunction>("RandomFunction");

            ReadVar(rf);
            agentParameters.RandFunc = rf.Value;

            InputVar <double> rp1 = new InputVar <double>("RandomParameter1");

            ReadVar(rp1);
            agentParameters.RandomParameter1 = rp1.Value;

            InputVar <double> rp2 = new InputVar <double>("RandomParameter2");

            ReadVar(rp2);
            agentParameters.RandomParameter2 = rp2.Value;

            InputVar <int> minROS = new InputVar <int>("MinROS");

            ReadVar(minROS);
            agentParameters.MinROS = minROS.Value;

            InputVar <int> maxROS = new InputVar <int>("MaxROS");

            ReadVar(maxROS);
            agentParameters.MaxROS = maxROS.Value;

            InputVar <bool> d = new InputVar <bool>("Dispersal");

            ReadVar(d);
            agentParameters.Dispersal = d.Value;

            InputVar <int> dr = new InputVar <int>("DispersalRate");

            ReadVar(dr);
            agentParameters.DispersalRate = dr.Value;

            InputVar <double> et = new InputVar <double>("EpidemicThresh");

            ReadVar(et);
            agentParameters.EpidemicThresh = et.Value;

            InputVar <int> ien = new InputVar <int>("InitialEpicenterNum");

            ReadVar(ien);
            agentParameters.EpicenterNum = ien.Value;

            InputVar <double> oec = new InputVar <double>("OutbreakEpicenterCoeff");

            ReadVar(oec);
            agentParameters.OutbreakEpicenterCoeff = oec.Value;

            InputVar <bool> se = new InputVar <bool>("SeedEpicenter");

            ReadVar(se);
            agentParameters.SeedEpicenter = se.Value;

            InputVar <double> sec = new InputVar <double>("SeedEpicenterCoeff");

            ReadVar(sec);
            agentParameters.SeedEpicenterCoeff = sec.Value;

            InputVar <DispersalTemplate> dispt = new InputVar <DispersalTemplate>("DispersalTemplate");

            ReadVar(dispt);
            agentParameters.DispersalTemp = dispt.Value;

            InputVar <bool> nf = new InputVar <bool>("NeighborFlag");

            ReadVar(nf);
            agentParameters.NeighborFlag = nf.Value;

            InputVar <NeighborSpeed> nspeed = new InputVar <NeighborSpeed>("NeighborSpeedUp");

            ReadVar(nspeed);
            agentParameters.NeighborSpeedUp = nspeed.Value;

            InputVar <int> nr = new InputVar <int>("NeighborRadius");

            ReadVar(nr);
            agentParameters.NeighborRadius = nr.Value;

            InputVar <NeighborShape> ns = new InputVar <NeighborShape>("NeighborShape");

            ReadVar(ns);
            agentParameters.ShapeOfNeighbor = ns.Value;

            InputVar <double> nw = new InputVar <double>("NeighborWeight");

            ReadVar(nw);
            agentParameters.NeighborWeight = nw.Value;

            //Added for budworm-BDA
            InputVar <double> class2_SV = new InputVar <double>("Class2_SV");

            ReadVar(class2_SV);
            agentParameters.Class2_SV = class2_SV.Value;

            InputVar <double> class3_SV = new InputVar <double>("Class3_SV");

            ReadVar(class3_SV);
            agentParameters.Class3_SV = class3_SV.Value;

            InputVar <int> bfAgeCutoff = new InputVar <int>("BFAgeCutoff");

            ReadVar(bfAgeCutoff);
            agentParameters.BFAgeCutoff = bfAgeCutoff.Value;

            //--------- Read In Ecoreigon Table ---------------------------------------
            PlugIn.ModelCore.Log.WriteLine("Begin parsing ECOREGION table.");

            InputVar <string> ecoName     = new InputVar <string>("Ecoregion Name");
            InputVar <double> ecoModifier = new InputVar <double>("Ecoregion Modifier");

            Dictionary <string, int> lineNumbers = new Dictionary <string, int>();
            const string             DistParms   = "DisturbanceModifiers";

            while (!AtEndOfInput && CurrentName != DistParms)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(ecoName, currentLine);
                IEcoregion ecoregion = EcoregionsDataset[ecoName.Value.Actual];
                if (ecoregion == null)
                {
                    throw new InputValueException(ecoName.Value.String,
                                                  "{0} is not an ecoregion name.",
                                                  ecoName.Value.String);
                }
                int lineNumber;
                if (lineNumbers.TryGetValue(ecoregion.Name, out lineNumber))
                {
                    throw new InputValueException(ecoName.Value.String,
                                                  "The ecoregion {0} was previously used on line {1}",
                                                  ecoName.Value.String, lineNumber);
                }
                else
                {
                    lineNumbers[ecoregion.Name] = LineNumber;
                }

                IEcoParameters ecoParms = new EcoParameters();
                agentParameters.EcoParameters[ecoregion.Index] = ecoParms;

                ReadValue(ecoModifier, currentLine);
                ecoParms.EcoModifier = ecoModifier.Value;

                CheckNoDataAfter("the " + ecoModifier.Name + " column",
                                 currentLine);
                GetNextLine();
            }

            //--------- Read In Disturbance Modifier Table -------------------------------
            PlugIn.ModelCore.Log.WriteLine("Begin parsing DISTURBANCE table.");

            ReadName(DistParms);

            InputVar <DisturbanceType> distType     = new InputVar <DisturbanceType>("Disturbance Type");
            InputVar <int>             duration     = new InputVar <int>("Duration");
            InputVar <double>          distModifier = new InputVar <double>("Disturbance Modifier");

            lineNumbers = new Dictionary <string, int>();
            const string SppParms = "BDASpeciesParameters";

            while (!AtEndOfInput && CurrentName != SppParms)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(distType, currentLine);
                int dt = (int)distType.Value.Actual;

                IDistParameters distParms = new DistParameters();
                agentParameters.DistParameters[dt] = distParms;

                ReadValue(duration, currentLine);
                distParms.Duration = duration.Value;

                ReadValue(distModifier, currentLine);
                distParms.DistModifier = distModifier.Value;

                CheckNoDataAfter("the " + distModifier.Name + " column",
                                 currentLine);
                GetNextLine();
            }
            //--------- Read In Species Table ---------------------------------------
            PlugIn.ModelCore.Log.WriteLine("Begin parsing SPECIES table.");

            ReadName(SppParms);

            //const string FireCurves = "FireCurveTable";
            InputVar <string> sppName            = new InputVar <string>("Species");
            InputVar <int>    minorHostAge       = new InputVar <int>("Minor Host Age");
            InputVar <double> minorHostSRD       = new InputVar <double>("Minor Host SRDProb");
            InputVar <int>    secondaryHostAge   = new InputVar <int>("Second Host Age");
            InputVar <double> secondaryHostSRD   = new InputVar <double>("Secondary Host SRDProb");
            InputVar <int>    primaryHostAge     = new InputVar <int>("Primary Host Age");
            InputVar <double> primaryHostSRD     = new InputVar <double>("Primary Host SRDProb");
            InputVar <int>    resistantHostAge   = new InputVar <int>("Resistant Host Age");
            InputVar <double> resistantHostVuln  = new InputVar <double>("Resistant Host VulnProb");
            InputVar <int>    tolerantHostAge    = new InputVar <int>("Tolerant Host Age");
            InputVar <double> tolerantHostVuln   = new InputVar <double>("Tolerant Host VulnProb");
            InputVar <int>    vulnerableHostAge  = new InputVar <int>("Vulnerable Host Age");
            InputVar <double> vulnerableHostVuln = new InputVar <double>("Vulnerable Host VulnProb");
            InputVar <bool>   cfsConifer         = new InputVar <bool>("CFS Conifer type:  yes/no");

            const string NegSpp = "IgnoredSpecies";

            while ((!AtEndOfInput) && (CurrentName != NegSpp))
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(sppName, currentLine);
                ISpecies species = SpeciesDataset[sppName.Value.Actual];
                if (species == null)
                {
                    throw new InputValueException(sppName.Value.String,
                                                  "{0} is not a species name.",
                                                  sppName.Value.String);
                }
                int lineNumber;
                if (lineNumbers.TryGetValue(species.Name, out lineNumber))
                {
                    throw new InputValueException(sppName.Value.String,
                                                  "The species {0} was previously used on line {1}",
                                                  sppName.Value.String, lineNumber);
                }
                else
                {
                    lineNumbers[species.Name] = LineNumber;
                }

                ISppParameters sppParms = new SppParameters();
                agentParameters.SppParameters[species.Index] = sppParms;

                ReadValue(minorHostAge, currentLine);
                sppParms.MinorHostAge = minorHostAge.Value;

                ReadValue(minorHostSRD, currentLine);
                sppParms.MinorHostSRD = minorHostSRD.Value;

                ReadValue(secondaryHostAge, currentLine);
                sppParms.SecondaryHostAge = secondaryHostAge.Value;

                ReadValue(secondaryHostSRD, currentLine);
                sppParms.SecondaryHostSRD = secondaryHostSRD.Value;

                ReadValue(primaryHostAge, currentLine);
                sppParms.PrimaryHostAge = primaryHostAge.Value;

                ReadValue(primaryHostSRD, currentLine);
                sppParms.PrimaryHostSRD = primaryHostSRD.Value;

                ReadValue(resistantHostAge, currentLine);
                sppParms.ResistantHostAge = resistantHostAge.Value;

                ReadValue(resistantHostVuln, currentLine);
                sppParms.ResistantHostVuln = resistantHostVuln.Value;

                ReadValue(tolerantHostAge, currentLine);
                sppParms.TolerantHostAge = tolerantHostAge.Value;

                ReadValue(tolerantHostVuln, currentLine);
                sppParms.TolerantHostVuln = tolerantHostVuln.Value;

                ReadValue(vulnerableHostAge, currentLine);
                sppParms.VulnerableHostAge = vulnerableHostAge.Value;

                ReadValue(vulnerableHostVuln, currentLine);
                sppParms.VulnerableHostVuln = vulnerableHostVuln.Value;

                ReadValue(cfsConifer, currentLine);
                sppParms.CFSConifer = cfsConifer.Value;

                CheckNoDataAfter("the " + cfsConifer.Name + " column",
                                 currentLine);


                GetNextLine();
            }

            //--------- Read In Ignored Species List ---------------------------------------

            List <ISpecies> negSppList = new List <ISpecies>();

            if (!AtEndOfInput)
            {
                ReadName(NegSpp);
                InputVar <string> negSppName = new InputVar <string>("Ignored Spp Name");

                while (!AtEndOfInput)
                {
                    StringReader currentLine = new StringReader(CurrentLine);

                    ReadValue(negSppName, currentLine);
                    ISpecies species = SpeciesDataset[negSppName.Value.Actual];
                    if (species == null)
                    {
                        throw new InputValueException(negSppName.Value.String,
                                                      "{0} is not a species name.",
                                                      negSppName.Value.String);
                    }
                    int lineNumber;
                    if (lineNumbers.TryGetValue(species.Name, out lineNumber))
                    {
                        PlugIn.ModelCore.Log.WriteLine("WARNING: The species {0} was previously used on line {1}.  Being listed in the IgnoredSpecies list will override any settings in the Host table.", negSppName.Value.String, lineNumber);
                    }
                    else
                    {
                        lineNumbers[species.Name] = LineNumber;
                    }

                    negSppList.Add(species);

                    GetNextLine();
                }
            }
            agentParameters.NegSppList = negSppList;


            return(agentParameters); //.GetComplete();
        }
Exemple #16
0
        //---------------------------------------------------------------------

        protected override IInputParameters Parse()
        {
            ReadLandisDataVar();

            //InputVar<string> landisData = new InputVar<string>("LandisData");
            //ReadVar(landisData);
            //if (landisData.Value.Actual != PlugIn.ExtensionName)
            //    throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", PlugIn.ExtensionName);


            InputParameters parameters = new InputParameters();

            InputVar <int> timestep = new InputVar <int>("Timestep");

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            InputVar <SeedingAlgorithms> seedAlg = new InputVar <SeedingAlgorithms>("SeedingAlgorithm");

            ReadVar(seedAlg);
            parameters.SeedAlgorithm = seedAlg.Value;

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

            InputVar <string> initCommunities = new InputVar <string>("InitialCommunities");

            ReadVar(initCommunities);
            parameters.InitialCommunities = initCommunities.Value;

            InputVar <string> communitiesMap = new InputVar <string>("InitialCommunitiesMap");

            ReadVar(communitiesMap);
            parameters.InitialCommunitiesMap = communitiesMap.Value;

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

            InputVar <string> dynInputFile = new InputVar <string>("DynamicInputFile");

            ReadVar(dynInputFile);
            parameters.DynamicInputFile = dynInputFile.Value;

            //ReadName("EstablishProbabilities");

            ////  Read ecoregion names as column headings
            //InputVar<string> ecoregionName = new InputVar<string>("Ecoregion");
            //if (AtEndOfInput)
            //    throw new InputVariableException(ecoregionName,
            //                                     "Expected a line with the names of 1 or more active ecoregions.");
            //List<IEcoregion> ecoregions = new List<IEcoregion>();
            //StringReader currentLine = new StringReader(CurrentLine);
            //TextReader.SkipWhitespace(currentLine);
            //while (currentLine.Peek() != -1)
            //{
            //    ReadValue(ecoregionName, currentLine);
            //    IEcoregion ecoregion = PlugIn.ModelCore.Ecoregions[ecoregionName.Value.Actual];
            //    if (ecoregion == null)
            //        throw new InputValueException(ecoregionName.Value.String,
            //                                      "{0} is not an ecoregion name.",
            //                                      ecoregionName.Value.String);
            //    if (! ecoregion.Active)
            //        throw new InputValueException(ecoregionName.Value.String,
            //                                      "{0} is not an active ecoregion.",
            //                                      ecoregionName.Value.String);
            //    if (ecoregions.Contains(ecoregion))
            //        throw new InputValueException(ecoregionName.Value.String,
            //                                      "The ecoregion {0} appears more than once.",
            //                                      ecoregionName.Value.String);
            //    ecoregions.Add(ecoregion);
            //    TextReader.SkipWhitespace(currentLine);
            //}
            //GetNextLine();

            //string lastEcoregion = ecoregions[ecoregions.Count-1].Name;

            ////  Read species and their probabilities
            //InputVar<string> speciesName = new InputVar<string>("Species");
            //Dictionary <string, int> speciesLineNumbers = new Dictionary<string, int>();
            //while (! AtEndOfInput) {
            //    currentLine = new StringReader(CurrentLine);

            //    ReadValue(speciesName, currentLine);
            //    //Species.ISpecies species = Model.Core.Species[speciesName.Value.Actual];
            //    ISpecies species = PlugIn.ModelCore.Species[speciesName.Value.Actual];
            //    if (species == null)
            //        throw new InputValueException(speciesName.Value.String,
            //                                      "{0} is not a species name.",
            //                                      speciesName.Value.String);
            //    int lineNumber;
            //    if (speciesLineNumbers.TryGetValue(species.Name, out lineNumber))
            //        throw new InputValueException(speciesName.Value.String,
            //                                      "The species {0} was previously used on line {1}",
            //                                      speciesName.Value.String, lineNumber);
            //    else
            //        speciesLineNumbers[species.Name] = LineNumber;

            //    foreach (IEcoregion ecoregion in ecoregions) {
            //        InputVar<double> probability = new InputVar<double>("Ecoregion " + ecoregion.Name);
            //        ReadValue(probability, currentLine);
            //        if (probability.Value.Actual < 0.0 || probability.Value.Actual > 1.0)
            //            throw new InputValueException(probability.Value.String,
            //                                          "{0} is not between 0.0 and 1.0",
            //                                          probability.Value.String);
            //        parameters.SetProbability(ecoregion, species, probability.Value.Actual);
            //    }

            //    CheckNoDataAfter("the Ecoregion " + lastEcoregion + " column",
            //                     currentLine);
            //    GetNextLine();
            //}

            return(parameters);            //.GetComplete();
        }
Exemple #17
0
 public void Init()
 {
     inputVar = new InputVar <int>("Effective Seed Dist", EffectiveSeedDist.ReadMethod);
 }
Exemple #18
0
        //---------------------------------------------------------------------

        protected override ExtensionInfo Parse()
        {
            ReadLandisDataVar();

            EditableExtensionInfo extension = new EditableExtensionInfo();

            InputVar <string> name = new InputVar <string>("Name");

            ReadVar(name);
            extension.Name = name.Value;

            InputVar <string> version = new InputVar <string>("Version");

            if (ReadOptionalVar(version))
            {
                extension.Version = version.Value;
            }

            //  If the extension is not being installed, but rather just an
            //  entry for it is being added to the dataset, then we need its
            //  type, assembly and class info.
            if (!App.InstallingExtension)
            {
                InputVar <string> type = new InputVar <string>("Type");
                ReadVar(type);
                extension.Type = type.Value;

                InputVar <string> assemblyPath = new InputVar <string>("Assembly");
                ReadVar(assemblyPath);
                extension.AssemblyName = assemblyPath.Value;

                InputVar <string> className = new InputVar <string>("Class");
                ReadVar(className);
                extension.ClassName = className.Value;
            }

            InputVar <string> description = new InputVar <string>("Description");

            if (ReadOptionalVar(description))
            {
                extension.Description = description.Value;
            }

            InputVar <string> userGuide = new InputVar <string>("UserGuide");

            if (ReadOptionalVar(userGuide))
            {
                extension.UserGuidePath = userGuide.Value;
            }

            //  CoreVersion is optional.  We don't use ReadOptionalVar because
            //  we want to be able to check for any data after the last known
            //  parameter.  But that last known parameter could Name, Version,
            //  Class, Description, or UserGuide.  And we want the error
            //  message to list any optional variables that weren't found.  So
            //  instead, we use ReadVar if there's a non-blank line left in
            //  the input.
            if (!AtEndOfInput)
            {
                InputVar <string> coreVersion = new InputVar <string>("CoreVersion");
                ReadVar(coreVersion);
                extension.CoreVersion = coreVersion.Value;

                CheckNoDataAfter(string.Format("the {0} parameter", coreVersion.Name));
            }

            return(extension.GetComplete());
        }
 public void Init()
 {
     strVar = new InputVar<string>("StringVar");
 }
Exemple #20
0
        //---------------------------------------------------------------------

        protected override IParameters Parse()
        {
            ReadLandisDataVar();

            Parameters parameters = new Parameters(ecoregionDataset, speciesDataset);

            InputVar <int> timestep = new InputVar <int>(Names.Timestep);

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            InputVar <SeedingAlgorithms> seedAlg = new InputVar <SeedingAlgorithms>(Names.SeedingAlgorithm);

            ReadVar(seedAlg);
            parameters.SeedAlgorithm = seedAlg.Value;

            InputVar <bool> calimode = new InputVar <bool>(Names.CalibrateMode);

            if (ReadOptionalVar(calimode))
            {
                parameters.CalibrateMode = calimode.Value;
            }
            else
            {
                parameters.CalibrateMode = false;
            }

            InputVar <double> spinMort = new InputVar <double>("SpinupMortalityFraction");

            if (ReadOptionalVar(spinMort))
            {
                parameters.SpinupMortalityFraction = spinMort.Value;
            }
            else
            {
                parameters.SpinupMortalityFraction = 0.0;
            }

            ParseBiomassParameters(parameters, Names.AgeOnlyDisturbanceParms,
                                   Names.ClimateChange);

            //  AgeOnlyDisturbances:BiomassParameters (optional)
            string lastParameter = null;

            if (!AtEndOfInput && CurrentName == Names.AgeOnlyDisturbanceParms)
            {
                InputVar <string> ageOnlyDisturbanceParms = new InputVar <string>(Names.AgeOnlyDisturbanceParms);
                ReadVar(ageOnlyDisturbanceParms);
                parameters.AgeOnlyDisturbanceParms = ageOnlyDisturbanceParms.Value;

                lastParameter = "the " + Names.AgeOnlyDisturbanceParms + " parameter";
            }

            //  Climate Change table (optional)
            if (ReadOptionalName(Names.ClimateChange))
            {
                ReadClimateChangeTable(parameters.ClimateChangeUpdates);
            }
            else if (lastParameter != null)
            {
                CheckNoDataAfter(lastParameter);
            }

            return(parameters); //.GetComplete();
        }
        //----------------------------------------------------------------------

        //  Need to include a copy of this method because it modifies an
        //  instance member "rankingMethod" in the original version.  Bad
        //  design; the ranking method should be passed as a parameter.
        
        protected void ReadForestTypeTable(IStandRankingMethod rankingMethod)
        {
            int optionalStatements = 0;
            
            //check if this is the ForestTypeTable
            if (CurrentName == Names.ForestTypeTable) {
                ReadName(Names.ForestTypeTable);

                //fresh input variables for table
                InputVar<string> inclusionRule = new InputVar<string>("Inclusion Rule");
                InputVar<AgeRange> age_range = new InputVar<AgeRange>("Age Range", ParseAgeOrRange);
                InputVar<string> percentOfCells = new InputVar<string>("PercentOfCells");  //as a string so it can include keyword 'highest'
                InputVar<string> speciesName = new InputVar<string>("Species");
                
                
                //list for each rule- each line is a separate rule
                List<InclusionRule> rule_list = new List<InclusionRule>();              
                //keep reading until no longer in the ForestTypeTable
                while (! AtEndOfInput && !namesThatFollowForestType.Contains(CurrentName)) {
                    StringReader currentLine = new StringReader(CurrentLine);

                    //  inclusionRule column
                    ReadValue(inclusionRule, currentLine);

                    //verify inclusion rule = 'optional', 'required', or 'forbidden'
                    if (inclusionRule.Value.Actual != "Optional" && inclusionRule.Value.Actual != "Required"
                                    && inclusionRule.Value.Actual != "Forbidden") {
                        string[] ic_list = new string[]{"Valid Inclusion Rules:",
                                                                           "    Optional",
                                                                           "    Required",
                                                                           "    Forbidden"};
                        throw new InputValueException(CurrentName, CurrentName + " is not a valid inclusion rule.",
                                                  new MultiLineText(ic_list));
                    }

                    if (inclusionRule.Value.Actual == "Optional")
                        optionalStatements++;
                    
                    
                    TextReader.SkipWhitespace(currentLine);
                    ReadValue(age_range, currentLine);

                    //percentage column
                    TextReader.SkipWhitespace(currentLine);
                    ReadValue(percentOfCells, currentLine);
                    //PlugIn.ModelCore.UI.WriteLine("percentOfCells = {0}", percentOfCells.Value.String);
                    //cannot validate until parsing is done.  will do this in the inclusionRule constructor

                    //a list in case there are multiple species on this line
                    List<string> species_list = new List<string>();
                    //add each species to this rule's species list
                    TextReader.SkipWhitespace(currentLine);
                    while (currentLine.Peek() != -1) {
                        //species column (build list)
                        
                        ReadValue(speciesName, currentLine);
                        string name = speciesName.Value.String;
                        
                        ISpecies species = GetSpecies(new InputValue<string>(name, speciesName.Value.String));
                        if (species_list.Contains(species.Name))
                            throw NewParseException("The species {0} appears more than once.", species.Name);
                        species_list.Add(species.Name);

                        //species_list.Add(species.Value.String);
                        TextReader.SkipWhitespace(currentLine);
                    }

                    //add this new inclusion rule (by parameters)  to the requirement
                    rule_list.Add(new InclusionRule(inclusionRule.Value.String,
                                                    age_range.Value.Actual,
                                                    percentOfCells.Value.String,
                                                    species_list));
                    
                    GetNextLine();
                }
                //create a new requirement with this list of rules
                IRequirement inclusionRequirement = new InclusionRequirement(rule_list);
                //add this requirement to the ranking method
                rankingMethod.AddRequirement(inclusionRequirement);
            }
            
            if(optionalStatements > 0 && optionalStatements < 2)
                throw new InputValueException(CurrentName, "If there are optional statements, there must be more than one",
                                                  "ForestTypeTable");
            
        }
Exemple #22
0
        //---------------------------------------------------------------------

        protected override IInputParameters Parse()
        {
            ReadLandisDataVar();

            int numLitterTypes     = 4;
            int numFunctionalTypes = 25;

            InputParameters parameters = new InputParameters(speciesDataset, numLitterTypes, numFunctionalTypes);

            InputVar <int> timestep = new InputVar <int>("Timestep");

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            InputVar <SeedingAlgorithms> seedAlg = new InputVar <SeedingAlgorithms>("SeedingAlgorithm");

            ReadVar(seedAlg);
            parameters.SeedAlgorithm = seedAlg.Value;

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

            InputVar <string> initCommunities = new InputVar <string>("InitialCommunities");

            ReadVar(initCommunities);
            parameters.InitialCommunities = initCommunities.Value;

            InputVar <string> communitiesMap = new InputVar <string>("InitialCommunitiesMap");

            ReadVar(communitiesMap);
            parameters.InitialCommunitiesMap = communitiesMap.Value;

            InputVar <string> climateConfigFile = new InputVar <string>("ClimateConfigFile");

            ReadVar(climateConfigFile);
            parameters.ClimateConfigFile = climateConfigFile.Value;

            InputVar <string> ageOnlyDisturbanceParms = new InputVar <string>("AgeOnlyDisturbances:BiomassParameters");

            ReadVar(ageOnlyDisturbanceParms);
            parameters.AgeOnlyDisturbanceParms = ageOnlyDisturbanceParms.Value;

            InputVar <string> soilDepthMapName = new InputVar <string>("SoilDepthMapName");

            ReadVar(soilDepthMapName);
            parameters.SoilDepthMapName = soilDepthMapName.Value;

            InputVar <string> soilDrainMapName = new InputVar <string>("SoilDrainMapName");

            ReadVar(soilDrainMapName);
            parameters.SoilDrainMapName = soilDrainMapName.Value;

            InputVar <string> soilBaseFlowMapName = new InputVar <string>("SoilBaseFlowMapName");

            ReadVar(soilBaseFlowMapName);
            parameters.SoilBaseFlowMapName = soilBaseFlowMapName.Value;

            InputVar <string> soilStormFlowMapName = new InputVar <string>("SoilStormFlowMapName");

            ReadVar(soilStormFlowMapName);
            parameters.SoilStormFlowMapName = soilStormFlowMapName.Value;

            InputVar <string> soilFCMapName = new InputVar <string>("SoilFieldCapacityMapName");

            ReadVar(soilFCMapName);
            parameters.SoilFieldCapacityMapName = soilFCMapName.Value;

            InputVar <string> soilWPMapName = new InputVar <string>("SoilWiltingPointMapName");

            ReadVar(soilWPMapName);
            parameters.SoilWiltingPointMapName = soilWPMapName.Value;

            InputVar <string> soilSandMapName = new InputVar <string>("SoilPercentSandMapName");

            ReadVar(soilSandMapName);
            parameters.SoilPercentSandMapName = soilSandMapName.Value;

            InputVar <string> soilClayMapName = new InputVar <string>("SoilPercentClayMapName");

            ReadVar(soilClayMapName);
            parameters.SoilPercentClayMapName = soilClayMapName.Value;

            InputVar <string> som1CsurfMapName = new InputVar <string>("InitialSOM1CsurfMapName");

            ReadVar(som1CsurfMapName);
            parameters.InitialSOM1CSurfaceMapName = som1CsurfMapName.Value;

            InputVar <string> som1NsurfMapName = new InputVar <string>("InitialSOM1NsurfMapName");

            ReadVar(som1NsurfMapName);
            parameters.InitialSOM1NSurfaceMapName = som1NsurfMapName.Value;

            InputVar <string> som1CsoilMapName = new InputVar <string>("InitialSOM1CsoilMapName");

            ReadVar(som1CsoilMapName);
            parameters.InitialSOM1CSoilMapName = som1CsoilMapName.Value;

            InputVar <string> som1NsoilMapName = new InputVar <string>("InitialSOM1NsoilMapName");

            ReadVar(som1NsoilMapName);
            parameters.InitialSOM1NSoilMapName = som1NsoilMapName.Value;

            InputVar <string> som2CMapName = new InputVar <string>("InitialSOM2CMapName");

            ReadVar(som2CMapName);
            parameters.InitialSOM2CMapName = som2CMapName.Value;

            InputVar <string> som2NMapName = new InputVar <string>("InitialSOM2NMapName");

            ReadVar(som2NMapName);
            parameters.InitialSOM2NMapName = som2NMapName.Value;

            InputVar <string> som3CMapName = new InputVar <string>("InitialSOM3CMapName");

            ReadVar(som3CMapName);
            parameters.InitialSOM3CMapName = som3CMapName.Value;

            InputVar <string> som3NMapName = new InputVar <string>("InitialSOM3NMapName");

            ReadVar(som3NMapName);
            parameters.InitialSOM3NMapName = som3NMapName.Value;

            InputVar <string> deadSurfMapName = new InputVar <string>("InitialDeadWoodSurfaceMapName");

            ReadVar(deadSurfMapName);
            parameters.InitialDeadSurfaceMapName = deadSurfMapName.Value;

            InputVar <string> deadSoilMapName = new InputVar <string>("InitialDeadWoodSoilMapName");

            ReadVar(deadSoilMapName);
            parameters.InitialDeadSoilMapName = deadSoilMapName.Value;

            InputVar <bool> calimode = new InputVar <bool>("CalibrateMode");

            if (ReadOptionalVar(calimode))
            {
                parameters.CalibrateMode = calimode.Value;
            }
            else
            {
                parameters.CalibrateMode = false;
            }

            //InputVar<double> spinMort = new InputVar<double>("SpinupMortalityFraction");
            //if (ReadOptionalVar(spinMort))
            //    parameters.SpinupMortalityFraction = spinMort.Value;
            //else
            //    parameters.SpinupMortalityFraction = 0.0;

            InputVar <string> wt = new InputVar <string>("WaterDecayFunction");

            ReadVar(wt);
            parameters.WType = WParse(wt.Value);

            InputVar <double> pea = new InputVar <double>("ProbabilityEstablishAdjust");

            ReadVar(pea);
            parameters.ProbEstablishAdjustment = pea.Value;

            InputVar <double> iMN = new InputVar <double>("InitialMineralN");

            ReadVar(iMN);
            parameters.SetInitMineralN(iMN.Value);

            InputVar <double> ans = new InputVar <double>("AtmosphericNSlope");

            ReadVar(ans);
            parameters.SetAtmosNslope(ans.Value);

            InputVar <double> ani = new InputVar <double>("AtmosphericNIntercept");

            ReadVar(ani);
            parameters.SetAtmosNintercept(ani.Value);

            InputVar <double> lat = new InputVar <double>("Latitude");

            ReadVar(lat);
            parameters.SetLatitude(lat.Value);

            InputVar <double> denits = new InputVar <double>("DenitrificationRate");

            ReadVar(denits);
            parameters.SetDenitrif(denits.Value);

            InputVar <double> drsoms = new InputVar <double>("DecayRateSurf");

            ReadVar(drsoms);
            parameters.SetDecayRateSurf(drsoms.Value);

            InputVar <double> drsom1 = new InputVar <double>("DecayRateSOM1");

            ReadVar(drsom1);
            parameters.SetDecayRateSOM1(drsom1.Value);

            InputVar <double> drsom2 = new InputVar <double>("DecayRateSOM2");

            ReadVar(drsom2);
            parameters.SetDecayRateSOM2(drsom2.Value);

            InputVar <double> drsom3 = new InputVar <double>("DecayRateSOM3");

            ReadVar(drsom3);
            parameters.SetDecayRateSOM3(drsom3.Value);

            //InputVar<string> soilCarbonMaps = new InputVar<string>("SoilCarbonMapNames");
            //if (ReadOptionalVar(soilCarbonMaps))
            //{
            //    PlugIn.SoilCarbonMapNames = soilCarbonMaps.Value;

            //    InputVar<int> soilCarbonMapFreq = new InputVar<int>("SoilCarbonMapFrequency");
            //    ReadVar(soilCarbonMapFreq);
            //    PlugIn.SoilCarbonMapFrequency = soilCarbonMapFreq.Value;

            //}

            //InputVar<string> soilNitrogenMaps = new InputVar<string>("SoilNitrogenMapNames");
            //if (ReadOptionalVar(soilNitrogenMaps))
            //{
            //    PlugIn.SoilNitrogenMapNames = soilNitrogenMaps.Value;

            //    InputVar<int> soilNitrogenMapFreq = new InputVar<int>("SoilNitrogenMapFrequency");
            //    ReadVar(soilNitrogenMapFreq);
            //    PlugIn.SoilNitrogenMapFrequency = soilNitrogenMapFreq.Value;

            //}

            InputVar <string> anppMaps = new InputVar <string>("ANPPMapNames");

            if (ReadOptionalVar(anppMaps))
            {
                PlugIn.ANPPMapNames = anppMaps.Value;

                InputVar <int> anppMapFreq = new InputVar <int>("ANPPMapFrequency");
                ReadVar(anppMapFreq);
                PlugIn.ANPPMapFrequency = anppMapFreq.Value;
            }

            InputVar <string> aneeMaps = new InputVar <string>("ANEEMapNames");

            if (ReadOptionalVar(aneeMaps))
            {
                PlugIn.ANEEMapNames = aneeMaps.Value;

                InputVar <int> aneeMapFreq = new InputVar <int>("ANEEMapFrequency");
                ReadVar(aneeMapFreq);
                PlugIn.ANEEMapFrequency = aneeMapFreq.Value;
            }

            InputVar <string> soilCarbonMaps = new InputVar <string>("SoilCarbonMapNames");

            if (ReadOptionalVar(soilCarbonMaps))
            {
                PlugIn.SoilCarbonMapNames = soilCarbonMaps.Value;

                InputVar <int> soilCarbonMapFreq = new InputVar <int>("SoilCarbonMapFrequency");
                ReadVar(soilCarbonMapFreq);
                PlugIn.SoilCarbonMapFrequency = soilCarbonMapFreq.Value;
            }

            InputVar <string> soilNitrogenMaps = new InputVar <string>("SoilNitrogenMapNames");

            if (ReadOptionalVar(soilNitrogenMaps))
            {
                PlugIn.SoilNitrogenMapNames = soilNitrogenMaps.Value;

                InputVar <int> soilNitrogenMapFreq = new InputVar <int>("SoilNitrogenMapFrequency");
                ReadVar(soilNitrogenMapFreq);
                PlugIn.SoilNitrogenMapFrequency = soilNitrogenMapFreq.Value;
            }

            InputVar <string> totalCMaps = new InputVar <string>("TotalCMapNames");

            if (ReadOptionalVar(totalCMaps))
            {
                PlugIn.TotalCMapNames = totalCMaps.Value;

                InputVar <int> totalCMapFreq = new InputVar <int>("TotalCMapFrequency");
                ReadVar(totalCMapFreq);
                PlugIn.TotalCMapFrequency = totalCMapFreq.Value;
            }

            //InputVar<string> LAIMaps = new InputVar<string>("LAIMapNames");
            //if (ReadOptionalVar(LAIMaps))
            //{
            //    PlugIn.LAIMapNames = LAIMaps.Value;

            //    InputVar<int> LAIMapFreq = new InputVar<int>("LAICMapFrequency");
            //    ReadVar(LAIMapFreq);
            //    PlugIn.LAICMapFrequency = LAIMapFreq.Value;

            //}

            //InputVar<string> ShadeClassMaps = new InputVar<string>("ShadeClassMapNames");
            //if (ReadOptionalVar(ShadeClassMaps))
            //{
            //    PlugIn.TotalCMapNames = ShadeClassMaps.Value;

            //    InputVar<int> ShadeClassMapFreq = new InputVar<int>("ShadeClassMapFrequency");
            //    ReadVar(ShadeClassMapFreq);
            //    PlugIn.ShadeClassMapFrequency = ShadeClassMapFreq.Value;

            //}

            //--------------------------
            //  MinRelativeBiomass table

            ReadName("MaximumLAI"); //"AvailableLightBiomass");
            InputVar <byte>   shadeClassVar = new InputVar <byte>("Shade Class");
            InputVar <double> maxLAI        = new InputVar <double>("Maximum LAI");

            //List<IEcoregion> ecoregions = ReadEcoregions();
            //string lastEcoregion = ecoregions[ecoregions.Count-1].Name;

            for (byte shadeClass = 1; shadeClass <= 5; shadeClass++)
            {
                if (AtEndOfInput)
                {
                    throw NewParseException("Expected a line with available light class {0}", shadeClass);
                }

                StringReader currentLine = new StringReader(CurrentLine);
                ReadValue(shadeClassVar, currentLine);
                if (shadeClassVar.Value.Actual != shadeClass)
                {
                    throw new InputValueException(shadeClassVar.Value.String,
                                                  "Expected the available light class {0}", shadeClass);
                }

                ReadValue(maxLAI, currentLine);
                parameters.SetMaximumShadeLAI(shadeClass, maxLAI.Value);

                //foreach (IEcoregion ecoregion in ecoregions)
                //{
                //    InputVar<Percentage> MinRelativeBiomass = new InputVar<Percentage>("Ecoregion " + ecoregion.Name);
                //}

                CheckNoDataAfter("the " + maxLAI + " column", currentLine);
                GetNextLine();
            }

            //----------------------------------------------------------
            //  Read table of sufficient light probabilities.
            //  Available light classes are in increasing order.
            ReadName("LightEstablishmentTable");

            InputVar <byte>   sc  = new InputVar <byte>("Available Light Class");
            InputVar <double> pl0 = new InputVar <double>("Probability of Germination - Light Level 0");
            InputVar <double> pl1 = new InputVar <double>("Probability of Germination - Light Level 1");
            InputVar <double> pl2 = new InputVar <double>("Probability of Germination - Light Level 2");
            InputVar <double> pl3 = new InputVar <double>("Probability of Germination - Light Level 3");
            InputVar <double> pl4 = new InputVar <double>("Probability of Germination - Light Level 4");
            InputVar <double> pl5 = new InputVar <double>("Probability of Germination - Light Level 5");

            int previousNumber = 0;

            while (!AtEndOfInput && CurrentName != Names.SpeciesParameters &&
                   previousNumber != 6)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ISufficientLight suffLight = new SufficientLight();

                ReadValue(sc, currentLine);
                suffLight.ShadeClass = sc.Value;

                //  Check that the current shade class is 1 more than
                //  the previous number (numbers are must be in increasing order).
                if (sc.Value.Actual != (byte)previousNumber + 1)
                {
                    throw new InputValueException(sc.Value.String,
                                                  "Expected the severity number {0}",
                                                  previousNumber + 1);
                }
                previousNumber = (int)sc.Value.Actual;

                ReadValue(pl0, currentLine);
                suffLight.ProbabilityLight0 = pl0.Value;

                ReadValue(pl1, currentLine);
                suffLight.ProbabilityLight1 = pl1.Value;

                ReadValue(pl2, currentLine);
                suffLight.ProbabilityLight2 = pl2.Value;

                ReadValue(pl3, currentLine);
                suffLight.ProbabilityLight3 = pl3.Value;

                ReadValue(pl4, currentLine);
                suffLight.ProbabilityLight4 = pl4.Value;

                ReadValue(pl5, currentLine);
                suffLight.ProbabilityLight5 = pl5.Value;

                parameters.LightClassProbabilities.Add(suffLight);

                CheckNoDataAfter("the " + pl5.Name + " column",
                                 currentLine);
                GetNextLine();
            }
            if (parameters.LightClassProbabilities.Count == 0)
            {
                throw NewParseException("No sufficient light probabilities defined.");
            }
            if (previousNumber != 5)
            {
                throw NewParseException("Expected shade class {0}", previousNumber + 1);
            }

            //-------------------------
            //  Species Parameters table

            ReadName("SpeciesParameters");

            speciesLineNums.Clear();  //  If parser re-used (i.e., for testing purposes)

            InputVar <int>    ft            = new InputVar <int>("Functional Type");
            InputVar <bool>   nt            = new InputVar <bool>("Nitrogen Fixer");
            InputVar <int>    gddmn         = new InputVar <int>("Growing Degree Day Minimum");
            InputVar <int>    gddmx         = new InputVar <int>("Growing Degree Day Maximum");
            InputVar <int>    mjt           = new InputVar <int>("Minimum January Temperature");
            InputVar <double> maxd          = new InputVar <double>("Maximum Allowable Drought");
            InputVar <double> leafLongevity = new InputVar <double>("Leaf Longevity");
            InputVar <bool>   epicorm       = new InputVar <bool>("Epicormic:  Y/N");
            InputVar <double> leafLignin    = new InputVar <double>("Leaf Percent Lignin");
            InputVar <double> wLignin       = new InputVar <double>("Wood Percent Lignin");
            InputVar <double> crLignin      = new InputVar <double>("Coarse Root Percent Lignin");
            InputVar <double> frLignin      = new InputVar <double>("Fine Root Percent Lignin");
            InputVar <double> leafCN        = new InputVar <double>("Leaf CN Ratio");
            InputVar <double> woodCN        = new InputVar <double>("Wood CN Ratio");
            InputVar <double> cRootCN       = new InputVar <double>("Coarse Root CN Ratio");
            InputVar <double> foliarCN      = new InputVar <double>("Foliage CN Ratio");
            InputVar <double> fRootCN       = new InputVar <double>("Fine Root CN Ratio");
            InputVar <int>    maxANPP       = new InputVar <int>("Maximum ANPP");
            InputVar <int>    maxBiomass    = new InputVar <int>("Maximum Aboveground Biomass");
            string            lastColumn    = "the " + maxBiomass.Name + " column";

            while (!AtEndOfInput && CurrentName != Names.FunctionalGroupParameters)
            {
                StringReader currentLine = new StringReader(CurrentLine);
                ISpecies     species     = ReadSpecies(currentLine);

                ReadValue(ft, currentLine);
                parameters.SetFunctionalType(species, ft.Value);

                ReadValue(nt, currentLine);
                parameters.NFixer[species] = nt.Value;

                ReadValue(gddmn, currentLine);
                parameters.SetGDDmin(species, gddmn.Value);

                ReadValue(gddmx, currentLine);
                parameters.SetGDDmax(species, gddmx.Value);

                ReadValue(mjt, currentLine);
                parameters.SetMinJanTemp(species, mjt.Value);

                ReadValue(maxd, currentLine);
                parameters.SetMaxDrought(species, maxd.Value);

                ReadValue(leafLongevity, currentLine);
                parameters.SetLeafLongevity(species, leafLongevity.Value);

                ReadValue(epicorm, currentLine);
                parameters.Epicormic[species] = epicorm.Value;

                ReadValue(leafLignin, currentLine);
                parameters.SetLeafLignin(species, leafLignin.Value);

                ReadValue(frLignin, currentLine);
                parameters.SetFineRootLignin(species, frLignin.Value);

                ReadValue(wLignin, currentLine);
                parameters.SetWoodLignin(species, wLignin.Value);

                ReadValue(crLignin, currentLine);
                parameters.SetCoarseRootLignin(species, crLignin.Value);

                ReadValue(leafCN, currentLine);
                parameters.SetLeafCN(species, leafCN.Value);

                ReadValue(fRootCN, currentLine);
                parameters.SetFineRootCN(species, fRootCN.Value);

                ReadValue(woodCN, currentLine);
                parameters.SetWoodCN(species, woodCN.Value);

                ReadValue(cRootCN, currentLine);
                parameters.SetCoarseRootCN(species, cRootCN.Value);

                ReadValue(foliarCN, currentLine);
                parameters.SetFoliageLitterCN(species, foliarCN.Value);

                ReadValue(maxANPP, currentLine);
                parameters.SetMaxANPP(species, maxANPP.Value);

                ReadValue(maxBiomass, currentLine);
                parameters.SetMaxBiomass(species, maxBiomass.Value);

                CheckNoDataAfter(lastColumn, currentLine);
                GetNextLine();
            }

            //--------- Read In Functional Group Table -------------------------------
            PlugIn.ModelCore.UI.WriteLine("   Begin parsing FUNCTIONAL GROUP table.");

            ReadName("FunctionalGroupParameters");
            //string InitialEcoregionParameters = "InitialEcoregionParameters";

            InputVar <string> ftname             = new InputVar <string>("Name");
            InputVar <int>    ftindex            = new InputVar <int>("Index (< 25)");
            InputVar <double> tempcurve1         = new InputVar <double>("TempCurve(1)");
            InputVar <double> tempcurve2         = new InputVar <double>("TempCurve(2)");
            InputVar <double> tempcurve3         = new InputVar <double>("TempCurve(3)");
            InputVar <double> tempcurve4         = new InputVar <double>("TempCurve(4)");
            InputVar <double> fcfleaf            = new InputVar <double>("FCFRAC: Leaf");
            InputVar <double> btolai             = new InputVar <double>("BTOLAI");
            InputVar <double> klai               = new InputVar <double>("KLAI");
            InputVar <double> maxlai             = new InputVar <double>("MAXLAI");
            InputVar <double> mwm                = new InputVar <double>("Monthly Wood Mortality");
            InputVar <double> wdr                = new InputVar <double>("Wood Decay Rate");
            InputVar <double> mortCurveShapeParm = new InputVar <double>("Mortality Curve Shape Parameter");
            InputVar <int>    leafNeedleDrop     = new InputVar <int>("Leaf or Needle Drop Month");

            InputVar <double> ppr2 = new InputVar <double>("MoistureCurve2");
            InputVar <double> ppr3 = new InputVar <double>("MoistureCurve3");
            InputVar <double> coarseRootFraction = new InputVar <double>("CRootFrac");
            InputVar <double> fineRootFraction   = new InputVar <double>("FRootFrac");

            while (!AtEndOfInput && CurrentName != Names.FireReductionParameters)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(ftname, currentLine);

                ReadValue(ftindex, currentLine);
                int ln = (int)ftindex.Value.Actual;

                if (ln >= numFunctionalTypes)
                {
                    throw new InputValueException(ftindex.Value.String,
                                                  "The index:  {0} exceeds the allowable number of functional groups, {1}",
                                                  ftindex.Value.String, numFunctionalTypes - 1);
                }


                //IEditableFunctionalType funcTParms = new EditableFunctionalType();
                FunctionalType funcTParms = new FunctionalType();
                parameters.FunctionalTypes[ln] = funcTParms;

                ReadValue(tempcurve1, currentLine);
                funcTParms.TempCurve1 = tempcurve1.Value;

                ReadValue(tempcurve2, currentLine);
                funcTParms.TempCurve2 = tempcurve2.Value;

                ReadValue(tempcurve3, currentLine);
                funcTParms.TempCurve3 = tempcurve3.Value;

                ReadValue(tempcurve4, currentLine);
                funcTParms.TempCurve4 = tempcurve4.Value;

                ReadValue(fcfleaf, currentLine);
                funcTParms.FCFRACleaf = fcfleaf.Value;

                ReadValue(btolai, currentLine);
                funcTParms.BTOLAI = btolai.Value;

                ReadValue(klai, currentLine);
                funcTParms.KLAI = klai.Value;

                ReadValue(maxlai, currentLine);
                funcTParms.MAXLAI = maxlai.Value;

                ReadValue(ppr2, currentLine);
                funcTParms.MoistureCurve2 = ppr2.Value;

                ReadValue(ppr3, currentLine);
                funcTParms.MoistureCurve3 = ppr3.Value;

                ReadValue(wdr, currentLine);
                funcTParms.WoodDecayRate = wdr.Value;

                ReadValue(mwm, currentLine);
                funcTParms.MonthlyWoodMortality = mwm.Value;

                ReadValue(mortCurveShapeParm, currentLine);
                funcTParms.MortCurveShape = mortCurveShapeParm.Value;

                ReadValue(leafNeedleDrop, currentLine);
                funcTParms.LeafNeedleDrop = leafNeedleDrop.Value;

                ReadValue(coarseRootFraction, currentLine);
                funcTParms.CoarseRootFraction = coarseRootFraction.Value;

                ReadValue(fineRootFraction, currentLine);
                funcTParms.FineRootFraction = fineRootFraction.Value;

                //PlugIn.ModelCore.UI.WriteLine("PPRPTS2={0}.", parameters.FunctionalTypeTable[ln].PPRPTS2);

                CheckNoDataAfter("the " + fineRootFraction.Name + " column", currentLine);
                GetNextLine();
            }


            //--------- Read In FIRST Ecoregion Table ---------------------------
            //PlugIn.ModelCore.UI.WriteLine("   Begin reading INITIAL ECOREGION parameters.");
            //ReadName(InitialEcoregionParameters);

            //InputVar<string> ecoregionName = new InputVar<string>("Ecoregion");
            //InputVar<double> iS1surfC = new InputVar<double>("Initial SOM1 surface C");
            //InputVar<double> iS1surfN = new InputVar<double>("Initial SOM1 surface N");
            //InputVar<double> iS1soilC = new InputVar<double>("Initial SOM1 soil C");
            //InputVar<double> iS1soilN = new InputVar<double>("Initial SOM1 soil N");
            //InputVar<double> iS2C = new InputVar<double>("Initial SOM2 (intermediate turnover) C");
            //InputVar<double> iS2N = new InputVar<double>("Initial SOM2 (intermediate turnover) N");
            //InputVar<double> iS3C = new InputVar<double>("Initial SOM3 (slow turnover) C");
            //InputVar<double> iS3N = new InputVar<double>("Initial SOM3 (slow turnover) N");
            //Dictionary <string, int> lineNumbers2 = new Dictionary<string, int>();

            //while (! AtEndOfInput && CurrentName != Names.FireReductionParameters){ //Names.EcoregionParameters ) {
            //    StringReader currentLine = new StringReader(CurrentLine);

            //    ReadValue(ecoregionName, currentLine);

            //    IEcoregion ecoregion = GetEcoregion(ecoregionName.Value,
            //                                        lineNumbers2);

            //ReadValue(iS1surfC, currentLine);
            //parameters.SetInitSOM1surfC(ecoregion, iS1surfC.Value);

            //ReadValue(iS1surfN, currentLine);
            //parameters.SetInitSOM1surfN(ecoregion, iS1surfN.Value);

            //ReadValue(iS1soilC, currentLine);
            //parameters.SetInitSOM1soilC(ecoregion, iS1soilC.Value);

            //ReadValue(iS1soilN, currentLine);
            //parameters.SetInitSOM1soilN(ecoregion, iS1soilN.Value);

            //ReadValue(iS2C, currentLine);
            //parameters.SetInitSOM2C(ecoregion, iS2C.Value);

            //ReadValue(iS2N, currentLine);
            //parameters.SetInitSOM2N(ecoregion, iS2N.Value);

            //ReadValue(iS3C, currentLine);
            //parameters.SetInitSOM3C(ecoregion, iS3C.Value);

            //ReadValue(iS3N, currentLine);
            //parameters.SetInitSOM3N(ecoregion, iS3N.Value);

            //    CheckNoDataAfter("the " + ecoregionName.Name + " column", currentLine);

            //    GetNextLine();
            //}

            //--------- Read In SECOND Ecoregion Table ---------------------------
            // First, read table of additional parameters for ecoregions
            //PlugIn.ModelCore.UI.WriteLine("   Begin reading FIXED ECOREGION parameters.");
            //ReadName(Names.EcoregionParameters);

            //InputVar<double> pclay = new InputVar<double>("Percent Clay");
            //InputVar<double> psand = new InputVar<double>("Percent Sand");
            //InputVar<int> sd = new InputVar<int>("Soil Depth");
            //InputVar<double> fc = new InputVar<double>("Field Capacity");
            //InputVar<double> wp = new InputVar<double>("Wilting Point");
            //InputVar<double> sff = new InputVar<double>("Storm Flow Fraction");
            //InputVar<double> bff = new InputVar<double>("Base Flow Fraction");
            //InputVar<double> drain = new InputVar<double>("Drain Fraction");
            //InputVar<double> lat = new InputVar<double>("Latitude");
            //InputVar<double> denits = new InputVar<double>("Denitrification");

            //Dictionary<string, int> lineNumbers = new Dictionary<string, int>();

            //while (! AtEndOfInput && CurrentName != Names.FireReductionParameters ) {
            //    StringReader currentLine = new StringReader(CurrentLine);

            //    ReadValue(ecoregionName, currentLine);

            //    IEcoregion ecoregion = GetEcoregion(ecoregionName.Value,
            //                                        lineNumbers);

            //    //ReadValue(sd, currentLine);
            //    //parameters.SetSoilDepth(ecoregion, sd.Value);

            //    ReadValue(pclay, currentLine);
            //    parameters.SetPercentClay(ecoregion, pclay.Value);

            //ReadValue(psand, currentLine);
            //parameters.SetPercentSand(ecoregion, psand.Value);

            //ReadValue(fc, currentLine);
            //parameters.SetFieldCapacity(ecoregion, fc.Value);

            //ReadValue(wp, currentLine);
            //parameters.SetWiltingPoint(ecoregion, wp.Value);

            //ReadValue(sff, currentLine);
            //parameters.SetStormFlowFraction(ecoregion, sff.Value);

            //ReadValue(bff, currentLine);
            //parameters.SetBaseFlowFraction(ecoregion, bff.Value);

            //ReadValue(drain, currentLine);
            //parameters.SetDrain(ecoregion, drain.Value);



            //    CheckNoDataAfter("the " + pclay.Name + " column", currentLine);

            //    GetNextLine();
            //}
            //--------- Read In Fire Reductions Table ---------------------------
            PlugIn.ModelCore.UI.WriteLine("   Begin reading FIRE REDUCTION parameters.");
            ReadName(Names.FireReductionParameters);

            InputVar <int>    frindex = new InputVar <int>("Fire Severity Index MUST = 1-5");
            InputVar <double> wred    = new InputVar <double>("Wood Reduction");
            InputVar <double> lred    = new InputVar <double>("Litter Reduction");

            while (!AtEndOfInput && CurrentName != Names.HarvestReductionParameters && CurrentName != Names.AgeOnlyDisturbanceParms)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(frindex, currentLine);
                int ln = (int)frindex.Value.Actual;

                if (ln < 1 || ln > 5)
                {
                    throw new InputValueException(ftindex.Value.String,
                                                  "The fire severity index:  {0} must be 1-5,",
                                                  frindex.Value.String);
                }


                FireReductions inputFireReduction = new FireReductions();  // ignoring severity = zero
                parameters.FireReductionsTable[ln] = inputFireReduction;

                ReadValue(wred, currentLine);
                inputFireReduction.WoodReduction = wred.Value;

                ReadValue(lred, currentLine);
                inputFireReduction.LitterReduction = lred.Value;

                CheckNoDataAfter("the " + lred.Name + " column", currentLine);

                GetNextLine();
            }

            //--------- Read In Harvest Reductions Table ---------------------------
            InputVar <string> hreds = new InputVar <string>("HarvestReductions");

            ReadOptionalName(Names.HarvestReductionParameters);
            {
                PlugIn.ModelCore.UI.WriteLine("   Begin reading HARVEST REDUCTION parameters.");
                InputVar <string> prescriptionName = new InputVar <string>("Prescription");
                InputVar <double> wred_pr          = new InputVar <double>("Wood Reduction");
                InputVar <double> lred_pr          = new InputVar <double>("Litter Reduction");

                List <string> prescriptionNames = new List <string>();

                while (!AtEndOfInput && CurrentName != Names.AgeOnlyDisturbanceParms)
                {
                    HarvestReductions harvReduction = new HarvestReductions();
                    parameters.HarvestReductionsTable.Add(harvReduction);

                    StringReader currentLine = new StringReader(CurrentLine);

                    ReadValue(prescriptionName, currentLine);
                    harvReduction.PrescriptionName = prescriptionName.Value;

                    ReadValue(wred_pr, currentLine);
                    harvReduction.WoodReduction = wred.Value;

                    ReadValue(lred_pr, currentLine);
                    harvReduction.LitterReduction = lred.Value;

                    GetNextLine();
                }
            }


            return(parameters);
        }
Exemple #23
0
        //---------------------------------------------------------------------
        protected override IInputParameters Parse()
        {
            InputVar <string> landisData = new InputVar <string>("LandisData");

            ReadVar(landisData);
            if (landisData.Value.Actual != PlugIn.ExtensionName)
            {
                throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", PlugIn.ExtensionName);
            }

            InputParameters parameters = new InputParameters();

            InputVar <int> timestep = new InputVar <int>("Timestep");

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            InputVar <string> varName = new InputVar <string>("VariableName");

            ReadVar(varName);
            parameters.VarName = varName.Value;

            InputVar <double> minDroughtYears = new InputVar <double>("MinDroughtVar");

            ReadVar(minDroughtYears);
            parameters.MinDroughtYears = minDroughtYears.Value;

            InputVar <double> maxDroughtYears = new InputVar <double>("MaxDroughtVar");

            ReadVar(maxDroughtYears);
            parameters.MaxDroughtYears = maxDroughtYears.Value;

            InputVar <string> backTransform = new InputVar <string>("BackTransformation");

            ReadVar(backTransform);
            parameters.BackTransform = backTransform.Value;

            InputVar <string> intCorrect = new InputVar <string>("InterceptCorrection");

            ReadVar(intCorrect);
            parameters.IntCorrect = intCorrect.Value;

            //-------------------------
            //  SpeciesParameters table

            ReadName("SpeciesParameters");
            speciesLineNums.Clear();  //  If parser re-used (i.e., for testing purposes)

            InputVar <double> drought_Y    = new InputVar <double>("Drought Y");
            InputVar <double> drought_YSE  = new InputVar <double>("Drought YSE");
            InputVar <double> drought_B    = new InputVar <double>("Drought B");
            InputVar <double> drought_BSE  = new InputVar <double>("Drought BSE");
            InputVar <double> drought_Sens = new InputVar <double>("Drought Sens");

            while (!AtEndOfInput && CurrentName != Names.MapName)
            {
                StringReader currentLine = new StringReader(CurrentLine);
                ISpecies     species     = ReadSpecies(currentLine);

                ReadValue(drought_Y, currentLine);
                parameters.SetDrought_Y(species, drought_Y.Value);
                ReadValue(drought_YSE, currentLine);
                parameters.SetDrought_YSE(species, drought_YSE.Value);
                ReadValue(drought_B, currentLine);
                parameters.SetDrought_B(species, drought_B.Value);
                ReadValue(drought_BSE, currentLine);
                parameters.SetDrought_BSE(species, drought_BSE.Value);
                ReadValue(drought_Sens, currentLine);
                parameters.SetDrought_Sens(species, drought_Sens.Value);

                CheckNoDataAfter(drought_Sens.Name, currentLine);
                GetNextLine();
            }

            InputVar <string> mapNames = new InputVar <string>("MapName");

            ReadVar(mapNames);
            parameters.MapNamesTemplate = mapNames.Value;

            InputVar <string> logFile = new InputVar <string>("LogFile");

            ReadVar(logFile);
            parameters.LogFileName = logFile.Value;

            return(parameters);
        }
Exemple #24
0
        //---------------------------------------------------------------------

        protected override IInputParameters Parse()
        {
            ReadLandisDataVar();
            InputParameters parameters = new InputParameters();

            InputVar <int> timestep = new InputVar <int>(Names.Timestep);

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            InputVar <SeedingAlgorithms> seedAlg = new InputVar <SeedingAlgorithms>(Names.SeedingAlgorithm);

            ReadVar(seedAlg);
            parameters.SeedAlgorithm = seedAlg.Value;

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

            InputVar <string> initCommunities = new InputVar <string>("InitialCommunities");

            ReadVar(initCommunities);
            parameters.InitialCommunities = initCommunities.Value;

            InputVar <string> communitiesMap = new InputVar <string>("InitialCommunitiesMap");

            ReadVar(communitiesMap);
            parameters.InitialCommunitiesMap = communitiesMap.Value;

            InputVar <string> climateConfigFile = new InputVar <string>(Names.ClimateConfigFile);

            if (ReadOptionalVar(climateConfigFile))
            {
                parameters.ClimateConfigFile = climateConfigFile.Value;
            }
            else
            {
                parameters.ClimateConfigFile = null;
            }

            //---------------------------------------------------------------------------------
            InputVar <bool> calimode = new InputVar <bool>(Names.CalibrateMode);

            if (ReadOptionalVar(calimode))
            {
                parameters.CalibrateMode = calimode.Value;
            }
            else
            {
                parameters.CalibrateMode = false;
            }

            InputVar <double> spinMort = new InputVar <double>("SpinupMortalityFraction");

            if (ReadOptionalVar(spinMort))
            {
                parameters.SpinupMortalityFraction = spinMort.Value;
            }
            else
            {
                parameters.SpinupMortalityFraction = 0.0;
            }

            //--------------------------
            //  MinRelativeBiomass table

            ReadName("MinRelativeBiomass");

            const string SufficientLight = "SufficientLight";

            List <IEcoregion> ecoregions    = ReadEcoregions();
            string            lastEcoregion = ecoregions[ecoregions.Count - 1].Name;

            InputVar <byte> shadeClassVar = new InputVar <byte>("Shade Class");

            for (byte shadeClass = 1; shadeClass <= 5; shadeClass++)
            {
                if (AtEndOfInput)
                {
                    throw NewParseException("Expected a line with shade class {0}", shadeClass);
                }

                StringReader currentLine = new StringReader(CurrentLine);
                ReadValue(shadeClassVar, currentLine);
                if (shadeClassVar.Value.Actual != shadeClass)
                {
                    throw new InputValueException(shadeClassVar.Value.String,
                                                  "Expected the shade class {0}", shadeClass);
                }

                foreach (IEcoregion ecoregion in ecoregions)
                {
                    InputVar <Percentage> MinRelativeBiomass = new InputVar <Percentage>("Ecoregion " + ecoregion.Name);
                    ReadValue(MinRelativeBiomass, currentLine);
                    parameters.SetMinRelativeBiomass(shadeClass, ecoregion, MinRelativeBiomass.Value);
                }

                CheckNoDataAfter("the Ecoregion " + lastEcoregion + " column",
                                 currentLine);
                GetNextLine();
            }
            //----------------------------------------------------------
            //  Read table of sufficient light probabilities.
            //  Shade classes are in increasing order.

            ReadName(SufficientLight);
            const string SpeciesParameters = "SpeciesParameters";


            InputVar <byte>   sc  = new InputVar <byte>("Shade Class");
            InputVar <double> pl0 = new InputVar <double>("Probability of Germination - Light Level 0");
            InputVar <double> pl1 = new InputVar <double>("Probability of Germination - Light Level 1");
            InputVar <double> pl2 = new InputVar <double>("Probability of Germination - Light Level 2");
            InputVar <double> pl3 = new InputVar <double>("Probability of Germination - Light Level 3");
            InputVar <double> pl4 = new InputVar <double>("Probability of Germination - Light Level 4");
            InputVar <double> pl5 = new InputVar <double>("Probability of Germination - Light Level 5");

            int previousNumber = 0;


            while (!AtEndOfInput && CurrentName != SpeciesParameters &&
                   previousNumber != 6)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ISufficientLight suffLight = new SufficientLight();

                parameters.LightClassProbabilities.Add(suffLight);

                ReadValue(sc, currentLine);
                suffLight.ShadeClass = sc.Value;

                //  Check that the current shade class is 1 more than
                //  the previous number (numbers are must be in increasing order).
                if (sc.Value.Actual != (byte)previousNumber + 1)
                {
                    throw new InputValueException(sc.Value.String,
                                                  "Expected the severity number {0}",
                                                  previousNumber + 1);
                }
                previousNumber = (int)sc.Value.Actual;

                ReadValue(pl0, currentLine);
                suffLight.ProbabilityLight0 = pl0.Value;

                ReadValue(pl1, currentLine);
                suffLight.ProbabilityLight1 = pl1.Value;

                ReadValue(pl2, currentLine);
                suffLight.ProbabilityLight2 = pl2.Value;

                ReadValue(pl3, currentLine);
                suffLight.ProbabilityLight3 = pl3.Value;

                ReadValue(pl4, currentLine);
                suffLight.ProbabilityLight4 = pl4.Value;

                ReadValue(pl5, currentLine);
                suffLight.ProbabilityLight5 = pl5.Value;


                CheckNoDataAfter("the " + pl5.Name + " column",
                                 currentLine);
                GetNextLine();
            }
            if (parameters.LightClassProbabilities.Count == 0)
            {
                throw NewParseException("No sufficient light probabilities defined.");
            }
            if (previousNumber != 5)
            {
                throw NewParseException("Expected shade class {0}", previousNumber + 1);
            }

            //-------------------------
            //  SpeciesParameters table

            ReadName("SpeciesParameters");
            const string EcoregionParameters = "EcoregionParameters";

            speciesLineNums.Clear();  //  If parser re-used (i.e., for testing purposes)

            InputVar <double> leafLongevity        = new InputVar <double>("Leaf Longevity");
            InputVar <double> woodyDecayRate       = new InputVar <double>("Woody Decay Rate");
            InputVar <double> mortCurveShapeParm   = new InputVar <double>("Mortality Curve Shape Parameter");
            InputVar <double> growthCurveShapeParm = new InputVar <double>("Mortality Curve Shape Parameter");
            InputVar <double> leafLignin           = new InputVar <double>("Leaf Percent Lignin");
            InputVar <double> maxlai = new InputVar <double>("Maximum LAI");
            InputVar <double> lec    = new InputVar <double>("Light extinction coefficient");
            InputVar <double> pctBio = new InputVar <double>("Pct Biomass Max LAI");

            //string lastColumn = "the " + mortCurveShapeParm.Name + " column";

            while (!AtEndOfInput && CurrentName != EcoregionParameters)
            {
                StringReader currentLine = new StringReader(CurrentLine);
                ISpecies     species     = ReadSpecies(currentLine);

                ReadValue(leafLongevity, currentLine);
                parameters.SetLeafLongevity(species, leafLongevity.Value);

                ReadValue(woodyDecayRate, currentLine);
                parameters.SetWoodyDecayRate(species, woodyDecayRate.Value);

                ReadValue(mortCurveShapeParm, currentLine);
                parameters.SetMortCurveShapeParm(species, mortCurveShapeParm.Value);

                ReadValue(growthCurveShapeParm, currentLine);
                parameters.SetGrowthCurveShapeParm(species, growthCurveShapeParm.Value);

                ReadValue(leafLignin, currentLine);
                parameters.SetLeafLignin(species, leafLignin.Value);

                CheckNoDataAfter(leafLignin.Name, currentLine);
                GetNextLine();
            }

            ReadName("EcoregionParameters");

            InputVar <string>        ecoregionName = new InputVar <string>("Ecoregion Name");
            InputVar <int>           aet           = new InputVar <int>("Actual Evapotranspiration");
            Dictionary <string, int> lineNumbers   = new Dictionary <string, int>();

            string lastColumn = "the " + aet.Name + " column";

            while (!AtEndOfInput && CurrentName != Names.DynamicInputFile)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(ecoregionName, currentLine);

                IEcoregion ecoregion = GetEcoregion(ecoregionName.Value,
                                                    lineNumbers);

                ReadValue(aet, currentLine);
                parameters.SetAET(ecoregion, aet.Value);

                CheckNoDataAfter(lastColumn, currentLine);
                GetNextLine();
            }


            InputVar <string> dynInputFile = new InputVar <string>(Names.DynamicInputFile);

            ReadVar(dynInputFile);
            parameters.DynamicInputFile = dynInputFile.Value;

            //--------- Read In Fire Reductions Table ---------------------------
            PlugIn.ModelCore.UI.WriteLine("   Begin reading FIRE REDUCTION parameters.");
            ReadName(Names.FireReductionParameters);

            InputVar <int>    frindex = new InputVar <int>("Fire Severity Index MUST = 1-5");
            InputVar <double> wred    = new InputVar <double>("Coarse Litter Reduction");
            InputVar <double> lred    = new InputVar <double>("Fine Litter Reduction");

            //InputVar<double> som_red = new InputVar<double>("SOM Reduction");

            while (!AtEndOfInput && CurrentName != Names.HarvestReductionParameters)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(frindex, currentLine);
                int ln = (int)frindex.Value.Actual;

                if (ln < 1 || ln > 5)
                {
                    throw new InputValueException(frindex.Value.String,
                                                  "The fire severity index:  {0} must be 1-5,",
                                                  frindex.Value.String);
                }


                FireReductions inputFireReduction = new FireReductions();  // ignoring severity = zero
                parameters.FireReductionsTable[ln] = inputFireReduction;

                ReadValue(wred, currentLine);
                inputFireReduction.CoarseLitterReduction = wred.Value;

                ReadValue(lred, currentLine);
                inputFireReduction.FineLitterReduction = lred.Value;

                //ReadValue(som_red, currentLine);
                //inputFireReduction.SOMReduction = som_red.Value;

                CheckNoDataAfter("the " + lred.Name + " column", currentLine);

                GetNextLine();
            }

            //--------- Read In Harvest Reductions Table ---------------------------
            InputVar <string> hreds = new InputVar <string>("HarvestReductions");

            ReadName(Names.HarvestReductionParameters);
            PlugIn.ModelCore.UI.WriteLine("   Begin reading HARVEST REDUCTION parameters.");

            InputVar <string> prescriptionName = new InputVar <string>("Prescription");
            InputVar <double> wred_pr          = new InputVar <double>("Coarse Litter Reduction");
            InputVar <double> lred_pr          = new InputVar <double>("Fine Litter Reduction");
            //InputVar<double> som_red_pr = new InputVar<double>("SOM Reduction");
            InputVar <double> cohortw_red_pr = new InputVar <double>("Cohort Biomass Removal");

            //InputVar<double> cohortl_red_pr = new InputVar<double>("Cohort Leaf Removal");


            while (!AtEndOfInput)
            {
                StringReader      currentLine   = new StringReader(CurrentLine);
                HarvestReductions harvReduction = new HarvestReductions();
                parameters.HarvestReductionsTable.Add(harvReduction);

                ReadValue(prescriptionName, currentLine);
                harvReduction.PrescriptionName = prescriptionName.Value;

                ReadValue(wred_pr, currentLine);
                harvReduction.CoarseLitterReduction = wred_pr.Value;

                ReadValue(lred_pr, currentLine);
                harvReduction.FineLitterReduction = lred_pr.Value;

                ReadValue(cohortw_red_pr, currentLine);
                harvReduction.CohortWoodReduction = cohortw_red_pr.Value;

                GetNextLine();
            }



            //string lastParameter = null;
            //if (! AtEndOfInput && CurrentName == Names.AgeOnlyDisturbanceParms) {
            //    InputVar<string> ageOnlyDisturbanceParms = new InputVar<string>(Names.AgeOnlyDisturbanceParms);
            //    ReadVar(ageOnlyDisturbanceParms);
            //    parameters.AgeOnlyDisturbanceParms = ageOnlyDisturbanceParms.Value;

            //    lastParameter = "the " + Names.AgeOnlyDisturbanceParms + " parameter";
            //}

            //if (lastParameter != null)
            //    CheckNoDataAfter(lastParameter);

            return(parameters);
        }
Exemple #25
0
        protected override IInsect Parse()
        {
            InputVar <string> landisData = new InputVar <string>("LandisData");

            ReadVar(landisData);
            if (landisData.Value.Actual != "InsectDefoliator")
            {
                throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", "InsectDefoliator");
            }

            InsectParameters parameters = new InsectParameters(PlugIn.ModelCore.Species.Count);

            InputVar <string> insectName = new InputVar <string>("InsectName");

            ReadVar(insectName);
            parameters.Name = insectName.Value;

            InputVar <int> insectStartYear = new InputVar <int>("StartYear");

            if (ReadOptionalVar(insectStartYear))
            {
                parameters.StartYear = insectStartYear.Value;
            }

            InputVar <DistributionType> ddt = new InputVar <DistributionType>("DurationDistribution");

            ReadVar(ddt);
            parameters.DurationDistribution = ddt.Value;

            InputVar <double> mD = new InputVar <double>("DurationParameter1");

            ReadVar(mD);
            parameters.DurationParameter1 = mD.Value;

            InputVar <double> sdD = new InputVar <double>("DurationParameter2");

            ReadVar(sdD);
            parameters.DurationParameter2 = sdD.Value;

            InputVar <double> maxDur = new InputVar <double>("MaxDuration");

            if (ReadOptionalVar(maxDur))
            {
                ;
            }
            parameters.MaxDuration = maxDur.Value;

            InputVar <int> mTBO = new InputVar <int>("MeanTimeBetweenOutbreaks");

            ReadVar(mTBO);
            parameters.MeanTimeBetweenOutbreaks = mTBO.Value;

            InputVar <int> sdTBO = new InputVar <int>("StdDevTimeBetweenOutbreaks");

            ReadVar(sdTBO);
            parameters.StdDevTimeBetweenOutbreaks = sdTBO.Value;

            InputVar <int> nhs = new InputVar <int>("NeighborhoodSize");

            ReadVar(nhs);
            parameters.NeighborhoodDistance = nhs.Value;

            InputVar <double> ipnc = new InputVar <double>("InitialPatchOutbreakSensitivity");

            ReadVar(ipnc);
            parameters.InitialPatchOutbreakSensitivity = ipnc.Value;

            InputVar <DistributionType> ipdt = new InputVar <DistributionType>("InitialPatchDistribution");

            ReadVar(ipdt);
            parameters.InitialPatchDistr = ipdt.Value;

            InputVar <double> ipv1 = new InputVar <double>("InitialPatchValue1");

            ReadVar(ipv1);
            parameters.InitialPatchValue1 = ipv1.Value;

            InputVar <double> ipv2 = new InputVar <double>("InitialPatchValue2");

            ReadVar(ipv2);
            parameters.InitialPatchValue2 = ipv2.Value;

            //--------- Read In Species Table ---------------------------------------
            PlugIn.ModelCore.UI.WriteLine("   Begin parsing SPECIES table.");
            ReadName("SpeciesParameters");

            InputVar <string> annMort = new InputVar <string>("MortalityEstimate");

            ReadVar(annMort);
            parameters.AnnMort = annMort.Value;

            InputVar <string>        sppName     = new InputVar <string>("Species");
            InputVar <int>           susc        = new InputVar <int>("Species Susceptibility");
            InputVar <double>        grs         = new InputVar <double>("Growth Reduction Slope");
            InputVar <double>        gri         = new InputVar <double>("Growth Reduction Intercept");
            InputVar <double>        msl         = new InputVar <double>("Mortality Slope");
            InputVar <double>        min         = new InputVar <double>("Mortality Intercept");
            Dictionary <string, int> lineNumbers = new Dictionary <string, int>();

            const string Susceptiblities = "Susceptibilities";

            while (!AtEndOfInput && CurrentName != Susceptiblities)
            {
                StringReader currentLine = new StringReader(CurrentLine);


                ReadValue(sppName, currentLine);
                ISpecies species = PlugIn.ModelCore.Species[sppName.Value.Actual];

                if (species == null)
                {
                    throw new InputValueException(sppName.Value.String,
                                                  "{0} is not a species name.",
                                                  sppName.Value.String);
                }
                int lineNumber;
                if (lineNumbers.TryGetValue(species.Name, out lineNumber))
                {
                    throw new InputValueException(sppName.Value.String,
                                                  "The species {0} was previously used on line {1}",
                                                  sppName.Value.String, lineNumber);
                }
                else
                {
                    lineNumbers[species.Name] = LineNumber;
                }

                ISppParameters sppParms = new SppParameters();

                //parameters.SppTable[species.Index] = sppParms; (commented out; BMiranda 11 Aug 2017)
                parameters.SppTable.Add(sppParms);

                ReadValue(susc, currentLine);
                sppParms.Susceptibility = susc.Value;

                ReadValue(grs, currentLine);
                sppParms.GrowthReduceSlope = grs.Value;

                ReadValue(gri, currentLine);
                sppParms.GrowthReduceIntercept = gri.Value;

                ReadValue(msl, currentLine);
                sppParms.MortalitySlope = msl.Value;

                ReadValue(min, currentLine);
                sppParms.MortalityIntercept = min.Value;

                CheckNoDataAfter("the " + min.Name + " column",
                                 currentLine);

                GetNextLine();
            }

            if (parameters.SppTable != null && PlugIn.ModelCore.Species != null &&
                parameters.SppTable.Count != PlugIn.ModelCore.Species.Count)
            {
                throw new MultiLineException("The number of tree species differs between the Species input file (" + PlugIn.ModelCore.Species.Count
                                             + " species) and Biomass Insects (" + parameters.SppTable.Count + " species).");
            }

            //  Read table of Susceptibilities.
            //  Susceptibilities are in decreasing order.
            ReadName(Susceptiblities);
            const string MapNames = "MapNames";

            InputVar <byte>             number = new InputVar <byte>("Susceptibility Number");
            InputVar <DistributionType> dt     = new InputVar <DistributionType>("Distribution");
            InputVar <double>           v1     = new InputVar <double>("Distribution Value 1");
            InputVar <double>           v2     = new InputVar <double>("Distribution Value 2");

            byte previousNumber = 0;

            while (!AtEndOfInput && CurrentName != MapNames)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ISusceptible susceptible = new Susceptible();

                parameters.SusceptibleTable.Add(susceptible);

                ReadValue(number, currentLine);
                susceptible.Number = number.Value;

                //  Check that the current severity's number is 1 less than
                //  the previous number (numbers are must be in decreasing
                //  order).
                if (number.Value.Actual != previousNumber + 1)
                {
                    throw new InputValueException(number.Value.String,
                                                  "Expected the severity number {0}",
                                                  previousNumber + 1);
                }
                previousNumber = number.Value.Actual;

                IDistribution distribution = new Distribution();

                ReadValue(dt, currentLine);
                distribution.Name = dt.Value;

                ReadValue(v1, currentLine);
                distribution.Value1 = v1.Value;

                ReadValue(v2, currentLine);
                distribution.Value2 = v2.Value;

                susceptible.Distribution_80 = distribution; //.GetComplete();

                distribution = new Distribution();

                ReadValue(dt, currentLine);
                distribution.Name = dt.Value;

                ReadValue(v1, currentLine);
                distribution.Value1 = v1.Value;

                ReadValue(v2, currentLine);
                distribution.Value2 = v2.Value;

                susceptible.Distribution_60 = distribution; //.GetComplete();

                distribution = new Distribution();

                ReadValue(dt, currentLine);
                distribution.Name = dt.Value;

                ReadValue(v1, currentLine);
                distribution.Value1 = v1.Value;

                ReadValue(v2, currentLine);
                distribution.Value2 = v2.Value;

                susceptible.Distribution_40 = distribution; //.GetComplete();

                distribution = new Distribution();

                ReadValue(dt, currentLine);
                distribution.Name = dt.Value;

                ReadValue(v1, currentLine);
                distribution.Value1 = v1.Value;

                ReadValue(v2, currentLine);
                distribution.Value2 = v2.Value;

                susceptible.Distribution_20 = distribution; //.GetComplete();

                distribution = new Distribution();

                ReadValue(dt, currentLine);
                distribution.Name = dt.Value;

                ReadValue(v1, currentLine);
                distribution.Value1 = v1.Value;

                ReadValue(v2, currentLine);
                distribution.Value2 = v2.Value;

                susceptible.Distribution_0 = distribution; //.GetComplete();

                CheckNoDataAfter("the " + v2.Name + " column",
                                 currentLine);
                GetNextLine();
            }
            if (parameters.SusceptibleTable.Count == 0)
            {
                throw NewParseException("No susceptibilities defined.");
            }

            return(parameters);//.GetComplete();
        }
 public void Init()
 {
     intVar = new InputVar<int>("IntegerVariable");
     strVar = new InputVar<string>("String_Var");
     longExtraText = "1234567890 abcedefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ\n";
 }
        //---------------------------------------------------------------------

        /// <summary>
        /// Reads 0 or more prescriptions from text input.
        /// </summary>
        protected void ReadPrescriptions(List <Prescription> prescriptions,
                                         int harvestTimestep)
        {
            Dictionary <string, int> lineNumbers = new Dictionary <string, int>();

            InputVar <int> singleRepeat   = new InputVar <int>(Names.SingleRepeat);
            InputVar <int> multipleRepeat = new InputVar <int>(Names.MultipleRepeat);

            int nameLineNumber = LineNumber;
            InputVar <string> prescriptionName = new InputVar <string>(Names.Prescription);

            while (ReadOptionalVar(prescriptionName))
            {
                string name = prescriptionName.Value.Actual;
                int    lineNumber;
                if (lineNumbers.TryGetValue(name, out lineNumber))
                {
                    throw new InputValueException(prescriptionName.Value.String,
                                                  "The name {0} was previously used on line {1}",
                                                  prescriptionName.Value.String, lineNumber);
                }
                else
                {
                    lineNumbers[name] = nameLineNumber;
                }

                //get ranking method
                rankingMethod = ReadRankingMethod();

                //get stand-harvesting requirements, will modify rankingMethod variable
                ReadForestTypeTable();

                //get site selection method
                ISiteSelector siteSelector = ReadSiteSelector();

                //get the minTimeSinceDamage
                int            minTimeSinceDamage    = 0;
                InputVar <int> minTimeSinceDamageVar = new InputVar <int>("MinTimeSinceDamage");
                if (ReadOptionalVar(minTimeSinceDamageVar))
                {
                    minTimeSinceDamage = minTimeSinceDamageVar.Value;
                }

                bool preventEstablishment = ReadPreventEstablishment();

                ICohortSelector cohortSelector = ReadCohortSelector(false);
                ICohortCutter   cohortCutter   = CreateCohortCutter(cohortSelector);

                Planting.SpeciesList speciesToPlant = ReadSpeciesToPlant();

                //  Repeat harvest?
                int repeatParamLineNumber = LineNumber;
                if (ReadOptionalVar(singleRepeat))
                {
                    int interval = ValidateRepeatInterval(singleRepeat.Value,
                                                          repeatParamLineNumber,
                                                          harvestTimestep);
                    ICohortSelector      additionalCohortSelector = ReadCohortSelector(true);
                    ICohortCutter        additionalCohortCutter   = CreateCohortCutter(additionalCohortSelector);
                    Planting.SpeciesList additionalSpeciesToPlant = ReadSpeciesToPlant();
                    ISiteSelector        additionalSiteSelector   = new CompleteStand();
                    prescriptions.Add(new SingleRepeatHarvest(name,
                                                              rankingMethod,
                                                              siteSelector,
                                                              cohortCutter,
                                                              speciesToPlant,
                                                              additionalCohortCutter,
                                                              additionalSpeciesToPlant,
                                                              additionalSiteSelector,
                                                              minTimeSinceDamage,
                                                              preventEstablishment,
                                                              interval));
                }
                else if (ReadOptionalVar(multipleRepeat))
                {
                    int interval = ValidateRepeatInterval(multipleRepeat.Value,
                                                          repeatParamLineNumber,
                                                          harvestTimestep);
                    ISiteSelector additionalSiteSelector = new CompleteStand();
                    prescriptions.Add(new RepeatHarvest(name,
                                                        rankingMethod,
                                                        siteSelector,
                                                        cohortCutter,
                                                        speciesToPlant,
                                                        additionalSiteSelector,
                                                        minTimeSinceDamage,
                                                        preventEstablishment,
                                                        interval));
                }
                else
                {
                    prescriptions.Add(new Prescription(name,
                                                       rankingMethod,
                                                       siteSelector,
                                                       cohortCutter,
                                                       speciesToPlant,
                                                       minTimeSinceDamage,
                                                       preventEstablishment));
                }
            }
        }
        //---------------------------------------------------------------------

        protected override IInputParameters Parse()
        {
            InputVar <string> landisData = new InputVar <string>("LandisData");

            ReadVar(landisData);
            if (landisData.Value.Actual != "Climate Config")
            {
                throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", "Climate Config");
            }

            InputParameters parameters = new InputParameters();

            string climateTimeSeries_PossibleValues = "Monthly_AverageAllYears, Monthly_AverageWithVariation, Monthly_RandomYears, Daily_RandomYears, Daily_AverageAllYears, Daily_SequencedYears, Monthly_SequencedYears";
            string climateFileFormat_PossibleValues = "Daily_Temp-C_Precip-mmDay, Monthly_Temp-C_Precip-mmMonth, Daily_Temp-K_Precip-kgM2Sec, Monthly_Temp-K_Precip-kgM2Sec, mauer_daily, monthly_temp-k_precip-mmmonth, daily_temp-k_precip-mmday";

            //InputVar<string> climateConfigFile = new InputVar<string>(Names.ClimateConfigFile);
            //ReadVar(climateConfigFile);
            //parameters.ClimateConfigFile = climateConfigFile.Value;

            InputVar <string> climateTimeSeries = new InputVar <string>(Names.ClimateTimeSeries);

            ReadVar(climateTimeSeries);
            parameters.ClimateTimeSeries = climateTimeSeries.Value;

            InputVar <string> climateFile = new InputVar <string>(Names.ClimateFile);

            ReadVar(climateFile);
            parameters.ClimateFile = climateFile.Value;

            InputVar <string> climateFileFormat = new InputVar <string>(Names.ClimateFileFormat);

            ReadVar(climateFileFormat);
            parameters.ClimateFileFormat = climateFileFormat.Value;

            InputVar <string> spinUpClimateTimeSeries = new InputVar <string>(Names.SpinUpClimateTimeSeries);

            ReadVar(spinUpClimateTimeSeries);
            parameters.SpinUpClimateTimeSeries = spinUpClimateTimeSeries.Value;

            InputVar <string> spinUpClimateFile       = new InputVar <string>(Names.SpinUpClimateFile);
            InputVar <string> spinUpClimateFileFormat = new InputVar <string>(Names.SpinUpClimateFileFormat);

            ReadVar(spinUpClimateFile);
            parameters.SpinUpClimateFile = spinUpClimateFile.Value;

            ReadVar(spinUpClimateFileFormat);
            parameters.SpinUpClimateFileFormat = spinUpClimateFileFormat.Value;

            if (!climateTimeSeries_PossibleValues.ToLower().Contains(parameters.ClimateTimeSeries.ToLower()) || !climateTimeSeries_PossibleValues.ToLower().Contains(parameters.SpinUpClimateTimeSeries.ToLower()))
            {
                throw new ApplicationException("Error in parsing climate-generator input file: invalid value for ClimateTimeSeries or SpinupTimeSeries provided. Possible values are: " + climateTimeSeries_PossibleValues);
            }

            if (!climateFileFormat_PossibleValues.ToLower().Contains(parameters.ClimateFileFormat.ToLower()) || !climateFileFormat_PossibleValues.ToLower().Contains(parameters.SpinUpClimateFileFormat.ToLower()))
            {
                throw new ApplicationException("Error in parsing climate-generator input file: invalid value for File Format provided. Possible values are: " + climateFileFormat_PossibleValues);
            }

            if (parameters.ClimateTimeSeries.ToLower().Contains("daily") && !parameters.ClimateFileFormat.ToLower().Contains("daily"))
            {
                throw new ApplicationException("You are requesting a Daily Time Step but not inputting daily data:" + parameters.ClimateTimeSeries + " and " + parameters.ClimateFileFormat);
            }

            InputVar <double> rHSlopeAdjust = new InputVar <double>(Names.RHSlopeAdjust);

            ReadOptionalVar(rHSlopeAdjust);
            parameters.RHSlopeAdjust = rHSlopeAdjust.Value;

            return(parameters);
        }
        //----------------------------------------------------------------------

        protected void ReadForestTypeTable()
        {
            SpeciesLineNumbers.Clear();  // in case parser re-used

            int optionalStatements = 0;

            //check if this is the ForestTypeTable
            if (CurrentName == Names.ForestTypeTable)
            {
                ReadName(Names.ForestTypeTable);

                //fresh input variables for table
                InputVar <string> inclusionRule = new InputVar <string>("Inclusion Rule");
                //InputVar<ushort> minAge = new InputVar<ushort>("Min Age");
                //InputVar<ushort> maxAge = new InputVar<ushort>("Max Age");
                InputVar <AgeRange> age_range      = new InputVar <AgeRange>("Age Range");
                InputVar <string>   percentOfCells = new InputVar <string>("PercentOfCells"); //as a string so it can include keyword 'highest'
                InputVar <string>   speciesName    = new InputVar <string>("Species");


                //list for each rule- each line is a separate rule
                List <InclusionRule> rule_list = new List <InclusionRule>();
                //keep reading until no longer in the ForestTypeTable
                while (!AtEndOfInput && !namesThatFollowForestType.Contains(CurrentName))
                {
                    StringReader currentLine = new StringReader(CurrentLine);

                    //  inclusionRule column
                    ReadValue(inclusionRule, currentLine);

                    //verify inclusion rule = 'optional', 'required', or 'forbidden'
                    if (inclusionRule.Value.Actual != "Optional" && inclusionRule.Value.Actual != "Required" &&
                        inclusionRule.Value.Actual != "Forbidden")
                    {
                        string[] ic_list = new string[] { "Valid Inclusion Rules:",
                                                          "    Optional",
                                                          "    Required",
                                                          "    Forbidden" };
                        throw new InputValueException(CurrentName, CurrentName + " is not a valid inclusion rule.",
                                                      new MultiLineText(ic_list));
                    }

                    if (inclusionRule.Value.Actual == "Optional")
                    {
                        optionalStatements++;
                    }


                    TextReader.SkipWhitespace(currentLine);
                    ReadValue(age_range, currentLine);

                    //percentage column
                    TextReader.SkipWhitespace(currentLine);
                    ReadValue(percentOfCells, currentLine);
                    //Model.Core.UI.WriteLine("percentOfCells = {0}", percentOfCells.Value.String);
                    //cannot validate until parsing is done.  will do this in the inclusionRule constructor

                    //a list in case there are multiple species on this line
                    List <string> species_list = new List <string>();
                    //add each species to this rule's species list
                    TextReader.SkipWhitespace(currentLine);
                    while (currentLine.Peek() != -1)
                    {
                        //species column (build list)

                        ReadValue(speciesName, currentLine);
                        string name = speciesName.Value.String;

                        ISpecies species = GetSpecies(new InputValue <string>(name, speciesName.Value.String));
                        if (species_list.Contains(species.Name))
                        {
                            throw NewParseException("The species {0} appears more than once.", species.Name);
                        }
                        species_list.Add(species.Name);

                        //species_list.Add(species.Value.String);
                        TextReader.SkipWhitespace(currentLine);
                    }

                    //add this new inclusion rule (by parameters)  to the requirement
                    rule_list.Add(new InclusionRule(inclusionRule.Value.String,
                                                    age_range.Value.Actual,
                                                    percentOfCells.Value.String,
                                                    species_list));

                    GetNextLine();
                }
                //create a new requirement with this list of rules
                IRequirement inclusionRequirement = new InclusionRequirement(rule_list);
                //add this requirement to the ranking method
                rankingMethod.AddRequirement(inclusionRequirement);
            }

            if (optionalStatements > 0 && optionalStatements < 2)
            {
                throw new InputValueException(CurrentName, "If there are optional statements, there must be more than one",
                                              "ForestTypeTable");
            }
        }
        protected override Land_type_Attributes Parse()
        {
            ReadLandisDataVar();

            InputVar <int>   int_val   = new InputVar <int>("int value");
            InputVar <float> float_val = new InputVar <float>("float value");

            Land_type_Attributes lt_att = new Land_type_Attributes();

            StringReader currentLine = new StringReader(CurrentLine);

            int num_new_map_files = 0;

            if (PlugIn.gl_param.FlagforSECFile == 3)
            {
                ReadValue(int_val, currentLine);
                num_new_map_files = int_val.Value.Actual;

                CheckNoDataAfter("num_new_map_files", currentLine);
                GetNextLine();

                InputVar <int>    year = new InputVar <int>("year");
                InputVar <string> mapf = new InputVar <string>("new map file name");

                for (byte i = 0; i < num_new_map_files; i++)
                {
                    currentLine = new StringReader(CurrentLine);

                    ReadValue(year, currentLine);
                    ReadValue(mapf, currentLine);


                    lt_att.Set_new_landtype_map(year.Value.Actual, mapf.Value.Actual);
                    lt_att.year_arr.Add(year.Value.Actual);

                    CheckNoDataAfter("a new_map_file", currentLine);

                    GetNextLine();
                }

                currentLine = new StringReader(CurrentLine);
            }


            int num_landtype = Land_type_Attributes.Landtype_count;

            for (byte i = 0; i < num_landtype; i++)
            {
                ReadValue(int_val, currentLine);
                Land_type_Attributes.set_min_shade(i, int_val.Value.Actual);
            }

            CheckNoDataAfter("min_shade", currentLine);

            GetNextLine();


            for (byte gsokind = 0; gsokind < 3; gsokind++)
            {
                currentLine = new StringReader(CurrentLine);

                for (byte j = 0; j < num_landtype; j++)
                {
                    ReadValue(float_val, currentLine);

                    Land_type_Attributes.set_gso(gsokind, j, float_val.Value.Actual);
                }


                //CheckNoDataAfter("gso" + gsokind.ToString(), currentLine);

                GetNextLine();
            }


            for (int count = 0; count <= num_new_map_files; count++)
            {
                currentLine = new StringReader(CurrentLine);

                float[] max_gso_value = new float[num_landtype];

                for (byte j = 0; j < num_landtype; j++)
                {
                    ReadValue(float_val, currentLine);

                    max_gso_value[j] = float_val.Value.Actual;
                }

                lt_att.set_maxgso(lt_att.year_arr[count], max_gso_value);

                //CheckNoDataAfter("max_gso", currentLine);

                GetNextLine();
            }

            return(lt_att);
        }
        //---------------------------------------------------------------------

        /// <summary>
        /// Reads harvest implementations: which prescriptions are applied to
        /// which management areas.
        /// </summary>
        protected void ReadHarvestImplementations(ManagementAreaDataset mgmtAreas,
                                                  List <Prescription> prescriptions)
        {
            ReadName(Names.HarvestImplementations);

            InputVar <ushort>     mgmtAreaMapCode  = new InputVar <ushort>("Mgmt Area");
            InputVar <string>     prescriptionName = new InputVar <string>("Prescription");
            InputVar <int>        beginTimeVar     = new InputVar <int>("Begin Time");
            InputVar <int>        endTimeVar       = new InputVar <int>("End Time");
            InputVar <Percentage> areaToHarvest    = new InputVar <Percentage>("Area To Harvest");

            while (!AtEndOfInput && CurrentName != Names.PrescriptionMaps)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                //  Mgmt Area column
                ReadValue(mgmtAreaMapCode, currentLine);
                ushort         mapCode  = mgmtAreaMapCode.Value.Actual;
                ManagementArea mgmtArea = mgmtAreas.Find(mapCode);
                if (mgmtArea == null)
                {
                    //add the management area, and add it to the collection of management areas
                    mgmtArea = new ManagementArea(mapCode);
                    mgmtAreas.Add(mgmtArea);
                }

                //  Prescription column
                ReadValue(prescriptionName, currentLine);
                string       name         = prescriptionName.Value.Actual;
                Prescription prescription = prescriptions.Find(new MatchName(name).Predicate);
                if (prescription == null)
                {
                    throw new InputValueException(prescriptionName.Value.String,
                                                  prescriptionName.Value.String + " is an unknown prescription name");
                }



                //  Area to Harvest column
                ReadValue(areaToHarvest, currentLine);
                //get percentage to harvest (type Percentage ensures that it is in percent format)
                Percentage percentageToHarvest = areaToHarvest.Value.Actual;
                //check for valid percentage
                if (percentageToHarvest <= 0.0 || percentageToHarvest > 1.0)
                {
                    throw new InputValueException(areaToHarvest.Value.String,
                                                  "Percentage must be between 0% and 100%");
                }

                //  Begin Time and End Time columns
                //  They are optional, so the possibilities are:
                //
                //          Begin Time   End Time
                //          ----------   --------
                //      1)   present     present
                //      2)   present     missing
                //      3)   missing     missing

                //  The default values for the starting and ending times for
                //  an applied prescription.
                int beginTime = scenarioStart;
                int endTime   = scenarioEnd;

                TextReader.SkipWhitespace(currentLine);
                if (currentLine.Peek() != -1)
                {
                    ReadValue(beginTimeVar, currentLine);
                    beginTime = beginTimeVar.Value.Actual;
                    if (beginTime < scenarioStart)
                    {
                        throw new InputValueException(beginTimeVar.Value.String,
                                                      string.Format("Year {0} is before the scenario start year ({1})",
                                                                    beginTimeVar.Value.String,
                                                                    scenarioStart));
                    }
                    if (beginTime > scenarioEnd)
                    {
                        throw new InputValueException(beginTimeVar.Value.String,
                                                      string.Format("Year {0} is after the scenario' end year ({1})",
                                                                    beginTimeVar.Value.String,
                                                                    scenarioEnd));
                    }

                    TextReader.SkipWhitespace(currentLine);
                    if (currentLine.Peek() != -1)
                    {
                        ReadValue(endTimeVar, currentLine);
                        endTime = endTimeVar.Value.Actual;
                        if (endTime < beginTime)
                        {
                            throw new InputValueException(endTimeVar.Value.String,
                                                          string.Format("Year {0} is before the Begin Time ({1})",
                                                                        endTimeVar.Value.String,
                                                                        beginTimeVar.Value.String));
                        }
                        if (endTime > scenarioEnd)
                        {
                            throw new InputValueException(endTimeVar.Value.String,
                                                          string.Format("Year {0} is after the scenario' end year ({1})",
                                                                        endTimeVar.Value.String,
                                                                        scenarioEnd));
                        }

                        CheckNoDataAfter("the " + endTimeVar.Name + " column",
                                         currentLine);
                    }
                }


                //if the perscription has already been applied to this management area
                //NOTE: .IsApplied has been modified, and this has been moved to AFTER the
                //begin and end times are founded.
                if (mgmtArea.IsApplied(prescriptionName.Value.String, beginTime, endTime))
                {
                    throw new InputValueException(prescriptionName.Value.String,
                                                  "Prescription {0} has already been applied to management area {1} with begin time = {2} and end time = {3}",
                                                  prescriptionName.Value.String, mgmtArea.MapCode, beginTime, endTime);
                }

                //begin applying prescription to this management area
                mgmtArea.ApplyPrescription(prescription,
                                           percentageToHarvest,
                                           beginTime,
                                           endTime);



                CheckNoDataAfter("the " + prescriptionName.Name + " column",
                                 currentLine);
                GetNextLine();
            }
        }
        //---------------------------------------------------------------------

        protected override IAgent Parse()
        {
            //PlugIn.ModelCore.Log.WriteLine("Parsing 1; sppCnt={0}", Model.Species.Count);
            //Agent agentParameters = new Agent(PlugIn.ModelCore.Species.Count, PlugIn.ModelCore.Ecoregions.Count, (int) DisturbanceType.Null);  //The last disturb Type is Null
            InputVar <string> landisData = new InputVar <string>("LandisData");

            ReadVar(landisData);
            if (landisData.Value.Actual != LandisDataValue)
            {
                throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", LandisDataValue);
            }

            Agent agentParameters = new Agent(PlugIn.ModelCore.Species.Count, PlugIn.ModelCore.Ecoregions.Count);

            InputVar <string> agentName = new InputVar <string>("BDAAgentName");

            ReadVar(agentName);
            agentParameters.AgentName = agentName.Value;

            InputVar <int> bdpc = new InputVar <int>("BDPCalibrator");

            ReadVar(bdpc);
            agentParameters.BDPCalibrator = bdpc.Value;

            InputVar <SRDmode> srd = new InputVar <SRDmode>("SRDMode");

            ReadVar(srd);
            agentParameters.SRDmode = srd.Value;

            InputVar <int> startYear = new InputVar <int>("StartYear");

            if (CurrentName == "StartYear")
            {
                ReadVar(startYear);
                agentParameters.StartYear = startYear.Value;
            }
            else
            {
                agentParameters.StartYear = 0;
            }

            InputVar <int> endYear = new InputVar <int>("EndYear");

            if (CurrentName == "EndYear")
            {
                ReadVar(endYear);
                agentParameters.EndYear = endYear.Value;
            }
            else
            {
                agentParameters.EndYear = PlugIn.ModelCore.EndTime;
            }

            InputVar <OutbreakPattern> rf = new InputVar <OutbreakPattern>("OutbreakPattern");

            ReadVar(rf);
            agentParameters.RandFunc = rf.Value;

            InputVar <double> normMean  = new InputVar <double>("Mean");
            InputVar <double> normStDev = new InputVar <double>("StDev");

            if ((rf.Value.ToString()) == "CyclicNormal")
            {
                ReadVar(normMean);
                agentParameters.NormMean = normMean.Value;
                ReadVar(normStDev);
                agentParameters.NormStDev = normStDev.Value;
            }
            else
            {
                agentParameters.NormMean  = 0;
                agentParameters.NormStDev = 0;
            }

            InputVar <double> maxInterval = new InputVar <double>("MaxInterval");
            InputVar <double> minInterval = new InputVar <double>("MinInterval");

            if (rf.Value.ToString() == "CyclicUniform")
            {
                ReadVar(maxInterval);
                agentParameters.MaxInterval = maxInterval.Value;
                ReadVar(minInterval);
                agentParameters.MinInterval = minInterval.Value;
            }
            else
            {
                agentParameters.MaxInterval = 0;
                agentParameters.MinInterval = 0;
            }

            InputVar <int> tSLE = new InputVar <int>("TimeSinceLastEpidemic");

            ReadVar(tSLE);
            agentParameters.TimeSinceLastEpidemic = tSLE.Value;

            InputVar <TemporalType> tt = new InputVar <TemporalType>("TemporalType");

            ReadVar(tt);
            agentParameters.TempType = tt.Value;

            InputVar <int> minROS = new InputVar <int>("MinROS");

            ReadVar(minROS);
            agentParameters.MinROS = minROS.Value;

            InputVar <int> maxROS = new InputVar <int>("MaxROS");

            ReadVar(maxROS);
            agentParameters.MaxROS = maxROS.Value;


            InputVar <bool> d = new InputVar <bool>("Dispersal");

            ReadVar(d);
            agentParameters.Dispersal = d.Value;

            InputVar <int> dr = new InputVar <int>("DispersalRate");

            ReadVar(dr);
            agentParameters.DispersalRate = dr.Value;

            InputVar <double> et = new InputVar <double>("EpidemicThresh");

            ReadVar(et);
            agentParameters.EpidemicThresh = et.Value;

            InputVar <int> ien = new InputVar <int>("InitialEpicenterNum");

            ReadVar(ien);
            agentParameters.EpicenterNum = ien.Value;

            InputVar <double> oec = new InputVar <double>("OutbreakEpicenterCoeff");

            ReadVar(oec);
            agentParameters.OutbreakEpicenterCoeff = oec.Value;

            InputVar <double> outEpiThresh = new InputVar <double>("OutbreakEpicenterThresh");

            ReadVar(outEpiThresh);
            agentParameters.OutbreakEpicenterThresh = outEpiThresh.Value;

            InputVar <bool> se = new InputVar <bool>("SeedEpicenter");

            ReadVar(se);
            agentParameters.SeedEpicenter = se.Value;

            InputVar <double> sec = new InputVar <double>("SeedEpicenterCoeff");

            ReadVar(sec);
            agentParameters.SeedEpicenterCoeff = sec.Value;

            InputVar <DispersalTemplate> dispt = new InputVar <DispersalTemplate>("DispersalTemplate");

            ReadVar(dispt);
            agentParameters.DispersalTemp = dispt.Value;

            InputVar <bool> nf = new InputVar <bool>("NeighborFlag");

            ReadVar(nf);
            agentParameters.NeighborFlag = nf.Value;

            InputVar <NeighborSpeed> nspeed = new InputVar <NeighborSpeed>("NeighborSpeedUp");

            ReadVar(nspeed);
            agentParameters.NeighborSpeedUp = nspeed.Value;

            InputVar <int> nr = new InputVar <int>("NeighborRadius");

            ReadVar(nr);
            agentParameters.NeighborRadius = nr.Value;

            InputVar <NeighborShape> ns = new InputVar <NeighborShape>("NeighborShape");

            ReadVar(ns);
            agentParameters.ShapeOfNeighbor = ns.Value;

            InputVar <double> nw = new InputVar <double>("NeighborWeight");

            ReadVar(nw);
            agentParameters.NeighborWeight = nw.Value;

            InputVar <double> class2_SV = new InputVar <double>("IntensityClass2_BDP");

            ReadVar(class2_SV);
            agentParameters.Class2_SV = class2_SV.Value;

            InputVar <double> class3_SV = new InputVar <double>("IntensityClass3_BDP");

            ReadVar(class3_SV);
            agentParameters.Class3_SV = class3_SV.Value;

            //--------- Read In Ecoreigon Table ---------------------------------------
            PlugIn.ModelCore.UI.WriteLine("Begin parsing ECOREGION table.");

            InputVar <string> ecoName     = new InputVar <string>("Ecoregion Name");
            InputVar <double> ecoModifier = new InputVar <double>("Ecoregion Modifier");

            Dictionary <string, int> lineNumbers = new Dictionary <string, int>();
            const string             DistParms   = "DisturbanceModifiers";
            const string             SppParms    = "BDASpeciesParameters";

            while (!AtEndOfInput && CurrentName != DistParms && CurrentName != SppParms)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(ecoName, currentLine);
                IEcoregion ecoregion = EcoregionsDataset[ecoName.Value.Actual];
                if (ecoregion == null)
                {
                    throw new InputValueException(ecoName.Value.String,
                                                  "{0} is not an ecoregion name.",
                                                  ecoName.Value.String);
                }
                int lineNumber;
                if (lineNumbers.TryGetValue(ecoregion.Name, out lineNumber))
                {
                    throw new InputValueException(ecoName.Value.String,
                                                  "The ecoregion {0} was previously used on line {1}",
                                                  ecoName.Value.String, lineNumber);
                }
                else
                {
                    lineNumbers[ecoregion.Name] = LineNumber;
                }

                IEcoParameters ecoParms = new EcoParameters();
                agentParameters.EcoParameters[ecoregion.Index] = ecoParms;

                ReadValue(ecoModifier, currentLine);
                ecoParms.EcoModifier = ecoModifier.Value;

                CheckNoDataAfter("the " + ecoModifier.Name + " column",
                                 currentLine);
                GetNextLine();
            }

            if (CurrentName == DistParms)
            {
                //--------- Read In Disturbance Modifier Table -------------------------------
                PlugIn.ModelCore.UI.WriteLine("Begin parsing DISTURBANCE table.");

                ReadName(DistParms);

                InputVar <string> prescriptionName = new InputVar <string>("Disturbance Type");
                InputVar <int>    duration         = new InputVar <int>("Duration");
                InputVar <double> distModifier     = new InputVar <double>("Disturbance Modifier");

                lineNumbers = new Dictionary <string, int>();
                Dictionary <int, int> DisturbanceTypeLineNumbers = new Dictionary <int, int>();


                while (!AtEndOfInput && CurrentName != SppParms)
                {
                    StringReader currentLine = new StringReader(CurrentLine);

                    ReadValue(distModifier, currentLine);

                    IDisturbanceType currentDisturbanceType = new DisturbanceType();
                    agentParameters.DisturbanceTypes.Add(currentDisturbanceType);

                    currentDisturbanceType.SRDModifier = distModifier.Value;

                    //IDistParameters distParms = new DistParameters();
                    //agentParameters.DistParameters[dt] = distParms;

                    ReadValue(duration, currentLine);
                    currentDisturbanceType.MaxAge = duration.Value;

                    List <string> prescriptionNames = new List <string>();
                    TextReader.SkipWhitespace(currentLine);
                    while (currentLine.Peek() != -1)
                    {
                        ReadValue(prescriptionName, currentLine);
                        prescriptionNames.Add(prescriptionName.Value);

                        TextReader.SkipWhitespace(currentLine);
                    }
                    if (prescriptionNames.Count == 0)
                    {
                        throw NewParseException("At least one disturbance type is required.");
                    }

                    currentDisturbanceType.PrescriptionNames = prescriptionNames;

                    //ReadValue(distType, currentLine);
                    //int dt = (int)distType.Value.Actual;

                    CheckNoDataAfter("the " + distModifier.Name + " column",
                                     currentLine);
                    GetNextLine();
                }
            }
            //--------- Read In Species Table ---------------------------------------
            PlugIn.ModelCore.UI.WriteLine("Begin parsing SPECIES table.");

            ReadName(SppParms);

            //const string FireCurves = "FireCurveTable";
            InputVar <string> sppName            = new InputVar <string>("Species");
            InputVar <int>    minorHostAge       = new InputVar <int>("Minor Host Age");
            InputVar <double> minorHostSRD       = new InputVar <double>("Minor Host SRDProb");
            InputVar <int>    secondaryHostAge   = new InputVar <int>("Second Host Age");
            InputVar <double> secondaryHostSRD   = new InputVar <double>("Secondary Host SRDProb");
            InputVar <int>    primaryHostAge     = new InputVar <int>("Primary Host Age");
            InputVar <double> primaryHostSRD     = new InputVar <double>("Primary Host SRDProb");
            InputVar <int>    resistantHostAge   = new InputVar <int>("Resistant Host Age");
            InputVar <double> resistantHostVuln  = new InputVar <double>("Resistant Host VulnProb");
            InputVar <int>    tolerantHostAge    = new InputVar <int>("Tolerant Host Age");
            InputVar <double> tolerantHostVuln   = new InputVar <double>("Tolerant Host VulnProb");
            InputVar <int>    vulnerableHostAge  = new InputVar <int>("Vulnerable Host Age");
            InputVar <double> vulnerableHostVuln = new InputVar <double>("Vulnerable Host VulnProb");
            InputVar <bool>   cfsConifer         = new InputVar <bool>("CFS Conifer type:  yes/no");

            const string NegSpp         = "IgnoredSpecies";
            const string AdvRegenSpp    = "AdvancedRegenSpecies";
            const string AdvRegenMaxAge = "AgeCutoff";

            while ((!AtEndOfInput) && (CurrentName != NegSpp) && (CurrentName != AdvRegenSpp) && (CurrentName != AdvRegenMaxAge))
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(sppName, currentLine);
                ISpecies species = SpeciesDataset[sppName.Value.Actual];
                if (species == null)
                {
                    throw new InputValueException(sppName.Value.String,
                                                  "{0} is not a species name.",
                                                  sppName.Value.String);
                }
                int lineNumber;
                if (lineNumbers.TryGetValue(species.Name, out lineNumber))
                {
                    throw new InputValueException(sppName.Value.String,
                                                  "The species {0} was previously used on line {1}",
                                                  sppName.Value.String, lineNumber);
                }
                else
                {
                    lineNumbers[species.Name] = LineNumber;
                }

                ISppParameters sppParms = new SppParameters();
                agentParameters.SppParameters[species.Index] = sppParms;

                ReadValue(minorHostAge, currentLine);
                sppParms.MinorHostAge = minorHostAge.Value;

                ReadValue(minorHostSRD, currentLine);
                sppParms.MinorHostSRD = minorHostSRD.Value;

                ReadValue(secondaryHostAge, currentLine);
                sppParms.SecondaryHostAge = secondaryHostAge.Value;

                ReadValue(secondaryHostSRD, currentLine);
                sppParms.SecondaryHostSRD = secondaryHostSRD.Value;

                ReadValue(primaryHostAge, currentLine);
                sppParms.PrimaryHostAge = primaryHostAge.Value;

                ReadValue(primaryHostSRD, currentLine);
                sppParms.PrimaryHostSRD = primaryHostSRD.Value;

                ReadValue(resistantHostAge, currentLine);
                sppParms.ResistantHostAge = resistantHostAge.Value;

                ReadValue(resistantHostVuln, currentLine);
                sppParms.ResistantHostVuln = resistantHostVuln.Value;

                ReadValue(tolerantHostAge, currentLine);
                sppParms.TolerantHostAge = tolerantHostAge.Value;

                ReadValue(tolerantHostVuln, currentLine);
                sppParms.TolerantHostVuln = tolerantHostVuln.Value;

                ReadValue(vulnerableHostAge, currentLine);
                sppParms.VulnerableHostAge = vulnerableHostAge.Value;

                ReadValue(vulnerableHostVuln, currentLine);
                sppParms.VulnerableHostVuln = vulnerableHostVuln.Value;

                ReadValue(cfsConifer, currentLine);
                sppParms.CFSConifer = cfsConifer.Value;

                CheckNoDataAfter("the " + cfsConifer.Name + " column",
                                 currentLine);


                GetNextLine();
            }

            //--------- Read In Ignored Species List ---------------------------------------

            List <ISpecies> negSppList = new List <ISpecies>();

            if (!AtEndOfInput && (CurrentName != AdvRegenSpp) && (CurrentName != AdvRegenMaxAge))
            {
                ReadName(NegSpp);
                InputVar <string> negSppName = new InputVar <string>("Ignored Spp Name");

                while (!AtEndOfInput && (CurrentName != AdvRegenSpp) && (CurrentName != AdvRegenMaxAge))
                {
                    StringReader currentLine = new StringReader(CurrentLine);

                    ReadValue(negSppName, currentLine);
                    ISpecies species = SpeciesDataset[negSppName.Value.Actual];
                    if (species == null)
                    {
                        throw new InputValueException(negSppName.Value.String,
                                                      "{0} is not a species name.",
                                                      negSppName.Value.String);
                    }
                    int lineNumber;
                    if (lineNumbers.TryGetValue(species.Name, out lineNumber))
                    {
                        PlugIn.ModelCore.UI.WriteLine("WARNING: The species {0} was previously used on line {1}.  Being listed in the IgnoredSpecies list will override any settings in the Host table.", negSppName.Value.String, lineNumber);
                    }
                    else
                    {
                        lineNumbers[species.Name] = LineNumber;
                    }

                    negSppList.Add(species);

                    GetNextLine();
                }
            }
            agentParameters.NegSppList = negSppList;

            //--------- Read In Advanced Regen Species List ---------------------------------------

            List <ISpecies> advRegenSppList = new List <ISpecies>();

            if (!AtEndOfInput && (CurrentName != AdvRegenMaxAge))
            {
                ReadName(AdvRegenSpp);
                InputVar <string> advRegenSppName = new InputVar <string>("Advanced Regen Spp Name");

                while (!AtEndOfInput && CurrentName != "AgeCutoff")
                {
                    StringReader currentLine = new StringReader(CurrentLine);

                    ReadValue(advRegenSppName, currentLine);
                    ISpecies species = SpeciesDataset[advRegenSppName.Value.Actual];
                    if (species == null)
                    {
                        throw new InputValueException(advRegenSppName.Value.String,
                                                      "{0} is not a species name.",
                                                      advRegenSppName.Value.String);
                    }

                    lineNumbers[species.Name] = LineNumber;

                    advRegenSppList.Add(species);

                    GetNextLine();
                }
            }
            agentParameters.AdvRegenSppList = advRegenSppList;

            InputVar <int> advRegenAgeCutoff = new InputVar <int>("AgeCutoff");

            if (!AtEndOfInput)
            {
                ReadVar(advRegenAgeCutoff);
                agentParameters.AdvRegenAgeCutoff = advRegenAgeCutoff.Value;
            }
            else
            {
                agentParameters.AdvRegenAgeCutoff = 0;
            }


            return(agentParameters); //.GetComplete();
        }
        public void Init()
        {
            doubleVar = new InputVar<double>("Double Input Var");

            values = new double[] { -4, 78900, 0, 555 };
            string[] valsAsStrs = Array.ConvertAll(values,
                                                   new Converter<double, string>(Convert.ToString));
            valuesAsStr = string.Join(" ", valsAsStrs);
        }
        //---------------------------------------------------------------------

        protected override IInputParameters Parse()
        {
            ReadLandisDataVar();

            InputParameters parameters = new InputParameters(PlugIn.ModelCore.Species.Count);

            InputVar <int> timestep = new InputVar <int>("Timestep");

            ReadVar(timestep);
            parameters.Timestep = timestep.Value;

            // Table of Fuel coefficients
            InputVar <string> speciesName = new InputVar <string>("Species");
            InputVar <double> FuelCoeff   = new InputVar <double>("Fuel Coefficient");

            Dictionary <string, int> lineNumbers = new Dictionary <string, int>();

            const string HardwoodLabel = "HardwoodMaximum";

            while (!AtEndOfInput && CurrentName != HardwoodLabel)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(speciesName, currentLine);
                ISpecies species = GetSpecies(speciesName.Value);
                CheckForRepeatedName(speciesName.Value, "species", lineNumbers);

                ReadValue(FuelCoeff, currentLine);
                parameters.FuelCoefficients[species.Index] = FuelCoeff.Value;

                CheckNoDataAfter(string.Format("the {0} column", FuelCoeff.Name),
                                 currentLine);
                GetNextLine();
            }

            const string FuelTypeNames = "FuelTypes";

            //------------------------------------------------------------
            InputVar <int> hardwoodMax = new InputVar <int>("HardwoodMaximum");

            ReadVar(hardwoodMax);
            parameters.HardwoodMax = hardwoodMax.Value;

            InputVar <int> deadFirMaxAge = new InputVar <int>("DeadFirMaxAge");

            ReadVar(deadFirMaxAge);
            parameters.DeadFirMaxAge = deadFirMaxAge.Value;


            //------------------------------------------------------------
            //  Read definitions of Fuel maps

            PlugIn.ModelCore.UI.WriteLine("   Reading in the Fuel Assignment table...");
            ReadName(FuelTypeNames);

            List <string> speciesNames = new List <string>();

            InputVar <int>          fi     = new InputVar <int>("Fuel Index (should match table in dynamic fire input file)");
            InputVar <BaseFuelType> bft    = new InputVar <BaseFuelType>("Base Fuel Type");
            InputVar <int>          minAge = new InputVar <int>("Min Age");
            InputVar <int>          maxAge = new InputVar <int>("Max Age");

            lineNumbers.Clear();
            Dictionary <int, int> FuelTypeLineNumbers = new Dictionary <int, int>();

            const string DisturbanceConversionTable = "DisturbanceConversionTable";
            const string EcoregionTable             = "EcoregionTable";

            while (!AtEndOfInput && CurrentName != DisturbanceConversionTable && CurrentName != EcoregionTable)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(fi, currentLine);
                CheckForRepeatedIndex(fi.Value, "fuel type", FuelTypeLineNumbers);

                IFuelType currentFuelType = new FuelType(PlugIn.ModelCore.Species.Count, PlugIn.ModelCore.Ecoregions.Count);
                parameters.FuelTypes.Add(currentFuelType);

                currentFuelType.Index = fi.Value;

                ReadValue(bft, currentLine);
                currentFuelType.BaseFuel = bft.Value;

                // Read the age ranges for the species:
                ReadValue(minAge, currentLine);
                currentFuelType.MinAge = minAge.Value;

                TextReader.SkipWhitespace(currentLine);
                string word = TextReader.ReadWord(currentLine);
                if (word != "to")
                {
                    StringBuilder message = new StringBuilder();
                    message.AppendFormat("Expected \"to\" after the minimum age ({0})",
                                         minAge.Value.String);
                    if (word.Length > 0)
                    {
                        message.AppendFormat(", but found \"{0}\" instead", word);
                    }
                    throw NewParseException(message.ToString());
                }

                ReadValue(maxAge, currentLine);
                currentFuelType.MaxAge = maxAge.Value;

                //  Read the species for the fuel type:
                speciesNames = new List <string>();

                TextReader.SkipWhitespace(currentLine);
                while (currentLine.Peek() != -1)
                {
                    ReadValue(speciesName, currentLine);
                    string name = speciesName.Value.Actual;
                    bool   negativeMultiplier = name.StartsWith("-");
                    if (negativeMultiplier)
                    {
                        name = name.Substring(1);
                        if (name.Length == 0)
                        {
                            throw new InputValueException(speciesName.Value.String,
                                                          "No species name after \"-\"");
                        }
                    }
                    ISpecies species = GetSpecies(new InputValue <string>(name, speciesName.Value.String));
                    if (speciesNames.Contains(species.Name))
                    {
                        throw NewParseException("The species {0} appears more than once.", species.Name);
                    }
                    speciesNames.Add(species.Name);

                    currentFuelType[species.Index] = negativeMultiplier ? -1 : 1;

                    TextReader.SkipWhitespace(currentLine);
                }
                if (speciesNames.Count == 0)
                {
                    throw NewParseException("At least one species is required.");
                }

                GetNextLine();
            }

            //----------------------------------------------------------
            // Optional ecoregion data
            if (ReadOptionalName(EcoregionTable))
            {
                PlugIn.ModelCore.UI.WriteLine("   Loading Ecoregion data...");
                InputVar <int>    fi2           = new InputVar <int>("Fuel Index (Ecoregion Table)");
                InputVar <string> ecoregionName = new InputVar <string>("Ecoregion Name");
                lineNumbers.Clear();

                while (!AtEndOfInput && CurrentName != DisturbanceConversionTable)
                {
                    StringReader currentLine = new StringReader(CurrentLine);

                    ReadValue(fi2, currentLine);
                    IFuelType currentFuelType = GetFuelType(fi2, lineNumbers, parameters);

                    bool[] ecoregions = new bool[PlugIn.ModelCore.Ecoregions.Count];
                    for (int i = 0; i < PlugIn.ModelCore.Ecoregions.Count; i++)
                    {
                        ecoregions[i] = false;
                    }

                    //  Read the ecoregions for the fuel type:
                    List <string> ecoNames = new List <string>();

                    TextReader.SkipWhitespace(currentLine);
                    while (currentLine.Peek() != -1)
                    {
                        ReadValue(ecoregionName, currentLine);
                        IEcoregion ecoregion = GetEcoregion(ecoregionName.Value);

                        if (ecoNames.Contains(ecoregion.Name))
                        {
                            throw NewParseException("The ecoregion {0} appears more than once.", ecoregion.Name);
                        }

                        ecoNames.Add(ecoregion.Name);

                        ecoregions[ecoregion.Index] = true;

                        TextReader.SkipWhitespace(currentLine);
                    }

                    currentFuelType.Ecoregions = ecoregions;

                    GetNextLine();
                }
            }


            //------------------------------------------------------------
            //  Read definitions of Disturbance Types
            PlugIn.ModelCore.UI.WriteLine("   Reading in the Disturbance Type table...");
            ReadName(DisturbanceConversionTable);

            InputVar <int>    fti              = new InputVar <int>("Fuel Index");
            InputVar <int>    maxAgeS          = new InputVar <int>("Max Age");
            InputVar <string> prescriptionName = new InputVar <string>("Prescription");

            lineNumbers.Clear();
            Dictionary <int, int> distTypeLineNumbers = new Dictionary <int, int>();

            const string MapFileNames       = "MapFileNames";
            const string PctConiferFileName = "PctConiferFileName";
            const string PctDeadFirFileName = "PctDeadFirFileName";

            while (!AtEndOfInput && CurrentName != MapFileNames)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                ReadValue(fti, currentLine);

                IDisturbanceType currentDisturbanceType = new DisturbanceType();
                parameters.DisturbanceTypes.Add(currentDisturbanceType);

                currentDisturbanceType.FuelIndex = fti.Value;

                ReadValue(maxAgeS, currentLine);
                currentDisturbanceType.MaxAge = maxAgeS.Value;

                List <string> prescriptionNames = new List <string>();

                TextReader.SkipWhitespace(currentLine);
                while (currentLine.Peek() != -1)
                {
                    ReadValue(prescriptionName, currentLine);
                    prescriptionNames.Add(prescriptionName.Value);

                    TextReader.SkipWhitespace(currentLine);
                }
                if (prescriptionNames.Count == 0)
                {
                    throw NewParseException("At least one prescription is required.");
                }

                currentDisturbanceType.PrescriptionNames = prescriptionNames;

                GetNextLine();
            }
            //------------------------------------------------------------
            // Template for filenames of Fuel maps

            PlugIn.ModelCore.UI.WriteLine("   Reading in map names...");

            InputVar <string> mapFileNames = new InputVar <string>(MapFileNames);

            ReadVar(mapFileNames);
            parameters.MapFileNames = mapFileNames.Value;

            //
            //GetNextLine();
            //------------------------------------------------------------
            // Template for filenames of percent conifer maps

            InputVar <string> pctConiferFileName = new InputVar <string>(PctConiferFileName);

            ReadVar(pctConiferFileName);
            parameters.PctConiferFileName = pctConiferFileName.Value;

            //GetNextLine();
            //------------------------------------------------------------
            // Template for filenames of percent dead fir maps

            InputVar <string> pctDeadFirFileName = new InputVar <string>(PctDeadFirFileName);

            ReadVar(pctDeadFirFileName);
            parameters.PctDeadFirFileName = pctDeadFirFileName.Value;

            CheckNoDataAfter(string.Format("the {0} parameter", PctDeadFirFileName));

            return(parameters);
        }
 public void ReadMethodNull()
 {
     InputVar<int> var = new InputVar<int>("var", (ReadMethod<int>) null);
 }
Exemple #36
0
 public SpeciesParameterParser()
 {
     this.speciesLineNums = new Dictionary <string, int>();
     this.speciesName     = new InputVar <string>("Species");
 }
 public void Init()
 {
     yearVar = new InputVar<int>("Year", InputValidation.ReadYear);
     InputValidation.Initialize(startYear, endYear);
 }
Exemple #38
0
        protected override IInputParameters Parse()
        {
            StringReader    currentLine;
            InputParameters parameters = new InputParameters();


            // to get the option to read species parameters from an external file
            MakeSureFileContainsKeyWord(InputParametersParser.Names.PnETSpeciesParameters);


            currentLine = new StringReader(CurrentLine);

            string line = currentLine.ReadLine().Trim();

            if (line.Contains("SpeciesName"))
            {
                line = line.Replace("SpeciesName", "");
                string[] Headers = new string[] { "TOfol", "FolRet", "TOroot", "TOwood", "GDDFolSt", "AmaxA", "AmaxB", "HalfSat", "BFolResp", "GrMstSens", "WltPnt", "PsnAgeRed",
                                                  "Q10", "PsnTMin", "PsnTOpt", "SLWmax", "SLWDel", "CDDFolEnd", "k", "FolN",
                                                  "DVPD1", "DVPD2", "WUEcnst", "MaintResp", "DNSC", "RtStRatio", "EstMoist", "EstRad", "KWdLit", "FolLignin" };


                headerlabels = CheckHeaderLabels(line, Headers);
                GetNextLine();
            }



            speciesLineNums.Clear();  //  If parser re-used (i.e., for testing purposes)

            InputVar <string> SpeciesNameHeader = new InputVar <string>("SpeciesName");

            // Make sure that all index numbers are called, if not throw an error
            bool[] AccountedFor = new bool[PlugIn.ModelCore.Species.Count];

            while (!AtEndOfInput && CurrentName != InputParametersParser.Names.EcoregionParameters)
            {
                currentLine = new StringReader(CurrentLine);

                ISpecies species = ReadSpecies(currentLine);
                AccountedFor[species.Index] = true;

                foreach (string label in headerlabels)
                {
                    InputVar <float> var = new InputVar <float>(label);

                    ReadValue(var, currentLine);

                    if (TrySet(label, "TOfol", var.Value, 0, 1000, species, parameters.TOfol))
                    {
                        continue;
                    }
                    if (TrySet(label, "FolRet", var.Value, 0, 1, species, parameters.FolRet))
                    {
                        continue;
                    }
                    if (TrySet(label, "TOroot", var.Value, 0, 1, species, parameters.TOroot))
                    {
                        continue;
                    }
                    if (TrySet(label, "TOwood", var.Value, 0, 1, species, parameters.TOwood))
                    {
                        continue;
                    }
                    if (TrySet(label, "GDDFolSt", var.Value, 1, 2000, species, parameters.GDDFolSt))
                    {
                        continue;
                    }
                    if (TrySet(label, "AmaxA", var.Value, -500, 500, species, parameters.AmaxA))
                    {
                        continue;
                    }
                    if (TrySet(label, "AmaxB", var.Value, 0, float.MaxValue, species, parameters.AmaxB))
                    {
                        continue;
                    }
                    if (TrySet(label, "HalfSat", var.Value, 0, float.MaxValue, species, parameters.HalfSat))
                    {
                        continue;
                    }
                    if (TrySet(label, "BFolResp", var.Value, 0, 1000, species, parameters.BFolResp))
                    {
                        continue;
                    }
                    if (TrySet(label, "GrMstSens", var.Value, 0.1F, float.MaxValue, species, parameters.GrMstSens))
                    {
                        continue;
                    }
                    if (TrySet(label, "WltPnt", var.Value, 0, 1, species, parameters.WltPnt))
                    {
                        continue;
                    }
                    if (TrySet(label, "PsnAgeRed", var.Value, 1.0F / float.MaxValue, float.MaxValue, species, parameters.PsnAgeRed))
                    {
                        continue;
                    }
                    if (TrySet(label, "Q10", var.Value, 0, 10, species, parameters.Q10))
                    {
                        continue;
                    }
                    if (TrySet(label, "PsnTMin", var.Value, -10, 10, species, parameters.PsnTMin))
                    {
                        continue;
                    }
                    if (TrySet(label, "PsnTOpt", var.Value, 0, 40, species, parameters.PsnTOpt))
                    {
                        continue;
                    }
                    if (TrySet(label, "SLWmax", var.Value, 0, 1000, species, parameters.SLWmax))
                    {
                        continue;
                    }
                    if (TrySet(label, "SLWDel", var.Value, 0, 2, species, parameters.SLWDel))
                    {
                        continue;
                    }
                    if (TrySet(label, "CDDFolEnd", var.Value, 0, 5000, species, parameters.CDDFolEnd))
                    {
                        continue;
                    }
                    if (TrySet(label, "k", var.Value, 0, 2, species, parameters.K))
                    {
                        continue;
                    }
                    if (TrySet(label, "FolN", var.Value, 0, 10, species, parameters.FolN))
                    {
                        continue;
                    }
                    if (TrySet(label, "DVPD1", var.Value, 0, 5, species, parameters.DVPD1))
                    {
                        continue;
                    }
                    if (TrySet(label, "DVPD2", var.Value, 0, 5, species, parameters.DVPD2))
                    {
                        continue;
                    }
                    if (TrySet(label, "WUEcnst", var.Value, 0, float.MaxValue, species, parameters.WUEcnst))
                    {
                        continue;
                    }
                    if (TrySet(label, "MaintResp", var.Value, 0, 1, species, parameters.MaintResp))
                    {
                        continue;
                    }
                    if (TrySet(label, "DNSC", var.Value, 0, 10, species, parameters.DNSC))
                    {
                        continue;
                    }
                    if (TrySet(label, "RtStRatio", var.Value, 0, 1, species, parameters.RtStRatio))
                    {
                        continue;
                    }
                    if (TrySet(label, "EstMoist", var.Value, 0, float.MaxValue, species, parameters.EstMoist))
                    {
                        continue;
                    }
                    if (TrySet(label, "EstRad", var.Value, 0, float.MaxValue, species, parameters.EstRad))
                    {
                        continue;
                    }
                    if (TrySet(label, "KWdLit", var.Value, 0, float.MaxValue, species, parameters.KWdLit))
                    {
                        continue;
                    }

                    if (label == "KNWdLit")
                    {
                        throw new System.Exception("KNWdLit is depreciated per 6/24/2014, foliage decomposition rate is calculated from leaf lignin (FolLignin) and site specific AET");
                    }

                    if (TrySet(label, "FolLignin", var.Value, 0, float.MaxValue, species, parameters.FolLignin))
                    {
                        continue;
                    }

                    throw new System.Exception("Undetermined parameter label name " + label);
                }
                GetNextLine();
            }

            foreach (ISpecies spc in PlugIn.modelCore.Species)
            {
                if (AccountedFor[spc.Index] == false)
                {
                    throw new System.Exception(spc.Name + " is not accounted for in PnET-Species parameter file");
                }
            }
            return(parameters);
        }
 public void Init()
 {
     inputVar = new InputVar<int>("Effective Seed Dist", EffectiveSeedDist.ReadMethod);
 }
        //---------------------------------------------------------------------

        protected override Dictionary <int, IClimateRecord[, ]> Parse()
        {
            ReadLandisDataVar();

            Dictionary <int, IClimateRecord[, ]> allData = new Dictionary <int, IClimateRecord[, ]>();

            const string nextTableName = "ClimateTable";


            //---------------------------------------------------------------------
            //Read in climate data:

            ReadName(nextTableName);

            //InputVar<string> ecoregionName = new InputVar<string>("Ecoregion");
            InputVar <int>    ecoregionIndex = new InputVar <int>("Ecoregion Index");
            InputVar <int>    year           = new InputVar <int>("Time step for updating the climate");
            InputVar <int>    month          = new InputVar <int>("The Month");
            InputVar <double> avgMinTemp     = new InputVar <double>("Monthly Minimum Temperature Value");
            InputVar <double> avgMaxTemp     = new InputVar <double>("Monthly Maximum Temperature Value");
            InputVar <double> stdDevTemp     = new InputVar <double>("Monthly Std Deviation Temperature Value");
            InputVar <double> avgPpt         = new InputVar <double>("Monthly Precipitation Value");
            InputVar <double> stdDevPpt      = new InputVar <double>("Monthly Std Deviation Precipitation Value");
            InputVar <double> par            = new InputVar <double>("Monthly Photosynthetically Active Radiation Value");

            while (!AtEndOfInput)
            {
                StringReader currentLine = new StringReader(CurrentLine);

                //ReadValue(ecoregionName, currentLine);
                ReadValue(ecoregionIndex, currentLine);

                //IEcoregion ecoregion = GetEcoregion(ecoregionName.Value);

                ReadValue(year, currentLine);
                int yr = year.Value.Actual;

                if (!allData.ContainsKey(yr))
                {
                    IClimateRecord[,] climateTable = new IClimateRecord[ecoregionDataset.Count, 12];
                    allData.Add(yr, climateTable);
                    //UI.WriteLine("  Climate Parser:  Add new year = {0}.", yr);
                }

                ReadValue(month, currentLine);
                int mo = month.Value.Actual;

                IClimateRecord climateRecord = new ClimateRecord();

                ReadValue(avgMinTemp, currentLine);
                climateRecord.AvgMinTemp = avgMinTemp.Value;

                ReadValue(avgMaxTemp, currentLine);
                climateRecord.AvgMaxTemp = avgMaxTemp.Value;

                ReadValue(stdDevTemp, currentLine);
                climateRecord.StdDevTemp = stdDevTemp.Value;

                ReadValue(avgPpt, currentLine);
                climateRecord.AvgPpt = avgPpt.Value;

                ReadValue(stdDevPpt, currentLine);
                climateRecord.StdDevPpt = stdDevPpt.Value;

                ReadValue(par, currentLine);
                climateRecord.PAR = par.Value;

                allData[yr][ecoregionIndex.Value, mo - 1] = climateRecord;

                //UI.WriteLine(" climateTable avgPpt={0:0.0}.", climateTable[ecoregion.Index, mo-1].AvgPpt);
                //UI.WriteLine(" allData yr={0}, mo={1}, avgPpt={2:0.0}.", yr, mo, allData[yr][ecoregion.Index, mo-1].AvgPpt);

                CheckNoDataAfter("the " + par.Name + " column",
                                 currentLine);

                GetNextLine();
            }

            return(allData);
        }
        //---------------------------------------------------------------------

        /// <summary>
        /// Reads 0 or more prescriptions from text input.
        /// </summary>
        new protected void ReadPrescriptions(List<Prescription> prescriptions,
                                             int harvestTimestep)
        {
            Dictionary<string, int> lineNumbers = new Dictionary<string, int>();

            InputVar<int> singleRepeat = new InputVar<int>(Names.SingleRepeat);
            InputVar<int> multipleRepeat = new InputVar<int>(Names.MultipleRepeat);

            int nameLineNumber = LineNumber;
            InputVar<string> prescriptionName = new InputVar<string>(Names.Prescription);
            while (ReadOptionalVar(prescriptionName))
            {
                string name = prescriptionName.Value.Actual;
                int lineNumber;
                if (lineNumbers.TryGetValue(name, out lineNumber))
                    throw new InputValueException(prescriptionName.Value.String,
                                                  "The name {0} was previously used on line {1}",
                                                  prescriptionName.Value.String, lineNumber);
                else
                    lineNumbers[name] = nameLineNumber;

                IStandRankingMethod rankingMethod = ReadRankingMethod();

                // Modify the ranking method with the forest-type table
                ReadForestTypeTable(rankingMethod);

                ISiteSelector siteSelector = ReadSiteSelector();

                bool isSiteSelectorWrapped = false;

                //get the minTimeSinceDamage
                minTimeSinceDamage = 0;
                InputVar<int> minTimeSinceDamageVar = new InputVar<int>("MinTimeSinceDamage");
                if (ReadOptionalVar(minTimeSinceDamageVar))
                {
                    minTimeSinceDamage = minTimeSinceDamageVar.Value;
                }

                //get preventEstablishment
                bool preventEstablishment = false;
                if (ReadOptionalName("PreventEstablishment"))
                {
                    preventEstablishment = true;
                }


                ICohortSelector cohortSelector = ReadCohortSelector(false);
                MultiSpeciesCohortSelector newCohortSelector = new MultiSpeciesCohortSelector();

                if (ageOrRangeWasRead)
                {
                    //PlugIn.ModelCore.UI.WriteLine("age or range was read");
                    siteSelector = WrapSiteSelector(siteSelector);
                    isSiteSelectorWrapped = true;
                    newCohortSelector = ReplaceSpecificAgeSelectors(cohortSelector);
                }

                Planting.SpeciesList speciesToPlant = ReadSpeciesToPlant();

                //  Repeat harvest?
                int repeatParamLineNumber = LineNumber;
                if (ReadOptionalVar(singleRepeat))
                {
                    MultiSpeciesCohortSelector newAddCohortSelector = new MultiSpeciesCohortSelector();
                    int interval = ValidateRepeatInterval(singleRepeat.Value,
                                                          repeatParamLineNumber,
                                                          harvestTimestep);
                    ICohortSelector additionalCohortSelector = ReadCohortSelector(true);
                    if (ageOrRangeWasRead)
                    {
                        newAddCohortSelector = ReplaceSpecificAgeSelectors(additionalCohortSelector);
                        if (!isSiteSelectorWrapped)
                        {
                            siteSelector = WrapSiteSelector(siteSelector);
                            isSiteSelectorWrapped = true;
                        }
                    }
                    Planting.SpeciesList additionalSpeciesToPlant = ReadSpeciesToPlant();
                    ISiteSelector additionalSiteSelector = WrapSiteSelector(new CompleteStand());
                    prescriptions.Add(new SingleRepeatHarvest(name,
                                                              rankingMethod,
                                                              siteSelector,
                                                              cohortSelector,
                                                              speciesToPlant,
                                                              additionalCohortSelector,
                                                              additionalSpeciesToPlant,
                                                              additionalSiteSelector,
                                                              minTimeSinceDamage,
                                                              preventEstablishment,
                                                              interval));
                }
                else if (ReadOptionalVar(multipleRepeat))
                {
                    int interval = ValidateRepeatInterval(multipleRepeat.Value,
                                                          repeatParamLineNumber,
                                                          harvestTimestep);
                    // After initial site selection repeats must be complete stand
                    ISiteSelector additionalSiteSelector = WrapSiteSelector(new CompleteStand());
                    prescriptions.Add(new RepeatHarvest(name,
                                                        rankingMethod,
                                                        siteSelector,
                                                        cohortSelector,
                                                        speciesToPlant,
                                                        additionalSiteSelector,
                                                        minTimeSinceDamage,
                                                        preventEstablishment,
                                                        interval));
                }
                else
                {
                    prescriptions.Add(new Prescription(name,
                                                       rankingMethod,
                                                       siteSelector,
                                                       cohortSelector,
                                                       speciesToPlant,
                                                       minTimeSinceDamage,
                                                       preventEstablishment));
                }
            }
        }
Exemple #42
0
        //---------------------------------------------------------------------

        protected override IDataset Parse()
        {
            // ReadLandisDataVar();

            InputVar <string> landisData = new InputVar <string>("LandisData");

            ReadVar(landisData);
            if (landisData.Value.Actual != name)
            {
                throw new InputValueException(landisData.Value.String, "The value is not \"{0}\"", name);
            }

            Dataset dataset = new Dataset();

            InputVar <ushort> mapCode     = new InputVar <ushort>("MapCode");
            InputVar <string> speciesName = new InputVar <string>("Species");
            InputVar <ushort> age         = new InputVar <ushort>("Age");

            Dictionary <ushort, int> mapCodeLineNumbers = new Dictionary <ushort, int>();

            while (!AtEndOfInput)
            {
                //  Read initial community
                int mapCodeLineNum = LineNumber;
                ReadVar(mapCode);
                int lineNumber;
                if (mapCodeLineNumbers.TryGetValue(mapCode.Value.Actual, out lineNumber))
                {
                    throw new InputValueException(mapCode.Value.String,
                                                  "The map code {0} was previously used on line {1}",
                                                  mapCode.Value.Actual, lineNumber);
                }
                else
                {
                    mapCodeLineNumbers[mapCode.Value.Actual] = mapCodeLineNum;
                }

                //  Read species and their ages
                List <ISpeciesCohorts> speciesCohortsList;
                //List<System.Collections.Generic.IEnumerable<Library.Cohort.AgeOnly.ISpeciesCohorts<Library.Cohort.AgeOnly.ICohort>>> speciesCohortsList;

                speciesCohortsList = new List <ISpeciesCohorts>();
                //speciesCohortsList = new List<System.Collections.Generic.IEnumerable<Library.Cohort.AgeOnly.ISpeciesCohorts<Library.Cohort.AgeOnly.ICohort>>>();
                Dictionary <string, int> speciesLineNumbers = new Dictionary <string, int>();
                while (!AtEndOfInput && CurrentName != mapCode.Name)
                {
                    StringReader currentLine = new StringReader(CurrentLine);

                    ReadValue(speciesName, currentLine);
                    //Species.ISpecies species = speciesDataset[speciesName.Value.Actual];
                    ISpecies species = speciesDataset[speciesName.Value.Actual];
                    if (species == null)
                    {
                        throw new InputValueException(speciesName.Value.String,
                                                      "{0} is not a species name.",
                                                      speciesName.Value.String);
                    }
                    if (speciesLineNumbers.TryGetValue(species.Name, out lineNumber))
                    {
                        throw new InputValueException(speciesName.Value.String,
                                                      "The species {0} was previously used on line {1}",
                                                      speciesName.Value.String, lineNumber);
                    }
                    else
                    {
                        speciesLineNumbers[species.Name] = LineNumber;
                    }

                    //  Read ages
                    List <ushort> ages = new List <ushort>();
                    TextReader.SkipWhitespace(currentLine);
                    while (currentLine.Peek() != -1)
                    {
                        ReadValue(age, currentLine);
                        if (age.Value.Actual == 0)
                        {
                            throw new InputValueException(age.Value.String,
                                                          "Ages must be > 0.");
                        }
                        if (ages.Contains(age.Value.Actual))
                        {
                            throw new InputValueException(age.Value.String,
                                                          "The age {0} appears more than once.",
                                                          age.Value.String);
                        }
                        if (age.Value.Actual > species.Longevity)
                        {
                            throw new InputValueException(age.Value.String,
                                                          "The age {0} is more than longevity ({1}).",
                                                          age.Value.String, species.Longevity);
                        }
                        ages.Add(age.Value.Actual);
                        TextReader.SkipWhitespace(currentLine);
                    }
                    if (ages.Count == 0)
                    {
                        //  Try reading age which will throw exception
                        ReadValue(age, currentLine);
                    }

                    ages = BinAges(ages);
                    speciesCohortsList.Add(new SpeciesCohorts(species, ages));

                    GetNextLine();
                }

                //    dataset.Add(new Community(mapCode.Value.Actual,
                //                              new Library.Cohort.AgeOnly.SiteCohorts(ISpeciesCohorts<ICohort> speciesCohortsList)));

                dataset.Add(new Community(mapCode.Value.Actual,
                                          new SiteCohorts(speciesCohortsList)));
            }

            return(dataset);
        }
        //---------------------------------------------------------------------

        new protected ISiteSelector ReadSiteSelector()
        {
            InputVar<ISiteSelector> siteSelector = new InputVar<ISiteSelector>(Names.SiteSelection, ReadSiteSelector);
            ReadVar(siteSelector);

            
            return siteSelector.Value.Actual;
        }
        public void Init()
        {
            //  Need to reference the class so its static ctor is called before
            //  any tests run; otherwise, they'll fail because a parse or read
            //  method hasn't been registered with InputValues class.
            Percentage p = new Percentage();

            percentVar = new InputVar<Percentage>("Percentage Var");
        }
 public void Init()
 {
     SeedingAlgorithmsUtil.RegisterForInputValues();
     seedAlgVar = new InputVar<SeedingAlgorithms>("SeedingAlgorithm");
 }
        //---------------------------------------------------------------------

        protected override IScenario Parse()
        {
            ReadLandisDataVar();

            IEditableScenario scenario = new EditableScenario();

            InputVar <int> duration = new InputVar <int>("Duration");

            ReadVar(duration);
            scenario.Duration = duration.Value;

            InputVar <string> species = new InputVar <string>("Species");

            ReadVar(species);
            scenario.Species = species.Value;

            InputVar <string> ecoregions = new InputVar <string>("Ecoregions");

            ReadVar(ecoregions);
            scenario.Ecoregions = ecoregions.Value;

            InputVar <string> ecoregionsMap = new InputVar <string>("EcoregionsMap");

            ReadVar(ecoregionsMap);
            scenario.EcoregionsMap = ecoregionsMap.Value;

            InputVar <string> initCommunities = new InputVar <string>("InitialCommunities");

            ReadVar(initCommunities);
            scenario.InitialCommunities = initCommunities.Value;

            InputVar <string> communitiesMap = new InputVar <string>("InitialCommunitiesMap");

            ReadVar(communitiesMap);
            scenario.InitialCommunitiesMap = communitiesMap.Value;

            if (AtEndOfInput)
            {
                throw ExpectedPlugInException(typeof(ISuccession));
            }
            ReadPlugIn(scenario.Succession);

            //  Disturbance plug-ins

            nameLineNumbers.Clear();  // Parse called more than once
            const string DisturbancesRandomOrder = "DisturbancesRandomOrder";

            while (!AtEndOfInput && CurrentName != DisturbancesRandomOrder &&
                   scenario.Outputs.Count == 0)
            {
                IEditablePlugIn <IDisturbance> disturbPlugIn;
                IEditablePlugIn <IOutput>      outputPlugIn;
                ReadPlugIn(out disturbPlugIn, out outputPlugIn);
                if (disturbPlugIn != null)
                {
                    scenario.Disturbances.InsertAt(scenario.Disturbances.Count,
                                                   disturbPlugIn);
                }
                else
                {
                    scenario.Outputs.InsertAt(scenario.Outputs.Count,
                                              outputPlugIn);
                }
            }

            //  Check for optional DisturbancesRandomOrder parameter
            InputVar <bool> randomOrder = new InputVar <bool>(DisturbancesRandomOrder);

            if (ReadOptionalVar(randomOrder))
            {
                scenario.DisturbancesRandomOrder = randomOrder.Value;
            }

            //  Output plug-ins

            if (scenario.Outputs.Count == 0)
            {
                nameLineNumbers.Clear();
            }
            while (!AtEndOfInput)
            {
                IEditablePlugIn <IOutput> plugIn = new EditablePlugIn <IOutput>();
                ReadPlugIn(plugIn);
                scenario.Outputs.InsertAt(scenario.Outputs.Count, plugIn);
            }
            if (scenario.Outputs.Count == 0)
            {
                throw ExpectedPlugInException(typeof(IOutput));
            }

            return(scenario.GetComplete());
        }