//---------------------------------------------------------------------
public Prescription(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector)
{
this.name = name;
this.rankingMethod = rankingMethod;
this.siteSelector = siteSelector;
this.cohortSelector = cohortSelector;
}
//---------------------------------------------------------------------
public RepeatHarvest(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant,
int interval)
: base(name, rankingMethod, siteSelector, cohortSelector, speciesToPlant)
{
this.interval = interval;
this.spreadingSiteSelector = siteSelector as StandSpreading;
this.harvestedStands = new List<Stand>();
}
//---------------------------------------------------------------------
public SingleRepeatHarvest(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant,
ICohortSelector additionalCohortSelector,
Planting.SpeciesList additionalSpeciesToPlant,
int interval)
: base(name, rankingMethod, siteSelector, cohortSelector, speciesToPlant, interval)
{
this.initialCohortSelector = cohortSelector;
this.initialSpeciesToPlant = speciesToPlant;
this.additionalCohortSelector = additionalCohortSelector;
this.additionalSpeciesToPlant = additionalSpeciesToPlant;
}
//---------------------------------------------------------------------
public RepeatHarvest(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortCutter cohortCutter,
Planting.SpeciesList speciesToPlant,
ISiteSelector additionalSiteSelector,
int minTimeSinceDamage,
bool preventEstablishment,
int interval)
: base(name, rankingMethod, siteSelector, cohortCutter, speciesToPlant, minTimeSinceDamage, preventEstablishment)
{
this.interval = interval;
this.spreadingSiteSelector = siteSelector as StandSpreading;
this.additionalSiteSelector = additionalSiteSelector;
this.harvestedStands = new List<Stand>();
}
//---------------------------------------------------------------------
public RepeatHarvest(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortCutter cohortCutter,
Planting.SpeciesList speciesToPlant,
ISiteSelector additionalSiteSelector,
int minTimeSinceDamage,
bool preventEstablishment,
int interval)
: base(name, rankingMethod, siteSelector, cohortCutter, speciesToPlant, minTimeSinceDamage, preventEstablishment)
{
this.interval = interval;
this.spreadingSiteSelector = siteSelector as StandSpreading;
this.additionalSiteSelector = additionalSiteSelector;
this.harvestedStands = new List <Stand>();
}
//---------------------------------------------------------------------
public Prescription(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant,
int minTimeSinceDamage,
bool preventEstablishment)
{
this.number = nextNumber;
nextNumber++;
this.name = name;
this.rankingMethod = rankingMethod;
this.siteSelector = siteSelector;
this.cohortSelector = cohortSelector;
this.speciesToPlant = speciesToPlant;
this.minTimeSinceDamage = minTimeSinceDamage;
this.preventEstablishment = preventEstablishment;
}
//---------------------------------------------------------------------
public Prescription(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant,
int minTimeSinceDamage,
bool preventEstablishment)
{
this.number = nextNumber;
nextNumber++;
this.name = name;
this.rankingMethod = rankingMethod;
this.siteSelector = siteSelector;
this.cohortSelector = cohortSelector;
this.speciesToPlant = speciesToPlant;
this.minTimeSinceDamage = minTimeSinceDamage;
this.preventEstablishment = preventEstablishment;
}
//---------------------------------------------------------------------
public SingleRepeatHarvest(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant,
ICohortSelector additionalCohortSelector,
Planting.SpeciesList additionalSpeciesToPlant,
ISiteSelector additionalSiteSelector,
int minTimeSinceDamage,
bool preventEstablishment,
int interval)
: base(name, rankingMethod, siteSelector, cohortSelector, speciesToPlant,additionalSiteSelector, minTimeSinceDamage, preventEstablishment, interval)
{
this.initialCohortSelector = cohortSelector;
this.initialSpeciesToPlant = speciesToPlant;
this.additionalCohortSelector = additionalCohortSelector;
this.additionalSpeciesToPlant = additionalSpeciesToPlant;
this.additionalSiteSelector = additionalSiteSelector;
}
//---------------------------------------------------------------------
public SingleRepeatHarvest(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant,
ICohortSelector additionalCohortSelector,
Planting.SpeciesList additionalSpeciesToPlant,
ISiteSelector additionalSiteSelector,
int minTimeSinceDamage,
bool preventEstablishment,
int interval)
: base(name, rankingMethod, siteSelector, cohortSelector, speciesToPlant, additionalSiteSelector, minTimeSinceDamage, preventEstablishment, interval)
{
this.initialCohortSelector = cohortSelector;
this.initialSpeciesToPlant = speciesToPlant;
this.additionalCohortSelector = additionalCohortSelector;
this.additionalSpeciesToPlant = additionalSpeciesToPlant;
this.additionalSiteSelector = additionalSiteSelector;
}
//---------------------------------------------------------------------
public Prescription(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortCutter cohortCutter,
Planting.SpeciesList speciesToPlant,
int minTimeSinceDamage,
bool preventEstablishment)
{
this.number = nextNumber;
nextNumber++;
this.name = name;
this.rankingMethod = rankingMethod;
this.siteSelector = siteSelector;
this.cohortCutter = cohortCutter;
this.speciesToPlant = speciesToPlant;
this.minTimeSinceDamage = minTimeSinceDamage;
this.preventEstablishment = preventEstablishment;
this.isSingleRepeatStep = false;
this.isSingleRepeatPrescription = false;
cohortCounts = new CohortCounts();
}
//---------------------------------------------------------------------
public RepeatHarvest(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortCutter cohortCutter,
Planting.SpeciesList speciesToPlant,
int minTimeSinceDamage,
bool preventEstablishment,
int interval,
int timesToRepeat = 0)
: base(name, rankingMethod, siteSelector, cohortCutter, speciesToPlant, minTimeSinceDamage, preventEstablishment)
{
this.interval = interval;
this.spreadingSiteSelector = siteSelector as StandSpreading;
this.harvestedStands = new List <Stand>();
if (timesToRepeat > 1)
{
this.timesToRepeat = timesToRepeat;
}
else
{
this.timesToRepeat = int.MaxValue;
}
}
//---------------------------------------------------------------------
public Prescription(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant)
{
this.number = nextNumber;
nextNumber++;
this.name = name;
this.rankingMethod = rankingMethod;
this.siteSelector = siteSelector;
this.cohortSelector = cohortSelector;
this.speciesToPlant = speciesToPlant;
}
//----------------------------------------------------------------------
// 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");
}
//---------------------------------------------------------------------
public Prescription(string name,
IStandRankingMethod rankingMethod,
ISiteSelector siteSelector,
ICohortSelector cohortSelector,
Planting.SpeciesList speciesToPlant,
int minTimeSinceDamage,
bool preventEstablishment)
{
this.number = nextNumber;
nextNumber++;
this.name = name;
this.rankingMethod = rankingMethod;
this.siteSelector = siteSelector;
this.cohortSelector = cohortSelector;
this.speciesToPlant = speciesToPlant;
this.minTimeSinceDamage = minTimeSinceDamage;
this.preventEstablishment = preventEstablishment;
// scan the name for LU-->{LU-name}
const string LUmarker = "LU-->";
int positionOfLUmarker = name.IndexOf(LUmarker);
int positionOfLUname = positionOfLUmarker + LUmarker.Length;
string LUname = name.Substring(positionOfLUname);
this.landUseAfterHarvest = LandUse.LookupName(LUname);
}
private static IStandRankingMethod CopyStandRankingMethod(IStandRankingMethod standRankingMethod)
{
IStandRankingMethod rankingMethodCopy;
if (standRankingMethod is EconomicRank economicRank)
{
var rankTable = GetTypePrivateField <EconomicRankTable>(economicRank, "rankTable");
var rankTableCopy = CopyEconomicRankTable(rankTable);
rankingMethodCopy = new EconomicRank(rankTableCopy);
}
else if (standRankingMethod is MaxCohortAge)
{
rankingMethodCopy = new MaxCohortAge();
}
else if (standRankingMethod is RandomRank)
{
rankingMethodCopy = new RandomRank();
}
else if (standRankingMethod is RegulateAgesRank)
{
rankingMethodCopy = new RegulateAgesRank();
}
else if (standRankingMethod is FireRiskRank fireRiskRank)
{
var fireRiskTable = GetTypePrivateField <FireRiskTable>(fireRiskRank, "rankTable");
var fireRiskTableCopy = CopyFireRiskTable(fireRiskTable);
rankingMethodCopy = new FireRiskRank(fireRiskTableCopy);
}
else if (standRankingMethod is TimeSinceDisturbanceRank)
{
rankingMethodCopy = new TimeSinceDisturbanceRank();
}
else
{
throw new Exception();
}
foreach (var requirement in standRankingMethod.Requirements)
{
if (requirement is Presalvage preSalvage)
{
var preSalvageYears = GetTypePrivateField <ushort>(preSalvage, "presalvYears");
rankingMethodCopy.AddRequirement(new Presalvage(preSalvageYears));
}
else if (requirement is MinimumAge minimumAge)
{
var minAge = GetTypePrivateField <ushort>(minimumAge, "minAge");
rankingMethodCopy.AddRequirement(new MinimumAge(minAge));
}
else if (requirement is MaximumAge maximumAge)
{
var maxAge = GetTypePrivateField <ushort>(maximumAge, "maxAge");
rankingMethodCopy.AddRequirement(new MaximumAge(maxAge));
}
else if (requirement is TimeSinceLastFire timeSinceLastFire)
{
var timeSinceFire = GetTypePrivateField <ushort>(timeSinceLastFire, "timeSinceFire");
rankingMethodCopy.AddRequirement(new TimeSinceLastFire(timeSinceFire));
}
else if (requirement is TimeSinceLastWind timeSinceLastWind)
{
var timeSinceWind = GetTypePrivateField <ushort>(timeSinceLastWind, "timeSinceWind");
rankingMethodCopy.AddRequirement(new TimeSinceLastWind(timeSinceWind));
}
else if (requirement is StandAdjacency standAdjacency)
{
var time = GetTypePrivateField <ushort>(standAdjacency, "time");
var type = GetTypePrivateField <string>(standAdjacency, "type");
rankingMethodCopy.AddRequirement(new StandAdjacency(time, type, standAdjacency.SetAside));
}
else if (requirement is SpatialArrangement spatialArrangement)
{
var minAge = GetTypePrivateField <ushort>(spatialArrangement, "minAge");
rankingMethodCopy.AddRequirement(new SpatialArrangement(minAge));
}
else if (requirement is MinTimeSinceLastHarvest minTimeSinceLastHarvest)
{
var minTime = GetTypePrivateField <ushort>(minTimeSinceLastHarvest, "minTime");
rankingMethodCopy.AddRequirement(new MinTimeSinceLastHarvest(minTime));
}
else if (requirement is InclusionRequirement inclusionRequirement)
{
var ruleList = GetTypePrivateField <List <InclusionRule> >(inclusionRequirement, "rule_list");
var ruleListCopy = CopyInclusionRuleList(ruleList);
rankingMethodCopy.AddRequirement(new InclusionRequirement(ruleListCopy));
}
}
return(rankingMethodCopy);
}
//---------------------------------------------------------------------
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);
}
//---------------------------------------------------------------------
/// <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));
}
}
}