/// <summary>
/// Constructor for dispersal: assigns all parameter values
/// </summary>
public AdvectiveDispersal(string globalModelTimeStepUnit, Boolean DrawRandomly)
{
InitialiseParatemersAdvectiveDispersal();
// Initialise the utility functions
UtilityFunctions Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of dispersal to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Initialise the advective dispersal temporal scaling to adjust between time steps appropriately
_AdvectionTimeStepsPerModelTimeStep = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, "day") * 24 / _AdvectiveModelTimeStepLengthHours;
// Convert velocity from m/s to km/month. Note that if the _TimeUnitImplementation changes, this will also have to change.
VelocityUnitConversion = 60 * 60 * 24 * Utilities.ConvertTimeUnits(globalModelTimeStepUnit, "day") * _DeltaT / 1000;
// Set the seed for the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
if (DrawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(14141);
}
}
/// <summary>
/// Constructor for starvation mortality: assigns all parameter values
///
/// </summary>
public StarvationMortality(string globalModelTimeStepUnit)
{
InitialiseParametersStarvationMortality();
// Initialise the utility functions
UtilityFunctions Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of mortality to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
}
/// <summary>
/// Constructor for metabolism: assigns all parameter values
/// </summary>
public MetabolismEndotherm(string globalModelTimeStepUnit)
{
// Initialise ecological parameters for metabolism
InitialiseMetabolismParameters();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of metabolism to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
}
/// <summary>
/// Constructor for metabolism: assigns all parameter values
/// </summary>
public MetabolismEctotherm(string globalModelTimeStepUnit)
{
// Initialise ecological parameters for metabolism
InitialiseMetabolismParameters();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of metabolism to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
_ProportionTimeActiveCalculatedThisTimestep = false;
}
/// <summary>
/// Constructor for metabolism: assigns all parameter values
/// </summary>
public MetabolismHeterotroph(string globalModelTimeStepUnit)
{
// Initialise ecological parameters for metabolism
InitialiseMetabolismParameters();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of metabolism to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Set the constant to convert temperature in degrees Celsius to Kelvin
_TemperatureUnitsConvert = 273.0;
}
/// <summary>
/// Constructor for herbivory: assigns all parameter values
/// </summary>
/// <param name="cellArea">The area (in square km) of the grid cell</param>
/// <param name="globalModelTimeStepUnit">The time step unit used in the model</param>
public RevisedHerbivory(double cellArea, string globalModelTimeStepUnit)
{
InitialiseParametersHerbivory();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of herbivory to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Store the specified cell area in this instance of this herbivory implementation
_CellArea = cellArea;
_CellAreaHectares = cellArea * 100;
}
/// <summary>
/// Constructor for metabolism: assigns all parameter values
/// </summary>
public MetabolismHeterotroph(string globalModelTimeStepUnit)
{
// Initialise ecological parameters for metabolism
InitialiseMetabolismParameters();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of metabolism to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Set the constant to convert temperature in degrees Celsius to Kelvin
_TemperatureUnitsConvert = 273.0;
}
/// <summary>
/// Constructor for predation: assigns all parameter values
/// </summary>
/// <param name="cellArea">The area (in square km) of the grid cell</param>
/// <param name="globalModelTimeStepUnit">The time step unit used in the model</param>
public RevisedPredation(double cellArea, string globalModelTimeStepUnit)
{
InitialiseParametersPredation();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of predation to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Store the specified cell area in this instance of this predation implementation
_CellArea = cellArea;
_CellAreaHectares = cellArea * 100;
HalfNumberOfBins = NumberOfBins / 2;
FeedingPreferenceHalfStandardDeviation = _FeedingPreferenceStandardDeviation * 0.5;
}
/// <summary>
/// Constructor for dispersal: assigns all parameter values
/// </summary>
public DiffusiveDispersal(string globalModelTimeStepUnit, Boolean DrawRandomly)
{
InitialiseParametersDiffusiveDispersal();
// Initialise the utility functions
UtilityFunctions Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of dispersal to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Set the seed for the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
if (DrawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(14141);
}
}
/// <summary>
/// Assigns all parameter values for repsonsive dispersal
/// </summary>
public ResponsiveDispersal(string globalModelTimeStepUnit, Boolean DrawRandomly)
{
InitialiseParametersResponsiveDispersal();
// Initialise the utility functions
UtilityFunctions Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of dispersal to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Set the seed for the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
if (DrawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(14141);
}
}
/// <summary>
/// Constructor for reproduction: assigns all parameter values
/// <param name="globalModelTimeStepUnit">The time step of the global model</param>
/// <param name="drawRandomly">Indicates whether to draw values randomly</param>
/// </summary>
public ReproductionBasic(string globalModelTimeStepUnit, Boolean drawRandomly)
{
// Initialise ecological parameters for reproduction
InitialiseReproductionParameters();
// Initialise the utility class
UtilityFunctions Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of herbivory to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Instantiate the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
// Set the seed for the random number generator
if (drawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(4000);
}
}
/// <summary>
/// Constructor for reproduction: assigns all parameter values
/// <param name="globalModelTimeStepUnit">The time step of the global model</param>
/// <param name="drawRandomly">Indicates whether to draw values randomly</param>
/// </summary>
public ReproductionBasic(string globalModelTimeStepUnit, Boolean drawRandomly)
{
// Initialise ecological parameters for reproduction
InitialiseReproductionParameters();
// Initialise the utility class
UtilityFunctions Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of herbivory to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Instantiate the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
// Set the seed for the random number generator
if (drawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(4000);
}
}
/// <summary>
/// Constructor for predation: assigns all parameter values
/// </summary>
/// <param name="cellArea">The area (in square km) of the grid cell</param>
/// <param name="globalModelTimeStepUnit">The time step unit used in the model</param>
public RevisedPredation(double cellArea, string globalModelTimeStepUnit)
{
InitialiseParametersPredation();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of predation to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Store the specified cell area in this instance of this predation implementation
_CellArea = cellArea;
_CellAreaHectares = cellArea * 100;
HalfNumberOfBins = NumberOfBins / 2;
FeedingPreferenceHalfStandardDeviation = _FeedingPreferenceStandardDeviation * 0.5;
}
/// <summary>
/// Update the leaf stock during a time step given the environmental conditions in the grid cell
/// </summary>
/// <param name="cellEnvironment">The environment in the current grid cell</param>
/// <param name="gridCellStocks">The stocks in the current grid cell</param>
/// <param name="actingStock">The position of the acting stock in the array of grid cell stocks</param>
/// <param name="currentTimeStep">The current model time step</param>
/// <param name="deciduous">Whether the acting stock consists of deciduous leaves</param>
/// <param name="GlobalModelTimeStepUnit">The time step unit used in the model</param>
/// <param name="tracker">Whether to track properties of the ecological processes</param>
/// <param name="globalTracker">Whether to output data describing the global environment</param>
/// <param name="currentMonth">The current model month</param>
/// <param name="outputDetail">The level of detail to use in model outputs</param>
/// <param name="specificLocations">Whether the model is being run for specific locations</param>
public double UpdateLeafStock(SortedList <string, double[]> cellEnvironment, GridCellStockHandler gridCellStocks, int[] actingStock,
uint currentTimeStep, bool deciduous, string GlobalModelTimeStepUnit, ProcessTracker tracker, GlobalProcessTracker globalTracker,
uint currentMonth, string outputDetail, bool specificLocations)
{
// ESTIMATE ANNUAL LEAF CARBON FIXATION ASSUMING ENVIRONMENT THROUGHOUT THE YEAR IS THE SAME AS IN THIS MONTH
// Calculate annual NPP
double NPP = this.CalculateMiamiNPP(cellEnvironment["Temperature"].Average(), cellEnvironment["Precipitation"].Sum());
// Calculate fractional allocation to structural tissue
double FracStruct = this.CalculateFracStruct(NPP);
// Estimate monthly NPP based on seasonality layer
NPP *= cellEnvironment["Seasonality"][currentMonth];
// Calculate leaf mortality rates
double AnnualLeafMortRate;
double MonthlyLeafMortRate;
double TimeStepLeafMortRate;
if (deciduous)
{
// Calculate annual deciduous leaf mortality
AnnualLeafMortRate = this.CalculateDeciduousAnnualLeafMortality(cellEnvironment["Temperature"].Average());
// For deciduous plants monthly leaf mortality is weighted by temperature deviance from the average, to capture seasonal patterns
double[] ExpTempDev = new double[12];
double SumExpTempDev = 0.0;
double[] TempDev = new double[12];
double Weight;
for (int i = 0; i < 12; i++)
{
TempDev[i] = cellEnvironment["Temperature"][i] - cellEnvironment["Temperature"].Average();
ExpTempDev[i] = Math.Exp(-TempDev[i] / 3);
SumExpTempDev += ExpTempDev[i];
}
Weight = ExpTempDev[currentMonth] / SumExpTempDev;
MonthlyLeafMortRate = AnnualLeafMortRate * Weight;
TimeStepLeafMortRate = MonthlyLeafMortRate * Utilities.ConvertTimeUnits(GlobalModelTimeStepUnit, "month");
}
else
{
// Calculate annual evergreen leaf mortality
AnnualLeafMortRate = this.CalculateEvergreenAnnualLeafMortality(cellEnvironment["Temperature"].Average());
// For evergreen plants, leaf mortality is assumed to be equal throughout the year
MonthlyLeafMortRate = AnnualLeafMortRate * (1.0 / 12.0);
TimeStepLeafMortRate = MonthlyLeafMortRate * Utilities.ConvertTimeUnits(GlobalModelTimeStepUnit, "month");
}
// Calculate fine root mortality rate
double AnnualFRootMort = this.CalculateFineRootMortalityRate(cellEnvironment["Temperature"][currentMonth]);
// Calculate the NPP allocated to non-structural tissues
double FracNonStruct = (1 - FracStruct);
// Calculate the fractional allocation to leaves
double FracLeaves = FracNonStruct * this.CalculateLeafFracAllocation(AnnualLeafMortRate, AnnualFRootMort);
// Calculate the fractional allocation of NPP to evergreen plant matter
double FracEvergreen = this.CalculateFracEvergreen(cellEnvironment["Fraction Year Frost"][0]);
// Update NPP depending on whether the acting stock is deciduous or evergreen
if (deciduous)
{
NPP *= (1 - FracEvergreen);
}
else
{
NPP *= FracEvergreen;
}
// Calculate the fire mortality rate
double FireMortRate = this.CalculateFireMortalityRate(NPP, cellEnvironment["Fraction Year Fire"][0]);
// Calculate the structural mortality rate
double StMort = this.CalculateStructuralMortality(cellEnvironment["AET"][currentMonth] * 12);
// Calculate leaf C fixation
double LeafCFixation = NPP * FracLeaves;
// Convert from carbon to leaf wet matter
double WetMatterIncrement = this.ConvertToLeafWetMass(LeafCFixation, cellEnvironment["Cell Area"][0]);
// Convert from the monthly time step used for this process to the global model time step unit
WetMatterIncrement *= Utilities.ConvertTimeUnits(GlobalModelTimeStepUnit, "month");
// Add the leaf wet matter to the acting stock
//gridCellStocks[actingStock].TotalBiomass += Math.Max(-gridCellStocks[actingStock].TotalBiomass, WetMatterIncrement);
double NPPWetMatter = Math.Max(-gridCellStocks[actingStock].TotalBiomass, WetMatterIncrement);
// If the processer tracker is enabled and output detail is high and the model is being run for specific locations, then track the biomass gained through primary production
if (tracker.TrackProcesses && (outputDetail == "high") && specificLocations)
{
tracker.TrackPrimaryProductionTrophicFlow((uint)cellEnvironment["LatIndex"][0], (uint)cellEnvironment["LonIndex"][0],
Math.Max(-gridCellStocks[actingStock].TotalBiomass, WetMatterIncrement));
}
if (globalTracker.TrackProcesses)
{
globalTracker.RecordNPP((uint)cellEnvironment["LatIndex"][0], (uint)cellEnvironment["LonIndex"][0], (uint)actingStock[0],
this.ConvertToLeafWetMass(NPP, cellEnvironment["Cell Area"][0]) *
Utilities.ConvertTimeUnits(GlobalModelTimeStepUnit, "month") / cellEnvironment["Cell Area"][0]);
}
// Calculate fractional leaf mortality
double LeafMortFrac = 1 - Math.Exp(-TimeStepLeafMortRate);
// Update the leaf stock biomass owing to the leaf mortality
gridCellStocks[actingStock].TotalBiomass *= (1 - LeafMortFrac);
NPPWetMatter *= (1 - LeafMortFrac);
return(NPPWetMatter);
}
/// <summary>
/// Constructor for herbivory: assigns all parameter values
/// </summary>
/// <param name="cellArea">The area (in square km) of the grid cell</param>
/// <param name="globalModelTimeStepUnit">The time step unit used in the model</param>
public RevisedHerbivory(double cellArea, string globalModelTimeStepUnit)
{
InitialiseParametersHerbivory();
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Calculate the scalar to convert from the time step units used by this implementation of herbivory to the global model time step units
_DeltaT = Utilities.ConvertTimeUnits(globalModelTimeStepUnit, _TimeUnitImplementation);
// Store the specified cell area in this instance of this herbivory implementation
_CellArea = cellArea;
_CellAreaHectares = cellArea * 100;
}
/// <summary>
/// Remove human appropriated matter from the grid cell autotroph stocks
/// </summary>
/// <param name="cellEnvironment">The environment in the current grid cell</param>
/// <param name="humanNPPScenario">The type of NPP extraction to apply</param>
/// <param name="gridCellStocks">The stocks in the current grid cell</param>
/// <param name="actingStock">The position of the acting stock in the jagged array of grid cell stocks</param>
/// <param name="currentTimestep">The current model time step</param>
/// <param name="burninSteps">The number of steps to run before impact is simulated</param>
/// <param name="impactSteps">The number of time steps to apply the impact for (for 'temporary' scenarios)</param>
/// <param name="impactCell">Whether this cell should have human impacts applied</param>
/// <remarks>Scenario types are: 'no' = no removal; 'hanpp' = appropriated NPP estimate from input map; constant = constant appropriation after burn-in;
/// temporary = constant after burn-in until specified time; value = proportion of plant biomass appropriated</remarks>
public double RemoveHumanAppropriatedMatter(double wetMatterNPP, SortedList <string, double[]> cellEnvironment,
Tuple <string, double, double> humanNPPScenario, GridCellStockHandler
gridCellStocks, int[] actingStock, uint currentTimestep, uint burninSteps,
uint impactSteps, uint recoverySteps, uint instantStep, uint numInstantStep, Boolean impactCell,
string globalModelTimestepUnits)
{
double RemovalRate = 0.0;
if (impactCell)
{
// Factor to convert NPP from units per m2 to units per km2
double m2Tokm2Conversion = 1000000.0;
if (humanNPPScenario.Item1 == "hanpp")
{
if (currentTimestep > burninSteps)
{
// Loop over stocks in the grid cell and calculate the total biomass of all stocks
double TotalAutotrophBiomass = 0.0;
foreach (var stockFunctionalGroup in gridCellStocks)
{
for (int i = 0; i < stockFunctionalGroup.Count; i++)
{
TotalAutotrophBiomass += stockFunctionalGroup[i].TotalBiomass;
}
}
// Get the total amount of NPP appropriated by humans from this cell
double HANPP = cellEnvironment["HANPP"][0];
// If HANPP value is missing, then assume zero
if (HANPP == cellEnvironment["Missing Value"][0])
{
HANPP = 0.0;
}
HANPP *= cellEnvironment["Seasonality"][currentTimestep % 12];
// Allocate HANPP for this stock according to the proportion of total autotroph biomass that the stock represents
if (TotalAutotrophBiomass == 0.0)
{
HANPP = 0.0;
}
else
{
HANPP *= (gridCellStocks[actingStock].TotalBiomass / TotalAutotrophBiomass);
}
// Convert gC/m2/month to gC/km2/month
HANPP *= m2Tokm2Conversion;
// Multiply by cell area (in km2) to get g/cell/day
HANPP *= cellEnvironment["Cell Area"][0];
// Convert from gC to g dry matter
double DryMatterAppropriated = HANPP * 2;
// Convert from g dry matter to g wet matter
double WetMatterAppropriated = DryMatterAppropriated * 2;
//Calculate the rate of HANPP offtake
if (wetMatterNPP.CompareTo(0.0) == 0)
{
RemovalRate = 0.0;
}
else
{
RemovalRate = Math.Min(1.0, WetMatterAppropriated / wetMatterNPP);
}
// Remove human appropriated autotroph biomass from total autotroph biomass
//gridCellStocks[actingStock].TotalBiomass -= WetMatterAppropriated;
//if (gridCellStocks[actingStock].TotalBiomass < 0.0) gridCellStocks[actingStock].TotalBiomass = 0.0;
}
}
else if (humanNPPScenario.Item1 == "no")
{
// Do not remove any autotroph biomass
}
else if (humanNPPScenario.Item1 == "constant")
{
// If the burn-in period has been completed, then remove the specified constant
// fraction from the acting autotroph stock
if (currentTimestep > burninSteps)
{
//gridCellStocks[actingStock].TotalBiomass -= (gridCellStocks[actingStock].TotalBiomass *
// humanNPPScenario.Item2);
RemovalRate = humanNPPScenario.Item2;
}
}
else if (humanNPPScenario.Item1 == "temporary")
{
// If the spin-up period has been completed and the period of impact has not elapsed,
// then remove the specified constant fraction from the acting autotroph stock
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
//gridCellStocks[actingStock].TotalBiomass -= (gridCellStocks[actingStock].TotalBiomass *
// humanNPPScenario.Item2);
RemovalRate = humanNPPScenario.Item2;
}
}
else if (humanNPPScenario.Item1 == "escalating")
{
// If the spin-up period has been completed, then remove a proportion of plant matter
// according to the number of time-steps that have elapsed since the spin-up ended
if (currentTimestep > burninSteps)
{
//gridCellStocks[actingStock].TotalBiomass -= gridCellStocks[actingStock].TotalBiomass *
// (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
RemovalRate = (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
}
}
else if (humanNPPScenario.Item1 == "temp-escalating")
{
// If the spin-up period has been completed and the period of impact has not elapsed,
// then remove a proportion of plant matter
// according to the number of time-steps that have elapsed since the spin-up ended
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
//gridCellStocks[actingStock].TotalBiomass -= gridCellStocks[actingStock].TotalBiomass *
// (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
RemovalRate = (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
}
}
else if (humanNPPScenario.Item1 == "temp-escalating-const-rate")
{
// If the spin-up period has been completed and the period of impact (specified by the third scenario element
// has not elapsed,
// then remove a proportion of plant matter
// according to the number of time-steps that have elapsed since the spin-up ended
int ConstImpactSteps = Convert.ToInt32(humanNPPScenario.Item3 * _Utilities.ConvertTimeUnits("year", globalModelTimestepUnits));
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + ConstImpactSteps)))
{
//gridCellStocks[actingStock].TotalBiomass -= gridCellStocks[actingStock].TotalBiomass *
// (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
RemovalRate = (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
}
}
else if (humanNPPScenario.Item1 == "temp-escalating-const-rate-duration")
{
// If the spin-up period has been completed and the period of impact (specified by the third scenario element
// has not elapsed,
// then remove a proportion of plant matter
// according to the number of time-steps that have elapsed since the spin-up ended
int ConstImpactSteps = Convert.ToInt32(humanNPPScenario.Item3 * _Utilities.ConvertTimeUnits("year", globalModelTimestepUnits));
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
//gridCellStocks[actingStock].TotalBiomass -= gridCellStocks[actingStock].TotalBiomass *
// (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
RemovalRate = (Math.Min(1.0,
Math.Min(((ConstImpactSteps / 12.0) * humanNPPScenario.Item2),
(((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2))));
}
}
else if (humanNPPScenario.Item1 == "temp-escalating-declining")
{
// If the spin-up period has been completed, then apply a level of harvesting
// according to the number of time-steps that have elapsed since the spin-up ended
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
//gridCellStocks[actingStock].TotalBiomass -= gridCellStocks[actingStock].TotalBiomass *
// (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
RemovalRate = Math.Max(0.0, (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2))));
}
else if ((currentTimestep > (burninSteps + impactSteps)) & (currentTimestep <= (burninSteps + impactSteps + recoverySteps)))
{
//gridCellStocks[actingStock].TotalBiomass -= gridCellStocks[actingStock].TotalBiomass *
// (Math.Min(1.0, (((burninSteps + impactSteps + recoverySteps - currentTimestep) / 12.0) * humanNPPScenario.Item2)));
//RemovalRate = (Math.Min(1.0, (((burninSteps + impactSteps + recoverySteps - currentTimestep) / 12.0) * humanNPPScenario.Item2)));
RemovalRate = Math.Max(0.0, Math.Min(1.0, ((int)((impactSteps) - (currentTimestep - (burninSteps + impactSteps))) / 12.0) * humanNPPScenario.Item2));
}
}
else
{
Debug.Fail("There is no method for the human extraction of NPP scenario specified");
}
}
return(RemovalRate);
}
/// <summary>
/// Remove individuals lost from cohorts through direct harvesting of animals
/// </summary>
/// <param name="gridCellCohorts">The cohorts in the current grid cell</param>
/// <param name="harvestingScenario">The scenario of direct harvesting of animals to apply</param>
/// <param name="currentTimestep">The current model time step</param>
/// <param name="burninSteps">The number of time steps to spin the model up for before applying the harvesting scenario</param>
/// <param name="impactSteps">The number of time steps to apply the scenario for</param>
/// <param name="cellEnvironment">The environment in the current grid cell</param>
/// <param name="impactCell">The index of the cell, within the list of all cells to run, to apply the scenario for</param>
public void RemoveHarvestedIndividuals(GridCellCohortHandler gridCellCohorts,
Tuple <string, double, double> harvestingScenario, uint currentTimestep, uint burninSteps, uint impactSteps, uint totalSteps,
SortedList <string, double[]> cellEnvironment, Boolean impactCell, string globalModelTimestepUnits, FunctionalGroupDefinitions cohortFGs)
{
if (impactCell)
{
//If this is marine cell
if (cellEnvironment["Realm"][0] == 2.0)
{
if (harvestingScenario.Item1 == "no")
{
// Do not apply any harvesting
}
else if (harvestingScenario.Item1 == "constant")
{
double TargetBiomass;
if (FisheriesCatch != null)
{
TargetBiomass = (1000 *
FisheriesCatch.ModelGridCatchTotal[Convert.ToInt32(cellEnvironment["LatIndex"][0]), Convert.ToInt32(cellEnvironment["LonIndex"][0])])
/ 12.0;
}
else
{
TargetBiomass = harvestingScenario.Item2;
}
// If the burn-in period has been completed, then apply
// the harvesting scenario
if (currentTimestep > burninSteps)
{
ApplyHarvesting(gridCellCohorts, TargetBiomass, cellEnvironment);
}
}
else if (harvestingScenario.Item1 == "fish-catch")
{
//Initialise an instance of ApplyFishingCatches for this cell
if (currentTimestep == burninSteps)
{
ApplyCatches[Convert.ToInt32(cellEnvironment["LatIndex"][0]),
Convert.ToInt32(cellEnvironment["LonIndex"][0])] = new ApplyFishingCatches(FisheriesCatch);
}
if (currentTimestep > burninSteps)
{
//Bin the cohorts of the current cell
ApplyCatches[Convert.ToInt32(cellEnvironment["LatIndex"][0]),
Convert.ToInt32(cellEnvironment["LonIndex"][0])].BinCohorts(gridCellCohorts, FisheriesCatch, cohortFGs);
//Now remove the catch
ApplyCatches[Convert.ToInt32(cellEnvironment["LatIndex"][0]),
Convert.ToInt32(cellEnvironment["LonIndex"][0])].ApplyCatches(gridCellCohorts, FisheriesCatch,
Convert.ToInt32(cellEnvironment["LatIndex"][0]),
Convert.ToInt32(cellEnvironment["LonIndex"][0]));
}
}
}
else
{
if (harvestingScenario.Item1 == "no")
{
// Do not apply any harvesting
}
else if (harvestingScenario.Item1 == "constant")
{
// If the burn-in period has been completed, then apply
// the harvesting scenario
if (currentTimestep > burninSteps)
{
ApplyHarvesting(gridCellCohorts, harvestingScenario.Item2, cellEnvironment);
}
}
else if (harvestingScenario.Item1 == "temporary")
{
// If the burn-in period has been completed and the period of impact has not elapsed,
// then apply the harvesting scenario
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
ApplyHarvesting(gridCellCohorts, harvestingScenario.Item2, cellEnvironment);
}
}
else if (harvestingScenario.Item1 == "escalating")
{
// If the spin-up period has been completed, then apply a level of harvesting
// according to the number of time-steps that have elapsed since the spin-up ended
if (currentTimestep > burninSteps)
{
// Calculate the target biomass for harvesting based on the number of time steps that have elapsed since the spin-up
double TargetBiomass = (Math.Min(50000, (((currentTimestep - burninSteps) / 12.0) * harvestingScenario.Item2)));
// Apply the harvesting scenario using the calculated target biomass
ApplyHarvesting(gridCellCohorts, TargetBiomass, cellEnvironment);
}
}
else if (harvestingScenario.Item1 == "temp-escalating-declining")
{
// If the spin-up period has been completed, then apply a level of harvesting
// according to the number of time-steps that have elapsed since the spin-up ended
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
// Calculate the target biomass for harvesting based on the number of time steps that have elapsed since the spin-up
double TargetBiomass = (Math.Min(50000, (((currentTimestep - burninSteps) / 12.0) * harvestingScenario.Item2)));
// Apply the harvesting scenario using the calculated target biomass
ApplyHarvesting(gridCellCohorts, TargetBiomass, cellEnvironment);
}
else if (currentTimestep > (burninSteps + impactSteps))
{
// Calculate the target biomass for harvesting based on the number of time steps that have elapsed since the spin-up
double TargetBiomass = (Math.Min(50000, ((-(totalSteps - currentTimestep) / 12.0) * harvestingScenario.Item2)));
// Apply the harvesting scenario using the calculated target biomass
ApplyHarvesting(gridCellCohorts, TargetBiomass, cellEnvironment);
}
}
else if (harvestingScenario.Item1 == "temp-escalating")
{
// If the spin-up period has been completed and the period of impact has not elapsed,
// then remove a proportion of plant matter
// according to the number of time-steps that have elapsed since the spin-up ended
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
// Calculate the target biomass for harvesting based on the number of time steps that have elapsed since the spin-up
double TargetBiomass = (Math.Min(50000, (((currentTimestep - burninSteps) / 12.0) * harvestingScenario.Item2)));
// Apply the harvesting scenarion using the calculated target biomass
ApplyHarvesting(gridCellCohorts, TargetBiomass, cellEnvironment);
}
}
else if (harvestingScenario.Item1 == "temp-escalating-const-rate")
{
// If the spin-up period has been completed and the period of impact (specified by the third scenario element
// has not elapsed,
// then remove a portion of plant matter
// according to the number of time-steps that have elapsed since the spin-up ended
int ConstImpactSteps = Convert.ToInt32(harvestingScenario.Item3 * Utilities.ConvertTimeUnits("year", globalModelTimestepUnits));
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + ConstImpactSteps)))
{
// Calculate the target biomass for harvesting based on the number of time steps that have elapsed since the spin-up
double TargetBiomass = (Math.Min(200000, (((currentTimestep - burninSteps) / 12.0) * harvestingScenario.Item2)));
// Apply the harvesting scenarion using the calculated target biomass
ApplyHarvesting(gridCellCohorts, TargetBiomass, cellEnvironment);
}
}
else if (harvestingScenario.Item1 == "temp-escalating-const-rate-duration")
{
// If the spin-up period has been completed and the period of impact (specified by the third scenario element
// has not elapsed,
// then remove a proportion of plant matter
// according to the number of time-steps that have elapsed since the spin-up ended
int ConstImpactSteps = Convert.ToInt32(harvestingScenario.Item3 * Utilities.ConvertTimeUnits("year", globalModelTimestepUnits));
if ((currentTimestep > burninSteps) && (currentTimestep <= (burninSteps + impactSteps)))
{
//gridCellStocks[actingStock].TotalBiomass -= gridCellStocks[actingStock].TotalBiomass *
// (Math.Min(1.0, (((currentTimestep - burninSteps) / 12.0) * humanNPPScenario.Item2)));
double TargetBiomass = (Math.Min(200000,
Math.Min(((ConstImpactSteps / 12.0) * harvestingScenario.Item2),
(((currentTimestep - burninSteps) / 12.0) * harvestingScenario.Item2))));
// Apply the harvesting scenarion using the calculated target biomass
ApplyHarvesting(gridCellCohorts, TargetBiomass, cellEnvironment);
}
}
else
{
Debug.Fail("There is no method for the harvesting scenario specified");
}
}
}
}