//---------------------------------------------------------------------
private void LogEvent(int currentTime,
Event windEvent)
{
//log.WriteLine("{0},\"{1}\",{2},{3},{4},{5:0.0}",
// currentTime,
// windEvent.StartLocation,
// windEvent.Size,
// windEvent.SitesDamaged,
// windEvent.CohortsKilled,
// windEvent.Severity);
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.InitRow = windEvent.StartLocation.Row;
el.InitColumn = windEvent.StartLocation.Column;
el.TotalSites = windEvent.Size;
el.DamagedSites = windEvent.SitesDamaged;
el.CohortsKilled = windEvent.CohortsKilled;
el.MeanSeverity = windEvent.Severity;
eventLog.AddObject(el);
eventLog.WriteToFile();
}
//---------------------------------------------------------------------
///<summary>
/// Run the plug-in at a particular timestep.
///</summary>
public override void Run()
{
modelCore.UI.WriteLine(" Processing Drought Generator ...");
SiteVars.DroughtYears.ActiveSiteValues = 0;
PlugIn.ModelCore.LognormalDistribution.Mu = mu;
PlugIn.ModelCore.LognormalDistribution.Sigma = sigma;
double dY = PlugIn.ModelCore.LognormalDistribution.NextDouble();
if (dY > 10)
{
dY = 10;
}
// Output carried in SiteVars represents # years drought per decade
eventsLog.Clear();
EventsLog el = new EventsLog();
el.Time = modelCore.CurrentTime;
el.DroughtYears = dY;
eventsLog.AddObject(el);
eventsLog.WriteToFile();
// Assign values to sites
foreach (Site site in modelCore.Landscape.AllSites)
{
if (site.IsActive)
{
SiteVars.DroughtYears[site] = dY;
}
else
{
SiteVars.DroughtYears[site] = 0;
}
}
}
//---------------------------------------------------------------------
private void WriteSummaryLog(int currentTime)
{
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.SimulationYear = currentTime;
sl.TotalBurnedSitesAccidental = totalBurnedSites[0];
sl.TotalBurnedSitesLightning = totalBurnedSites[1];
sl.TotalBurnedSitesRx = totalBurnedSites[2];
sl.NumberFiresAccidental = numberOfFire[0];
sl.NumberFiresLightning = numberOfFire[1];
sl.NumberFiresRx = numberOfFire[2];
sl.TotalBiomassMortalityAccidental = totalBiomassMortality[0];
sl.TotalBiomassMortalityLightning = totalBiomassMortality[1];
sl.TotalBiomassMortalityRx = totalBiomassMortality[2];
//sl.NumberCellsSeverity1 = numCellsSeverity1;
//sl.NumberCellsSeverity2 = numCellsSeverity2;
//sl.NumberCellsSeverity3 = numCellsSeverity3;
//sl.NumberCellsSeverity4 = numCellsSeverity4;
//sl.NumberCellsSeverity5 = numCellsSeverity5;
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
}
//---------------------------------------------------------------------
public static void WriteShortPrimaryLogFile(int CurrentTime)
{
double avgNEEc = 0.0;
double avgSOMtc = 0.0;
double avgAGB = 0.0;
double avgAGNPPtc = 0.0;
double avgMineralN = 0.0;
double avgDeadWoodC = 0.0;
foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
{
avgNEEc += SiteVars.AnnualNEE[site] / PlugIn.ModelCore.Landscape.ActiveSiteCount;
avgSOMtc += GetOrganicCarbon(site) / PlugIn.ModelCore.Landscape.ActiveSiteCount;
avgAGB += (double)Main.ComputeLivingBiomass(SiteVars.Cohorts[site]) / PlugIn.ModelCore.Landscape.ActiveSiteCount;
avgAGNPPtc += SiteVars.AGNPPcarbon[site] / PlugIn.ModelCore.Landscape.ActiveSiteCount;
avgMineralN += SiteVars.MineralN[site] / PlugIn.ModelCore.Landscape.ActiveSiteCount;
avgDeadWoodC += SiteVars.SurfaceDeadWood[site].Carbon / PlugIn.ModelCore.Landscape.ActiveSiteCount;
}
primaryLogShort.Clear();
PrimaryLogShort pl = new PrimaryLogShort();
pl.Time = CurrentTime;
pl.NEEC = avgNEEc;
pl.SOMTC = avgSOMtc;
pl.AGB = avgAGB;
pl.AG_NPPC = avgAGNPPtc;
pl.MineralN = avgMineralN;
pl.C_DeadWood = avgDeadWoodC;
primaryLogShort.AddObject(pl);
primaryLogShort.WriteToFile();
}
//---------------------------------------------------------------------
private static void Write(IClimateRecord[,] TimestepData, int year, string period)
{
//spinup_allData.
foreach (IEcoregion ecoregion in Climate.ModelCore.Ecoregions)
{
if (ecoregion.Active)
{
for (int month = 0; month < 12; month++)
{
MonthlyLog.Clear();
MonthlyLog ml = new MonthlyLog();
ml.SimulationPeriod = period;
ml.Time = year;
ml.Month = month + 1;
ml.EcoregionName = ecoregion.Name;
ml.EcoregionIndex = ecoregion.Index;
ml.min_airtemp = TimestepData[ecoregion.Index, month].AvgMinTemp;
ml.max_airtemp = TimestepData[ecoregion.Index, month].AvgMaxTemp;
ml.std_temp = TimestepData[ecoregion.Index, month].StdDevTemp;
ml.ppt = TimestepData[ecoregion.Index, month].AvgPpt;
ml.std_ppt = TimestepData[ecoregion.Index, month].StdDevPpt;
MonthlyLog.AddObject(ml);
MonthlyLog.WriteToFile();
}
}
}
}
//---------------------------------------------------------------------
private void LogEvent(int currentTime,
Event windEvent)
{
//log.WriteLine("{0},\"{1}\",{2},{3},{4},{5:0.0}",
// currentTime,
// windEvent.StartLocation,
// windEvent.Size,
// windEvent.SitesDamaged,
// windEvent.CohortsKilled,
// windEvent.Severity);
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.InitRow = windEvent.StartLocation.Row;
el.InitColumn = windEvent.StartLocation.Column;
el.Type = windEvent.Type;
el.TotalSites = windEvent.SitesInEvent;
el.DamageSites = windEvent.SitesDamaged;
el.TotalArea = windEvent.SizeHectares;
el.DamagedArea = windEvent.SitesDamaged * (PlugIn.ModelCore.CellLength * PlugIn.ModelCore.CellLength) / 10000;
el.CohortsKilled = windEvent.CohortsKilled;
el.MeanSeverity = windEvent.Severity;
el.Intensity = windEvent.Intensity;
el.Direction = windEvent.WindDirection;
el.Length = windEvent.Length;
el.Width = windEvent.Width;
eventLog.AddObject(el);
eventLog.WriteToFile();
}
private void LogEvent(int currentTime, HurricaneEvent hurricaneEvent = null)
{
// commented out in case I want to use it later.
// commented out to eliminate a warning.
//string cvtKilometersToMiles(double kValue, unitType unitType)
//{
// double milesValue = kValue * 0.621371;
// string kUnits = unitType == unitType.Dist ? "kilometers" : "kph";
// string mUnits = unitType == unitType.Dist ? " miles" : " mph";
// return $"{kValue:F1} {kUnits} / {milesValue:F1} {mUnits}";
//}
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.HurricaneNumber = hurricaneEvent.hurricaneNumber;
el.ImpactsStudyArea = hurricaneEvent.studyAreaImpacts;
el.StudyAreaMaxWS = hurricaneEvent.StudyAreaMaxWindspeed;
el.StudyAreaMinWS = hurricaneEvent.StudyAreaMinWindspeed;
el.LandfallLatitude = hurricaneEvent.landfallLatitude;
el.LandfallMaxWindSpeed = hurricaneEvent.landfallMaxWindSpeed;
el.PathHeading = hurricaneEvent.stormTrackHeading;
eventLog.AddObject(el);
eventLog.WriteToFile();
if (hurricaneEvent.studyAreaImpacts)
{
summaryEventCount++;
}
//summaryTotalSites += hurricaneEvent.studyAreaImpacts;
}
//---------------------------------------------------------------------
//private static void WriteAnnualLog(IEcoregion ecoregion, int year, AnnualClimate_Monthly annualClimateMonthly, AnnualClimate_Daily annualClimate_Daily)
private static void WriteAnnualLog(IEcoregion ecoregion, int year, AnnualClimate_Monthly annualClimateMonthly)
{
AnnualLog.Clear();
AnnualLog al = new AnnualLog();
//al.SimulationPeriod = TBD
al.Time = year;
al.EcoregionName = ecoregion.Name;
al.EcoregionIndex = ecoregion.Index;
//if (future_allData_granularity == TemporalGranularity.Daily)
// al.BeginGrow = annualClimate_Daily.BeginGrowing;
//else
al.BeginGrow = annualClimateMonthly.BeginGrowing;
//if (future_allData_granularity == TemporalGranularity.Daily)
// al.EndGrow = annualClimate_Daily.EndGrowing;
//else
al.EndGrow = annualClimateMonthly.EndGrowing;
al.TAP = annualClimateMonthly.TotalAnnualPrecip;
al.MAT = annualClimateMonthly.MeanAnnualTemperature;
al.PDSI = Future_MonthlyData[year][ecoregion.Index].PDSI;
// VS: might need FWI in annual climate
//al.FWI = Future_MonthlyData[year][ecoregion.Index].FWI;
AnnualLog.AddObject(al);
AnnualLog.WriteToFile();
}
//---------------------------------------------------------------------
private void LogEvent(int currentTime,
Event diseaseEvent)
{
eventLog.Clear();
foreach (int i in Enumerable.Range(0, PlugIn.ModelCore.Species.Count))
{
EventsLog el = new EventsLog();
el.Time = currentTime;
el.Species = PlugIn.ModelCore.Species[i].Name;
el.MortalityBiomass = diseaseEvent.BiomassRemovedList[i];
eventLog.AddObject(el);
}
eventLog.WriteToFile();
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = currentTime;
sl.UninfectedSites = (float)diseaseEvent.UninfectedSites / (float)PlugIn.ModelCore.Landscape.ActiveSiteCount;
sl.InfectedSites = (float)diseaseEvent.InfectedSites / (float)PlugIn.ModelCore.Landscape.ActiveSiteCount;
sl.DiseasedSites = (float)diseaseEvent.DiseasedSites / (float)PlugIn.ModelCore.Landscape.ActiveSiteCount;
sl.DamageSites = (float)diseaseEvent.TotalSitesDamaged / (float)PlugIn.ModelCore.Landscape.ActiveSiteCount;
sl.Absent = (float)diseaseEvent.Absent / (float)PlugIn.ModelCore.Landscape.ActiveSiteCount;
sl.CohortsDamaged = diseaseEvent.CohortsDamaged;
sl.CohortsKilled = diseaseEvent.CohortsKilled;
sl.MortalityBiomass = diseaseEvent.BiomassRemoved;
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
}
public static void WriteSummaryLogEntry(ManagementArea mgmtArea, AppliedPrescription prescription, uint repeatNumber = 0, bool lastHarvest = false)
{
double[] species_cohorts = new double[modelCore.Species.Count];
double[] species_biomass = new double[modelCore.Species.Count];
foreach (ISpecies species in modelCore.Species)
{
species_cohorts[species.Index] = totalSpeciesCohorts[prescription.Prescription.Number, species.Index];
species_biomass[species.Index] = totalSpeciesBiomass[prescription.Prescription.Number, species.Index];
}
if (totalSites[prescription.Prescription.Number] > 0 && prescriptionReported[prescription.Prescription.Number] != true)
{
string name = prescription.Prescription.Name;
if (repeatNumber > 0)
{
name = name + "(" + repeatNumber + ")";
}
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = modelCore.CurrentTime;
sl.ManagementArea = mgmtArea.MapCode;
sl.Prescription = name;
sl.HarvestedSites = totalDamagedSites[prescription.Prescription.Number];
sl.TotalBiomassHarvested = totalBiomassRemoved[prescription.Prescription.Number];
sl.TotalCohortsPartialHarvest = totalCohortsDamaged[prescription.Prescription.Number];
sl.TotalCohortsCompleteHarvest = totalCohortsKilled[prescription.Prescription.Number];
sl.CohortsHarvested_ = species_cohorts;
sl.BiomassHarvestedMg_ = species_biomass;
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
// Do not mark this as recorded until the final summary is logged. Because repeat steps will be
// recorded first and then new initiations, mark this as reported once the initiation step is complete
if (repeatNumber == 0 || (ModelCore.CurrentTime > prescription.EndTime && lastHarvest))
{
prescriptionReported[prescription.Prescription.Number] = true;
}
// Clear the log for the initial harvests
if (lastHarvest)
{
totalDamagedSites[prescription.Prescription.Number] = 0;
totalBiomassRemoved[prescription.Prescription.Number] = 0;
totalCohortsDamaged[prescription.Prescription.Number] = 0;
totalCohortsKilled[prescription.Prescription.Number] = 0;
foreach (ISpecies species in modelCore.Species)
{
totalSpeciesCohorts[prescription.Prescription.Number, species.Index] = 0;
totalSpeciesBiomass[prescription.Prescription.Number, species.Index] = 0;
}
}
}
}
//---------------------------------------------------------------------
private void WriteSummaryLog(int currentTime)
{
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = currentTime;
//sl.TotalSitesDisturbed = summaryTotalSites;
sl.NumberEvents = summaryEventCount;
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
}
//---------------------------------------------------------------------
private static void WriteFutureInputLog(ClimateRecord[][] TimestepData, int year)
{
//CalculateFWI(ref TimestepData, year);
int maxtimestep = 12;
if (future_allData_granularity == TemporalGranularity.Daily)
{
maxtimestep = 365;
}
foreach (IEcoregion ecoregion in Climate.ModelCore.Ecoregions)
{
if (ecoregion.Active)
{
for (int timestep = 0; timestep < maxtimestep; timestep++)
{
FutureInputLog.Clear();
var il = new InputLog();
il.Year = year;
il.Timestep = timestep + 1;
il.EcoregionName = ecoregion.Name;
il.EcoregionIndex = ecoregion.Index;
il.ppt = TimestepData[ecoregion.Index][timestep].AvgPpt;
il.min_airtemp = TimestepData[ecoregion.Index][timestep].AvgMinTemp;
il.max_airtemp = TimestepData[ecoregion.Index][timestep].AvgMaxTemp;
//il.std_ppt = TimestepData[ecoregion.Index][timestep].StdDevPpt;
//il.std_temp = TimestepData[ecoregion.Index][timestep].StdDevTemp;
il.winddirection = TimestepData[ecoregion.Index][timestep].AvgWindDirection;
il.windspeed = TimestepData[ecoregion.Index][timestep].AvgWindSpeed;
il.ndeposition = TimestepData[ecoregion.Index][timestep].AvgNDeposition;
il.relativehumidity = TimestepData[ecoregion.Index][timestep].AvgRH;
il.min_relativehumidity = TimestepData[ecoregion.Index][timestep].AvgMinRH;
il.max_relativehumidity = TimestepData[ecoregion.Index][timestep].AvgMaxRH;
il.specifichumidty = TimestepData[ecoregion.Index][timestep].AvgSpecificHumidity;
il.co2 = TimestepData[ecoregion.Index][timestep].AvgCO2;
il.par = TimestepData[ecoregion.Index][timestep].AvgPAR;
il.ozone = TimestepData[ecoregion.Index][timestep].AvgOzone;
il.shortwave = TimestepData[ecoregion.Index][timestep].AvgShortWaveRadiation;
il.temperature = TimestepData[ecoregion.Index][timestep].Temp;
if (Climate.ConfigParameters.UsingFireClimate)
{
il.FWI = TimestepData[ecoregion.Index][timestep].AvgFWI;
}
FutureInputLog.AddObject(il);
FutureInputLog.WriteToFile();
}
}
}
}
//---------------------------------------------------------------------
private void WriteLogFile()
{
double[,] allSppEcos = new double[ModelCore.Ecoregions.Count, ModelCore.Species.Count];
int[] activeSiteCount = new int[ModelCore.Ecoregions.Count];
//UI.WriteLine("Next, reset all values to zero.");
foreach (IEcoregion ecoregion in ModelCore.Ecoregions)
{
foreach (ISpecies species in ModelCore.Species)
{
allSppEcos[ecoregion.Index, species.Index] = 0.0;
}
activeSiteCount[ecoregion.Index] = 0;
}
//UI.WriteLine("Next, accumulate data.");
foreach (ActiveSite site in ModelCore.Landscape)
{
IEcoregion ecoregion = ModelCore.Ecoregion[site];
foreach (ISpecies species in ModelCore.Species)
{
allSppEcos[ecoregion.Index, species.Index] += ComputeSpeciesBiomass(SiteVars.Cohorts[site][species]);
}
activeSiteCount[ecoregion.Index]++;
}
foreach (IEcoregion ecoregion in ModelCore.Ecoregions)
{
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = modelCore.CurrentTime;
sl.EcoName = ecoregion.Name;
sl.NumActiveSites = activeSiteCount[ecoregion.Index];
double[] aboveBiomass = new double[modelCore.Species.Count];
foreach (ISpecies species in ModelCore.Species)
{
aboveBiomass[species.Index] = allSppEcos[ecoregion.Index, species.Index] / (double)activeSiteCount[ecoregion.Index];
}
sl.AboveGroundBiomass_ = aboveBiomass;
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
}
}
//---------------------------------------------------------------------
public static void LogIgnition(int currentTime, double fwi, string type, int numIgns, int doy)
{
ignitionsLog.Clear();
IgnitionsLog ign = new IgnitionsLog();
ign.SimulationYear = currentTime;
ign.AttemptedNumberIgnitions = numIgns;
ign.DayOfYear = doy;
ign.FireWeatherIndex = fwi;
ign.IgnitionType = type;
ignitionsLog.AddObject(ign);
ignitionsLog.WriteToFile();
}
void Randomize <T>(MetadataTable <T> tbl)
{
T[] t = tbl.OfType <T>().ToArray();
for (int i = 0; i < t.Length; i++)
{
T tmp = t[i];
int j = Random.Next(0, t.Length);
t[i] = t[j];
t[j] = tmp;
}
tbl.Clear();
foreach (var i in t)
{
tbl.AddRow(i);
}
}
//---------------------------------------------------------------------
/*private void LogEvent(int currentTime,
* Epidemic CurrentEvent,
* int ROS, IAgent agent)
* {
* log.Write("{0},{1},{2},{3},{4},{5:0.0}",
* currentTime,
* ROS,
* agent.AgentName,
* CurrentEvent.CohortsKilled,
* CurrentEvent.TotalSitesDamaged,
* CurrentEvent.MeanSeverity);
* log.WriteLine("");
* }
*/
//---------------------------------------------------------------------
private void LogEvent(int currentTime,
Epidemic CurrentEvent,
int ROS, IAgent agent)
{
EventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.ROS = ROS;
el.AgentName = agent.AgentName;
el.DamagedSites = CurrentEvent.TotalSitesDamaged;
el.CohortsKilled = CurrentEvent.CohortsKilled;
el.MeanSeverity = CurrentEvent.MeanSeverity;
EventLog.AddObject(el);
EventLog.WriteToFile();
}
//---------------------------------------------------------------------
private static void WriteFutureInputLog(ClimateRecord[][] TimestepData, int year)
{
//spinup_allData.
//CalculateFWI(ref TimestepData, year);
int maxtimestep = 12;
if (future_allData_granularity == TemporalGranularity.Daily)
{
maxtimestep = 365;
}
foreach (IEcoregion ecoregion in Climate.ModelCore.Ecoregions)
{
if (ecoregion.Active)
{
//for (int month = 0; month < 12; month++)
for (int timestep = 0; timestep < maxtimestep; timestep++)
{
FutureInputLog.Clear();
InputLog fil = new InputLog();
//fil.SimulationPeriod = period;
fil.Year = year;
fil.Timestep = timestep + 1;
fil.EcoregionName = ecoregion.Name;
fil.EcoregionIndex = ecoregion.Index;
fil.min_airtemp = TimestepData[ecoregion.Index][timestep].AvgMinTemp;
fil.max_airtemp = TimestepData[ecoregion.Index][timestep].AvgMaxTemp;
fil.std_temp = TimestepData[ecoregion.Index][timestep].StdDevTemp;
fil.ppt = TimestepData[ecoregion.Index][timestep].AvgPpt;
fil.std_ppt = TimestepData[ecoregion.Index][timestep].StdDevPpt;
fil.winddirection = TimestepData[ecoregion.Index][timestep].AvgWindDirection;
fil.windspeed = TimestepData[ecoregion.Index][timestep].AvgWindSpeed;
fil.ndeposition = TimestepData[ecoregion.Index][timestep].AvgNDeposition;
//fil.co2 = TimestepData[ecoregion.Index][timestep].AvgCO2;
//if (FireClimate.UsingFireClimate)
//{
fil.FWI = TimestepData[ecoregion.Index][timestep].AvgFWI;
//}
FutureInputLog.AddObject(fil);
FutureInputLog.WriteToFile();
}
}
}
}
//---------------------------------------------------------------------
private void LogEvent(int currentTime,
Event windEvent)
{
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.InitRow = windEvent.StartLocation.Row;
el.InitColumn = windEvent.StartLocation.Column;
el.TotalSites = windEvent.Size;
el.DamagedSites = windEvent.SitesDamaged;
el.CohortsKilled = windEvent.CohortsKilled;
el.MeanSeverity = windEvent.Severity;
summaryTotalSites += windEvent.SitesDamaged;
eventLog.AddObject(el);
eventLog.WriteToFile();
}
private void LogEvent(int currentTime,
Epidemic CurrentEvent,
IAgent agent)
{
EventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.AgentName = agent.AgentName;
el.InfectedSites = CurrentEvent.TotalSitesInfected; //total number of infected sites
el.DiseasedSites = CurrentEvent.TotalSitesDiseased; //total number of diseased sites
el.DamagedSites = CurrentEvent.TotalSitesDamaged; //total number of damaged (i.e. with mortality) sites
el.TotalCohortsKilled = CurrentEvent.TotalCohortsKilled; //total number of cohorts killed (all species)
el.CohortsMortSppKilled = CurrentEvent.MortSppCohortsKilled; //total number of cohorts killed (species of interest)
EventLog.AddObject(el);
EventLog.WriteToFile();
}
public static void WriteReproductionLog(int CurrentTime)
{
foreach (ISpecies spp in PlugIn.ModelCore.Species)
{
reproductionLog.Clear();
ReproductionLog rl = new ReproductionLog();
rl.Time = CurrentTime;
rl.SpeciesName = spp.Name;
rl.NumCohortsPlanting = PlugIn.SpeciesByPlant[spp.Index];
rl.NumCohortsSerotiny = PlugIn.SpeciesBySerotiny[spp.Index];
rl.NumCohortsSeed = PlugIn.SpeciesBySeed[spp.Index];
rl.NumCohortsResprout = PlugIn.SpeciesByResprout[spp.Index];
reproductionLog.AddObject(rl);
reproductionLog.WriteToFile();
}
}
//---------------------------------------------------------------------
private void LogEvent(int currentTime,
Event fireEvent)
{
//HEADER: Time,Initiation Site,Sites Checked,Cohorts Killed,Mean Severity,
int totalSitesInEvent = 0;
if (fireEvent.EventSeverity > 0)
{
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.InitSite = fireEvent.StartLocation;
el.InitFireRegion = fireEvent.InitiationFireRegion.Name;
el.InitFuel = fireEvent.InitiationFuel;
el.InitPercentConifer = fireEvent.InitiationPercentConifer;
el.SelectedSizeOrDuration = fireEvent.MaxFireParameter;
el.SizeBin = fireEvent.SizeBin;
el.Duration = fireEvent.MaxDuration;
el.FireSeason = fireEvent.FireSeason.NameOfSeason;
el.WindSpeed = fireEvent.WindSpeed;
el.WindDirection = fireEvent.WindDirection;
el.FFMC = fireEvent.FFMC;
el.BUI = fireEvent.BuildUpIndex;
el.PercentCuring = fireEvent.FireSeason.PercentCuring;
el.ISI = fireEvent.ISI;
el.SitesChecked = fireEvent.NumSitesChecked;
el.CohortsKilled = fireEvent.CohortsKilled;
el.MeanSeverity = fireEvent.EventSeverity;
el.EcoMaps_ = new double[FireRegions.Dataset.Count];
int i = 0;
//----------
foreach (IFireRegion fire_region in FireRegions.Dataset)
{
el.EcoMaps_[i] = fireEvent.SitesInEvent[fire_region.Index];
totalSitesInEvent += fireEvent.SitesInEvent[fire_region.Index];
summaryFireRegionEventCount[fire_region.Index] += fireEvent.SitesInEvent[fire_region.Index];
i = i + 1;
}
summaryTotalSites += totalSitesInEvent;
el.TotalSitesInEvent = totalSitesInEvent;
eventLog.AddObject(el);
eventLog.WriteToFile();
}
}
//---------------------------------------------------------------------
private static void WriteSpinupInputLog(ClimateRecord[][] TimestepData, int year)
{
int maxtimestep = 12;
if (spinup_allData_granularity == TemporalGranularity.Daily)
{
maxtimestep = 365;
}
//spinup_allData.
foreach (IEcoregion ecoregion in Climate.ModelCore.Ecoregions)
{
if (ecoregion.Active)
{
//for (int month = 0; month < 12; month++)
for (int timestep = 0; timestep < maxtimestep; timestep++)
{
SpinupInputLog.Clear();
InputLog sil = new InputLog();
//sil.SimulationPeriod = period;
sil.Year = year;
sil.Timestep = timestep + 1;
sil.EcoregionName = ecoregion.Name;
sil.EcoregionIndex = ecoregion.Index;
sil.min_airtemp = TimestepData[ecoregion.Index][timestep].AvgMinTemp;
sil.max_airtemp = TimestepData[ecoregion.Index][timestep].AvgMaxTemp;
sil.std_temp = TimestepData[ecoregion.Index][timestep].StdDevTemp;
sil.ppt = TimestepData[ecoregion.Index][timestep].AvgPpt;
sil.std_ppt = TimestepData[ecoregion.Index][timestep].StdDevPpt;
sil.ndeposition = TimestepData[ecoregion.Index][timestep].AvgNDeposition;
//sil.co2 = TimestepData[ecoregion.Index][timestep].AvgCO2;
if (FireClimate.UsingFireClimate)
{
sil.FWI = TimestepData[ecoregion.Index][timestep].AvgFWI;
}
SpinupInputLog.AddObject(sil);
SpinupInputLog.WriteToFile();
}
}
}
}
//---------------------------------------------------------------------
private void LogEvent(int currentTime,
Event FireEvent)
{
int totalSitesInEvent = 0;
if (FireEvent.Severity > 0)
{
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = currentTime;
el.Row = FireEvent.StartLocation.Row;
el.Column = FireEvent.StartLocation.Column;
el.SitesChecked = FireEvent.NumSiteChecked;
el.CohortsKilled = FireEvent.CohortsKilled;
el.Severity = FireEvent.Severity;
int[] fireSites = new int[FireRegions.Dataset.Count];
int i = 0;
foreach (IFireRegion fireregion in FireRegions.Dataset)
{
fireSites[i] = FireEvent.SitesInEvent[fireregion.Index];
i = i + 1;
totalSitesInEvent += FireEvent.SitesInEvent[fireregion.Index];
summaryFireRegionEventCount[fireregion.Index] += FireEvent.SitesInEvent[fireregion.Index];
}
el.SitesEvent = new double[fireSites.Length];
i = 0;
while (i < fireSites.Length)
{
el.SitesEvent[i] = fireSites[i];
++i;
}
summaryTotalSites += totalSitesInEvent;
el.BurnedSites = totalSitesInEvent;
eventLog.AddObject(el);
eventLog.WriteToFile();
}
}
//---------------------------------------------------------------------
private void WriteSummaryLog(int currentTime)
{
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = currentTime;
sl.TotalSitesBurned = summaryTotalSites;
sl.NumberFires = summaryEventCount;
int[] summaryFireCount = new int[FireRegions.Dataset.Count];
foreach (IFireRegion ecoregion in FireRegions.Dataset)
{
summaryFireCount[ecoregion.Index] = summaryFireRegionEventCount[ecoregion.Index];
}
sl.EcoCounts_ = new double[summaryFireCount.Length];
for (int i = 0; i < sl.EcoCounts_.Length; i++)
{
sl.EcoCounts_[i] = summaryFireCount[i];
}
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
}
public static void WriteMonthlyLogFile(int month)
{
double[] ppt = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] airtemp = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgNPPtc = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgResp = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgNEE = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] Ndep = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] StreamN = new double[PlugIn.ModelCore.Ecoregions.Count];
foreach (IEcoregion ecoregion in PlugIn.ModelCore.Ecoregions)
{
ppt[ecoregion.Index] = 0.0;
airtemp[ecoregion.Index] = 0.0;
avgNPPtc[ecoregion.Index] = 0.0;
avgResp[ecoregion.Index] = 0.0;
avgNEE[ecoregion.Index] = 0.0;
Ndep[ecoregion.Index] = 0.0;
StreamN[ecoregion.Index] = 0.0;
}
foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
{
IEcoregion ecoregion = PlugIn.ModelCore.Ecoregion[site];
ppt[ecoregion.Index] = ClimateRegionData.AnnualWeather[ecoregion].MonthlyPrecip[month];
airtemp[ecoregion.Index] = ClimateRegionData.AnnualWeather[ecoregion].MonthlyTemp[month];
avgNPPtc[ecoregion.Index] += SiteVars.MonthlyAGNPPcarbon[site][month] + SiteVars.MonthlyBGNPPcarbon[site][month];
avgResp[ecoregion.Index] += SiteVars.MonthlyResp[site][month];
avgNEE[ecoregion.Index] += SiteVars.MonthlyNEE[site][month];
SiteVars.AnnualNEE[site] += SiteVars.MonthlyNEE[site][month];
Ndep[ecoregion.Index] = ClimateRegionData.MonthlyNDeposition[ecoregion][month];
StreamN[ecoregion.Index] += SiteVars.MonthlyStreamN[site][month];
}
foreach (IEcoregion ecoregion in PlugIn.ModelCore.Ecoregions)
{
if (ClimateRegionData.ActiveSiteCount[ecoregion] > 0)
{
monthlyLog.Clear();
MonthlyLog ml = new MonthlyLog();
ml.Time = PlugIn.ModelCore.CurrentTime;
ml.Month = month + 1;
ml.ClimateRegionName = ecoregion.Name;
ml.ClimateRegionIndex = ecoregion.Index;
ml.NumSites = Convert.ToInt32(ClimateRegionData.ActiveSiteCount[ecoregion]);
ml.ppt = ClimateRegionData.AnnualWeather[ecoregion].MonthlyPrecip[month];
ml.airtemp = ClimateRegionData.AnnualWeather[ecoregion].MonthlyTemp[month];
ml.avgNPPtc = (avgNPPtc[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
ml.avgResp = (avgResp[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
ml.avgNEE = (avgNEE[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
ml.Ndep = Ndep[ecoregion.Index];
ml.StreamN = (StreamN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
monthlyLog.AddObject(ml);
monthlyLog.WriteToFile();
}
}
}
//---------------------------------------------------------------------
public void WriteLogEntry(ManagementArea mgmtArea, Stand stand)
{
int damagedSites = 0;
int cohortsDamaged = 0;
int cohortsKilled = 0;
int standPrescriptionNumber = 0;
double biomassRemoved = 0.0;
double biomassRemovedPerHa = 0.0;
IDictionary <ISpecies, double> totalBiomassBySpecies = new Dictionary <ISpecies, double>();
//ModelCore.UI.WriteLine("BiomassHarvest: PlugIn.cs: WriteLogEntry: mgmtArea {0}, Stand {1} ", mgmtArea.Prescriptions.Count, stand.MapCode);
foreach (ActiveSite site in stand)
{
//set the prescription name for this site
if (HarvestMgmtLib.SiteVars.Prescription[site] != null)
{
standPrescriptionNumber = HarvestMgmtLib.SiteVars.Prescription[site].Number;
HarvestMgmtLib.SiteVars.PrescriptionName[site] = HarvestMgmtLib.SiteVars.Prescription[site].Name;
HarvestMgmtLib.SiteVars.TimeOfLastEvent[site] = modelCore.CurrentTime;
}
cohortsDamaged += Landis.Library.BiomassHarvest.SiteVars.CohortsPartiallyDamaged[site];
cohortsKilled += (HarvestMgmtLib.SiteVars.CohortsDamaged[site] - Landis.Library.BiomassHarvest.SiteVars.CohortsPartiallyDamaged[site]);
if (Landis.Library.BiomassHarvest.SiteVars.CohortsPartiallyDamaged[site] > 0 || HarvestMgmtLib.SiteVars.CohortsDamaged[site] > 0)
{
damagedSites++;
//Conversion from [g m-2] to [Mg ha-1] to [Mg]
biomassRemoved += SiteVars.BiomassRemoved[site] / 100.0 * modelCore.CellArea;
IDictionary <ISpecies, int> siteBiomassBySpecies = SiteVars.BiomassBySpecies[site];
if (siteBiomassBySpecies != null)
{
// Sum up total biomass for each species
foreach (ISpecies species in modelCore.Species)
{
int addValue = 0;
siteBiomassBySpecies.TryGetValue(species, out addValue);
double oldValue;
if (totalBiomassBySpecies.TryGetValue(species, out oldValue))
{
totalBiomassBySpecies[species] += addValue / 100.0 * modelCore.CellArea;
}
else
{
totalBiomassBySpecies.Add(species, addValue / 100.0 * modelCore.CellArea);
}
}
}
}
}
totalSites[standPrescriptionNumber] += stand.SiteCount;
totalDamagedSites[standPrescriptionNumber] += damagedSites;
totalCohortsDamaged[standPrescriptionNumber] += cohortsDamaged;
totalCohortsKilled[standPrescriptionNumber] += cohortsKilled;
totalBiomassRemoved[standPrescriptionNumber] += biomassRemoved;
double[] species_cohorts = new double[modelCore.Species.Count];
double[] species_biomass = new double[modelCore.Species.Count];
double biomass_value;
foreach (ISpecies species in modelCore.Species)
{
int cohortCount = stand.DamageTable[species];
species_cohorts[species.Index] = cohortCount;
totalSpeciesCohorts[standPrescriptionNumber, species.Index] += cohortCount;
totalBiomassBySpecies.TryGetValue(species, out biomass_value);
species_biomass[species.Index] = biomass_value;
totalSpeciesBiomass[standPrescriptionNumber, species.Index] += biomass_value;
}
//now that the damage table for this stand has been recorded, clear it!!
stand.ClearDamageTable();
//write to log file:
if (biomassRemoved > 0.0)
{
biomassRemovedPerHa = biomassRemoved / (double)damagedSites / modelCore.CellArea;
}
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = modelCore.CurrentTime;
el.ManagementArea = mgmtArea.MapCode;
el.Prescription = stand.PrescriptionName;
el.Stand = stand.MapCode;
el.EventID = stand.EventId;
el.StandAge = stand.Age;
el.StandRank = Convert.ToInt32(stand.HarvestedRank);
el.NumberOfSites = stand.SiteCount;
el.HarvestedSites = damagedSites;
el.MgBiomassRemoved = biomassRemoved;
el.MgBioRemovedPerDamagedHa = biomassRemovedPerHa;
el.TotalCohortsPartialHarvest = cohortsDamaged;
el.TotalCohortsCompleteHarvest = cohortsKilled;
el.CohortsHarvested_ = species_cohorts;
el.BiomassHarvestedMg_ = species_biomass;
eventLog.AddObject(el);
eventLog.WriteToFile();
}
//---------------------------------------------------------------------
///<summary>
/// Run Biomass Insects extension at a particular timestep.
///</summary>
public override void Run()
{
running = true;
PlugIn.ModelCore.UI.WriteLine(" Processing landscape for Biomass Insect events ...");
SiteVars.SiteDefoliation.ActiveSiteValues = 0;
foreach (IInsect insect in manyInsect)
{
//SiteVars.BiomassRemoved.ActiveSiteValues = 0;
//SiteVars.InitialOutbreakProb.ActiveSiteValues = 0.0;
if (insect.MortalityYear == PlugIn.ModelCore.CurrentTime)
{
Outbreak.Mortality(insect);
}
if (insect.MortalityYear != PlugIn.ModelCore.CurrentTime)
{
insect.LastBioRemoved = 0;
}
// Copy the data from current to last
foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
{
double thisYearDefol = insect.ThisYearDefoliation[site];
insect.LastYearDefoliation[site] = thisYearDefol;
SiteVars.SiteDefoliation[site] += (int)Math.Round(thisYearDefol * 100);
if (thisYearDefol > 0)
{
SiteVars.TimeOfLastEvent[site] = PlugIn.ModelCore.CurrentTime - 1;
SiteVars.InsectName[site] = insect.Name;
}
}
insect.ThisYearDefoliation.ActiveSiteValues = 0.0;
insect.ActiveOutbreak = false;
insect.SingleOutbreakYear = false;
//PlugIn.ModelCore.NormalDistribution.Mu = 0.0;
//PlugIn.ModelCore.NormalDistribution.Sigma = 1.0;
//double randomNum = PlugIn.ModelCore.NormalDistribution.NextDouble();
//randomNum = PlugIn.ModelCore.NormalDistribution.NextDouble();
double randomNum = Distribution.GenerateRandomNum(DistributionType.Normal, 0.0, 1.0);
DistributionType distDuration = insect.DurationDistribution;
double randomNumE = Distribution.GenerateRandomNum(distDuration, insect.DurationParameter1, insect.DurationParameter2);
// First, has enough time passed since the last outbreak? This is calculated each year,
// but only used in last year of an outbreak to generate next outbreak characteristics.
double timeBetweenOutbreaks = insect.MeanTimeBetweenOutbreaks + (insect.StdDevTimeBetweenOutbreaks * randomNum);
double duration = System.Math.Round(randomNumE);
if (distDuration == DistributionType.Exponential || distDuration == DistributionType.Normal)
{
duration = System.Math.Max(duration + 1, 1); // Duration cannot be less than 1. Added to allow Normal distribution parameters.
}
else
{
duration = System.Math.Max(duration, 1); // Duration cannot be less than 1.
}
// Apply optional maximum - if not used maxDur = Inf
if (duration > insect.MaxDuration)
{
duration = insect.MaxDuration;
}
double timeAfterDuration = timeBetweenOutbreaks - duration;
// Users can parameterize model to have overlapping outbreaks, but then patches will not initialize correctly.
// Do below to prevent overlapping outbreaks of same insect. This will affect the realized distribution of time between outbreaks somewhat.
while (timeAfterDuration <= 1.0)
{
PlugIn.ModelCore.UI.WriteLine("CAUTION: Time Between Outbreaks TOO SMALL (< 1), you may need to adjust timing parameters: {0}.", timeAfterDuration);
timeBetweenOutbreaks = timeBetweenOutbreaks + 1;
timeAfterDuration = timeBetweenOutbreaks - duration;
}
//PlugIn.ModelCore.UI.WriteLine("Calculated time between = {0:0.00}. inputMeanTime={1:0.00}, inputStdTime={2:0.00}., timeAftDur={3:0.00}.", timeBetweenOutbreaks, insect.MeanTimeBetweenOutbreaks, insect.StdDevTimeBetweenOutbreaks, timeAfterDuration);
// The logic below determines whether an outbreak is active. And sets a new outbreak duration and timeBetweenOutbreaks
// for the next outbreak if is the last year of an outbreak.
// The very first outbreak is set first.
if (PlugIn.ModelCore.CurrentTime == 1)
{
PlugIn.ModelCore.UI.WriteLine(" Year 1: Setting initial start and stop times.");
double randomNum1 = PlugIn.ModelCore.GenerateUniform();
//insect.OutbreakStartYear = (int) (timeBetweenOutbreaks / 2.0) + 1;
insect.OutbreakStartYear = Math.Max(2, (int)(randomNum1 * timeBetweenOutbreaks + 1)); // New, try making 1st start year more random. 1st outbreak has to occur > year1 to for InitializeDefoliationPatches to work properly.
insect.OutbreakStartYear = Math.Max(insect.OutbreakStartYear, insect.StartYear); // BRM - optional start year (first outbreak can't be before StartYear)
insect.OutbreakStopYear = insect.OutbreakStartYear + (int)duration - 1;
// PlugIn.ModelCore.UI.WriteLine(" {0} is not active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, PlugIn.ModelCore.CurrentTime);
}
else if (insect.OutbreakStartYear <= PlugIn.ModelCore.CurrentTime &&
insect.OutbreakStopYear > PlugIn.ModelCore.CurrentTime) // first year of a multiyear outbreak
{
// PlugIn.ModelCore.UI.WriteLine(" An outbreak starts or continues. Start and stop time do not change.");
insect.ActiveOutbreak = true;
PlugIn.ModelCore.UI.WriteLine(" {0} is active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, PlugIn.ModelCore.CurrentTime);
insect.MortalityYear = PlugIn.ModelCore.CurrentTime + 1;
insect.LastStartYear = insect.OutbreakStartYear; // Added here for Brian's log file.
insect.LastStopYear = insect.OutbreakStopYear; // Added here for Brian's log file.
}
//Special case for single year outbreak.
else if (insect.OutbreakStartYear == PlugIn.ModelCore.CurrentTime &&
insect.OutbreakStopYear == PlugIn.ModelCore.CurrentTime)
{
insect.ActiveOutbreak = true;
PlugIn.ModelCore.UI.WriteLine(" {0} is active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, PlugIn.ModelCore.CurrentTime);
if (insect.OutbreakStartYear == insect.OutbreakStopYear) // shouldn't need this. JRF
{
insect.SingleOutbreakYear = true;
}
insect.MortalityYear = PlugIn.ModelCore.CurrentTime + 1;
insect.LastStartYear = insect.OutbreakStartYear; // Added here for Brian's log file.
insect.LastStopYear = insect.OutbreakStopYear; // Added here for Brian's log file.
insect.OutbreakStartYear = PlugIn.ModelCore.CurrentTime + (int)timeBetweenOutbreaks;
insect.OutbreakStopYear = insect.OutbreakStartYear + (int)duration - 1;
}
else if (insect.OutbreakStopYear <= PlugIn.ModelCore.CurrentTime &&
timeAfterDuration > PlugIn.ModelCore.CurrentTime - insect.OutbreakStopYear)
{
// PlugIn.ModelCore.UI.WriteLine(" In between outbreaks, reset start and stop times.");
insect.ActiveOutbreak = true;
PlugIn.ModelCore.UI.WriteLine(" {0} is active. StartYear={1}, StopYear={2}, CurrentYear={3}.", insect.Name, insect.OutbreakStartYear, insect.OutbreakStopYear, PlugIn.ModelCore.CurrentTime);
insect.MortalityYear = PlugIn.ModelCore.CurrentTime + 1;
insect.LastStartYear = insect.OutbreakStartYear; // Added here for Brian's log file.
insect.LastStopYear = insect.OutbreakStopYear; // Added here for Brian's log file.
insect.OutbreakStartYear = PlugIn.ModelCore.CurrentTime + (int)timeBetweenOutbreaks;
insect.OutbreakStopYear = insect.OutbreakStartYear + (int)duration - 1;
}
PlugIn.ModelCore.UI.WriteLine(" Insect Start Time = {0}, Stop Time = {1}.", insect.OutbreakStartYear, insect.OutbreakStopYear);
// Now that logic determining when an outbreak will be active is done, tell model what to do when outbreak is occurring.
if (insect.ActiveOutbreak)
{
// PlugIn.ModelCore.UI.WriteLine(" OutbreakStartYear={0}.", insect.OutbreakStartYear);
if (insect.OutbreakStartYear == PlugIn.ModelCore.CurrentTime || insect.SingleOutbreakYear)
{
// Initialize neighborhoodGrowthReduction with patches
Outbreak.InitializeDefoliationPatches(insect);
}
else
{
insect.NeighborhoodDefoliation.ActiveSiteValues = 0;
}
}
// Now report on the previous year's defoliation, that which has been processed
// through biomass succession. Calculations for logfile.
double sumDefoliation = 0.0;
double meanDefoliation = 0.0;
int numSites0_33 = 0;
int numSites33_66 = 0;
int numSites66_100 = 0;
int numInitialSites = 0;
int numSitesActive = 0; // Just get a sum of all active sites to calculate mean defoliation accurately for log file.
// ONly calculate for log file when outbreak or mortality is active <- Modified, JRF, add to log file each year.
if (insect.ActiveOutbreak || insect.SingleOutbreakYear || (insect.LastStopYear + 1 >= PlugIn.ModelCore.CurrentTime) || (insect.LastBioRemoved > 0))
{
foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
{
sumDefoliation += insect.LastYearDefoliation[site];
if (insect.LastYearDefoliation[site] > 0.0 && insect.LastYearDefoliation[site] <= 0.33)
{
numSites0_33++;
}
if (insect.LastYearDefoliation[site] > 0.33 && insect.LastYearDefoliation[site] <= 0.66)
{
numSites33_66++;
}
if (insect.LastYearDefoliation[site] > 0.66 && insect.LastYearDefoliation[site] <= 1.0)
{
numSites66_100++;
}
if (insect.Disturbed[site] && SiteVars.InitialOutbreakProb[site] > 0)
{
numInitialSites++;
}
numSitesActive++;
}
if (insect.OutbreakStartYear == PlugIn.ModelCore.CurrentTime)
{
insect.InitialSites = numInitialSites;
}
if (numSites0_33 + numSites33_66 + numSites66_100 > 0)
{
meanDefoliation = sumDefoliation / (double)numSitesActive;
}
//PlugIn.ModelCore.UI.WriteLine(" sumDefoliation={0}, numSites={1}.", sumDefoliation, numSites0_33 + numSites33_66 + numSites66_100);
}
int totalBioRemoved = 0;
foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
{
totalBioRemoved += SiteVars.BiomassRemoved[site]; // kg across all defoliated sites
}
insect.LastBioRemoved = totalBioRemoved; //Assign variables for the logfile
// PlugIn.ModelCore.UI.WriteLine(" totalBioRemoved={0}.", totalBioRemoved);
// ONly add to log & output maps during outbreak <- Modified, JRF, add to log file each year.
//if ((insect.ActiveOutbreak && insect.OutbreakStartYear < PlugIn.ModelCore.CurrentTime) || (meanDefoliation > 0) || (insect.LastBioRemoved > 0))
//{
/* Old code for log file
* if (meanDefoliation > 0)
* {
*
* log.Write("{0},{1},{2},{3},{4:0.0000},{5},{6},{7},{8},{9}",
* PlugIn.ModelCore.CurrentTime-1, //0
* insect.Name, //1
* insect.LastStartYear, //2
* insect.LastStopYear, //3
* meanDefoliation, //4
* numSites0_33, //5
* numSites33_66, //6
* numSites66_100, //7
* insect.InitialSites, //8
* insect.LastBioRemoved //9
* );
* }
*
* else
* {
* log.Write("{0},{1},{2},{3},{4:0.0000},{5},{6},{7},{8},{9}",
* PlugIn.ModelCore.CurrentTime - 1, //0
* insect.Name, //1
* 0, //2
* 0, //3
* meanDefoliation, //4
* numSites0_33, //5
* numSites33_66, //6
* numSites66_100, //7
* 0, //8
* insect.LastBioRemoved //9
* );
* }
*
*
* //foreach (IEcoregion ecoregion in Ecoregions.Dataset)
* // log.Write(",{0}", 1);
*
* log.WriteLine("");
*/
eventLog.Clear();
EventsLog el = new EventsLog();
el.Time = PlugIn.ModelCore.CurrentTime - 1;
el.InsectName = insect.Name;
el.MeanDefoliation = meanDefoliation;
el.NumSitesDefoliated0_33 = numSites0_33;
el.NumSitesDefoliated33_66 = numSites33_66;
el.NumSitesDefoliated66_100 = numSites66_100;
el.NumOutbreakInitialSites = insect.InitialSites;
el.MortalityBiomass = insect.LastBioRemoved;
if (insect.ActiveOutbreak)
{
el.StartYear = insect.OutbreakStartYear;
el.StopYear = insect.OutbreakStopYear;
}
else
{
el.StartYear = insect.LastStartYear;
el.StopYear = insect.LastStopYear;
}
eventLog.AddObject(el);
eventLog.WriteToFile();
//----- Write Insect Defoliation/GrowthReduction maps --------
string path = MapNames.ReplaceTemplateVars(mapNameTemplate, insect.Name, PlugIn.ModelCore.CurrentTime - 1);
using (IOutputRaster <ShortPixel> outputRaster = modelCore.CreateRaster <ShortPixel>(path, modelCore.Landscape.Dimensions))
{
ShortPixel pixel = outputRaster.BufferPixel;
foreach (Site site in PlugIn.ModelCore.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.MapCode.Value = (short)(insect.LastYearDefoliation[site] * 100.0);
}
else
{
// Inactive site
pixel.MapCode.Value = 0;
}
outputRaster.WriteBufferPixel();
}
}
//----- Write Initial Patch maps --------
string path2 = MapNames.ReplaceTemplateVars(mapNameTemplate, ("InitialPatchMap" + insect.Name), PlugIn.ModelCore.CurrentTime);
using (IOutputRaster <ShortPixel> outputRaster = modelCore.CreateRaster <ShortPixel>(path2, modelCore.Landscape.Dimensions))
{
ShortPixel pixel = outputRaster.BufferPixel;
foreach (Site site in PlugIn.ModelCore.Landscape.AllSites)
{
if (site.IsActive)
{
if (insect.Disturbed[site])
{
pixel.MapCode.Value = (short)(SiteVars.InitialOutbreakProb[site] * 100);
}
else
{
pixel.MapCode.Value = 0;
}
}
else
{
// Inactive site
pixel.MapCode.Value = 0;
}
outputRaster.WriteBufferPixel();
//Zero out the InitialOutbreakProb after output maps are written.
SiteVars.InitialOutbreakProb[site] = 0;
}
}
//----- Write Biomass Reduction maps --------
string path3 = MapNames.ReplaceTemplateVars(mapNameTemplate, ("BiomassRemoved" + insect.Name), PlugIn.ModelCore.CurrentTime);
using (IOutputRaster <ShortPixel> outputRaster = modelCore.CreateRaster <ShortPixel>(path3, modelCore.Landscape.Dimensions))
{
ShortPixel pixel = outputRaster.BufferPixel;
foreach (Site site in PlugIn.ModelCore.Landscape.AllSites)
{
if (site.IsActive)
{
if (SiteVars.BiomassRemoved[site] > 0)
{
pixel.MapCode.Value = Math.Max((short)1, (short)(SiteVars.BiomassRemoved[site] / 100)); // convert to Mg/ha
}
else
{
pixel.MapCode.Value = 0;
}
}
else
{
// Inactive site
pixel.MapCode.Value = 0;
}
outputRaster.WriteBufferPixel();
//Zero out the BiomassRemoved after the last insect mortality event in a given year.
SiteVars.BiomassRemoved[site] = 0;
}
}
//}
//insect.ThisYearDefoliation.ActiveSiteValues = 0.0; //reset this year to 0 for all sites, this was already done at the top of loop to initialize defoliation patchs, Outbreak.cs
}
}
//---------------------------------------------------------------------
public override void Initialize()
{
Timestep = parameters.Timestep;
fireSizeType = parameters.FireSizeType;
bui = parameters.BUI;
mapNameTemplate = parameters.MapNamesTemplate;
dynamicWeather = parameters.DynamicWeather;
severityCalibrate = parameters.SeverityCalibrate;
modelCore.UI.WriteLine(" Initializing Fire Events...");
Event.Initialize(parameters.SeasonParameters, parameters.FuelTypeParameters, parameters.FireDamages);
seasonParameters = parameters.SeasonParameters;
dynamicEcos = parameters.DynamicFireRegions;
summaryFireRegionEventCount = new int[FireRegions.Dataset.Count];
ecoregionSitesCount = new int[FireRegions.Dataset.Count];
//foreach (IFireRegion fire_region in FireRegions.Dataset)
//modelCore.UI.WriteLine(" FireSize={0}, SD={1}", fire_region.MeanSize, fire_region.StandardDeviation);
// Count the number of sites per fire_region:
foreach (Site site in modelCore.Landscape)
{
if (site.IsActive)
{
IFireRegion fire_region = SiteVars.FireRegion[site];
ecoregionSitesCount[fire_region.Index]++;
}
}
modelCore.UI.WriteLine(" Opening and Initializing Fire log files \"{0}\" and \"{1}\"...", parameters.LogFileName, parameters.SummaryLogFileName);
List <string> colnames = new List <string>();
foreach (IFireRegion fire_region in FireRegions.Dataset)
{
colnames.Add(fire_region.MapCode.ToString());
}
ExtensionMetadata.ColumnNames = colnames;
MetadataHandler.InitializeMetadata(mapNameTemplate, parameters.LogFileName, parameters.SummaryLogFileName);
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = 0;
sl.TotalSitesBurned = 0;
sl.NumberFires = 0;
sl.EcoMaps_ = new double[FireRegions.Dataset.Count];
int i = 0;
foreach (IFireRegion fire_region in FireRegions.Dataset)
{
sl.EcoMaps_[i] = ecoregionSitesCount[fire_region.Index];
i = i + 1;
}
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
if (isDebugEnabled)
{
modelCore.UI.WriteLine("Initialization done");
}
}
//---------------------------------------------------------------------
public static void WritePrimaryLogFile(int CurrentTime)
{
double[] avgAnnualPPT = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgJJAtemp = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgNEEc = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOMtc = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgAGB = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgAGNPPtc = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgBGNPPtc = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgLittertc = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgWoodMortality = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgMineralN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgGrossMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgTotalN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortLeafC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortFRootC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortWoodC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgWoodC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortCRootC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCRootC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortLeafN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortFRootN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortWoodN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCohortCRootN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgWoodN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgCRootN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSurfStrucC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSurfMetaC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSoilStrucC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSoilMetaC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSurfStrucN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSurfMetaN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSoilStrucN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSoilMetaN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSurfStrucNetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSurfMetaNetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSoilStrucNetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSoilMetaNetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM1surfC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM1soilC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM2C = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM3C = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM1surfN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM1soilN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM2N = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM3N = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM1surfNetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM1soilNetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM2NetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgSOM3NetMin = new double[PlugIn.ModelCore.Ecoregions.Count];
//doubl[] avgNDeposition = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgStreamC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgStreamN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgFireCEfflux = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgFireNEfflux = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgNvol = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgNresorbed = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgTotalSoilN = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgNuptake = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avgfrassC = new double[PlugIn.ModelCore.Ecoregions.Count];
double[] avglai = new double[PlugIn.ModelCore.Ecoregions.Count];
foreach (IEcoregion ecoregion in PlugIn.ModelCore.Ecoregions)
{
avgAnnualPPT[ecoregion.Index] = 0.0;
avgJJAtemp[ecoregion.Index] = 0.0;
avgNEEc[ecoregion.Index] = 0.0;
avgSOMtc[ecoregion.Index] = 0.0;
avgAGB[ecoregion.Index] = 0.0;
avgAGNPPtc[ecoregion.Index] = 0.0;
avgBGNPPtc[ecoregion.Index] = 0.0;
avgLittertc[ecoregion.Index] = 0.0;
avgWoodMortality[ecoregion.Index] = 0.0;
avgMineralN[ecoregion.Index] = 0.0;
avgGrossMin[ecoregion.Index] = 0.0;
avgTotalN[ecoregion.Index] = 0.0;
avgCohortLeafC[ecoregion.Index] = 0.0;
avgCohortFRootC[ecoregion.Index] = 0.0;
avgCohortWoodC[ecoregion.Index] = 0.0;
avgCohortCRootC[ecoregion.Index] = 0.0;
avgWoodC[ecoregion.Index] = 0.0;
avgCRootC[ecoregion.Index] = 0.0;
avgSurfStrucC[ecoregion.Index] = 0.0;
avgSurfMetaC[ecoregion.Index] = 0.0;
avgSoilStrucC[ecoregion.Index] = 0.0;
avgSoilMetaC[ecoregion.Index] = 0.0;
avgCohortLeafN[ecoregion.Index] = 0.0;
avgCohortFRootN[ecoregion.Index] = 0.0;
avgCohortWoodN[ecoregion.Index] = 0.0;
avgCohortCRootN[ecoregion.Index] = 0.0;
avgWoodN[ecoregion.Index] = 0.0;
avgCRootN[ecoregion.Index] = 0.0;
avgSurfStrucN[ecoregion.Index] = 0.0;
avgSurfMetaN[ecoregion.Index] = 0.0;
avgSoilStrucN[ecoregion.Index] = 0.0;
avgSoilMetaN[ecoregion.Index] = 0.0;
avgSurfStrucNetMin[ecoregion.Index] = 0.0;
avgSurfMetaNetMin[ecoregion.Index] = 0.0;
avgSoilStrucNetMin[ecoregion.Index] = 0.0;
avgSoilMetaNetMin[ecoregion.Index] = 0.0;
avgSOM1surfC[ecoregion.Index] = 0.0;
avgSOM1soilC[ecoregion.Index] = 0.0;
avgSOM2C[ecoregion.Index] = 0.0;
avgSOM3C[ecoregion.Index] = 0.0;
avgSOM1surfN[ecoregion.Index] = 0.0;
avgSOM1soilN[ecoregion.Index] = 0.0;
avgSOM2N[ecoregion.Index] = 0.0;
avgSOM3N[ecoregion.Index] = 0.0;
avgSOM1surfNetMin[ecoregion.Index] = 0.0;
avgSOM1soilNetMin[ecoregion.Index] = 0.0;
avgSOM2NetMin[ecoregion.Index] = 0.0;
avgSOM3NetMin[ecoregion.Index] = 0.0;
//avgNDeposition[ecoregion.Index] = 0.0;
avgStreamC[ecoregion.Index] = 0.0;
avgStreamN[ecoregion.Index] = 0.0;
avgFireCEfflux[ecoregion.Index] = 0.0;
avgFireNEfflux[ecoregion.Index] = 0.0;
avgNuptake[ecoregion.Index] = 0.0;
avgNresorbed[ecoregion.Index] = 0.0;
avgTotalSoilN[ecoregion.Index] = 0.0;
avgNvol[ecoregion.Index] = 0.0;
avgfrassC[ecoregion.Index] = 0.0;
}
foreach (ActiveSite site in PlugIn.ModelCore.Landscape)
{
IEcoregion ecoregion = PlugIn.ModelCore.Ecoregion[site];
avgNEEc[ecoregion.Index] += SiteVars.AnnualNEE[site];
avgSOMtc[ecoregion.Index] += GetOrganicCarbon(site);
avgAGB[ecoregion.Index] += Main.ComputeLivingBiomass(SiteVars.Cohorts[site]);
avgAGNPPtc[ecoregion.Index] += SiteVars.AGNPPcarbon[site];
avgBGNPPtc[ecoregion.Index] += SiteVars.BGNPPcarbon[site];
avgLittertc[ecoregion.Index] += SiteVars.LitterfallC[site];
avgWoodMortality[ecoregion.Index] += SiteVars.WoodMortality[site] * 0.47;
avgMineralN[ecoregion.Index] += SiteVars.MineralN[site];
avgTotalN[ecoregion.Index] += GetTotalNitrogen(site);
avgGrossMin[ecoregion.Index] += SiteVars.GrossMineralization[site];
avgCohortLeafC[ecoregion.Index] += SiteVars.CohortLeafC[site];
avgCohortFRootC[ecoregion.Index] += SiteVars.CohortFRootC[site];
avgCohortWoodC[ecoregion.Index] += SiteVars.CohortWoodC[site];
avgCohortCRootC[ecoregion.Index] += SiteVars.CohortCRootC[site];
avgWoodC[ecoregion.Index] += SiteVars.SurfaceDeadWood[site].Carbon;
avgCRootC[ecoregion.Index] += SiteVars.SoilDeadWood[site].Carbon;
avgSurfStrucC[ecoregion.Index] += SiteVars.SurfaceStructural[site].Carbon;
avgSurfMetaC[ecoregion.Index] += SiteVars.SurfaceMetabolic[site].Carbon;
avgSoilStrucC[ecoregion.Index] += SiteVars.SoilStructural[site].Carbon;
avgSoilMetaC[ecoregion.Index] += SiteVars.SoilMetabolic[site].Carbon;
avgSOM1surfC[ecoregion.Index] += SiteVars.SOM1surface[site].Carbon;
avgSOM1soilC[ecoregion.Index] += SiteVars.SOM1soil[site].Carbon;
avgSOM2C[ecoregion.Index] += SiteVars.SOM2[site].Carbon;
avgSOM3C[ecoregion.Index] += SiteVars.SOM3[site].Carbon;
avgCohortLeafN[ecoregion.Index] += SiteVars.CohortLeafN[site];
avgCohortFRootN[ecoregion.Index] += SiteVars.CohortFRootN[site];
avgCohortWoodN[ecoregion.Index] += SiteVars.CohortWoodN[site];
avgCohortCRootN[ecoregion.Index] += SiteVars.CohortCRootN[site];
avgWoodN[ecoregion.Index] += SiteVars.SurfaceDeadWood[site].Nitrogen;
avgCRootN[ecoregion.Index] += SiteVars.SoilDeadWood[site].Nitrogen;
avgSurfStrucN[ecoregion.Index] += SiteVars.SurfaceStructural[site].Nitrogen;
avgSurfMetaN[ecoregion.Index] += SiteVars.SurfaceMetabolic[site].Nitrogen;
avgSoilStrucN[ecoregion.Index] += SiteVars.SoilStructural[site].Nitrogen;
avgSoilMetaN[ecoregion.Index] += SiteVars.SoilMetabolic[site].Nitrogen;
avgSOM1surfN[ecoregion.Index] += SiteVars.SOM1surface[site].Nitrogen;
avgSOM1soilN[ecoregion.Index] += SiteVars.SOM1soil[site].Nitrogen;
avgSOM2N[ecoregion.Index] += SiteVars.SOM2[site].Nitrogen;
avgSOM3N[ecoregion.Index] += SiteVars.SOM3[site].Nitrogen;
avgTotalSoilN[ecoregion.Index] += GetTotalSoilNitrogen(site);
avgSurfStrucNetMin[ecoregion.Index] += SiteVars.SurfaceStructural[site].NetMineralization;
avgSurfMetaNetMin[ecoregion.Index] += SiteVars.SurfaceMetabolic[site].NetMineralization;
avgSoilStrucNetMin[ecoregion.Index] += SiteVars.SoilStructural[site].NetMineralization;
avgSoilMetaNetMin[ecoregion.Index] += SiteVars.SoilMetabolic[site].NetMineralization;
avgSOM1surfNetMin[ecoregion.Index] += SiteVars.SOM1surface[site].NetMineralization;
avgSOM1soilNetMin[ecoregion.Index] += SiteVars.SOM1soil[site].NetMineralization;
avgSOM2NetMin[ecoregion.Index] += SiteVars.SOM2[site].NetMineralization;
avgSOM3NetMin[ecoregion.Index] += SiteVars.SOM3[site].NetMineralization;
//avgNDeposition[ecoregion.Index] = ClimateRegionData.AnnualNDeposition[ecoregion];
avgStreamC[ecoregion.Index] += SiteVars.Stream[site].Carbon;
avgStreamN[ecoregion.Index] += SiteVars.Stream[site].Nitrogen; //+ SiteVars.NLoss[site];
avgFireCEfflux[ecoregion.Index] += SiteVars.FireCEfflux[site];
avgFireNEfflux[ecoregion.Index] += SiteVars.FireNEfflux[site];
avgNresorbed[ecoregion.Index] += SiteVars.ResorbedN[site];
avgNuptake[ecoregion.Index] += GetSoilNuptake(site);
avgNvol[ecoregion.Index] += SiteVars.Nvol[site];
avgfrassC[ecoregion.Index] += SiteVars.FrassC[site];
}
foreach (IEcoregion ecoregion in PlugIn.ModelCore.Ecoregions)
{
if (!ecoregion.Active || ClimateRegionData.ActiveSiteCount[ecoregion] < 1)
{
continue;
}
primaryLog.Clear();
PrimaryLog pl = new PrimaryLog();
pl.Time = CurrentTime;
pl.ClimateRegionName = ecoregion.Name;
pl.ClimateRegionIndex = ecoregion.Index;
pl.NumSites = ClimateRegionData.ActiveSiteCount[ecoregion];
pl.NEEC = (avgNEEc[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SOMTC = (avgSOMtc[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.AGB = (avgAGB[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.AG_NPPC = (avgAGNPPtc[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.BG_NPPC = (avgBGNPPtc[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.Litterfall = (avgLittertc[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.AgeMortality = (avgWoodMortality[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.MineralN = (avgMineralN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.TotalN = (avgTotalN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.GrossMineralization = (avgGrossMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.TotalNdep = (ClimateRegionData.AnnualNDeposition[ecoregion] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_LiveLeaf = (avgCohortLeafC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_LiveFRoot = (avgCohortFRootC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_LiveWood = (avgCohortWoodC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_LiveCRoot = (avgCohortCRootC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_DeadWood = (avgWoodC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_DeadCRoot = (avgCRootC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_DeadLeaf_Struc = (avgSurfStrucC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_DeadLeaf_Meta = (avgSurfMetaC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_DeadFRoot_Struc = (avgSoilStrucC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_DeadFRoot_Meta = (avgSoilMetaC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_SOM1surf = (avgSOM1surfC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_SOM1soil = (avgSOM1soilC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_SOM2 = (avgSOM2C[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.C_SOM3 = (avgSOM3C[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_Leaf = (avgCohortLeafN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_FRoot = (avgCohortFRootN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_Wood = (avgCohortWoodN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_CRoot = (avgCohortCRootN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_DeadWood = (avgWoodN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_DeadCRoot = (avgCRootN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_DeadLeaf_Struc = (avgSurfStrucN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_DeadLeaf_Meta = (avgSurfMetaN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_DeadFRoot_Struc = (avgSoilStrucN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_DeadFRoot_Meta = (avgSoilMetaN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_SOM1surf = (avgSOM1surfN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_SOM1soil = (avgSOM1soilN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_SOM2 = (avgSOM2N[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.N_SOM3 = (avgSOM3N[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SurfStrucNetMin = (avgSurfStrucNetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SurfMetaNetMin = (avgSurfMetaNetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SoilStrucNetMin = (avgSoilStrucNetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SoilMetaNetMin = (avgSoilMetaNetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SOM1surfNetMin = (avgSOM1surfNetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SOM1soilNetMin = (avgSOM1soilNetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SOM2NetMin = (avgSOM2NetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.SOM3NetMin = (avgSOM3NetMin[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.StreamC = (avgStreamC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.StreamN = (avgStreamN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.FireCEfflux = (avgFireCEfflux[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.FireNEfflux = (avgFireNEfflux[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.Nuptake = (avgNuptake[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.Nresorbed = (avgNresorbed[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.TotalSoilN = (avgTotalSoilN[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.Nvol = (avgNvol[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
pl.FrassC = (avgfrassC[ecoregion.Index] / (double)ClimateRegionData.ActiveSiteCount[ecoregion]);
primaryLog.AddObject(pl);
primaryLog.WriteToFile();
}
//Reset back to zero:
//These are being reset here because fire effects are handled in the first year of the
//growth loop but the reporting doesn't happen until after all growth is finished.
SiteVars.FireCEfflux.ActiveSiteValues = 0.0;
SiteVars.FireNEfflux.ActiveSiteValues = 0.0;
}
//---------------------------------------------------------------------
public override void Run()
{
running = true;
HarvestMgmtLib.SiteVars.Prescription.ActiveSiteValues = null;
SiteVars.BiomassRemoved.ActiveSiteValues = 0;
Landis.Library.BiomassHarvest.SiteVars.CohortsPartiallyDamaged.ActiveSiteValues = 0;
HarvestMgmtLib.SiteVars.CohortsDamaged.ActiveSiteValues = 0;
SiteVars.BiomassBySpecies.ActiveSiteValues = null;
SiteBiomass.EnableRecordingForHarvest();
//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, modelCore.Species.Count];
totalCohortsDamaged = new int[Prescription.Count];
totalCohortsKilled = new int[Prescription.Count];
// 2015-09-14 LCB Track prescriptions as they are reported in summary log so we don't duplicate
prescriptionReported = new bool[Prescription.Count];
totalSpeciesBiomass = new double[Prescription.Count, modelCore.Species.Count];
totalBiomassRemoved = new double[Prescription.Count];
mgmtArea.HarvestStands();
//and record each stand that's been harvested
foreach (Stand stand in mgmtArea)
{
//ModelCore.UI.WriteLine(" List of stands {0} ...", stand.MapCode);
if (stand.Harvested)
{
WriteLogEntry(mgmtArea, stand);
}
}
// Prevent establishment:
foreach (Stand stand in mgmtArea)
{
if (stand.Harvested && stand.LastPrescription.PreventEstablishment)
{
List <ActiveSite> sitesToDelete = new List <ActiveSite>();
foreach (ActiveSite site in stand)
{
if (Landis.Library.BiomassHarvest.SiteVars.CohortsPartiallyDamaged[site] > 0 || HarvestMgmtLib.SiteVars.CohortsDamaged[site] > 0)
{
Landis.Library.Succession.Reproduction.PreventEstablishment(site);
sitesToDelete.Add(site);
}
}
foreach (ActiveSite site in sitesToDelete)
{
stand.DelistActiveSite(site);
}
}
}
// Write Summary Log File:
foreach (AppliedPrescription aprescription in mgmtArea.Prescriptions)
{
Prescription prescription = aprescription.Prescription;
double[] species_cohorts = new double[modelCore.Species.Count];
double[] species_biomass = new double[modelCore.Species.Count];
foreach (ISpecies species in modelCore.Species)
{
species_cohorts[species.Index] = totalSpeciesCohorts[prescription.Number, species.Index];
species_biomass[species.Index] = totalSpeciesBiomass[prescription.Number, species.Index];
}
if (totalSites[prescription.Number] > 0 && prescriptionReported[prescription.Number] != true)
{
summaryLog.Clear();
SummaryLog sl = new SummaryLog();
sl.Time = modelCore.CurrentTime;
sl.ManagementArea = mgmtArea.MapCode;
sl.Prescription = prescription.Name;
sl.HarvestedSites = totalDamagedSites[prescription.Number];
sl.TotalBiomassHarvested = totalBiomassRemoved[prescription.Number];
sl.TotalCohortsPartialHarvest = totalCohortsDamaged[prescription.Number];
sl.TotalCohortsCompleteHarvest = totalCohortsKilled[prescription.Number];
sl.CohortsHarvested_ = species_cohorts;
sl.BiomassHarvestedMg_ = species_biomass;
summaryLog.AddObject(sl);
summaryLog.WriteToFile();
prescriptionReported[prescription.Number] = true;
}
}
}
WritePrescriptionMap(modelCore.CurrentTime);
if (biomassMaps != null)
{
biomassMaps.WriteMap(modelCore.CurrentTime);
}
running = false;
SiteBiomass.DisableRecordingForHarvest();
}