/// <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 dispersal: assigns all parameter values
/// </summary>
public AdvectiveDispersal(string globalModelTimeStepUnit, Boolean DrawRandomly)
{
InitialiseParatemersAdvectiveDispersal();
// 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 CohortMerge: sets the seed for the random number generator
/// </summary>
/// <param name="DrawRandomly"></param>
public CohortMerge(Boolean DrawRandomly)
{
// Seed the random number generator
// Set the seed for the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
if (DrawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(4000);
}
}
/// <summary>
/// Constructor for CohortMerge: sets the seed for the random number generator
/// </summary>
/// <param name="DrawRandomly"></param>
public CohortMerge(Boolean DrawRandomly)
{
// Seed the random number generator
// Set the seed for the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
if (DrawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(4000);
}
}
/// <summary>
/// Assigns all parameter values for repsonsive dispersal
/// </summary>
public ResponsiveDispersal(string globalModelTimeStepUnit, Boolean DrawRandomly)
{
InitialiseParametersResponsiveDispersal();
// 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();
// 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();
// 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();
// 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 model grid: assigns grid properties and initialises the grid cells
/// </summary>
/// <param name="minLat">Minimum grid latitude (degrees)</param>
/// <param name="minLon">Minimum grid longitude (degrees, currently -180 to 180)</param>
/// <param name="maxLat">Maximum grid latitude (degrees)</param>
/// <param name="maxLon">Maximum grid longitude (degrees, currently -180 to 180)</param>
/// <param name="latCellSize">Latitudinal resolution of grid cell</param>
/// <param name="lonCellSize">Longitudinal resolution of grid cell</param>
/// <param name="cellRarefaction">The rarefaction to be applied to active grid cells in the model</param>
/// <param name="enviroStack">Environmental data layers</param>
/// <param name="cohortFunctionalGroups">The functional group definitions for cohorts in the model</param>
/// <param name="stockFunctionalGroups">The functional group definitions for stocks in the model</param>
/// <param name="globalDiagnostics">Global daignostic variables</param>
/// <param name="tracking">Whether process-tracking is enabled</param>
/// <param name="DrawRandomly">Whether the model is set to use a random draw</param>
/// <param name="specificLocations">Whether the model is to be run for specific locations</param>
public ModelGrid(float minLat, float minLon,float maxLat,float maxLon,float latCellSize,float lonCellSize,
SortedList<string,EnviroData> enviroStack, FunctionalGroupDefinitions cohortFunctionalGroups, FunctionalGroupDefinitions
stockFunctionalGroups, SortedList<string, double> globalDiagnostics, Boolean tracking, Boolean DrawRandomly,
Boolean specificLocations)
{
// Add one to the counter of the number of grids. If there is more than one model grid, exit the program with a debug crash.
NumGrids = NumGrids + 1;
//Debug.Assert(NumGrids < 2, "You have initialised more than one grid on which to apply models. At present, this is not supported");
// Initialise the utility functions
Utilities = new UtilityFunctions();
// Seed the random number generator
// Set the seed for the random number generator
RandomNumberGenerator = new NonStaticSimpleRNG();
if (DrawRandomly)
{
RandomNumberGenerator.SetSeedFromSystemTime();
}
else
{
RandomNumberGenerator.SetSeed(4315);
}
// CURRENTLY DEFINING MODEL CELLS BY BOTTOM LEFT CORNER
_MinLatitude = minLat;
_MinLongitude = minLon;
_MaxLatitude = maxLat;
_MaxLongitude = maxLon;
_LatCellSize = latCellSize;
_LonCellSize = lonCellSize;
// Check to see if the number of grid cells is an integer
Debug.Assert((((_MaxLatitude - _MinLatitude) % _LatCellSize) == 0), "Error: number of grid cells is non-integer: check cell size");
_NumLatCells = (UInt32)((_MaxLatitude - _MinLatitude) / _LatCellSize);
_NumLonCells = (UInt32)((_MaxLongitude - _MinLongitude) / _LonCellSize);
_Lats = new float[_NumLatCells];
_Lons = new float[_NumLonCells];
// Set up latitude and longitude vectors - lower left
for (int ii = 0; ii < _NumLatCells; ii++)
{
_Lats[ii] = _MinLatitude + ii * _LatCellSize;
}
for (int jj = 0; jj < _NumLonCells; jj++)
{
_Lons[jj] = _MinLongitude + jj * _LonCellSize;
}
// Instantiate a grid of grid cells
InternalGrid = new GridCell[_NumLatCells, _NumLonCells];
// Instantiate the arrays of lists of cohorts to disperse
DeltaFunctionalGroupDispersalArray = new List<uint>[_NumLatCells, _NumLonCells];
DeltaCohortNumberDispersalArray = new List<uint>[_NumLatCells, _NumLonCells];
// Instantiate the array of lists of grid cells to disperse those cohorts to
DeltaCellToDisperseToArray = new List<uint[]>[_NumLatCells, _NumLonCells];
// Instantiate the arrays of cell entry and exit directions
DeltaCellExitDirection = new List<uint>[_NumLatCells, _NumLonCells];
DeltaCellEntryDirection = new List<uint>[_NumLatCells, _NumLonCells];
// An array of lists of cells to which organisms in each cell can disperse to; includes all cells which contribute to the
// perimeter list, plus diagonal cells if they are in the same realm
CellsForDispersal = new List<uint[]>[_NumLatCells, _NumLonCells];
// An array of lists of directions corresponding to cells which organisms can disperse to
CellsForDispersalDirection = new List<uint>[_NumLatCells, _NumLonCells];
Console.WriteLine("Initialising grid cell environment:");
// Loop through to set up model grid
for (int ii = 0; ii < _NumLatCells; ii+=GridCellRarefaction)
{
for (int jj = 0; jj < _NumLonCells; jj+=GridCellRarefaction)
{
InternalGrid[ii, jj] = new GridCell(_Lats[ii],(uint)ii, _Lons[jj],(uint)jj, LatCellSize, LonCellSize, enviroStack,
GlobalMissingValue, cohortFunctionalGroups, stockFunctionalGroups, globalDiagnostics, tracking, specificLocations);
CellsForDispersal[ii,jj] = new List<uint[]>();
CellsForDispersalDirection[ii, jj] = new List<uint>();
Console.Write("\rRow {0} of {1}", ii+1, NumLatCells/GridCellRarefaction);
}
}
Console.WriteLine("");
Console.WriteLine("");
InterpolateMissingValues();
// Fill in the array of dispersable perimeter lengths for each grid cell
CalculatePerimeterLengthsAndCellsDispersableTo();
CellHeightsKm = new double[_Lats.Length];
CellWidthsKm = new double[_Lats.Length];
// Calculate the lengths of widths of grid cells in each latitudinal strip
// Assume that we are at the midpoint of each cell when calculating lengths
for (int ii = 0; ii < _Lats.Length; ii++)
{
CellHeightsKm[ii] = Utilities.CalculateLengthOfDegreeLatitude(_Lats[ii] + _LatCellSize / 2) * _LatCellSize;
CellWidthsKm[ii] = Utilities.CalculateLengthOfDegreeLongitude(_Lats[ii] + _LatCellSize / 2) * _LonCellSize;
}
}