public XmlNode Get_XmlNode(XmlDocument doc)
{
XmlNode node = doc.CreateElement("extension");
XmlAttribute nameAtt = doc.CreateAttribute("name");
nameAtt.Value = this.Name;
node.Attributes.Append(nameAtt);
XmlAttribute timeIntervalAtt = doc.CreateAttribute("timeInterval");
timeIntervalAtt.Value = this.TimeInterval.ToString();
node.Attributes.Append(timeIntervalAtt);
//XmlNode srNode = doc.CreateElement("scenario-replication");
XmlNode outsColl = doc.CreateElement("outputs");
foreach (OutputMetadata om in OutputMetadatas)
{
outsColl.AppendChild(om.Get_XmlNode(doc));
}
node.AppendChild(ScenarioReplicationMetadata.Get_XmlNode(doc));
node.AppendChild(outsColl);
return(node);
}
public ExtensionMetadata(ICore mCore)
//public ExtensionMetadata()
{
modelCore = mCore;
ScenarioReplicationMetadata = new ScenarioReplicationMetadata();
OutputMetadatas = new List <OutputMetadata>();
}
public ExtensionMetadata(ICore mCore)
//public ExtensionMetadata()
{
modelCore = mCore;
ScenarioReplicationMetadata = new ScenarioReplicationMetadata();
OutputMetadatas = new List<OutputMetadata>();
}
public static void InitializeMetadata(int timestep, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = Climate.ModelCore.CellArea,
TimeMin = Climate.ModelCore.StartTime,
TimeMax = Climate.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(mCore){
Name = "Climate-Library",
TimeInterval = timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
Climate.PdsiLog = new MetadataTable<PDSI_Log>("Climate-PDSI-log.csv");
Climate.MonthlyLog = new MetadataTable<MonthlyLog>("Climate-monthly-log.csv");
OutputMetadata tblOut_monthly = new OutputMetadata()
{
Type = OutputType.Table,
Name = "MonthlyLog",
FilePath = Climate.MonthlyLog.FilePath,
Visualize = true,
};
tblOut_monthly.RetriveFields(typeof(MonthlyLog));
Extension.OutputMetadatas.Add(tblOut_monthly);
OutputMetadata tblOut_pdsi = new OutputMetadata()
{
Type = OutputType.Table,
Name = "PDSILog",
FilePath = Climate.PdsiLog.FilePath,
Visualize = false,
};
tblOut_pdsi.RetriveFields(typeof(PDSI_Log));
Extension.OutputMetadatas.Add(tblOut_pdsi);
//---------------------------------------
// map outputs:
//---------------------------------------
// NONE
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string MapFileName, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime//,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(mCore){
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
PlugIn.eventLog = new MetadataTable<EventsLog>("wind-events-log.csv");
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "WindLog",
FilePath = PlugIn.eventLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
//---------------------------------------
// map outputs:
//---------------------------------------
OutputMetadata mapOut_Severity = new OutputMetadata()
{
Type = OutputType.Map,
Name = "severity",
FilePath = @MapFileName,
Map_DataType = MapDataType.Ordinal,
Map_Unit = FieldUnits.Severity_Rank,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Severity);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string MapFileName, IEnumerable<IModelDefinition> modelDefs, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime//,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(mCore){
Name = PlugIn.PlugInName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
// NO LOG FILE PlugIn.eventLog = new MetadataTable<EventsLog>("wind-events-log.csv");
//OutputMetadata tblOut_events = new OutputMetadata()
//{
// Type = OutputType.Table,
// Name = "WindLog",
// FilePath = PlugIn.eventLog.FilePath,
// Visualize = false,
//};
//tblOut_events.RetriveFields(typeof(EventsLog));
//Extension.OutputMetadatas.Add(tblOut_events);
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (ModelDefinition sppModel in modelDefs)
{
string sppMapPath = MapFileNames.ReplaceTemplateVars(MapFileName, sppModel.Name);
OutputMetadata mapOut_Birds = new OutputMetadata()
{
Type = OutputType.Map,
Name = ("Bird Species Map: " + sppModel.Name),
FilePath = @MapFileName,
Map_DataType = MapDataType.Continuous,
//Map_Unit = FieldUnits.Severity_Rank,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Birds);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string MapFileName, IEnumerable<IModelDefinition> modelDefs, ICore mCore, string LogFileName)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime//,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(mCore){
Name = PlugIn.PlugInName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
/*
//---------------------------------------
// table outputs:
//---------------------------------------
PlugIn.habitatLog = new MetadataTable<SpeciesHabitatLog>(LogFileName);
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "SppHabitatLog",
FilePath = PlugIn.habitatLog.FilePath,
Visualize = true,
};
tblOut_events.RetriveFields(typeof(SpeciesHabitatLog));
Extension.OutputMetadatas.Add(tblOut_events);
*/
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (ModelDefinition sppModel in modelDefs)
{
OutputMetadata mapOut_Birds = new OutputMetadata()
{
Type = OutputType.Map,
Name = sppModel.Name,
FilePath = @MapFileName,
Map_DataType = MapDataType.Continuous,
//Map_Unit = FieldUnits.Severity_Rank,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Birds);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int timestep, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = Climate.ModelCore.CellArea,
TimeMin = Climate.ModelCore.StartTime,
TimeMax = Climate.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(mCore){
Name = "Climate-Library",
TimeInterval = timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
//Climate.PdsiLog = new MetadataTable<PDSI_Log>("Climate-PDSI-log.csv");
Climate.SpinupInputLog = new MetadataTable<InputLog>("Climate-spinup-input-log.csv");
Climate.FutureInputLog = new MetadataTable<InputLog>("Climate-future-input-log.csv");
Climate.AnnualLog = new MetadataTable<AnnualLog>("Climate-annual-log.csv");
OutputMetadata tblOut_spinupInput = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Spinup-Input-Log",
FilePath = Climate.SpinupInputLog.FilePath,
Visualize = false,
};
tblOut_spinupInput.RetriveFields(typeof(InputLog));
Extension.OutputMetadatas.Add(tblOut_spinupInput);
OutputMetadata tblOut_futureInput = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Future-Input-Log",
FilePath = Climate.FutureInputLog.FilePath,
Visualize = false,
};
tblOut_futureInput.RetriveFields(typeof(InputLog));
Extension.OutputMetadatas.Add(tblOut_futureInput);
OutputMetadata tblOut_annual = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Annual-Log",
FilePath = Climate.AnnualLog.FilePath,
Visualize = false,
};
tblOut_annual.RetriveFields(typeof(AnnualLog));
Extension.OutputMetadatas.Add(tblOut_annual);
//---------------------------------------
// map outputs:
//---------------------------------------
// NONE
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string SpeciesMapFileName, IEnumerable<IModelDefinition> modelDefs, ICore mCore, string LogFileName, string SpeciesLogFileNames)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime//,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(mCore){
Name = PlugIn.PlugInName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
if (LogFileName != null)
{
System.IO.Directory.CreateDirectory(Path.GetDirectoryName(LogFileName));
PlugIn.habitatLog = new MetadataTable<SpeciesHabitatLog>(LogFileName);
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "SppHabitatLog",
FilePath = PlugIn.habitatLog.FilePath,
Visualize = true,
};
tblOut_events.RetriveFields(typeof(SpeciesHabitatLog));
Extension.OutputMetadatas.Add(tblOut_events);
}
if (SpeciesLogFileNames != null)
{
PlugIn.sppLogs = new MetadataTable<IndividualSpeciesHabitatLog>[50];
int selectModelCount = 0;
foreach (ModelDefinition sppModel in modelDefs)
{
string sppLogPath = BirdHabitat.SpeciesLogFileNames.ReplaceTemplateVars(SpeciesLogFileNames, sppModel.Name);
System.IO.Directory.CreateDirectory(Path.GetDirectoryName(sppLogPath));
PlugIn.sppLogs[selectModelCount] = new MetadataTable<IndividualSpeciesHabitatLog>(sppLogPath);
selectModelCount++;
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = ("SpeciesLog_" + sppModel.Name),
FilePath = sppLogPath,
Visualize = true,
};
tblOut_events.RetriveFields(typeof(IndividualSpeciesHabitatLog));
Extension.OutputMetadatas.Add(tblOut_events);
}
}
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (ModelDefinition sppModel in modelDefs)
{
string sppMapPath = SpeciesMapFileNames.ReplaceTemplateVars(SpeciesMapFileName, sppModel.Name);
OutputMetadata mapOut_Birds = new OutputMetadata()
{
Type = OutputType.Map,
Name = ("Species Habitat Map: " + sppModel.Name),
//sppModel.Name,
FilePath = @sppMapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = "Index of Abundance",
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Birds);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep,
string severityMapFileName,
string srdMapFileName,
string nrdMapFileName,
string logFileName,
IEnumerable<IAgent> manyAgentParameters,
ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
//String outputFolder = OutputPath.ReplaceTemplateVars("", FINISH ME LATER);
//FolderName = System.IO.Directory.GetCurrentDirectory().Split("\\".ToCharArray()).Last(),
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
//ProjectionFilePath = "Projection.?" //How do we get projections???
};
Extension = new ExtensionMetadata(mCore){
Name = PlugIn.ExtensionName,
TimeInterval = Timestep, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
//PlugIn.EventLog = new MetadataTable<EventsLog>(logFileName);
PlugIn.EventLog = new MetadataTable<EventsLog>("bda-log.csv");
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "EventLog",
FilePath = PlugIn.EventLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
//PlugIn.PDSILog = new MetadataTable<PDSI_Log>("PDSI_log.csv");
//OutputMetadata tblOut_PDSI = new OutputMetadata()
//{
// Type = OutputType.Table,
// Name = "PDSILog",
// FilePath = PlugIn.PDSILog.FilePath
//};
//tblOut_events.RetriveFields(typeof(PDSI_Log));
//Extension.OutputMetadatas.Add(tblOut_PDSI);
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (IAgent activeAgent in manyAgentParameters)
{
string mapTypePath = MapNames.ReplaceTemplateVarsMetadata(severityMapFileName, activeAgent.AgentName);
OutputMetadata mapOut_Severity = new OutputMetadata()
{
Type = OutputType.Map,
Name = System.String.Format(activeAgent.AgentName + " Outbreak Severity"),
FilePath = @mapTypePath,
Map_DataType = MapDataType.Ordinal,
Map_Unit = FieldUnits.Severity_Rank,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Severity);
if (srdMapFileName != null)
{
mapTypePath = MapNames.ReplaceTemplateVarsMetadata(srdMapFileName, activeAgent.AgentName);
OutputMetadata mapOut_SRD = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Site Resource Dominance",
FilePath = @mapTypePath,
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.Percentage,
Visualize = false,
};
Extension.OutputMetadatas.Add(mapOut_SRD);
}
if (nrdMapFileName != null)
{
mapTypePath = MapNames.ReplaceTemplateVarsMetadata(nrdMapFileName, activeAgent.AgentName);
OutputMetadata mapOut_NRD = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Neighborhood Resource Dominance",
FilePath = @mapTypePath,
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.Percentage,
Visualize = false,
};
Extension.OutputMetadatas.Add(mapOut_NRD);
}
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string MapFileName, string eventLogName, string summaryLogName)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
//Extension = new ExtensionMetadata()
{
Name = PlugIn.ExtensionName,
TimeInterval = Timestep, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
CreateDirectory(eventLogName);
CreateDirectory(summaryLogName);
PlugIn.eventLog = new MetadataTable<EventsLog>(eventLogName);
PlugIn.summaryLog = new MetadataTable<SummaryLog>(summaryLogName);
//PlugIn.eventLog = new MetadataTable<EventsLog>("Harvest-event-log.csv");
//PlugIn.summaryLog = new MetadataTable<SummaryLog>("Harvest-summary-log.csv");
PlugIn.ModelCore.UI.WriteLine(" Generating event table...");
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "EventLog",
FilePath = PlugIn.eventLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
PlugIn.ModelCore.UI.WriteLine(" Generating summary table...");
OutputMetadata tblOut_summary = new OutputMetadata()
{
Type = OutputType.Table,
Name = "SummaryLog",
FilePath = PlugIn.summaryLog.FilePath,
Visualize = true,
};
tblOut_summary.RetriveFields(typeof(SummaryLog));
Extension.OutputMetadatas.Add(tblOut_summary);
//---------------------------------------
// map outputs:
//---------------------------------------
//OutputMetadata mapOut_BiomassRemoved = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "biomass removed",
// FilePath = @HarvestMapName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.Mg_ha,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_BiomassRemoved);
OutputMetadata mapOut_Prescription = new OutputMetadata()
{
Type = OutputType.Map,
Name = "prescription",
FilePath = @MapFileName,
Map_DataType = MapDataType.Nominal,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Prescription);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, IEnumerable<IMapDefinition> mapDefs, string mapNameTemplate)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(PlugIn.ModelCore){
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
//PlugIn.individualForestTypeLog = new MetadataTable<ForestTypeLog>[50];
//foreach (IMapDefinition map in mapDefs)
//{
// int forestTypesCnt = 0;
// List<IForestType> forestTypes = map.ForestTypes;
// foreach (IForestType ftype in forestTypes)
// {
// string forestTypeLogName = ("output-leaf-biomass-reclass/" + ftype.Name + "-forest-type-log.csv");
// CreateDirectory(forestTypeLogName);
// PlugIn.individualForestTypeLog[forestTypesCnt] = new MetadataTable<ForestTypeLog>(forestTypeLogName);
// OutputMetadata tblOut_events = new OutputMetadata()
// {
// Type = OutputType.Table,
// Name = "ForestTypeCountLog",
// FilePath = PlugIn.individualForestTypeLog[forestTypesCnt].FilePath,
// Visualize = true
// };
// tblOut_events.RetriveFields(typeof(ForestTypeLog));
// Extension.OutputMetadatas.Add(tblOut_events);
// forestTypesCnt++;
// }
// break; // only the first one.
//}
// RMS 03/2016: Added dynamic column names.
PlugIn.individualMapDefLog = new MetadataTable<MapDefLog>[50];
int mapDefCnt = 0;
foreach (IMapDefinition map in mapDefs)
{
int forestTypeCnt = 0;
List<string> forestTypeNames = new List<string>();
foreach (IForestType ftype in map.ForestTypes)
{
forestTypeNames.Add(ftype.Name);
forestTypeCnt++;
}
PlugIn.forestTypeNames[mapDefCnt] = forestTypeNames;
ExtensionMetadata.ColumnNames = PlugIn.forestTypeNames[mapDefCnt];
string forestTypeLogName = ("output-leaf-biomass-reclass/" + map.Name + "-forest-type-log.csv");
CreateDirectory(forestTypeLogName);
PlugIn.individualMapDefLog[mapDefCnt] = new MetadataTable<MapDefLog>(forestTypeLogName);
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "ForestTypeCountLog",
FilePath = PlugIn.individualMapDefLog[mapDefCnt].FilePath,
Visualize = true
};
tblOut_events.RetriveFields(typeof(MapDefLog));
Extension.OutputMetadatas.Add(tblOut_events);
mapDefCnt++;
}
//---------------------------------------
// map outputs:
//---------------------------------------
//PlugIn.ModelCore.UI.WriteLine(" Writing biomass maps ...");
foreach (IMapDefinition map in mapDefs)
{
string mapTypePath = MapFileNames.ReplaceTemplateVarsMetadata(mapNameTemplate, map.Name);
OutputMetadata mapOut_ForestType = new OutputMetadata()
{
Type = OutputType.Map,
Name = (map.Name + " Forest Type Map"),
FilePath = @mapTypePath,
Map_DataType = MapDataType.Nominal,
Visualize = true//,
};
Extension.OutputMetadatas.Add(mapOut_ForestType);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int timestep, ICore mCore,
string SoilCarbonMapNames,
string SoilNitrogenMapNames,
string ANPPMapNames,
string ANEEMapNames,
string TotalCMapNames)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(mCore){
Name = "NECN-Succession",
TimeInterval = timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
Outputs.primaryLog = new MetadataTable<PrimaryLog>("NECN-succession-log.csv");
Outputs.primaryLogShort = new MetadataTable<PrimaryLogShort>("NECN-succession-log-short.csv");
Outputs.monthlyLog = new MetadataTable<MonthlyLog>("NECN-succession-monthly-log.csv");
OutputMetadata tblOut_monthly = new OutputMetadata()
{
Type = OutputType.Table,
Name = "MonthlyLog",
FilePath = Outputs.monthlyLog.FilePath,
Visualize = true,
};
tblOut_monthly.RetriveFields(typeof(MonthlyLog));
Extension.OutputMetadatas.Add(tblOut_monthly);
OutputMetadata tblOut_primary = new OutputMetadata()
{
Type = OutputType.Table,
Name = "PrimaryLog",
FilePath = Outputs.primaryLog.FilePath,
Visualize = false,
};
tblOut_primary.RetriveFields(typeof(PrimaryLog));
Extension.OutputMetadatas.Add(tblOut_primary);
OutputMetadata tblOut_primaryShort = new OutputMetadata()
{
Type = OutputType.Table,
Name = "PrimaryLogShort",
FilePath = Outputs.primaryLogShort.FilePath,
Visualize = true,
};
tblOut_primaryShort.RetriveFields(typeof(PrimaryLogShort));
Extension.OutputMetadatas.Add(tblOut_primaryShort);
//---------------------------------------
// map outputs:
//---------------------------------------
if (ANPPMapNames != null)
{
OutputMetadata mapOut_ANPP = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Aboveground Net Primary Production",
FilePath = @"NECN\AG_NPP-{timestep}.gis", //century
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_ANPP);
}
if (ANEEMapNames != null)
{
OutputMetadata mapOut_Nee = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Net Ecosystem Exchange",
FilePath = @"NECN\NEE-{timestep}.gis", //century
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Nee);
}
if (SoilCarbonMapNames != null)
{
OutputMetadata mapOut_SOC = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Soil Organic Carbon",
FilePath = @"NECN\SOC-{timestep}.gis", //century
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_SOC);
}
if (SoilNitrogenMapNames != null)
{
OutputMetadata mapOut_SON = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Soil Organic Nitrogen",
FilePath = @"NECN\SON-{timestep}.gis", //century
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_N_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_SON);
}
if (TotalCMapNames != null)
{
OutputMetadata mapOut_TotalC = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Total Carbon",
FilePath = @"NECN\TotalC-{timestep}.gis", //century
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_TotalC);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep,
string MapFileName,
string logFileName,
IEnumerable<IInsect> insects,
ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(mCore){
Name = PlugIn.ExtensionName,
TimeInterval = 1, //Timestep, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
PlugIn.eventLog = new MetadataTable<EventsLog>("insects-log.csv");
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "EventsLog",
FilePath = PlugIn.eventLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (IInsect insect in insects)
{
string mapPath = MapNames.ReplaceTemplateVarsMetadata(MapFileName, insect.Name);
OutputMetadata mapOut_GrowthReduction = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Growth Reduction",
FilePath = @mapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.Percentage,
Visualize = false,
};
Extension.OutputMetadatas.Add(mapOut_GrowthReduction);
mapPath = MapNames.ReplaceTemplateVarsMetadata(MapFileName, ("InitialPatchMap-" + insect.Name));
OutputMetadata mapOut_InitialPatchProb = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Initial Outbreak Probabilities",
FilePath = @mapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.Percentage,
Visualize = false,
};
Extension.OutputMetadatas.Add(mapOut_InitialPatchProb);
mapPath = MapNames.ReplaceTemplateVarsMetadata(MapFileName, ("BiomassRemoved-" + insect.Name));
OutputMetadata mapOut_BiomassRemoved = new OutputMetadata()
{
Type = OutputType.Map,
Name = System.String.Format(insect.Name + " Biomass Mortality"),
FilePath = @mapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.Mg_ha,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_BiomassRemoved);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, IEnumerable<ISpecies> selectedSpecies, string sppMapNames, ICore mCore)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata() {
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime
};
Extension = new ExtensionMetadata(mCore){
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
string sppBiomassLog = ("output-leaf-biomass/spp-biomass-log.csv");
CreateDirectory(sppBiomassLog);
PlugIn.sppBiomassLog = new MetadataTable<SppBiomassLog>(sppBiomassLog);
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "SppBiomassLog",
FilePath = PlugIn.sppBiomassLog.FilePath,
Visualize = true
};
tblOut_events.RetriveFields(typeof(SppBiomassLog));
Extension.OutputMetadatas.Add(tblOut_events);
//PlugIn.individualBiomassLog = new MetadataTable<SppBiomassLog>[50];
//int selectSppCnt = 0;
//foreach (ISpecies species in selectedSpecies)
//{
// string individualBiomassLog = ("output-leaf-biomass/" + species.Name + "-biomass-log.csv");
// CreateDirectory(individualBiomassLog);
// PlugIn.individualBiomassLog[selectSppCnt] = new MetadataTable<SppBiomassLog>(individualBiomassLog);
// selectSppCnt++;
// tblOut_events = new OutputMetadata()
// {
// Type = OutputType.Table,
// Name = (species.Name + "BiomassLog"),
// FilePath = PlugIn.sppBiomassLog.FilePath,
// Visualize = false
// };
// tblOut_events.RetriveFields(typeof(SppBiomassLog));
// Extension.OutputMetadatas.Add(tblOut_events);
//}
//int selectSppCnt = 0;
//PlugIn.sppBiomassLogLandscape = new MetadataTable<SppBiomassLogLandscape>;
//foreach (ISpecies species in selectedSpecies)
//{
string sppBiomassLogLandscape = ("output-leaf-biomass/biomass-log-landscape.csv");
CreateDirectory(sppBiomassLogLandscape);
PlugIn.sppBiomassLogLandscape = new MetadataTable<SppBiomassLogLandscape>(sppBiomassLogLandscape);
//selectSppCnt++;
tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = ("BiomassLogLandscape"),
FilePath = PlugIn.sppBiomassLogLandscape.FilePath,
Visualize = true
};
tblOut_events.RetriveFields(typeof(SppBiomassLogLandscape));
Extension.OutputMetadatas.Add(tblOut_events);
//}
//---------------------------------------
// map outputs:
//---------------------------------------
if (PlugIn.MakeMaps)
{
foreach (ISpecies species in selectedSpecies)
{
string sppMapPath = MapNames.ReplaceTemplateVars(sppMapNames, species.Name);
OutputMetadata mapOut_SppBiomass = new OutputMetadata()
{
Type = OutputType.Map,
Name = ("Species Biomass Map: " + species.Name),
FilePath = @sppMapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_B_m2,
Visualize = true
};
Extension.OutputMetadatas.Add(mapOut_SppBiomass);
}
}
string totalBioMapPath = MapNames.ReplaceTemplateVars(sppMapNames, "TotalBiomass");
OutputMetadata mapOut_TotalBiomass = new OutputMetadata()
{
Type = OutputType.Map,
Name = ("Total Biomass Map"),
FilePath = @totalBioMapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_B_m2,
Visualize = true
};
Extension.OutputMetadatas.Add(mapOut_TotalBiomass);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}