//---------------------------------------------------------------------
//public Species.AuxParm<Ecoregions.AuxParm<double>> EstablishProbabilities
//{
// get {
// return establishProbs;
// }
//}
//---------------------------------------------------------------------
public InputParameters()
{
ecoregionDataset = PlugIn.ModelCore.Ecoregions;
speciesDataset = PlugIn.ModelCore.Species;
//establishProbs = CreateSpeciesEcoregionParm<double>();
}
//---------------------------------------------------------------------
public InputParameterParser()
{
// ToDo: fix this Hack to ensure that Percentage is registered with InputValues
//Landis.Utilities.Percentage p = new Landis.Utilities.Percentage();
this.speciesDataset = PlugIn.ModelCore.Species;
this.speciesName = new InputVar <string>("Species");
}
//---------------------------------------------------------------------
//public static void Initialize(double[,] establishProbabilities,
public static void Initialize(SeedingAlgorithm seedingAlgorithm,
Delegates.AddNewCohort addNewCohort)
{
// Reproduction.establishProbabilities = establishProbabilities;
seeding = new Seeding(seedingAlgorithm);
Reproduction.addNewCohort = addNewCohort;
SiteVars.Cohorts = Model.Core.GetSiteVar <SiteCohorts>("Succession.Cohorts");
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar <BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar <BitArray>();
noEstablish = Model.Core.Landscape.NewSiteVar <bool>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites)
{
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
noEstablish.ActiveSiteValues = false;
planting = new Planting();
}
//---------------------------------------------------------------------
public InputParameters(ISpeciesDataset speciesDataset, int litterCnt, int functionalCnt)
{
this.speciesDataset = speciesDataset;
functionalTypes = new FunctionalTypeTable(functionalCnt);
fireReductionsTable = new FireReductions[6];
harvestReductionsTable = new List <HarvestReductions>();
sppFunctionalType = new Landis.Library.Parameters.Species.AuxParm <int>(speciesDataset);
nFixer = new Landis.Library.Parameters.Species.AuxParm <bool>(speciesDataset);
gddMin = new Landis.Library.Parameters.Species.AuxParm <int>(speciesDataset);
gddMax = new Landis.Library.Parameters.Species.AuxParm <int>(speciesDataset);
minJanTemp = new Landis.Library.Parameters.Species.AuxParm <int>(speciesDataset);
maxDrought = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
leafLongevity = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
epicormic = new Landis.Library.Parameters.Species.AuxParm <bool>(speciesDataset);
leafLignin = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
woodLignin = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
coarseRootLignin = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
fineRootLignin = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
leafCN = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
woodCN = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
coarseRootCN = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
foliageLitterCN = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
fineRootCN = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
maxANPP = new Landis.Library.Parameters.Species.AuxParm <int>(speciesDataset);
maxBiomass = new Landis.Library.Parameters.Species.AuxParm <int>(speciesDataset);
maximumShadeLAI = new double[6];
sufficientLight = new List <ISufficientLight>();
}
//---------------------------------------------------------------------
public ParametersParser()
//: base(ecoregionDataset,
// speciesDataset)
{
this.ecoregionDataset = PlugIn.ModelCore.Ecoregions;
this.speciesDataset = PlugIn.ModelCore.Species;
}
//---------------------------------------------------------------------
public InputParametersParser()
{
this.ecoregionDataset = PlugIn.ModelCore.Ecoregions;
this.speciesDataset = PlugIn.ModelCore.Species;
this.speciesLineNums = new Dictionary <string, int>();
this.speciesName = new InputVar <string>("Species");
}
//---------------------------------------------------------------------
private void CompareDatasetAndFile(ISpeciesDataset dataset,
string filename)
{
FileLineReader file = OpenFile(filename);
InputLine inputLine = new InputLine(file);
InputVar <string> LandisData = new InputVar <string>(Landis.Data.InputVarName);
inputLine.ReadVar(LandisData);
int expectedIndex = 0;
foreach (ISpecies species in dataset)
{
Assert.AreEqual(expectedIndex, species.Index);
expectedIndex++;
Assert.IsTrue(inputLine.GetNext());
currentLine = new StringReader(inputLine.ToString());
Assert.AreEqual(ReadValue <string>(), species.Name);
Assert.AreEqual(ReadValue <int>(), species.Longevity);
Assert.AreEqual(ReadValue <int>(), species.Maturity);
Assert.AreEqual(ReadValue <byte>(), species.ShadeTolerance);
Assert.AreEqual(ReadValue <byte>(), species.FireTolerance);
Assert.AreEqual(ReadEffectiveSeedDist(), species.EffectiveSeedDist);
Assert.AreEqual(ReadValue <int>(), species.MaxSeedDist);
Assert.AreEqual(ReadValue <float>(), species.VegReprodProb);
Assert.AreEqual(ReadValue <int>(), species.MinSproutAge);
Assert.AreEqual(ReadValue <int>(), species.MaxSproutAge);
Assert.AreEqual(ReadValue <PostFireRegeneration>(), species.PostFireRegeneration);
}
Assert.IsFalse(inputLine.GetNext());
file.Close();
}
//---------------------------------------------------------------------
//public Species.AuxParm<Ecoregions.AuxParm<double>> EstablishProbabilities
//{
// get {
// return establishProbs;
// }
//}
//---------------------------------------------------------------------
public InputParameters()
{
ecoregionDataset = PlugIn.ModelCore.Ecoregions;
speciesDataset = PlugIn.ModelCore.Species;
//establishProbs = CreateSpeciesEcoregionParm<double>();
}
//---------------------------------------------------------------------
private void TryParse(string filename,
int errorLineNum)
{
try {
reader = OpenFile(filename);
// This method is only called on bad files, so we expect the
// statement below to throw an exception. Since we knowingly
// ignore the variable "dataset", disable the CS0219 warning
// "The variable '...' is assigned but its value is never used'.
#pragma warning disable 0219
ISpeciesDataset dataset = parser.Parse(reader);
#pragma warning restore 0219
}
catch (System.Exception e) {
Data.Output.WriteLine(e.Message.Replace(Data.Directory,
Data.DirPlaceholder));
Data.Output.WriteLine();
LineReaderException lrExc = e as LineReaderException;
if (lrExc != null)
{
Assert.AreEqual(errorLineNum, lrExc.LineNumber);
}
throw;
}
finally {
reader.Close();
}
}
public void FullTable()
{
string filename = "FullTable.txt";
ISpeciesDataset dataset = ParseFile(filename);
CompareDatasetAndFile(dataset, filename);
}
//---------------------------------------------------------------------
/*public override string LandisDataValue
* {
* get {
* return "Initial Communities";
* }
* }*/
//---------------------------------------------------------------------
public DatasetParser(int successionTimestep,
ISpeciesDataset speciesDataset)
//Species.IDataset speciesDataset)
{
this.successionTimestep = successionTimestep;
this.speciesDataset = speciesDataset;
}
///<Summary>
/// Initializes a species and ecoregion specific parameter
///</Summary>
public SpeciesEcoregionAuxParm(ISpeciesDataset speciesDataset, IEcoregionDataset ecoregionDataset)
{
values = new Parameters.Species.AuxParm <Parameters.Ecoregions.AuxParm <T> >(speciesDataset);
foreach (ISpecies species in speciesDataset)
{
values[species] = new Parameters.Ecoregions.AuxParm <T>(ecoregionDataset);
}
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="speciesDataset">
/// The dataset of species to look up species' names in. Important note: the base harvest
/// speciesDataset must be overwritten with the HarvestSpeciesDataset. Methods within base harvest
/// will set the MostRecentlyFetchedSpecies parameter when they are reading in species names
/// from a list of cohorts to be removed. The value of MostRecentlyFetchedSpecies is not set within
/// biomass harvest.
/// </param>
public InputParametersParser(ISpeciesDataset speciesDataset)
//int scenarioStart,
//int scenarioEnd)
: base(new HarvestSpeciesDataset(speciesDataset))
{
this.speciesDataset = speciesDataset;
ageSelectors = new SpecificAgesCohortSelector[speciesDataset.Count];
}
//---------------------------------------------------------------------
private ISpeciesDataset ParseFile(string filename)
{
reader = OpenFile(filename);
ISpeciesDataset dataset = parser.Parse(reader);
reader.Close();
return(dataset);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="speciesDataset">
/// The dataset of species to look up species' names in.
/// </param>
/// <param name="keywordsEnabled">
/// Are keywords like "Oldest" and "AllExceptYoungest" accepted?
/// </param>
public BasicParameterParser(ISpeciesDataset speciesDataset,
bool keywordsEnabled)
{
this.keywordsEnabled = keywordsEnabled;
this.speciesDataset = speciesDataset;
this.speciesName = new InputVar <string>("Species");
this.SpeciesLineNumbers = new Dictionary <string, int>();
}
//---------------------------------------------------------------------
public Parameters(IEcoregionDataset ecoregionDataset,
ISpeciesDataset speciesDataset)
{
this.ecoregionDataset = ecoregionDataset;
this.speciesDataset = speciesDataset;
maxANPP = CreateSpeciesEcoregionParm <int>();
maxBiomass = CreateSpeciesEcoregionParm <int>();
}
//---------------------------------------------------------------------
public InputParameterParser()
{
//Edu.Wisc.Forest.Flel.Util.Percentage p = new Edu.Wisc.Forest.Flel.Util.Percentage();
// RegisterForInputValues();
this.speciesDataset = PlugIn.ModelCore.Species;
this.speciesLineNums = new Dictionary <string, int>();
this.speciesName = new InputVar <string>("Species");
}
//---------------------------------------------------------------------
private byte CalcForestType(Site site, List <IForestType> forestTypes)
{
int forTypeCnt = 0;
double[] forTypValue = new double[forestTypes.Count];
ISpeciesDataset SpeciesDataset = modelCore.Species;
foreach (ISpecies species in SpeciesDataset)
{
ushort maxSpeciesAge = 0;
double sppValue = 0.0;
//ISpeciesCohorts speciesCohorts = cohorts[species];
// maxSpeciesAge = Library.Cohort.AgeOnly.Util.GetMaxAge(cohorts[site][species]);
//MaxAge(speciesCohorts);
if (maxSpeciesAge > 0)
{
sppValue = (double)maxSpeciesAge /
(double)species.Longevity *
(double)reclassCoefs[species.Index];
forTypeCnt = 0;
foreach (IForestType ftype in forestTypes)
{
if (ftype[species.Index] != 0)
{
if (ftype[species.Index] == -1)
{
forTypValue[forTypeCnt] -= sppValue;
}
if (ftype[species.Index] == 1)
{
forTypValue[forTypeCnt] += sppValue;
}
}
forTypeCnt++;
}
}
}
int finalForestType = 0;
double maxValue = 0.0;
forTypeCnt = 0;
foreach (IForestType ftype in forestTypes)
{
//System.Console.WriteLine("ForestTypeNum={0}, Value={1}.",forTypeCnt,forTypValue[forTypeCnt]);
if (forTypValue[forTypeCnt] > maxValue)
{
maxValue = forTypValue[forTypeCnt];
finalForestType = forTypeCnt + 1;
}
forTypeCnt++;
}
return((byte)finalForestType);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="speciesDataset">
/// The dataset of species to look up species' names in.
/// </param>
public InputParametersParser(string extensionName,
ISpeciesDataset speciesDataset)
: base(speciesDataset, true)
// The "true" above --> keywords are enabled for cohort selectors
{
this.extensionName = extensionName;
this.speciesDataset = speciesDataset;
this.speciesName = new InputVar <string>("Species");
this.roundedIntervals = new List <RoundedInterval>();
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
public SpeciesList(IEnumerable<ISpecies> speciesList,
ISpeciesDataset speciesDataset)
{
bitArray = new BitArray(speciesDataset.Count);
if (speciesList != null) {
foreach (ISpecies species in speciesList) {
bitArray.Set(species.Index, true);
}
}
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
public SpeciesList(IEnumerable <ISpecies> speciesList,
ISpeciesDataset speciesDataset)
{
bitArray = new BitArray(speciesDataset.Count);
if (speciesList != null)
{
foreach (ISpecies species in speciesList)
{
bitArray.Set(species.Index, true);
}
}
}
//---------------------------------------------------------------------
public InputParameters(ISpeciesDataset speciesDataset)
{
this.speciesDataset = speciesDataset;
ladderFuelSpeciesList = new List <ISpecies>();
deadWoodList = new List <IDeadWood>();
suppressionFWI_Table = new Dictionary <int, ISuppressionTable>();
dynamicRxIgnitions = new List <IDynamicIgnitionMap>();
dynamicLightningIgnitions = new List <IDynamicIgnitionMap>();
dynamicAccidentalIgnitions = new List <IDynamicIgnitionMap>();
dynamicSuppression = new List <IDynamicSuppressionMap>();
ageDBH = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
maximumBarkThickness = new Landis.Library.Parameters.Species.AuxParm <double>(speciesDataset);
}
// If BDA is running, then use that information to calculate the percent of all cohorts
// that are dead fir cohorts.
private int CalcPercentDeadFir(ActiveSite site)
{
int numDeadFir = 0;
if (SiteVars.NumberDeadFirCohorts == null) // Is BDA even running?
{
return(0);
}
int minimumStartTime = System.Math.Max(0, SiteVars.TimeOfLastFire[site]);
for (int i = minimumStartTime; i <= modelCore.CurrentTime; i++)
{
if (modelCore.CurrentTime - i <= deadFirMaxAge)
{
//if(SiteVars.NumberDeadFirCohorts[site][i] > 0) // Only if a map actually exists
// numDeadFir += SiteVars.NumberDeadFirCohorts[site][i];
if (SiteVars.NumberDeadFirCohorts[site].ContainsKey(i))
{
numDeadFir += SiteVars.NumberDeadFirCohorts[site][i];
}
}
}
int numSiteCohorts = 0;
int percentDeadFir = 0;
ISpeciesDataset SpeciesDataset = modelCore.Species;
foreach (ISpeciesCohorts speciesCohorts in SiteVars.Cohorts[site])
{
foreach (ICohort cohort in speciesCohorts)
{
numSiteCohorts++;
}
}
percentDeadFir = (int)(((double)numDeadFir / (double)(numSiteCohorts + numDeadFir)) * 100.0 + 0.5);
return(System.Math.Min(percentDeadFir, 100));
}
//---------------------------------------------------------------------
public static void Initialize(SeedingAlgorithm seedingAlgorithm)
{
seeding = new Seeding(seedingAlgorithm);
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar <BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar <BitArray>();
noEstablish = Model.Core.Landscape.NewSiteVar <bool>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites)
{
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
noEstablish.ActiveSiteValues = false;
planting = new Planting();
}
private int CalcPercentDeadFir(ActiveSite site)
{
int numDeadFir = 0;
if (SiteVars.NumberDeadFirCohorts == null)
{
return(0);
}
int minimumStartTime = System.Math.Max(0, SiteVars.TimeOfLastFire[site]);
for (int i = minimumStartTime; i <= modelCore.CurrentTime; i++)
{
if (modelCore.CurrentTime - i <= deadFirMaxAge)
{
if (SiteVars.NumberDeadFirCohorts[site].ContainsKey(i))
{
numDeadFir += SiteVars.NumberDeadFirCohorts[site][i];
}
}
}
int numSiteCohorts = 0;
int percentDeadFir = 0;
ISpeciesDataset SpeciesDataset = modelCore.Species;
foreach (ISpeciesCohorts speciesCohorts in (Landis.Library.BiomassCohorts.ISpeciesCohorts)SiteVars.Cohorts[site])
{
foreach (ICohort cohort in speciesCohorts)
{
numSiteCohorts++;
}
}
percentDeadFir = (int)(((double)numDeadFir / (double)(numSiteCohorts + numDeadFir)) * 100.0 + 0.5);
return(System.Math.Min(percentDeadFir, 100));
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
public InputParameters(//IEcoregionDataset ecoregionDataset,
ISpeciesDataset speciesDataset,
int litterCnt, int functionalCnt)
{
this.speciesDataset = speciesDataset;
//this.ecoregionDataset = ecoregionDataset;
functionalTypes = new FunctionalTypeTable(functionalCnt);
fireReductionsTable = new FireReductions[6];
harvestReductionsTable = new List <HarvestReductions>();
sppFunctionalType = new Species.AuxParm <int>(speciesDataset);
nFixer = new Species.AuxParm <bool>(speciesDataset);
gddMin = new Species.AuxParm <int>(speciesDataset);
gddMax = new Species.AuxParm <int>(speciesDataset);
minJanTemp = new Species.AuxParm <int>(speciesDataset);
maxDrought = new Species.AuxParm <double>(speciesDataset);
leafLongevity = new Species.AuxParm <double>(speciesDataset);
epicormic = new Species.AuxParm <bool>(speciesDataset);
leafLignin = new Species.AuxParm <double>(speciesDataset);
woodLignin = new Species.AuxParm <double>(speciesDataset);
coarseRootLignin = new Species.AuxParm <double>(speciesDataset);
fineRootLignin = new Species.AuxParm <double>(speciesDataset);
leafCN = new Species.AuxParm <double>(speciesDataset);
woodCN = new Species.AuxParm <double>(speciesDataset);
coarseRootCN = new Species.AuxParm <double>(speciesDataset);
foliageLitterCN = new Species.AuxParm <double>(speciesDataset);
fineRootCN = new Species.AuxParm <double>(speciesDataset);
maxANPP = new Species.AuxParm <int>(speciesDataset);
maxBiomass = new Species.AuxParm <int>(speciesDataset);
maximumShadeLAI = new double[6];
//minRelativeBiomass = new Ecoregions.AuxParm<Percentage>[6];
//for (byte shadeClass = 1; shadeClass <= 5; shadeClass++) {
// minRelativeBiomass[shadeClass] = new Ecoregions.AuxParm<Percentage>(ecoregionDataset);
//}
sufficientLight = new List <ISufficientLight>();
}
//---------------------------------------------------------------------
static FormOfReproduction()
{
speciesDataset = Model.Core.Species;
}
//---------------------------------------------------------------------
//public static void Initialize(double[,] establishProbabilities,
public static void Initialize(SeedingAlgorithm seedingAlgorithm,
Delegates.AddNewCohort addNewCohort)
{
// Reproduction.establishProbabilities = establishProbabilities;
seeding = new Seeding(seedingAlgorithm);
Reproduction.addNewCohort = addNewCohort;
SiteVars.Cohorts = Model.Core.GetSiteVar<SiteCohorts>("Succession.Cohorts");
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar<BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar<BitArray>();
noEstablish = Model.Core.Landscape.NewSiteVar<bool>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites) {
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
noEstablish.ActiveSiteValues = false;
planting = new Planting();
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="speciesDataset">
/// The dataset of species to look up species' names in.
/// </param>
public ParametersParser(ISpeciesDataset speciesDataset)
: base(PlugIn.ExtensionName, speciesDataset)
{
}
//---------------------------------------------------------------------
public AuxParm(ISpeciesDataset species)
{
values = new T[species.Count];
}
//---------------------------------------------------------------------
public static void Initialize(SeedingAlgorithm seedingAlgorithm)
{
seeding = new Seeding(seedingAlgorithm);
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar<BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar<BitArray>();
noEstablish = Model.Core.Landscape.NewSiteVar<bool>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites) {
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
noEstablish.ActiveSiteValues = false;
planting = new Planting();
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="speciesDataset">
/// The dataset of species to look up species' names in.
/// </param>
public InputParametersParser(ISpeciesDataset speciesDataset)
: base(PlugIn.ExtensionName, speciesDataset)
{
}
//---------------------------------------------------------------------
public static Landis.Library.Biomass.Species.AuxParm <Landis.Library.Biomass.Ecoregions.AuxParm <T> > CreateSpeciesEcoregionParm <T>(ISpeciesDataset speciesDataset, IEcoregionDataset ecoregionDataset)
{
Landis.Library.Biomass.Species.AuxParm <Landis.Library.Biomass.Ecoregions.AuxParm <T> > newParm;
newParm = new Landis.Library.Biomass.Species.AuxParm <Landis.Library.Biomass.Ecoregions.AuxParm <T> >(speciesDataset);
foreach (ISpecies species in speciesDataset)
{
newParm[species] = new Landis.Library.Biomass.Ecoregions.AuxParm <T>(ecoregionDataset);
}
return(newParm);
}
//---------------------------------------------------------------------
static FormOfReproduction()
{
speciesDataset = Model.Core.Species;
}
public static Species.AuxParm <Ecoregions.AuxParm <T> > CreateSpeciesEcoregionParm <T>(ISpeciesDataset speciesDataset, IEcoregionDataset ecoregionDataset)
{
Species.AuxParm <Ecoregions.AuxParm <T> > newParm;
newParm = new Species.AuxParm <Ecoregions.AuxParm <T> >(speciesDataset);
foreach (ISpecies species in speciesDataset)
{
newParm[species] = new Ecoregions.AuxParm <T>(ecoregionDataset);
}
return(newParm);
}
//---------------------------------------------------------------------
private int CalcFuelType(Site site,
IEnumerable <IFuelType> FuelTypes,
IEnumerable <IDisturbanceType> DisturbanceTypes)
{
double[] forTypValue = new double[100]; //Maximum of 100 fuel types
double sumConifer = 0.0;
double sumDecid = 0.0;
ISpeciesDataset SpeciesDataset = modelCore.Species;
foreach (ISpecies species in SpeciesDataset)
{
// This is the new algorithm, based on where a cohort is within it's age range.
// This algorithm is less biased towards older cohorts.
ISpeciesCohorts speciesCohorts = SiteVars.Cohorts[site][species];
if (speciesCohorts == null)
{
continue;
}
foreach (IFuelType ftype in FuelTypes)
{
if (ftype[species.Index] != 0)
{
double sppValue = 0.0;
foreach (ICohort cohort in speciesCohorts)
{
double cohortValue = 0.0;
if (cohort.Age >= ftype.MinAge && cohort.Age <= ftype.MaxAge)
{
// Adjust max range age to the spp longevity
double maxAge = System.Math.Min(ftype.MaxAge, (double)species.Longevity);
// The fuel type range must be at least 5 years:
double ftypeRange = System.Math.Max(1.0, maxAge - (double)ftype.MinAge);
// The cohort age relative to the fuel type range:
double relativeCohortAge = System.Math.Max(1.0, (double)cohort.Age - ftype.MinAge);
cohortValue = relativeCohortAge / ftypeRange * fuelCoefs[species.Index];
// Use the one cohort with the largest value:
//sppValue += System.Math.Max(sppValue, cohortValue); // A BUG, should be...
sppValue = System.Math.Max(sppValue, cohortValue);
}
}
if (ftype[species.Index] == -1)
{
forTypValue[ftype.FuelIndex] -= sppValue;
}
if (ftype[species.Index] == 1)
{
forTypValue[ftype.FuelIndex] += sppValue;
}
}
}
}
int finalFuelType = 0;
int decidFuelType = 0;
double maxValue = 0.0;
double maxDecidValue = 0.0;
//Set the PERCENT CONIFER DOMINANCE:
int coniferDominance = 0;
int hardwoodDominance = 0;
//First accumulate data for the BASE fuel types:
foreach (IFuelType ftype in FuelTypes)
{
if (ftype != null)
{
if ((ftype.BaseFuel == BaseFuelType.Conifer || ftype.BaseFuel == BaseFuelType.ConiferPlantation) &&
forTypValue[ftype.FuelIndex] > 0)
{
sumConifer += forTypValue[ftype.FuelIndex];
}
//This is calculated for the mixed types:
if ((ftype.BaseFuel == BaseFuelType.Deciduous) &&
forTypValue[ftype.FuelIndex] > 0)
{
sumDecid += forTypValue[ftype.FuelIndex];
}
if (forTypValue[ftype.FuelIndex] > maxValue)
{
maxValue = forTypValue[ftype.FuelIndex];
finalFuelType = ftype.FuelIndex;
}
if (ftype.BaseFuel == BaseFuelType.Deciduous && forTypValue[ftype.FuelIndex] > maxDecidValue)
{
maxDecidValue = forTypValue[ftype.FuelIndex];
decidFuelType = ftype.FuelIndex;
}
}
}
// Next, use rules to modify the conifer and deciduous dominance:
foreach (IFuelType ftype in FuelTypes)
{
if (ftype != null)
{
if (ftype.FuelIndex == finalFuelType && ftype.BaseFuel == BaseFuelType.ConiferPlantation)
{
decidFuelType = 0;
sumConifer = 100;
sumDecid = 0;
}
// a SLASH type
else if (ftype.FuelIndex == finalFuelType && ftype.BaseFuel == BaseFuelType.Slash)
{
//maxValue = maxSlashValue;
//finalFuelType = slashFuelType;
//decidFuelType = 0;
sumConifer = 0;
sumDecid = 0;
}
// an OPEN type
else if (ftype.FuelIndex == finalFuelType && ftype.BaseFuel == BaseFuelType.Open)
{
//maxValue = maxOpenValue;
//finalFuelType = openFuelType;
//decidFuelType = 0;
sumConifer = 0;
sumDecid = 0;
}
}
}
//Set the PERCENT DOMINANCE values:
if (sumConifer > 0 || sumDecid > 0)
{
coniferDominance = (int)((sumConifer / (sumConifer + sumDecid) * 100) + 0.5);
hardwoodDominance = (int)((sumDecid / (sumConifer + sumDecid) * 100) + 0.5);
if (hardwoodDominance < hardwoodMax)
{
coniferDominance = 100;
hardwoodDominance = 0;
}
if (coniferDominance < hardwoodMax)
{
coniferDominance = 0;
hardwoodDominance = 100;
finalFuelType = decidFuelType;
}
}
//---------------------------------------------------------------------
// Next check the disturbance types. This will override any other existing fuel type.
foreach (DisturbanceType slash in DisturbanceTypes)
{
//if (SiteVars.HarvestCohortsKilled != null && SiteVars.HarvestCohortsKilled[site] > 0)
//{
if (SiteVars.TimeOfLastHarvest != null &&
(modelCore.CurrentTime - SiteVars.TimeOfLastHarvest[site] <= slash.MaxAge))
{
foreach (string pName in slash.PrescriptionNames)
{
if (SiteVars.HarvestPrescriptionName != null && SiteVars.HarvestPrescriptionName[site].Trim() == pName.Trim())
{
finalFuelType = slash.FuelIndex; //Name;
decidFuelType = 0;
coniferDominance = 0;
hardwoodDominance = 0;
}
}
}
//}
//Check for fire severity effects of fuel type
if (SiteVars.FireSeverity != null && SiteVars.FireSeverity[site] > 0)
{
if (SiteVars.TimeOfLastFire != null &&
(modelCore.CurrentTime - SiteVars.TimeOfLastFire[site] <= slash.MaxAge))
{
foreach (string pName in slash.PrescriptionNames)
{
if (pName.StartsWith("FireSeverity"))
{
if ((pName.Substring((pName.Length - 1), 1)).ToString() == SiteVars.FireSeverity[site].ToString())
{
finalFuelType = slash.FuelIndex; //Name;
decidFuelType = 0;
coniferDominance = 0;
hardwoodDominance = 0;
}
}
}
}
}
//Check for wind severity effects of fuel type
if (SiteVars.WindSeverity != null && SiteVars.WindSeverity[site] > 0)
{
if (SiteVars.TimeOfLastWind != null &&
(modelCore.CurrentTime - SiteVars.TimeOfLastWind[site] <= slash.MaxAge))
{
foreach (string pName in slash.PrescriptionNames)
{
if (pName.StartsWith("WindSeverity"))
{
if ((pName.Substring((pName.Length - 1), 1)).ToString() == SiteVars.WindSeverity[site].ToString())
{
finalFuelType = slash.FuelIndex; //Name;
decidFuelType = 0;
coniferDominance = 0;
hardwoodDominance = 0;
}
}
}
}
}
}
//Assign Percent Conifer:
SiteVars.PercentConifer[site] = coniferDominance;
SiteVars.PercentHardwood[site] = hardwoodDominance;
SiteVars.FuelType[site] = finalFuelType;
SiteVars.DecidFuelType[site] = decidFuelType;
return(finalFuelType);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="speciesDataset">
/// The dataset of species to look up species' names in. Important note: the base harvest
/// speciesDataset must be overwritten with the HarvestSpeciesDataset. Methods within base harvest
/// will set the MostRecentlyFetchedSpecies parameter when they are reading in species names
/// from a list of cohorts to be removed. The value of MostRecentlyFetchedSpecies is not set within
/// biomass harvest.
/// </param>
public ParametersParser(ISpeciesDataset speciesDataset)
: base(new HarvestSpeciesDataset(speciesDataset))
{
this.speciesDataset = speciesDataset;
ageSelectors = new SpecificAgesCohortSelector[speciesDataset.Count];
}
