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