/// <summary>
/// Calculate the proportion of time for which this cohort could be active and assign it to the cohort's properties
/// </summary>
/// <param name="actingCohort">The Cohort for which proportion of time active is being calculated</param>
/// <param name="cellEnvironment">The environmental information for current grid cell</param>
/// <param name="madingleyCohortDefinitions">Functional group definitions and code to interrogate the cohorts in current grid cell</param>
/// <param name="currentTimestep">Current timestep index</param>
/// <param name="currentMonth">Current month</param>
public void AssignProportionTimeActive(Cohort actingCohort, SortedList <string, double[]> cellEnvironment,
FunctionalGroupDefinitions madingleyCohortDefinitions, uint currentTimestep, uint currentMonth)
{
double Realm = cellEnvironment["Realm"][0];
//Only work on heterotroph cohorts
if (madingleyCohortDefinitions.GetTraitNames("Heterotroph/Autotroph", actingCohort.FunctionalGroupIndex) == "heterotroph")
{
//Check if this is an endotherm or ectotherm
Boolean Endotherm = madingleyCohortDefinitions.GetTraitNames("Endo/Ectotherm", actingCohort.FunctionalGroupIndex) == "endotherm";
if (Endotherm)
{
//Assumes the whole timestep is suitable for endotherms to be active - actual time active is therefore the proportion specified for this functional group.
actingCohort.ProportionTimeActive = madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("proportion suitable time active", actingCohort.FunctionalGroupIndex);
}
else
{
//If ectotherm then use realm specific function
if (Realm == 1.0)
{
actingCohort.ProportionTimeActive = CalculateProportionTimeSuitableTerrestrial(cellEnvironment, currentMonth, Endotherm) *
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("proportion suitable time active", actingCohort.FunctionalGroupIndex);
}
else
{
actingCohort.ProportionTimeActive = CalculateProportionTimeSuitableMarine(cellEnvironment, currentMonth, Endotherm) *
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("proportion suitable time active", actingCohort.FunctionalGroupIndex);
}
}
}
}
/// <summary>
/// Assign the juvenile and adult masses of the new cohort to produce
/// </summary>
/// <param name="gridCellCohorts">The cohorts in the current grid cell</param>
/// <param name="actingCohort">The position of the acting cohort in the jagged array of grid cell cohorts</param>
/// <param name="madingleyCohortDefinitions">The definitions of cohort functional groups in the model</param>
/// <returns>A vector containing the juvenile and adult masses of the cohort to be produced</returns>
private double[] GetOffspringCohortProperties(GridCellCohortHandler gridCellCohorts, int[] actingCohort, FunctionalGroupDefinitions madingleyCohortDefinitions)
{
// A two-element vector holding adult and juvenile body masses in elements zero and one respectively
double[] _CohortJuvenileAdultMasses = new double[2];
// Determine whether offspring cohort 'evolves' in terms of adult and juvenile body masses
if (RandomNumberGenerator.GetUniform() > _MassEvolutionProbabilityThreshold)
{
// Determine the new juvenile body mass
_CohortJuvenileAdultMasses[0] = Math.Max(RandomNumberGenerator.GetNormal(gridCellCohorts[actingCohort].JuvenileMass, _MassEvolutionStandardDeviation * gridCellCohorts[actingCohort].JuvenileMass),
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("Minimum mass", actingCohort[0]));
// Determine the new adult body mass
_CohortJuvenileAdultMasses[1] = Math.Min(RandomNumberGenerator.GetNormal(gridCellCohorts[actingCohort].AdultMass, _MassEvolutionStandardDeviation * gridCellCohorts[actingCohort].AdultMass),
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("Maximum mass", actingCohort[0]));
}
// If not, it just gets the same values as the parent cohort
else
{
// Assign masses to the offspring cohort that are equal to those of the parent cohort
_CohortJuvenileAdultMasses[0] = gridCellCohorts[actingCohort].JuvenileMass;
_CohortJuvenileAdultMasses[1] = gridCellCohorts[actingCohort].AdultMass;
}
// Return the vector of adult and juvenile masses
return(_CohortJuvenileAdultMasses);
}
/// <summary>
/// Seed grid cell with cohorts, as specified in the model input files
/// </summary>
/// <param name="functionalGroups">The functional group definitions for cohorts in the grid cell</param>
/// <param name="cellEnvironment">The environment in the grid cell</param>
/// <param name="globalDiagnostics">A list of global diagnostic variables</param>
/// <param name="nextCohortID">YThe unique ID to assign to the next cohort produced</param>
/// <param name="tracking">boolean to indicate if cohorts are to be tracked in this model</param>
/// <param name="totalCellTerrestrialCohorts">The total number of cohorts to be seeded in each terrestrial grid cell</param>
/// <param name="totalCellMarineCohorts">The total number of cohorts to be seeded in each marine grid cell</param>
/// <param name="DrawRandomly">Whether the model is set to use random draws</param>
/// <param name="ZeroAbundance">Set this parameter to 'true' if you want to seed the cohorts with zero abundance</param>
private void SeedGridCellCohorts(ref FunctionalGroupDefinitions functionalGroups, ref SortedList<string, double[]>
cellEnvironment, SortedList<string, double> globalDiagnostics, Int64 nextCohortID, Boolean tracking, double totalCellTerrestrialCohorts,
double totalCellMarineCohorts, Boolean DrawRandomly, Boolean ZeroAbundance)
{
// Set the seed for the random number generator from the system time
RandomNumberGenerator.SetSeedFromSystemTime();
// StreamWriter tempsw = new StreamWriter("C://Temp//adult_juvenile_masses.txt");
// tempsw.WriteLine("adult mass\tjuvenilemass");
// Define local variables
double CohortJuvenileMass;
double CohortAdultMassRatio;
double CohortAdultMass;
double ExpectedLnAdultMassRatio;
int[] FunctionalGroupsToUse;
double NumCohortsThisCell;
double TotalNewBiomass =0.0;
// Get the minimum and maximum possible body masses for organisms in each functional group
double[] MassMinima = functionalGroups.GetBiologicalPropertyAllFunctionalGroups("minimum mass");
double[] MassMaxima = functionalGroups.GetBiologicalPropertyAllFunctionalGroups("maximum mass");
string[] NutritionSource = functionalGroups.GetTraitValuesAllFunctionalGroups("nutrition source");
double[] ProportionTimeActive = functionalGroups.GetBiologicalPropertyAllFunctionalGroups("proportion suitable time active");
//Variable for altering the juvenile to adult mass ratio for marine cells when handling certain functional groups eg baleen whales
double Scaling = 0.0;
Int64 CohortIDIncrementer = nextCohortID;
// Check which realm the cell is in
if (cellEnvironment["Realm"][0] == 1.0)
{
// Get the indices of all terrestrial functional groups
FunctionalGroupsToUse = functionalGroups.GetFunctionalGroupIndex("realm", "terrestrial", true);
NumCohortsThisCell = totalCellTerrestrialCohorts;
}
else
{
// Get the indices of all marine functional groups
FunctionalGroupsToUse = functionalGroups.GetFunctionalGroupIndex("realm", "marine", true);
NumCohortsThisCell = totalCellMarineCohorts;
}
Debug.Assert(cellEnvironment["Realm"][0] > 0.0, "Missing realm for grid cell");
if (NumCohortsThisCell > 0)
{
// Loop over all functional groups in the model
for (int FunctionalGroup = 0; FunctionalGroup < functionalGroups.GetNumberOfFunctionalGroups(); FunctionalGroup++)
{
// Create a new list to hold the cohorts in the grid cell
_GridCellCohorts[FunctionalGroup] = new List<Cohort>();
// If it is a functional group that corresponds to the current realm, then seed cohorts
if (FunctionalGroupsToUse.Contains(FunctionalGroup))
{
// Loop over the initial number of cohorts
double NumberOfCohortsInThisFunctionalGroup = 1.0;
if (!ZeroAbundance)
{
NumberOfCohortsInThisFunctionalGroup = functionalGroups.GetBiologicalPropertyOneFunctionalGroup("initial number of gridcellcohorts", FunctionalGroup);
}
for (int jj = 0; jj < NumberOfCohortsInThisFunctionalGroup; jj++)
{
// Check whether the model is set to randomly draw the body masses of new cohorts
if (DrawRandomly)
{
// Draw adult mass from a log-normal distribution with mean -6.9 and standard deviation 10.0,
// within the bounds of the minimum and maximum body masses for the functional group
CohortAdultMass = Math.Pow(10, (RandomNumberGenerator.GetUniform() * (Math.Log10(MassMaxima[FunctionalGroup]) - Math.Log10(50 * MassMinima[FunctionalGroup])) + Math.Log10(50 * MassMinima[FunctionalGroup])));
// Terrestrial and marine organisms have different optimal prey/predator body mass ratios
if (cellEnvironment["Realm"][0] == 1.0)
// Optimal prey body size 10%
OptimalPreyBodySizeRatio = Math.Max(0.01, RandomNumberGenerator.GetNormal(0.1, 0.02));
else
{
if (functionalGroups.GetTraitNames("Diet", FunctionalGroup) == "allspecial")
{
// Note that for this group
// it is actually (despite the name) not an optimal prey body size ratio, but an actual body size.
// This is because it is invariant as the predator (filter-feeding baleen whale) grows.
// See also the predation classes.
OptimalPreyBodySizeRatio = Math.Max(0.00001, RandomNumberGenerator.GetNormal(0.0001, 0.1));
}
else
{
// Optimal prey body size or marine organisms is 10%
OptimalPreyBodySizeRatio = Math.Max(0.01, RandomNumberGenerator.GetNormal(0.1, 0.02));
}
}
// Draw from a log-normal distribution with mean 10.0 and standard deviation 5.0, then add one to obtain
// the ratio of adult to juvenile body mass, and then calculate juvenile mass based on this ratio and within the
// bounds of the minimum and maximum body masses for this functional group
if (cellEnvironment["Realm"][0] == 1.0)
{
do
{
ExpectedLnAdultMassRatio = 2.24 + 0.13 * Math.Log(CohortAdultMass);
CohortAdultMassRatio = 1.0 + RandomNumberGenerator.GetLogNormal(ExpectedLnAdultMassRatio, 0.5);
CohortJuvenileMass = CohortAdultMass * 1.0 / CohortAdultMassRatio;
} while (CohortAdultMass <= CohortJuvenileMass || CohortJuvenileMass < MassMinima[FunctionalGroup]);
}
// In the marine realm, have a greater difference between the adult and juvenile body masses, on average
else
{
uint Counter = 0;
Scaling = 0.2;
// Use the scaling to deal with baleen whales not having such a great difference
do
{
ExpectedLnAdultMassRatio = 2.5 + Scaling * Math.Log(CohortAdultMass);
CohortAdultMassRatio = 1.0 + 10 * RandomNumberGenerator.GetLogNormal(ExpectedLnAdultMassRatio, 0.5);
CohortJuvenileMass = CohortAdultMass * 1.0 / CohortAdultMassRatio;
Counter++;
if (Counter > 10)
{
Scaling -= 0.01;
Counter = 0;
}
} while (CohortAdultMass <= CohortJuvenileMass || CohortJuvenileMass < MassMinima[FunctionalGroup]);
}
}
else
{
// Use the same seed for the random number generator every time
RandomNumberGenerator.SetSeed((uint)(jj + 1), (uint)((jj + 1) * 3));
// Draw adult mass from a log-normal distribution with mean -6.9 and standard deviation 10.0,
// within the bounds of the minimum and maximum body masses for the functional group
CohortAdultMass = Math.Pow(10, (RandomNumberGenerator.GetUniform() * (Math.Log10(MassMaxima[FunctionalGroup]) - Math.Log10(50 * MassMinima[FunctionalGroup])) + Math.Log10(50 * MassMinima[FunctionalGroup])));
OptimalPreyBodySizeRatio = Math.Max(0.01, RandomNumberGenerator.GetNormal(0.1, 0.02));
// Draw from a log-normal distribution with mean 10.0 and standard deviation 5.0, then add one to obtain
// the ratio of adult to juvenile body mass, and then calculate juvenile mass based on this ratio and within the
// bounds of the minimum and maximum body masses for this functional group
if (cellEnvironment["Realm"][0] == 1.0)
{
do
{
ExpectedLnAdultMassRatio = 2.24 + 0.13 * Math.Log(CohortAdultMass);
CohortAdultMassRatio = 1.0 + RandomNumberGenerator.GetLogNormal(ExpectedLnAdultMassRatio, 0.5);
CohortJuvenileMass = CohortAdultMass * 1.0 / CohortAdultMassRatio;
} while (CohortAdultMass <= CohortJuvenileMass || CohortJuvenileMass < MassMinima[FunctionalGroup]);
}
// In the marine realm, have a greater difference between the adult and juvenile body masses, on average
else
{
do
{
ExpectedLnAdultMassRatio = 2.24 + 0.13 * Math.Log(CohortAdultMass);
CohortAdultMassRatio = 1.0 + 10 * RandomNumberGenerator.GetLogNormal(ExpectedLnAdultMassRatio, 0.5);
CohortJuvenileMass = CohortAdultMass * 1.0 / CohortAdultMassRatio;
} while (CohortAdultMass <= CohortJuvenileMass || CohortJuvenileMass < MassMinima[FunctionalGroup]);
}
}
// An instance of Cohort to hold the new cohort
Cohort NewCohort;
//double NewBiomass = Math.Pow(0.2, (Math.Log10(CohortAdultMass))) * (1.0E9 * _CellEnvironment["Cell Area"][0]) / NumCohortsThisCell;
// 3000*(0.6^log(mass)) gives individual cohort biomass density in g ha-1
// * 100 to give g km-2
// * cell area to give g grid cell
//*3300/NumCohortsThisCell scales total initial biomass in the cell to some approximately reasonable mass
double NewBiomass = (3300 / NumCohortsThisCell) * 100 * 3000 *
Math.Pow(0.6, (Math.Log10(CohortJuvenileMass))) * (_CellEnvironment["Cell Area"][0]);
TotalNewBiomass += NewBiomass;
double NewAbund = 0.0;
if (!ZeroAbundance)
{
NewAbund = NewBiomass / CohortJuvenileMass;
}
/*
// TEMPORARILY MARINE ONLY
if (cellEnvironment["Realm"][0] == 1)
{
NewAbund = 0.0;
}
*/
double TrophicIndex;
switch (NutritionSource[FunctionalGroup])
{
case "herbivore":
TrophicIndex = 2;
break;
case "omnivore":
TrophicIndex = 2.5;
break;
case "carnivore":
TrophicIndex = 3;
break;
default:
Debug.Fail("Unexpected nutrition source trait value when assigning trophic index");
TrophicIndex = 0.0;
break;
}
// Initialise the new cohort with the relevant properties
NewCohort = new Cohort((byte)FunctionalGroup, CohortJuvenileMass, CohortAdultMass, CohortJuvenileMass, NewAbund,
OptimalPreyBodySizeRatio, (ushort)0, ProportionTimeActive[FunctionalGroup], ref CohortIDIncrementer,TrophicIndex, tracking);
// Add the new cohort to the list of grid cell cohorts
_GridCellCohorts[FunctionalGroup].Add(NewCohort);
// TEMPORARY
/*
// Check whether the model is set to randomly draw the body masses of new cohorts
if ((Longitude % 4 == 0) && (Latitude % 4 == 0))
{
if (DrawRandomly)
{
CohortAdultMass = 100000;
CohortJuvenileMass = 100000;
}
else
{
CohortAdultMass = 100000;
CohortJuvenileMass = 100000;
}
// An instance of Cohort to hold the new cohort
Cohort NewCohort;
double NewBiomass = (1.0E7 * _CellEnvironment["Cell Area"][0]) / NumCohortsThisCell;
double NewAbund = 0.0;
NewAbund = 3000;
// Initialise the new cohort with the relevant properties
NewCohort = new Cohort((byte)FunctionalGroup, CohortJuvenileMass, CohortAdultMass, CohortJuvenileMass, NewAbund,
(ushort)0, ref nextCohortID, tracking);
// Add the new cohort to the list of grid cell cohorts
_GridCellCohorts[FunctionalGroup].Add(NewCohort);
}
*/
// Incrememt the variable tracking the total number of cohorts in the model
globalDiagnostics["NumberOfCohortsInModel"]++;
}
}
}
}
else
{
// Loop over all functional groups in the model
for (int FunctionalGroup = 0; FunctionalGroup < functionalGroups.GetNumberOfFunctionalGroups(); FunctionalGroup++)
{
// Create a new list to hold the cohorts in the grid cell
_GridCellCohorts[FunctionalGroup] = new List<Cohort>();
}
}
// tempsw.Dispose();
}
/// <summary>
/// Set up the file, screen and live outputs prior to the model run
/// </summary>
/// <param name="EcosystemModelGrid">The model grid that output data will be derived from</param>
/// <param name="CohortFunctionalGroupDefinitions">The definitions for cohort functional groups</param>
/// <param name="StockFunctionalGroupDefinitions">The definitions for stock functional groups</param>
/// <param name="NumTimeSteps">The number of time steps in the model run</param>
public void SetUpOutputs(ModelGrid EcosystemModelGrid, FunctionalGroupDefinitions CohortFunctionalGroupDefinitions,
FunctionalGroupDefinitions StockFunctionalGroupDefinitions, uint NumTimeSteps, string FileOutputs)
{
// Get the functional group indices of herbivore, carnivore and omnivore cohorts, and autotroph stocks
string[] Trait = { "Nutrition source" };
string[] Trait2 = { "Heterotroph/Autotroph" };
string[] TraitValue1 = { "Herbivory" };
string[] TraitValue2 = { "Carnivory" };
string[] TraitValue3 = { "Omnivory" };
string[] TraitValue4 = { "Autotroph" };
HerbivoreIndices = CohortFunctionalGroupDefinitions.GetFunctionalGroupIndex(Trait, TraitValue1, false);
CarnivoreIndices = CohortFunctionalGroupDefinitions.GetFunctionalGroupIndex(Trait, TraitValue2, false);
OmnivoreIndices = CohortFunctionalGroupDefinitions.GetFunctionalGroupIndex(Trait, TraitValue3, false);
AutotrophIndices = StockFunctionalGroupDefinitions.GetFunctionalGroupIndex(Trait2, TraitValue4, false);
// Set up vectors to hold dimension data for the output variables
float[] outLats = new float[EcosystemModelGrid.NumLatCells];
float[] outLons = new float[EcosystemModelGrid.NumLonCells];
float[] IdentityMassBins;
// Populate the dimension variable vectors with cell centre latitude and longitudes
for (int ii = 0; ii < EcosystemModelGrid.NumLatCells; ii++)
{
outLats[ii] = EcosystemModelGrid.Lats[ii] + (EcosystemModelGrid.LatCellSize / 2);
}
for (int jj = 0; jj < EcosystemModelGrid.NumLonCells; jj++)
{
outLons[jj] = EcosystemModelGrid.Lons[jj] + (EcosystemModelGrid.LonCellSize / 2);
}
// Create vector to hold the values of the time dimension
OutTimes = new float[NumTimeSteps + 1];
// Set the first value to be -1 (this will hold initial outputs)
OutTimes[0] = -1;
// Fill other values from 0 (this will hold outputs during the model run)
for (int ii = 1; ii < NumTimeSteps + 1; ii++)
{
OutTimes[ii] = ii + 1;
}
// Set up a vector to hold (log) individual body mass bins
OutMassBins = new float[MassBinNumber];
IdentityMassBins = new float[MassBinNumber];
// Get the (log) minimum and maximum possible (log) masses across all functional groups combined, start with default values of
// Infinity and -Infinity
float MaximumMass = -1 / 0F;
float MinimumMass = 1 / 0F;
foreach (int FunctionalGroupIndex in CohortFunctionalGroupDefinitions.AllFunctionalGroupsIndex)
{
MinimumMass = (float)Math.Min(MinimumMass, Math.Log(CohortFunctionalGroupDefinitions.GetBiologicalPropertyOneFunctionalGroup("minimum mass", FunctionalGroupIndex)));
MaximumMass = (float)Math.Max(MaximumMass, Math.Log(CohortFunctionalGroupDefinitions.GetBiologicalPropertyOneFunctionalGroup("maximum mass", FunctionalGroupIndex)));
}
// Get the interval required to span the range between the minimum and maximum values in 100 steps
float MassInterval = (MaximumMass - MinimumMass) / MassBinNumber;
// Fill the vector of output mass bins with (log) body masses spread evenly between the minimum and maximum values
for (int ii = 0; ii < MassBinNumber; ii++)
{
OutMassBins[ii] = MinimumMass + ii * MassInterval;
IdentityMassBins[ii] = Convert.ToSingle(Math.Exp(Convert.ToDouble(OutMassBins[ii])));
}
// Create file for model outputs
DataSetForFileOutput = CreateSDSObject.CreateSDS("netCDF", FileOutputs);
// Add three-dimensional variables to output file, dimensioned by latitude, longtiude and time
string[] dimensions3D = { "Latitude", "Longitude", "Time step" };
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Biomass density", 3, dimensions3D, 0, outLats, outLons, OutTimes);
dimensions3D = new string[] { "Adult Mass bin", "Juvenile Mass bin", "Time step" };
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Carnivore abundance in juvenile vs adult bins", 3, dimensions3D,Math.Log(0), OutMassBins, OutMassBins, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Herbivore abundance in juvenile vs adult bins", 3, dimensions3D, Math.Log(0), OutMassBins, OutMassBins, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Carnivore biomass in juvenile vs adult bins", 3, dimensions3D, Math.Log(0), OutMassBins, OutMassBins, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Herbivore biomass in juvenile vs adult bins", 3, dimensions3D, Math.Log(0), OutMassBins, OutMassBins, OutTimes);
// Add two-dimensional variables to output file, dimensioned by mass bins and time
string[] dimensions2D = { "Time step", "Mass bin" };
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Carnivore abundance in mass bins", 2, dimensions2D, Math.Log(0), OutTimes, OutMassBins);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Herbivore abundance in mass bins", 2, dimensions2D, Math.Log(0), OutTimes, OutMassBins);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Carnivore biomass in mass bins", 2, dimensions2D, Math.Log(0), OutTimes, OutMassBins);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Log Herbivore biomass in mass bins", 2, dimensions2D, Math.Log(0), OutTimes, OutMassBins);
// Add one-dimensional variables to the output file, dimensioned by time
string[] dimensions1D = { "Time step" };
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Herbivore density", "Individuals / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Herbivore abundance", "Individuals", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Herbivore biomass", "Kg / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Carnivore density", "Individuals / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Carnivore abundance", "Individuals", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Carnivore biomass", "Kg / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Omnivore density", "Individuals / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Omnivore abundance", "Individuals", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Omnivore biomass", "Kg / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Autotroph biomass", "Kg / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Organic matter pool", "Kg / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Respiratory CO2 pool", "Kg / km^2", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Number of cohorts extinct", "", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Number of cohorts produced", "", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Number of cohorts combined", "", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Number of cohorts in model", "", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
ArraySDSConvert.AddVariable(DataSetForFileOutput, "Number of stocks in model", "", 1, dimensions1D, EcosystemModelGrid.GlobalMissingValue, OutTimes);
// Add one-dimensional variables to the output file, dimensioned by mass bin index
// To enable outputs to be visualised against mass instead of index
// Initialise the arrays that will be used for the grid-based outputs
LogBiomassDensityGridCohorts = new double[EcosystemModelGrid.NumLatCells, EcosystemModelGrid.NumLonCells];
LogBiomassDensityGridStocks = new double[EcosystemModelGrid.NumLatCells, EcosystemModelGrid.NumLonCells];
LogBiomassDensityGrid = new double[EcosystemModelGrid.NumLatCells, EcosystemModelGrid.NumLonCells];
}
/// <summary>
/// Assign the juvenile and adult masses of the new cohort to produce
/// </summary>
/// <param name="gridCellCohorts">The cohorts in the current grid cell</param>
/// <param name="actingCohort">The position of the acting cohort in the jagged array of grid cell cohorts</param>
/// <param name="madingleyCohortDefinitions">The definitions of cohort functional groups in the model</param>
/// <returns>A vector containing the juvenile and adult masses of the cohort to be produced</returns>
private double[] GetOffspringCohortProperties(GridCellCohortHandler gridCellCohorts, int[] actingCohort, FunctionalGroupDefinitions madingleyCohortDefinitions)
{
// A two-element vector holding adult and juvenile body masses in elements zero and one respectively
double[] _CohortJuvenileAdultMasses = new double[2];
// Determine whether offspring cohort 'evolves' in terms of adult and juvenile body masses
if (RandomNumberGenerator.GetUniform() > _MassEvolutionProbabilityThreshold)
{
// Determine the new juvenile body mass
_CohortJuvenileAdultMasses[0] = Math.Max(RandomNumberGenerator.GetNormal(gridCellCohorts[actingCohort].JuvenileMass, _MassEvolutionStandardDeviation * gridCellCohorts[actingCohort].JuvenileMass),
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("Minimum mass",actingCohort[0]));
// Determine the new adult body mass
_CohortJuvenileAdultMasses[1] = Math.Min(RandomNumberGenerator.GetNormal(gridCellCohorts[actingCohort].AdultMass, _MassEvolutionStandardDeviation * gridCellCohorts[actingCohort].AdultMass),
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("Maximum mass", actingCohort[0]));
}
// If not, it just gets the same values as the parent cohort
else
{
// Assign masses to the offspring cohort that are equal to those of the parent cohort
_CohortJuvenileAdultMasses[0] = gridCellCohorts[actingCohort].JuvenileMass;
_CohortJuvenileAdultMasses[1] = gridCellCohorts[actingCohort].AdultMass;
}
// Return the vector of adult and juvenile masses
return _CohortJuvenileAdultMasses;
}
/// <summary>
/// Run eating
/// </summary>
/// <param name="gridCellCohorts">The cohorts in the current grid cell</param>
/// <param name="gridCellStocks">The stocks in the current grid cell</param>
/// <param name="actingCohort">The position of the acting cohort in the jagged array of grid cell cohorts</param>
/// <param name="cellEnvironment">The environment in the current grid cell</param>
/// <param name="deltas">The sorted list to track changes in biomass and abundance of the acting cohort in this grid cell</param>
/// <param name="madingleyCohortDefinitions">The definitions for cohort functional groups in the model</param>
/// <param name="madingleyStockDefinitions">The definitions for stock functional groups in the model</param>
/// <param name="currentTimestep">The current model time step</param>
/// <param name="trackProcesses">An instance of ProcessTracker to hold diagnostics for eating</param>
/// <param name="partial">Thread-locked variables</param>
/// <param name="specificLocations">Whether the model is being run for specific locations</param>
/// <param name="outputDetail">The level of output detail being used for the current model run</param>
/// <param name="currentMonth">The current model month</param>
/// <param name="initialisation">The Madingley Model initialisation</param>
public void RunEcologicalProcess(GridCellCohortHandler gridCellCohorts,
GridCellStockHandler gridCellStocks, int[] actingCohort,
SortedList <string, double[]> cellEnvironment,
Dictionary <string, Dictionary <string, double> > deltas,
FunctionalGroupDefinitions madingleyCohortDefinitions,
FunctionalGroupDefinitions madingleyStockDefinitions,
uint currentTimestep, ProcessTracker trackProcesses,
ref ThreadLockedParallelVariables partial, Boolean specificLocations,
string outputDetail, uint currentMonth, MadingleyModelInitialisation initialisation)
{
PreviousTrophicIndex = gridCellCohorts[actingCohort].TrophicIndex;
//Reset this cohort's trohic index ready for calculation across its feeding this timetsstep
gridCellCohorts[actingCohort].TrophicIndex = 0.0;
// Get the nutrition source (herbivory, carnivory or omnivory) of the acting cohort
string NutritionSource = madingleyCohortDefinitions.GetTraitNames("Nutrition source", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Switch to the appropriate eating process(es) given the cohort's nutrition source
switch (NutritionSource)
{
case "herbivore":
// Get the assimilation efficiency for herbivory for this cohort from the functional group definitions
Implementations["revised herbivory"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("herbivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Get the proportion of time spent eating for this cohort from the functional group definitions
Implementations["revised herbivory"].ProportionTimeEating = gridCellCohorts[actingCohort].ProportionTimeActive;
// Calculate the potential biomass available from herbivory
if (cellEnvironment["Realm"][0] == 2.0)
{
Implementations["revised herbivory"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
}
else
{
Implementations["revised herbivory"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
}
// Run herbivory to apply changes in autotroph biomass from herbivory and add biomass eaten to the delta arrays
Implementations["revised herbivory"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, deltas, madingleyCohortDefinitions,
madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations, outputDetail, initialisation);
break;
case "carnivore":
// Get the assimilation efficiency for predation for this cohort from the functional group definitions
Implementations["revised predation"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("carnivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
Implementations["revised predation"].ProportionTimeEating = gridCellCohorts[actingCohort].ProportionTimeActive;
// Calculate the potential biomass available from predation
if (cellEnvironment["Realm"][0] == 2.0)
{
Implementations["revised predation"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
}
else
{
Implementations["revised predation"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
}
// Run predation to apply changes in prey biomass from predation and add biomass eaten to the delta arrays
Implementations["revised predation"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort, cellEnvironment, deltas,
madingleyCohortDefinitions, madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations, outputDetail, initialisation);
break;
case "omnivore":
// Get the assimilation efficiency for predation for this cohort from the functional group definitions
Implementations["revised predation"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("carnivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Get the assimilation efficiency for herbivory for this cohort from the functional group definitions
Implementations["revised herbivory"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("herbivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Get the proportion of time spent eating and assign to both the herbivory and predation implementations
double ProportionTimeEating = gridCellCohorts[actingCohort].ProportionTimeActive;
Implementations["revised predation"].ProportionTimeEating = ProportionTimeEating;
Implementations["revised herbivory"].ProportionTimeEating = ProportionTimeEating;
// Calculate the potential biomass available from herbivory
if (cellEnvironment["Realm"][0] == 2.0)
{
Implementations["revised herbivory"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
}
else
{
Implementations["revised herbivory"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
}
// Calculate the potential biomass available from predation
if (cellEnvironment["Realm"][0] == 2.0)
{
Implementations["revised predation"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
}
else
{
Implementations["revised predation"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
}
// Calculate the total handling time for all expected kills from predation and expected plant matter eaten in herbivory
TotalTimeToEatForOmnivores =
Implementations["revised herbivory"].TimeUnitsToHandlePotentialFoodItems +
Implementations["revised predation"].TimeUnitsToHandlePotentialFoodItems;
// Assign this total time to the relevant variables in both herbviory and predation, so that actual amounts eaten are calculated correctly
Implementations["revised herbivory"].TimeUnitsToHandlePotentialFoodItems = TotalTimeToEatForOmnivores;
Implementations["revised predation"].TimeUnitsToHandlePotentialFoodItems = TotalTimeToEatForOmnivores;
// Run predation to update prey cohorts and delta biomasses for the acting cohort
Implementations["revised predation"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, deltas, madingleyCohortDefinitions,
madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations, outputDetail, initialisation);
// Run herbivory to update autotroph biomass and delta biomasses for the acting cohort
Implementations["revised herbivory"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, deltas, madingleyCohortDefinitions,
madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations, outputDetail, initialisation);
break;
default:
// For nutrition source that are not supported, throw an error
Debug.Fail("The model currently does not contain an eating model for nutrition source:" + NutritionSource);
break;
}
// Check that the biomasses from predation and herbivory in the deltas is a number
Debug.Assert(!double.IsNaN(deltas["biomass"]["predation"]), "BiomassFromEating is NaN");
Debug.Assert(!double.IsNaN(deltas["biomass"]["herbivory"]), "BiomassFromEating is NaN");
double biomassEaten = 0.0;
if (madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("carnivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex) > 0)
{
biomassEaten += (deltas["biomass"]["predation"] / madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("carnivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex));
}
if (madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("herbivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex) > 0)
{
biomassEaten += (deltas["biomass"]["herbivory"] / madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("herbivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex));
}
if (biomassEaten > 0.0)
{
gridCellCohorts[actingCohort].TrophicIndex = 1 +
(gridCellCohorts[actingCohort].TrophicIndex / (biomassEaten * gridCellCohorts[actingCohort].CohortAbundance));
}
else
{
gridCellCohorts[actingCohort].TrophicIndex = PreviousTrophicIndex;
}
}
/// <summary>
/// Run eating
/// </summary>
/// <param name="gridCellCohorts">The cohorts in the current grid cell</param>
/// <param name="gridCellStocks">The stocks in the current grid cell</param>
/// <param name="actingCohort">The position of the acting cohort in the jagged array of grid cell cohorts</param>
/// <param name="cellEnvironment">The environment in the current grid cell</param>
/// <param name="deltas">The sorted list to track changes in biomass and abundance of the acting cohort in this grid cell</param>
/// <param name="madingleyCohortDefinitions">The definitions for cohort functional groups in the model</param>
/// <param name="madingleyStockDefinitions">The definitions for stock functional groups in the model</param>
/// <param name="currentTimestep">The current model time step</param>
/// <param name="trackProcesses">An instance of ProcessTracker to hold diagnostics for eating</param>
/// <param name="partial">Thread-locked variables</param>
/// <param name="specificLocations">Whether the model is being run for specific locations</param>
/// <param name="outputDetail">The level of output detail being used for the current model run</param>
/// <param name="currentMonth">The current model month</param>
/// <param name="initialisation">The Madingley Model initialisation</param>
public void RunEcologicalProcess(GridCellCohortHandler gridCellCohorts,
GridCellStockHandler gridCellStocks, int[] actingCohort,
SortedList<string, double[]> cellEnvironment,
Dictionary<string, Dictionary<string, double>> deltas,
FunctionalGroupDefinitions madingleyCohortDefinitions,
FunctionalGroupDefinitions madingleyStockDefinitions,
uint currentTimestep, ProcessTracker trackProcesses,
ref ThreadLockedParallelVariables partial, Boolean specificLocations,
string outputDetail, uint currentMonth, MadingleyModelInitialisation initialisation)
{
PreviousTrophicIndex = gridCellCohorts[actingCohort].TrophicIndex;
//Reset this cohort's trohic index ready for calculation across its feeding this timetsstep
gridCellCohorts[actingCohort].TrophicIndex = 0.0;
// Get the nutrition source (herbivory, carnivory or omnivory) of the acting cohort
string NutritionSource = madingleyCohortDefinitions.GetTraitNames("Nutrition source", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Switch to the appropriate eating process(es) given the cohort's nutrition source
switch (NutritionSource)
{
case "herbivore":
// Get the assimilation efficiency for herbivory for this cohort from the functional group definitions
Implementations["revised herbivory"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("herbivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Get the proportion of time spent eating for this cohort from the functional group definitions
Implementations["revised herbivory"].ProportionTimeEating = gridCellCohorts[actingCohort].ProportionTimeActive;
// Calculate the potential biomass available from herbivory
if (cellEnvironment["Realm"][0] == 2.0)
Implementations["revised herbivory"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
else
Implementations["revised herbivory"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
// Run herbivory to apply changes in autotroph biomass from herbivory and add biomass eaten to the delta arrays
Implementations["revised herbivory"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, deltas, madingleyCohortDefinitions,
madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations,outputDetail, initialisation);
break;
case "carnivore":
// Get the assimilation efficiency for predation for this cohort from the functional group definitions
Implementations["revised predation"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("carnivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
Implementations["revised predation"].ProportionTimeEating = gridCellCohorts[actingCohort].ProportionTimeActive;
// Calculate the potential biomass available from predation
if (cellEnvironment["Realm"][0] == 2.0)
Implementations["revised predation"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
else
Implementations["revised predation"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions, madingleyStockDefinitions);
// Run predation to apply changes in prey biomass from predation and add biomass eaten to the delta arrays
Implementations["revised predation"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort, cellEnvironment, deltas,
madingleyCohortDefinitions, madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations,outputDetail, initialisation);
break;
case "omnivore":
// Get the assimilation efficiency for predation for this cohort from the functional group definitions
Implementations["revised predation"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("carnivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Get the assimilation efficiency for herbivory for this cohort from the functional group definitions
Implementations["revised herbivory"].AssimilationEfficiency =
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup
("herbivory assimilation", gridCellCohorts[actingCohort].FunctionalGroupIndex);
// Get the proportion of time spent eating and assign to both the herbivory and predation implementations
double ProportionTimeEating = gridCellCohorts[actingCohort].ProportionTimeActive;
Implementations["revised predation"].ProportionTimeEating = ProportionTimeEating;
Implementations["revised herbivory"].ProportionTimeEating = ProportionTimeEating;
// Calculate the potential biomass available from herbivory
if (cellEnvironment["Realm"][0] == 2.0)
Implementations["revised herbivory"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
else
Implementations["revised herbivory"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
// Calculate the potential biomass available from predation
if (cellEnvironment["Realm"][0] == 2.0)
Implementations["revised predation"].GetEatingPotentialMarine
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
else
Implementations["revised predation"].GetEatingPotentialTerrestrial
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, madingleyCohortDefinitions,
madingleyStockDefinitions);
// Calculate the total handling time for all expected kills from predation and expected plant matter eaten in herbivory
TotalTimeToEatForOmnivores =
Implementations["revised herbivory"].TimeUnitsToHandlePotentialFoodItems +
Implementations["revised predation"].TimeUnitsToHandlePotentialFoodItems;
// Assign this total time to the relevant variables in both herbviory and predation, so that actual amounts eaten are calculated correctly
Implementations["revised herbivory"].TimeUnitsToHandlePotentialFoodItems = TotalTimeToEatForOmnivores;
Implementations["revised predation"].TimeUnitsToHandlePotentialFoodItems = TotalTimeToEatForOmnivores;
// Run predation to update prey cohorts and delta biomasses for the acting cohort
Implementations["revised predation"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, deltas, madingleyCohortDefinitions,
madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations,outputDetail, initialisation);
// Run herbivory to update autotroph biomass and delta biomasses for the acting cohort
Implementations["revised herbivory"].RunEating
(gridCellCohorts, gridCellStocks, actingCohort,
cellEnvironment, deltas, madingleyCohortDefinitions,
madingleyStockDefinitions, trackProcesses,
currentTimestep, specificLocations,outputDetail, initialisation);
break;
default:
// For nutrition source that are not supported, throw an error
Debug.Fail("The model currently does not contain an eating model for nutrition source:" + NutritionSource);
break;
}
// Check that the biomasses from predation and herbivory in the deltas is a number
Debug.Assert(!double.IsNaN(deltas["biomass"]["predation"]), "BiomassFromEating is NaN");
Debug.Assert(!double.IsNaN(deltas["biomass"]["herbivory"]), "BiomassFromEating is NaN");
double biomassEaten = 0.0;
if (madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("carnivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex) > 0)
{
biomassEaten += (deltas["biomass"]["predation"] / madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("carnivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex));
}
if (madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("herbivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex) > 0)
{
biomassEaten += (deltas["biomass"]["herbivory"]/madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("herbivory assimilation",
gridCellCohorts[actingCohort].FunctionalGroupIndex));
}
if (biomassEaten > 0.0)
{
gridCellCohorts[actingCohort].TrophicIndex = 1 +
(gridCellCohorts[actingCohort].TrophicIndex / (biomassEaten * gridCellCohorts[actingCohort].CohortAbundance));
}
else
{
gridCellCohorts[actingCohort].TrophicIndex = PreviousTrophicIndex;
}
}
/// <summary>
/// Seed the stocks and cohorts for all active cells in the model grid
/// </summary>
/// <param name="cellIndices">A list of the active cells in the model grid</param>
/// <param name="cohortFunctionalGroupDefinitions">The functional group definitions for cohorts in the model</param>
/// <param name="stockFunctionalGroupDefinitions">The functional group definitions for stocks in the model</param>
/// <param name="globalDiagnostics">A list of global diagnostic variables</param>
/// <param name="nextCohortID">The ID number to be assigned to the next produced cohort</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="dispersalOnly">Whether to run dispersal only (i.e. to turn off all other ecological processes</param>
/// <param name="dispersalOnlyType">For dispersal only runs, the type of dispersal to apply</param>
public void SeedGridCellStocksAndCohorts(List<uint[]> cellIndices, FunctionalGroupDefinitions cohortFunctionalGroupDefinitions,
FunctionalGroupDefinitions stockFunctionalGroupDefinitions, SortedList<string, double> globalDiagnostics, ref Int64 nextCohortID,
Boolean tracking, Boolean DrawRandomly, Boolean dispersalOnly, string dispersalOnlyType, Boolean runCellsInParallel)
{
Console.WriteLine("Seeding grid cell stocks and cohorts:");
//Work out how many cohorts are to be seeded in each grid cell - split by realm as different set of cohorts initialised by realm
int TotalTerrestrialCellCohorts = 0;
int TotalMarineCellCohorts = 0;
int[] TerrestrialFunctionalGroups = cohortFunctionalGroupDefinitions.GetFunctionalGroupIndex("Realm", "Terrestrial", false);
if (TerrestrialFunctionalGroups == null)
{
TotalTerrestrialCellCohorts = 0;
}
else
{
foreach (int F in TerrestrialFunctionalGroups)
{
TotalTerrestrialCellCohorts += (int)cohortFunctionalGroupDefinitions.GetBiologicalPropertyOneFunctionalGroup("Initial number of GridCellCohorts", F);
}
}
int[] MarineFunctionalGroups = cohortFunctionalGroupDefinitions.GetFunctionalGroupIndex("Realm", "Marine", false);
if (MarineFunctionalGroups == null)
{
TotalMarineCellCohorts = 0;
}
else
{
foreach (int F in MarineFunctionalGroups)
{
TotalMarineCellCohorts += (int)cohortFunctionalGroupDefinitions.GetBiologicalPropertyOneFunctionalGroup("Initial number of GridCellCohorts", F);
}
}
// Now loop through and determine the starting CohortID number for each cell. This allows the seeding to be done in parallel.
Int64[] StartingCohortsID = new Int64[cellIndices.Count];
StartingCohortsID[0] = nextCohortID;
for (int kk = 1; kk < cellIndices.Count; kk++)
{
if (InternalGrid[cellIndices[kk - 1][0], cellIndices[kk - 1][1]].CellEnvironment["Realm"][0] == 1)
{
// Terrestrial cell
StartingCohortsID[kk] = StartingCohortsID[kk - 1] + TotalTerrestrialCellCohorts;
}
else
{
// Marine cell
StartingCohortsID[kk] = StartingCohortsID[kk - 1] + TotalMarineCellCohorts;
}
}
int Count = 0;
if (runCellsInParallel)
{
Parallel.For(0, cellIndices.Count, (ii, loopState) =>
{
if (dispersalOnly)
{
if (dispersalOnlyType == "diffusion")
{
// Diffusive dispersal
if ((cellIndices[ii][0] == 90) && (cellIndices[ii][1] == 180))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else if ((cellIndices[ii][0] == 95) && (cellIndices[ii][1] == 110))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
Console.Write("\rGrid Cell: {0} of {1}", ii++, cellIndices.Count);
}
else if (dispersalOnlyType == "advection")
{
// Advective dispersal
/*
if ((cellIndices[ii][0] == 58) && (cellIndices[ii][1] == 225))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else if ((cellIndices[ii][0] == 95) && (cellIndices[ii][1] == 110))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
*/
if (InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].CellEnvironment["Realm"][0] == 1.0)
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(
cohortFunctionalGroupDefinitions, stockFunctionalGroupDefinitions, globalDiagnostics,
StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(
cohortFunctionalGroupDefinitions, stockFunctionalGroupDefinitions, globalDiagnostics,
StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
Console.Write("\rGrid Cell: {0} of {1}", ii++, cellIndices.Count);
}
else if (dispersalOnlyType == "responsive")
{
// Responsive dispersal
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
else
{
Debug.Fail("Dispersal only type not recognized from initialisation file");
}
Count++;
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(
cohortFunctionalGroupDefinitions, stockFunctionalGroupDefinitions, globalDiagnostics,
StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
Count++;
}
Console.Write("\rGrid Cell: {0} of {1}", Count, cellIndices.Count);
}
);
}
else
{
for (int ii = 0; ii < cellIndices.Count; ii++)
{
if (dispersalOnly)
{
if (dispersalOnlyType == "diffusion")
{
// Diffusive dispersal
if ((cellIndices[ii][0] == 90) && (cellIndices[ii][1] == 180))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else if ((cellIndices[ii][0] == 95) && (cellIndices[ii][1] == 110))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
Console.Write("\rGrid Cell: {0} of {1}", ii++, cellIndices.Count);
}
else if (dispersalOnlyType == "advection")
{
// Advective dispersal
/*
if ((cellIndices[ii][0] == 58) && (cellIndices[ii][1] == 225))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else if ((cellIndices[ii][0] == 95) && (cellIndices[ii][1] == 110))
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
*/
if (InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].CellEnvironment["Realm"][0] == 1.0)
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(
cohortFunctionalGroupDefinitions, stockFunctionalGroupDefinitions, globalDiagnostics,
StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(
cohortFunctionalGroupDefinitions, stockFunctionalGroupDefinitions, globalDiagnostics,
StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
}
Console.Write("\rGrid Cell: {0} of {1}", ii++, cellIndices.Count);
}
else if (dispersalOnlyType == "responsive")
{
// Responsive dispersal
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(cohortFunctionalGroupDefinitions,
stockFunctionalGroupDefinitions, globalDiagnostics, StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, true);
}
else
{
Debug.Fail("Dispersal only type not recognized from initialisation file");
}
Count++;
}
else
{
InternalGrid[cellIndices[ii][0], cellIndices[ii][1]].SeedGridCellCohortsAndStocks(
cohortFunctionalGroupDefinitions, stockFunctionalGroupDefinitions, globalDiagnostics,
StartingCohortsID[ii], tracking, TotalTerrestrialCellCohorts, TotalMarineCellCohorts,
DrawRandomly, false);
Count++;
}
Console.Write("\rGrid Cell: {0} of {1}", Count, cellIndices.Count);
}
}
Console.WriteLine("");
Console.WriteLine("");
if (InternalGrid[cellIndices[cellIndices.Count - 1][0], cellIndices[cellIndices.Count - 1][1]].CellEnvironment["Realm"][0] == 1)
nextCohortID = StartingCohortsID[cellIndices.Count - 1] + TotalTerrestrialCellCohorts;
else
nextCohortID = StartingCohortsID[cellIndices.Count - 1] + TotalMarineCellCohorts;
}
/// <summary>
/// Calculate the proportion of time for which this cohort could be active and assign it to the cohort's properties
/// </summary>
/// <param name="actingCohort">The Cohort for which proportion of time active is being calculated</param>
/// <param name="cellEnvironment">The environmental information for current grid cell</param>
/// <param name="madingleyCohortDefinitions">Functional group definitions and code to interrogate the cohorts in current grid cell</param>
/// <param name="currentTimestep">Current timestep index</param>
/// <param name="currentMonth">Current month</param>
public void AssignProportionTimeActive(Cohort actingCohort, SortedList<string, double[]> cellEnvironment,
FunctionalGroupDefinitions madingleyCohortDefinitions,uint currentTimestep, uint currentMonth)
{
double Realm = cellEnvironment["Realm"][0];
//Only work on heterotroph cohorts
if (madingleyCohortDefinitions.GetTraitNames("Heterotroph/Autotroph", actingCohort.FunctionalGroupIndex) == "heterotroph")
{
//Check if this is an endotherm or ectotherm
Boolean Endotherm = madingleyCohortDefinitions.GetTraitNames("Endo/Ectotherm", actingCohort.FunctionalGroupIndex) == "endotherm";
if (Endotherm)
{
//Assumes the whole timestep is suitable for endotherms to be active - actual time active is therefore the proportion specified for this functional group.
actingCohort.ProportionTimeActive = madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("proportion suitable time active", actingCohort.FunctionalGroupIndex);
}
else
{
//If ectotherm then use realm specific function
if (Realm == 1.0)
{
actingCohort.ProportionTimeActive = CalculateProportionTimeSuitableTerrestrial(cellEnvironment, currentMonth, Endotherm) *
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("proportion suitable time active", actingCohort.FunctionalGroupIndex);
}
else
{
actingCohort.ProportionTimeActive = CalculateProportionTimeSuitableMarine(cellEnvironment, currentMonth, Endotherm) *
madingleyCohortDefinitions.GetBiologicalPropertyOneFunctionalGroup("proportion suitable time active", actingCohort.FunctionalGroupIndex);
}
}
}
}
