/// <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 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 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;
}
}
public uint[] WeightedMassOrderedIndices(GridCellCohortHandler gridCellCohorts, uint[][] cohortIndices, uint numberIndices)
{
NonStaticSimpleRNG random = new NonStaticSimpleRNG();
random.SetSeedFromSystemTime();
// A vector to hold indices of cohorts in order
int[] MassOrderedIndices;
double AboveMinMass = 0;
double OverallMinMass = 1E9;
double MaxMass = 0;
int MaxFG = 0;
int MaxC = 0;
double MinMass = 1E9;
int MinFG = 0;
int MinC = 0;
for (int ll = 0; ll < gridCellCohorts.Count; ll++)
{
// Loop over gridCellCohorts in the functional group
for (int kk = 0; kk < gridCellCohorts[ll].Count(); kk++)
{
//Check if this cohort is the smallest
if (gridCellCohorts[ll][kk].IndividualBodyMass.CompareTo(MaxMass) > 0)
{
MaxFG = ll;
MaxC = kk;
MaxMass = gridCellCohorts[ll][kk].IndividualBodyMass;
}
//Check if this cohort is the smallest
if (gridCellCohorts[ll][kk].IndividualBodyMass.CompareTo(OverallMinMass) < 0)
{
MinFG = ll;
MinC = kk;
OverallMinMass = gridCellCohorts[ll][kk].IndividualBodyMass;
}
}
}
double MassRange = MaxMass - OverallMinMass;
double logMassRange = Math.Log(MaxMass) - Math.Log(OverallMinMass);
MassOrderedIndices = (int[])(object)this.RandomlyOrderedIndices(numberIndices);//this.MassOrderedIndices(gridCellCohorts,cohortIndices,numberIndices);
uint[] OrderedIndices = new uint[numberIndices];
int[] Acted = new int[numberIndices];
int[] UseIndices;
int[] UnActedIndices;
uint UnActedCounter;
double p = 0;
int OrderIndex = 0;
int[] Cinds;
do
{
//UseIndices = MassOrderedIndices.Where((x,idx) => Acted[idx] == 0).ToArray();
UseIndices = new int[numberIndices - Acted.Sum()];
UnActedIndices = new int[numberIndices - Acted.Sum()];
UnActedCounter = 0;
for (int i = 0; i < Acted.Length; i++)
{
if (Acted[i] == 0)
{
UnActedIndices[UnActedCounter] = i;
UnActedCounter++;
}
}
for (int i = 0; i < UnActedIndices.Length; i++)
{
UseIndices[i] = MassOrderedIndices[UnActedIndices[i]];
}
foreach (uint i in UseIndices)
{
Cinds = FindJaggedArrayIndex(i, cohortIndices, numberIndices);
p = (Math.Log(gridCellCohorts[Cinds[0]][Cinds[1]].IndividualBodyMass) - Math.Log(OverallMinMass)) / logMassRange;
if (random.GetUniform() > p)
{
OrderedIndices[OrderIndex] = cohortIndices[Cinds[0]][Cinds[1]];
OrderIndex++;
Acted[Array.FindIndex(MassOrderedIndices, row => row == i)] = 1;
}
}
} while (Acted.Sum() < (int)(numberIndices * 0.8));
UseIndices = new int[numberIndices - Acted.Sum()];
UnActedIndices = new int[numberIndices - Acted.Sum()];
UnActedCounter = 0;
for (int i = 0; i < Acted.Length; i++)
{
if (Acted[i] == 0)
{
UnActedIndices[UnActedCounter] = i;
UnActedCounter++;
}
}
for (int i = 0; i < UnActedIndices.Length; i++)
{
UseIndices[i] = MassOrderedIndices[UnActedIndices[i]];
}
foreach (uint i in UseIndices)
{
Cinds = FindJaggedArrayIndex(i, cohortIndices, numberIndices);
OrderedIndices[OrderIndex] = cohortIndices[Cinds[0]][Cinds[1]];
OrderIndex++;
Acted[Array.FindIndex(MassOrderedIndices, row => row == i)] = 1;
}
//OrderedIndices[OrderIndex] = cohortIndices[MaxFG][MaxC];
return(OrderedIndices);
}
