//---------------------------------------------------------------------
public override void Initialize()
{
//initialize event id
event_id = 1;
MetadataHandler.InitializeMetadata(parameters.Timestep, parameters.PrescriptionMapNames, parameters.EventLog, parameters.SummaryLog);
Timestep = parameters.Timestep;
managementAreas = parameters.ManagementAreas;
PlugIn.ModelCore.UI.WriteLine(" Reading management-area map {0} ...", parameters.ManagementAreaMap);
ManagementAreas.ReadMap(parameters.ManagementAreaMap, managementAreas);
//readMap reads the stand map and adds all the stands to a management area
PlugIn.ModelCore.UI.WriteLine(" Reading stand map {0} ...", parameters.StandMap);
Stands.ReadMap(parameters.StandMap);
//finish initializing SiteVars
SiteVars.GetExternalVars();
//finish each managementArea's initialization
//after reading the stand map, finish the initializations
foreach (ManagementArea mgmtArea in managementAreas)
{
mgmtArea.FinishInitialization();
}
prescriptionMaps = new PrescriptionMaps(parameters.PrescriptionMapNames);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes the plug-in with a data file.
/// </summary>
/// <param name="dataFile">
/// Path to the file with initialization data.
/// </param>
/// <param name="startTime">
/// Initial timestep (year): the timestep that will be passed to the
/// first call to the component's Run method.
/// </param>
public override void Initialize()
{
Timestep = parameters.Timestep;
SiteVars.Initialize(parameters);
Impacts.Initialize();
Outputs.Initialize();
Dispersal.Initialize();
/*
* //Debug distribution
* StreamWriter randLog = Landis.Data.CreateTextFile("G:/Budworm_model/TEST/E_TEST/rand.csv");
* randLog.AutoFlush = true;
* randLog.WriteLine("Rand1, Rand2");
* //Troschuetz.Random.NormalDistribution r1 = new Troschuetz.Random.NormalDistribution();
* for (int i = 0; i < 10000; i++)
* {
*
* r1.Mu = 1;
* r1.Sigma = 0.01;
* double rand = r1.NextDouble();
* rand = r1.NextDouble();
*
* r1.Mu = 2;
* r1.Sigma = 0.01;
* double rand2 = r1.NextDouble();
* rand2 = r1.NextDouble();
*
* PlugIn.ModelCore.NormalDistribution.Mu = 1;
* PlugIn.ModelCore.NormalDistribution.Sigma = 0.01;
* double rand = PlugIn.ModelCore.NormalDistribution.NextDouble();
* //rand = PlugIn.ModelCore.NormalDistribution.NextDouble();
*
* PlugIn.ModelCore.NormalDistribution.Mu = 2;
* PlugIn.ModelCore.NormalDistribution.Sigma = 0.01;
* double rand2 = PlugIn.ModelCore.NormalDistribution.NextDouble();
* //rand2 = PlugIn.ModelCore.NormalDistribution.NextDouble();
*
* randLog.Write("{0:0.000}, {1:0.000}",
* rand,rand2);
* randLog.WriteLine("");
* }
*/
}
public static void CalculateDispersal()
{
SiteVars.Dispersed.ActiveSiteValues = 0;
foreach (Site site in PlugIn.ModelCore.Landscape.ActiveSites)
{
// Calculate LDD/SDD ratio (16)
double LDDHabitat = 0;
double LDDFlight = 0;
double LDDRatio = 0;
double siteDefol = SiteVars.TotalDefoliation[site] / SiteVars.CurrentHostFoliage[site];
double minLDD = PlugIn.Parameters.EmigrationMinLDD;
double halfLDD = PlugIn.Parameters.EmigrationHalfLDD;
double maxLDD = PlugIn.Parameters.EmigrationMaxLDD;
double maxLDDProp = PlugIn.Parameters.EmigrationMaxLDDProp;
if ((siteDefol > minLDD) && (siteDefol <= halfLDD))
{
double m1 = 0;
if ((halfLDD - minLDD) > 0)
{
m1 = 0.5 / (halfLDD - minLDD);
}
double b1 = 0.5 - (m1 * halfLDD);
LDDHabitat = m1 * siteDefol + b1;
}
else if ((siteDefol > halfLDD) && (siteDefol <= maxLDD))
{
double m2 = 0;
if ((maxLDD - halfLDD) > 0)
{
m2 = 0.5 / (maxLDD - halfLDD);
}
double b2 = 1.0 - (m2 * maxLDD);
LDDHabitat = m2 * siteDefol + b2;
}
else if (siteDefol > maxLDD)
{
LDDHabitat = 1.0;
}
double slope = (maxLDDProp - (1 - maxLDDProp)) / (1.0 - 0.46);
double intercept = maxLDDProp - slope;
double rprimeZ = (-0.0054 * SiteVars.PctDefoliation[site] + 1);
if (PlugIn.Parameters.PositiveFecundDispersal)
{
if (rprimeZ < 0.46)
{
LDDFlight = 0.0;
}
else
{
LDDFlight = slope * rprimeZ + intercept;
}
}
else
{
double slope2 = (-1.0) * slope;
double intercept2 = (-1.0) * intercept + 1.0;
if (rprimeZ < 0.46)
{
LDDFlight = 1.0;
}
else
{
LDDFlight = slope2 * rprimeZ + intercept2;
}
}
LDDRatio = LDDHabitat * LDDFlight;
// Calculate LDD dispersers (16b)
double LDDout = SiteVars.EggCountFall[site] * LDDRatio; //Units: eggs/m2
SiteVars.LDDout[site] = LDDout;
SiteVars.SDDout[site] = SiteVars.EggCountFall[site] - LDDout;
}
PlugIn.ModelCore.UI.WriteLine("LD Dispersal of moths...");
SiteVars.Disperse_n.ActiveSiteValues = 0;
SiteVars.Disperse_v.ActiveSiteValues = 0;
SiteVars.Dispersed.ActiveSiteValues = 0;
foreach (Site site in PlugIn.ModelCore.Landscape.ActiveSites)
{
if (SiteVars.LDDout[site] > 0)
{
// Distribute LDD dispersers (17)
if (PlugIn.Parameters.LDDSpeedUp)
{
//DisperseLDDSpeedUp(site, PlugIn.Parameters.WrapLDD);
DisperseLDDBinarySearch(site, PlugIn.Parameters.WrapLDD, PlugIn.Parameters.LDDEdgeWrapReduction);
}
else
{
DisperseLDD(site, PlugIn.Parameters.WrapLDD);
}
}
// Calculate SDD dispersers (16b)
SiteVars.DisperseSDD(site, PlugIn.Parameters.SDDRadius, PlugIn.Parameters.SDDEdgeEffect, PlugIn.Parameters.EcoParameters);
}
foreach (Site site in PlugIn.ModelCore.Landscape.ActiveSites)
{
if (!PlugIn.Parameters.LDDSpeedUp)
{
if (SiteVars.Disperse_n[site] > 0)
{
DisperseLDD_Part2(site);
}
}
SiteVars.BudwormCount[site] = SiteVars.EggCountFall[site] - SiteVars.LDDout[site] - SiteVars.SDDout[site] + SiteVars.Dispersed[site];
}
}
//---------------------------------------------------------------------
///<summary>
/// Run the plug-in at a particular timestep.
///</summary>
public override void Run()
{
ModelCore.UI.WriteLine("Processing landscape for spruce budworm events ...");
// Calculate host foliage
SiteVars.CalculateHostFoliage(parameters.SBWHost, parameters.MinSusceptibleAge);
double randWinter = 1;
double randFecund = 1;
double phenolLimit = 1;
if (ModelCore.CurrentTime >= parameters.BudwormStartYear)
{
if (ModelCore.CurrentTime == parameters.BudwormStartYear)
{
foreach (Site site in PlugIn.ModelCore.Landscape.ActiveSites)
{
SiteVars.BudwormCount[site] = SiteVars.BudwormDensityL2[site] * SiteVars.CurrentHostFoliage[site];
SiteVars.EnemyCount[site] = SiteVars.EnemyDensity[site] * SiteVars.BudwormCount[site];
}
}
SiteVars.BiomassRemoved.ActiveSiteValues = 0;
SiteVars.TotalDefoliation.ActiveSiteValues = 0;
// Draw random overwinter survival (to be applied globally)
// To be replaced with spatially-autocorrelated winter temp function
PlugIn.ModelCore.NormalDistribution.Mu = parameters.OverwinterMean;
PlugIn.ModelCore.NormalDistribution.Sigma = parameters.OverwinterStdev;
randWinter = PlugIn.ModelCore.NormalDistribution.NextDouble();
randWinter = PlugIn.ModelCore.NormalDistribution.NextDouble();
if (parameters.OverwinterConstant)
{
randWinter = parameters.OverwinterMean;
}
// Draw random fecundity (to be applied globally)
// To be replaced by spatially autocorrelated function
PlugIn.ModelCore.NormalDistribution.Mu = parameters.FecundityMean;
PlugIn.ModelCore.NormalDistribution.Sigma = parameters.FecundityStdev;
randFecund = PlugIn.ModelCore.NormalDistribution.NextDouble();
randFecund = PlugIn.ModelCore.NormalDistribution.NextDouble();
if (parameters.FecundityConstant)
{
randFecund = parameters.FecundityMean;
}
// Draw random phenological limitation (to be applied globally)
// To be replaced by spatially autocorrelated function
PlugIn.ModelCore.NormalDistribution.Mu = parameters.PhenolMean;
PlugIn.ModelCore.NormalDistribution.Sigma = parameters.PhenolStdev;
phenolLimit = PlugIn.ModelCore.NormalDistribution.NextDouble();
phenolLimit = PlugIn.ModelCore.NormalDistribution.NextDouble();
if (parameters.PhenolConstant)
{
phenolLimit = parameters.PhenolMean;
}
SiteVars.CalculatePopulation(randWinter, randFecund, phenolLimit);
// Calculate cohort defoliation and impacts
SiteVars.CalculateDefoliation();
// Calculate long-distance dispersal
Dispersal.CalculateDispersal();
}
Outputs.WriteLogFile(ModelCore.CurrentTime, randWinter, randFecund, phenolLimit);
Outputs.WriteMaps(ModelCore.CurrentTime);
}
//---------------------------------------------------------------------
/// <summary>
/// Runs a model scenario.
/// </summary>
public static void Run(string scenarioPath)
{
// Initialize plug-ins manager with the default plug-ins
// database in the folder where application resides.
PlugIns.Manager.Initialize(PlugIns.Database.DefaultPath);
IScenario scenario = LoadScenario(scenarioPath);
cellLength = 29.0f; // 29m hard-wired until metadata implemented in raster driver
LoadSpecies(scenario.Species);
LoadEcoregions(scenario.Ecoregions);
Log.Info("Initializing landscape from ecoregions map \"{0}\" ...", scenario.EcoregionsMap);
Ecoregions.Map ecoregionsMap = new Ecoregions.Map(scenario.EcoregionsMap,
Model.Ecoregions);
using (Landscape.IInputGrid <bool> grid = ecoregionsMap.OpenAsInputGrid()) {
landscape = new Landscape.Landscape(grid);
}
landscapeMapDims = new Raster.Dimensions((int)landscape.Rows,
(int)landscape.Columns);
SiteVars.Initialize(ecoregionsMap);
// Load and initialize plug-ins.
Log.Info("Loading {0} plug-in ...", scenario.Succession.Info.Name);
succession = PlugIns.Manager.Load <ISuccession>(scenario.Succession.Info);
succession.Initialize(scenario.Succession.InitFile);
succession.InitializeSites(scenario.InitialCommunities,
scenario.InitialCommunitiesMap);
IDisturbance[] disturbancePlugIns = LoadPlugIns <IDisturbance>(scenario.Disturbances);
IOutput[] outputPlugIns = LoadPlugIns <IOutput>(scenario.Outputs);
// Run those output plug-ins whose next time to run is 0.
foreach (IOutput outPlugIn in GetPlugInsToRun <IOutput>(outputPlugIns, 0))
{
outPlugIn.Run(0);
}
//******************// for Rob
// Main time loop //
//******************//
// currentTime (years)
for (int currentTime = 1; currentTime <= scenario.Duration; ++currentTime)
{
List <IDisturbance> distPlugInsToRun;
distPlugInsToRun = GetPlugInsToRun <IDisturbance>(disturbancePlugIns, currentTime);
bool isDistTimestep = distPlugInsToRun.Count > 0;
List <IOutput> outPlugInsToRun;
outPlugInsToRun = GetPlugInsToRun <IOutput>(outputPlugIns, currentTime);
bool isOutTimestep = outPlugInsToRun.Count > 0;
bool isSuccTimestep = succession.NextTimeToRun == currentTime;
// If not a succession timestep, a disturance timestep or
// an output timestep, then go to the next timestep.
if (!(isSuccTimestep || isDistTimestep || isOutTimestep))
{
continue;
}
Log.Info("Current time: {0}", currentTime);
if (isDistTimestep)
{
if (scenario.DisturbancesRandomOrder)
{
distPlugInsToRun = Shuffle(distPlugInsToRun);
}
foreach (IDisturbance distPlugIn in distPlugInsToRun)
{
distPlugIn.Run(currentTime);
}
}
if (isSuccTimestep || isDistTimestep)
{
IEnumerable <ActiveSite> sites;
if (isSuccTimestep)
{
sites = Model.Landscape.ActiveSites;
}
else
{
sites = DisturbedSites();
}
succession.AgeCohorts(sites, currentTime);
succession.ComputeShade(sites);
succession.ReproducePlants(sites);
}
// Run output plug-ins.
foreach (IOutput outPlugIn in outPlugInsToRun)
{
outPlugIn.Run(currentTime);
}
if (!isSuccTimestep)
{
SiteVars.Disturbed.ActiveSiteValues = false;
}
} // main time loop
}
//---------------------------------------------------------------------
public override void Run()
{
SiteVars.GetExternalVars(); // ReInitialize();
SiteVars.Prescription.ActiveSiteValues = null;
SiteVars.CohortsDamaged.ActiveSiteValues = 0;
//harvest each management area in the list
foreach (ManagementArea mgmtArea in managementAreas)
{
totalSites = new int[Prescription.Count];
totalDamagedSites = new int[Prescription.Count];
totalSpeciesCohorts = new int[Prescription.Count, PlugIn.ModelCore.Species.Count];
prescriptionReported = new bool[Prescription.Count];
mgmtArea.HarvestStands();
//and record each stand that's been harvested
foreach (Stand stand in mgmtArea)
{
if (stand.Harvested)
{
WriteLogEntry(mgmtArea, stand);
}
}
// updating for preventing establishment
foreach (Stand stand in mgmtArea)
{
if (stand.Harvested && stand.LastPrescription.PreventEstablishment)
{
List <ActiveSite> sitesToDelete = new List <ActiveSite>();
foreach (ActiveSite site in stand)
{
if (SiteVars.CohortsDamaged[site] > 0)
{
Reproduction.PreventEstablishment(site);
sitesToDelete.Add(site);
}
}
foreach (ActiveSite site in sitesToDelete)
{
stand.DelistActiveSite(site);
}
}
} // foreach (Stand stand in mgmtArea)
foreach (AppliedPrescription aprescription in mgmtArea.Prescriptions)
{
Prescription prescription = aprescription.Prescription;
//string species_string = "";
double[] species_count = new double[modelCore.Species.Count];
foreach (ISpecies species in PlugIn.ModelCore.Species)
{
species_count[species.Index] += totalSpeciesCohorts[prescription.Number, species.Index];
}
if (totalSites[prescription.Number] > 0 && prescriptionReported[prescription.Number] != true)
{
//summaryLog.WriteLine("{0},{1},{2},{3}{4}",
// PlugIn.ModelCore.CurrentTime,
// mgmtArea.MapCode,
// prescription.Name,
// totalDamagedSites[prescription.Number],
// species_string);
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = modelCore.CurrentTime;
sl.ManagementArea = mgmtArea.MapCode;
sl.Prescription = prescription.Name;
sl.HarvestedSites = totalDamagedSites[prescription.Number];
sl.CohortsHarvested_ = species_count;
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
prescriptionReported[prescription.Number] = true;
}
}
}
prescriptionMaps.WriteMap(PlugIn.ModelCore.CurrentTime);
}
