public static void InitializeMetadata(int Timestep, string eventLogName)
{
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,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
CreateDirectory(eventLogName);
PlugIn.eventsLog = new MetadataTable <EventsLog>(eventLogName);
//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.eventsLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
//---------------------------------------
// 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);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string MapFileName, 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.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(LogFileName));
PlugIn.eventLog = new MetadataTable <EventsLog>(LogFileName);
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, 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, 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(string speciesNameTemplate, IEnumerable <ISpecies> selectedSpecies)
{
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 = PlugIn.ModelCore.CurrentTime,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (ISpecies species in selectedSpecies)
{
OutputMetadata mapOut_max = new OutputMetadata()
{
Type = OutputType.Map,
Name = "max_age_" + species.Name,
FilePath = MapNameTemplates.ReplaceTemplateVars(speciesNameTemplate, species.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_max);
}
OutputMetadata mapOut_max_all = new OutputMetadata()
{
Type = OutputType.Map,
Name = "AllSppMaxAge",
FilePath = MapNameTemplates.ReplaceTemplateVars(speciesNameTemplate, "AllSppMaxAge", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_max_all);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep)
{
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
};
//---------------------------------------
// 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);
foreach (ISpecies species in PlugIn.speciesToMap)
{
foreach (AgeClass age in PlugIn.ages[species.Name])
{
OutputMetadata mapOut_Species = new OutputMetadata()
{
Type = OutputType.Map,
Name = species.Name,
FilePath = PlugIn.MakeSpeciesMapName(species.Name, age.Name),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Species);
}
}
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(string MapFileTemplate, IEnumerable <IMapDefinition> maps)
{
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 = PlugIn.ModelCore.CurrentTime, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// 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);
foreach (IMapDefinition map in maps)
{
OutputMetadata mapOut_bioReclass = new OutputMetadata()
{
Type = OutputType.Map,
Name = map.Name,
FilePath = MapFileNames.ReplaceTemplateVars(MapFileTemplate, map.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_bioReclass);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(int Timestep, string SpeciesMapFileName, IEnumerable <ISuitabilityParameters> suitabilityParams, 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:
//---------------------------------------
// NONE
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (SuitabilityParameters habitatModel in suitabilityParams)
{
string sppMapPath = MapFileNames.ReplaceTemplateVars(SpeciesMapFileName, habitatModel.HabitatName);
OutputMetadata mapOut_LocalHabitat = new OutputMetadata()
{
Type = OutputType.Map,
Name = ("Local Habitat Map: " + habitatModel.HabitatName),
//sppModel.Name,
FilePath = @sppMapPath,
Map_DataType = MapDataType.Continuous,
Map_Unit = "Habitat Class",
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_LocalHabitat);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
private void describe_()
{
context["given the start command"] = () =>
{
OutputMetadata metaData = null;
before = () => metaData = new OutputMetadata()
{
ExecutionMetadata = new ExecutionMetadata()
{
StartCommand = "foo",
}
};
context["and some arguments"] = () =>
{
before =
() =>
metaData.ExecutionMetadata.StartCommandArgs = new string[] {"bar", "baz"};
it["sets the detected start command"] = () =>
{
metaData.DetectedStartCommand.Web.should_be("foo bar baz");
};
it["returns execution_metadata as json string"] = () =>
{
metaData.execution_metadata.should_be("{\"start_command\":\"foo\",\"start_command_args\":[\"bar\",\"baz\"]}");
};
};
context["and no arguments"] = () =>
{
it["sets the detected start command"] = () =>
{
metaData.DetectedStartCommand.Web.should_be("foo");
};
it["returns execution_metadata as json string"] = () =>
{
metaData.execution_metadata.should_be("{\"start_command\":\"foo\",\"start_command_args\":[]}");
};
};
};
}
public static void InitializeMetadata()
{
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 = PlugIn.Parameters.Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// Table output:
//---------------------------------------
CreateDirectory("Forest Roads Construction Log.csv");
PlugIn.roadConstructionLog = new MetadataTable <RoadLog>("Forest Roads Construction Log.csv");
PlugIn.ModelCore.UI.WriteLine(" Generating event table...");
OutputMetadata tblOut_constructionLog = new OutputMetadata()
{
Type = OutputType.Table,
Name = "Forest Roads Construction Log.csv",
FilePath = "./",
Visualize = true,
};
tblOut_constructionLog.RetriveFields(typeof(RoadLog));
Extension.OutputMetadatas.Add(tblOut_constructionLog);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
private void describe_()
{
context["given the start command"] = () =>
{
OutputMetadata outputMetadata = null;
before = () =>
{
outputMetadata = new OutputMetadata()
{
ExecutionMetadata = new ExecutionMetadata()
{
StartCommand = "foo",
StartCommandArgs = new string[] {},
}
};
};
context["and some arguments"] = () =>
{
before =
() =>
outputMetadata.ExecutionMetadata.StartCommandArgs = new string[]
{
"bar", "baz"
};
it["sets the detected start command"] = () =>
{
outputMetadata.ProcessTypes.Web.should_be("foo bar baz");
};
};
context["and no arguments"] = () =>
{
it["sets the detected start command"] = () =>
{
outputMetadata.ProcessTypes.Web.should_be("foo");
};
};
};
}
private void describe_()
{
context["given the start command"] = () =>
{
OutputMetadata outputMetadata = null;
before = () =>
{
outputMetadata = new OutputMetadata()
{
ExecutionMetadata = new ExecutionMetadata() {
StartCommand = "foo",
StartCommandArgs = new string[] {},
}
};
};
context["and some arguments"] = () =>
{
before =
() =>
outputMetadata.ExecutionMetadata.StartCommandArgs = new string[]
{
"bar", "baz"
};
it["sets the detected start command"] = () =>
{
outputMetadata.ProcessTypes.Web.should_be("foo bar baz");
};
};
context["and no arguments"] = () =>
{
it["sets the detected start command"] = () =>
{
outputMetadata.ProcessTypes.Web.should_be("foo");
};
};
};
}
public static void InitializeMetadata(int Timestep, string summaryLogName, bool makeTable)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = EcoregionData.ModelCore.CellArea,
TimeMin = EcoregionData.ModelCore.StartTime,
TimeMax = EcoregionData.ModelCore.EndTime,
};
Extension = new ExtensionMetadata(EcoregionData.ModelCore)
{
Name = Names.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
if (makeTable)
{
CreateDirectory(summaryLogName);
SiteVars.summaryLogMortality = new MetadataTable <SummaryLogMortality>(summaryLogName);
EcoregionData.ModelCore.UI.WriteLine(" Generating summary table...");
OutputMetadata tblOut_summary = new OutputMetadata()
{
Type = OutputType.Table,
Name = "SummaryLog",
FilePath = SiteVars.summaryLogMortality.FilePath,
Visualize = true,
};
tblOut_summary.RetriveFields(typeof(SummaryLogMortality));
Extension.OutputMetadatas.Add(tblOut_summary);
}
}
public static void InitializeMetadata(string summaryLogFileName)
{
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 = PlugIn.ModelCore.CurrentTime, //change this to PlugIn.TimeStep for other extensions
ScenarioReplicationMetadata = scenRep
};
CreateDirectory(summaryLogFileName);
PlugIn.summaryLog = new MetadataTable <SummaryLog>(summaryLogFileName);
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);
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
static ShaderGraphVfxAsset GenerateVfxShaderGraphAsset(VfxMasterNode masterNode)
{
var nl = Environment.NewLine;
var indent = new string(' ', 4);
var asset = ScriptableObject.CreateInstance <ShaderGraphVfxAsset>();
var result = asset.compilationResult = new GraphCompilationResult();
var mode = GenerationMode.ForReals;
var graph = masterNode.owner;
asset.lit = masterNode.lit.isOn;
asset.alphaClipping = masterNode.alphaTest.isOn;
var assetGuid = masterNode.owner.assetGuid;
var assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
var hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
var ports = new List <MaterialSlot>();
masterNode.GetInputSlots(ports);
var nodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(nodes, masterNode);
var bodySb = new ShaderStringBuilder(1);
var registry = new FunctionRegistry(new ShaderStringBuilder(), true);
foreach (var properties in graph.properties)
{
properties.ValidateConcretePrecision(graph.concretePrecision);
}
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode bodyGenerator)
{
bodySb.currentNode = node;
bodyGenerator.GenerateNodeCode(bodySb, mode);
bodySb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
if (node is IGeneratesFunction generatesFunction)
{
registry.builder.currentNode = node;
generatesFunction.GenerateNodeFunction(registry, mode);
}
}
bodySb.currentNode = null;
var portNodeSets = new HashSet <AbstractMaterialNode> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
var nodeSet = new HashSet <AbstractMaterialNode>();
NodeUtils.CollectNodeSet(nodeSet, port);
portNodeSets[portIndex] = nodeSet;
}
var portPropertySets = new HashSet <Guid> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertySets[portIndex] = new HashSet <Guid>();
}
foreach (var node in nodes)
{
if (!(node is PropertyNode propertyNode))
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(node))
{
portPropertySets[portIndex].Add(propertyNode.propertyGuid);
}
}
}
var shaderProperties = new PropertyCollector();
foreach (var node in nodes)
{
node.CollectShaderProperties(shaderProperties, GenerationMode.ForReals);
}
asset.SetTextureInfos(shaderProperties.GetConfiguredTexutres());
var codeSnippets = new List <string>();
var portCodeIndices = new List <int> [ports.Count];
var sharedCodeIndices = new List <int>();
for (var i = 0; i < portCodeIndices.Length; i++)
{
portCodeIndices[i] = new List <int>();
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"#include \"Assets/Scripts/URP/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl\"{nl}");
for (var registryIndex = 0; registryIndex < registry.names.Count; registryIndex++)
{
var name = registry.names[registryIndex];
var source = registry.sources[name];
var precision = source.nodes.First().concretePrecision;
var hasPrecisionMismatch = false;
var nodeNames = new HashSet <string>();
foreach (var node in source.nodes)
{
nodeNames.Add(node.name);
if (node.concretePrecision != precision)
{
hasPrecisionMismatch = true;
break;
}
}
if (hasPrecisionMismatch)
{
var message = new StringBuilder($"Precision mismatch for function {name}:");
foreach (var node in source.nodes)
{
message.AppendLine($"{node.name} ({node.guid}): {node.concretePrecision}");
}
throw new InvalidOperationException(message.ToString());
}
var code = source.code.Replace(PrecisionUtil.Token, precision.ToShaderString());
code = $"// Node: {string.Join(", ", nodeNames)}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code + nl);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
foreach (var node in source.nodes)
{
if (portNodeSet.Contains(node))
{
portCodeIndices[portIndex].Add(codeIndex);
break;
}
}
}
}
foreach (var property in graph.properties)
{
if (property.isExposable && property.generatePropertyBlock)
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.guid))
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
}
codeSnippets.Add($"// Property: {property.displayName}{nl}{property.GetPropertyDeclarationString()}{nl}{nl}");
}
var inputStructName = $"SG_Input_{assetGuid}";
var outputStructName = $"SG_Output_{assetGuid}";
var evaluationFunctionName = $"SG_Evaluate_{assetGuid}";
#region Input Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {inputStructName}{nl}{{{nl}");
#region Requirements
var portRequirements = new ShaderGraphRequirements[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portRequirements[portIndex] = ShaderGraphRequirements.FromNodes(portNodeSets[portIndex].ToList(), ports[portIndex].stageCapability);
}
var portIndices = new List <int>();
portIndices.Capacity = ports.Count;
void AddRequirementsSnippet(Func <ShaderGraphRequirements, bool> predicate, string snippet)
{
portIndices.Clear();
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
if (predicate(portRequirements[portIndex]))
{
portIndices.Add(portIndex);
}
}
if (portIndices.Count > 0)
{
foreach (var portIndex in portIndices)
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
codeSnippets.Add($"{indent}{snippet};{nl}");
}
}
void AddCoordinateSpaceSnippets(InterpolatorType interpolatorType, Func <ShaderGraphRequirements, NeededCoordinateSpace> selector)
{
foreach (var space in EnumInfo <CoordinateSpace> .values)
{
var neededSpace = space.ToNeededCoordinateSpace();
AddRequirementsSnippet(r => (selector(r) & neededSpace) > 0, $"float3 {space.ToVariableName(interpolatorType)}");
}
}
// TODO: Rework requirements system to make this better
AddCoordinateSpaceSnippets(InterpolatorType.Normal, r => r.requiresNormal);
AddCoordinateSpaceSnippets(InterpolatorType.Tangent, r => r.requiresTangent);
AddCoordinateSpaceSnippets(InterpolatorType.BiTangent, r => r.requiresBitangent);
AddCoordinateSpaceSnippets(InterpolatorType.ViewDirection, r => r.requiresViewDir);
AddCoordinateSpaceSnippets(InterpolatorType.Position, r => r.requiresPosition);
AddRequirementsSnippet(r => r.requiresVertexColor, $"float4 {ShaderGeneratorNames.VertexColor}");
AddRequirementsSnippet(r => r.requiresScreenPosition, $"float4 {ShaderGeneratorNames.ScreenPosition}");
AddRequirementsSnippet(r => r.requiresFaceSign, $"float4 {ShaderGeneratorNames.FaceSign}");
foreach (var uvChannel in EnumInfo <UVChannel> .values)
{
AddRequirementsSnippet(r => r.requiresMeshUVs.Contains(uvChannel), $"half4 {uvChannel.GetUVName()}");
}
AddRequirementsSnippet(r => r.requiresTime, $"float3 {ShaderGeneratorNames.TimeParameters}");
#endregion
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"}};{nl}{nl}");
#endregion
#region Output Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {outputStructName}{nl}{{");
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}{port.concreteValueType.ToShaderString(graph.concretePrecision)} {port.shaderOutputName}_{port.id};");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}}};{nl}{nl}");
#endregion
#region Graph Function
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{outputStructName} {evaluationFunctionName}({nl}{indent}{inputStructName} IN");
var inputProperties = new List <AbstractShaderProperty>();
var portPropertyIndices = new List <int> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertyIndices[portIndex] = new List <int>();
}
foreach (var property in graph.properties)
{
if (!property.isExposable || !property.generatePropertyBlock)
{
continue;
}
var propertyIndex = inputProperties.Count;
var codeIndex = codeSnippets.Count;
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.guid))
{
portCodeIndices[portIndex].Add(codeIndex);
portPropertyIndices[portIndex].Add(propertyIndex);
}
}
inputProperties.Add(property);
codeSnippets.Add($",{nl}{indent}/* Property: {property.displayName} */ {property.GetPropertyAsArgumentString()}");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"){nl}{{");
#region Node Code
for (var mappingIndex = 0; mappingIndex < bodySb.mappings.Count; mappingIndex++)
{
var mapping = bodySb.mappings[mappingIndex];
var code = bodySb.ToString(mapping.startIndex, mapping.count);
if (string.IsNullOrWhiteSpace(code))
{
continue;
}
code = $"{nl}{indent}// Node: {mapping.node.name}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(mapping.node))
{
portCodeIndices[portIndex].Add(codeIndex);
}
}
}
#endregion
#region Output Mapping
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}// {masterNode.name}{nl}{indent}{outputStructName} OUT;{nl}");
// Output mapping
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{indent}OUT.{port.shaderOutputName}_{port.id} = {masterNode.GetSlotValue(port.id, GenerationMode.ForReals, graph.concretePrecision)};{nl}");
}
#endregion
// Function end
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{indent}return OUT;{nl}}}{nl}");
#endregion
result.codeSnippets = codeSnippets.ToArray();
result.sharedCodeIndices = sharedCodeIndices.ToArray();
result.outputCodeIndices = new IntArray[ports.Count];
for (var i = 0; i < ports.Count; i++)
{
result.outputCodeIndices[i] = portCodeIndices[i].ToArray();
}
var outputMetadatas = new OutputMetadata[ports.Count];
for (int portIndex = 0; portIndex < outputMetadatas.Length; portIndex++)
{
outputMetadatas[portIndex] = new OutputMetadata(portIndex, ports[portIndex].shaderOutputName, ports[portIndex].id);
}
asset.SetOutputs(outputMetadatas);
asset.evaluationFunctionName = evaluationFunctionName;
asset.inputStructName = inputStructName;
asset.outputStructName = outputStructName;
asset.portRequirements = portRequirements;
asset.concretePrecision = graph.concretePrecision;
asset.SetProperties(inputProperties);
asset.outputPropertyIndices = new IntArray[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
asset.outputPropertyIndices[portIndex] = portPropertyIndices[portIndex].ToArray();
}
return(asset);
}
public static void InitializeMetadata(string speciesAgeMap, string siteAgeMap, string siteSpeciesMap, Dictionary <string, IEnumerable <ISpecies> > ageStatSpecies, List <string> siteAgeStats, List <string> siteSppStats)
{
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 = PlugIn.ModelCore.CurrentTime,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// 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);
foreach (KeyValuePair <string, IEnumerable <ISpecies> > sppAgeStatIter in ageStatSpecies)
{
CohortUtils.SpeciesCohortStatDelegate species_stat_func;
switch (sppAgeStatIter.Key)
{
case "MAX":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMaxAge);
break;
case "MIN":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMinAge);
break;
case "MED":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMedianAge);
break;
case "AVG":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetAvgAge);
break;
case "SD":
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetStdDevAge);
break;
default:
//this shouldn't ever occur
System.Console.WriteLine("Unhandled statistic: {0}, using MaxAge Instead", sppAgeStatIter.Key);
species_stat_func = new CohortUtils.SpeciesCohortStatDelegate(CohortUtils.GetMaxAge);
break;
}
foreach (ISpecies species in sppAgeStatIter.Value)
{
OutputMetadata mapOut_age_stats = new OutputMetadata()
{
Type = OutputType.Map,
Name = species.Name + "_age_stats_map",
FilePath = SpeciesMapNames.ReplaceTemplateVars(speciesAgeMap, species.Name, sppAgeStatIter.Key, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_age_stats);
}
}
foreach (string ageStatIter in siteAgeStats)
{
CohortUtils.SiteCohortStatDelegate site_stat_func;
switch (ageStatIter)
{
case "MAX":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMaxAge);
break;
case "MIN":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMinAge);
break;
case "MED":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMedianAge);
break;
case "AVG":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetAvgAge);
break;
case "SD":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetStdDevAge);
break;
case "COUNT":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetCohortCount);
break;
case "RICH":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetAgeRichness);
break;
case "EVEN":
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetAgeEvenness);
break;
default:
System.Console.WriteLine("Unhandled statistic: {0}, using MaxAge Instead", ageStatIter);
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetMaxAge);
break;
}
OutputMetadata mapOut_site_age_stats = new OutputMetadata()
{
Type = OutputType.Map,
Name = ageStatIter + "_age_stats_map",
FilePath = SiteMapNames.ReplaceTemplateVars(siteAgeMap, ageStatIter, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_site_age_stats);
}
foreach (string sppStatIter in siteSppStats)
{
CohortUtils.SiteCohortStatDelegate site_stat_func;
switch (sppStatIter)
{
case "RICH":
//FIXME
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetSppRichness);
break;
//add in richness
default:
System.Console.WriteLine("Unhandled statistic: {0}, using Species Richness Instead", sppStatIter);
site_stat_func = new CohortUtils.SiteCohortStatDelegate(CohortUtils.GetSppRichness);
break;
}
OutputMetadata mapOut_site_species_stats = new OutputMetadata()
{
Type = OutputType.Map,
Name = sppStatIter + "_age_stats_map",
FilePath = SiteMapNames.ReplaceTemplateVars(siteSpeciesMap, sppStatIter, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_site_species_stats);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
/// <summary>
/// Get the ModuleMetadata from a cmdlet assembly.
/// </summary>
/// <param name="assmeblyPath">Path to the cmdlet assembly.</param>
/// <returns>ModuleMetadata containing information about the cmdlets found in the given assembly.</returns>
public ModuleMetadata GetModuleMetadata(string assemblyPath)
{
List <CmdletMetadata> results = new List <CmdletMetadata>();
ModuleMetadata = new ModuleMetadata();
try
{
var assembly = Assembly.LoadFrom(assemblyPath);
foreach (var type in assembly.GetCmdletTypes())
{
var cmdlet = type.GetAttribute <CmdletAttribute>();
var outputs = type.GetAttributes <OutputTypeAttribute>();
var parameters = type.GetParameters();
var cmdletMetadata = new CmdletMetadata
{
VerbName = cmdlet.VerbName,
NounName = cmdlet.NounName,
ConfirmImpact = cmdlet.ConfirmImpact,
SupportsPaging = cmdlet.SupportsPaging,
SupportsShouldProcess = cmdlet.SupportsShouldProcess,
ClassName = type.FullName,
DefaultParameterSetName = cmdlet.DefaultParameterSetName ?? "__AllParameterSets"
};
if (type.HasAttribute <AliasAttribute>())
{
var aliases = type.GetAttributes <AliasAttribute>();
cmdletMetadata.AliasList.AddRange(
aliases.SelectMany(a => a.AliasNames));
}
foreach (var output in outputs)
{
foreach (var outputType in output.Type)
{
var outputMetadata = new OutputMetadata
{
Type = outputType.Type
};
outputMetadata.ParameterSets.AddRange(output.ParameterSetName);
cmdletMetadata.OutputTypes.Add(outputMetadata);
}
}
List <Parameter> globalParameters = new List <Parameter>();
foreach (var parameter in parameters)
{
if (string.Equals(parameter.Name, "Force", StringComparison.OrdinalIgnoreCase) && parameter.PropertyType == typeof(SwitchParameter))
{
cmdletMetadata.HasForceSwitch = true;
}
var parameterData = new Models.ParameterMetadata
{
Type = parameter.PropertyType,
Name = parameter.Name
};
if (parameter.HasAttribute <AliasAttribute>())
{
var aliases = parameter.GetAttributes <AliasAttribute>();
parameterData.AliasList.AddRange(
aliases.SelectMany(a => a.AliasNames));
}
if (parameter.HasAttribute <ValidateSetAttribute>())
{
var validateSet = parameter.GetAttribute <ValidateSetAttribute>();
parameterData.ValidateSet.AddRange(validateSet.ValidValues);
}
if (parameter.HasAttribute <ValidateRangeAttribute>())
{
var validateRange = parameter.GetAttribute <ValidateRangeAttribute>();
parameterData.ValidateRangeMin = Convert.ToInt64(validateRange.MinRange);
parameterData.ValidateRangeMax = Convert.ToInt64(validateRange.MaxRange);
}
parameterData.ValidateNotNullOrEmpty = parameter.HasAttribute <ValidateNotNullOrEmptyAttribute>();
cmdletMetadata.Parameters.Add(parameterData);
foreach (var parameterSet in parameter.GetAttributes <ParameterAttribute>())
{
var parameterSetMetadata = cmdletMetadata.ParameterSets.FirstOrDefault(s => s.Name.Equals(parameterSet.ParameterSetName));
if (parameterSetMetadata == null)
{
parameterSetMetadata = new Models.ParameterSetMetadata()
{
Name = parameterSet.ParameterSetName ?? "__AllParameterSets"
};
}
Parameter param = new Parameter
{
ParameterMetadata = parameterData,
Mandatory = parameterSet.Mandatory,
Position = parameterSet.Position,
ValueFromPipeline = parameterSet.ValueFromPipeline,
ValueFromPipelineByPropertyName = parameterSet.ValueFromPipelineByPropertyName
};
if (parameterSet.ParameterSetName.Equals("__AllParameterSets"))
{
globalParameters.Add(param);
}
parameterSetMetadata.Parameters.Add(param);
if (parameterSetMetadata.Parameters.Count == 1)
{
cmdletMetadata.ParameterSets.Add(parameterSetMetadata);
}
}
}
foreach (var parameterSet in cmdletMetadata.ParameterSets)
{
if (parameterSet.Name.Equals("__AllParameterSets"))
{
continue;
}
foreach (var parameter in globalParameters)
{
var param = parameterSet.Parameters.FirstOrDefault(p => p.ParameterMetadata.Name.Equals(parameter.ParameterMetadata.Name));
if (param == null)
{
parameterSet.Parameters.Add(parameter);
}
}
}
if (!cmdletMetadata.ParameterSets
.Where(p => p.Name.Equals(cmdletMetadata.DefaultParameterSetName, StringComparison.OrdinalIgnoreCase))
.Any())
{
var defaultSet = new Models.ParameterSetMetadata()
{
Name = cmdletMetadata.DefaultParameterSetName
};
cmdletMetadata.ParameterSets.Add(defaultSet);
}
results.Add(cmdletMetadata);
}
}
catch (Exception ex)
{
throw ex;
}
ModuleMetadata.Cmdlets = results;
return(ModuleMetadata);
}
public static void InitializeMetadata(int timestep, ICore mCore,
string SoilCarbonMapNames,
string SoilNitrogenMapNames,
string ANPPMapNames,
string ANEEMapNames,
string TotalCMapNames)
//string LAIMapNames,
//string ShadeClassMapNames)
{
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");
Outputs.reproductionLog = new MetadataTable <ReproductionLog>("NECN-reproduction-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);
OutputMetadata tblOut_repro = new OutputMetadata()
{
Type = OutputType.Table,
Name = "ReproductionLog",
FilePath = Outputs.reproductionLog.FilePath,
Visualize = false,
};
tblOut_repro.RetriveFields(typeof(ReproductionLog));
Extension.OutputMetadatas.Add(tblOut_repro);
//---------------------------------------
// map outputs:
//---------------------------------------
if (ANPPMapNames != null)
{
PlugIn.ModelCore.UI.WriteLine(" ANPP Map Names = \"{0}\" ...", ANPPMapNames);
string[] paths = { @"NECN", "AG_NPP-{timestep}.img" };
OutputMetadata mapOut_ANPP = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Aboveground Net Primary Production",
//FilePath = @"NECN\AG_NPP-{timestep}.img",
FilePath = Path.Combine(paths),
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_ANPP);
}
if (ANEEMapNames != null)
{
string[] paths = { @"NECN", "NEE-{timestep}.img" };
OutputMetadata mapOut_Nee = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Net Ecosystem Exchange",
//FilePath = @"NECN\NEE-{timestep}.img",
FilePath = Path.Combine(paths),
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Nee);
}
if (SoilCarbonMapNames != null)
{
string[] paths = { @"NECN", "SOC-{timestep}.img" };
OutputMetadata mapOut_SOC = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Soil Organic Carbon",
//FilePath = @"NECN\SOC-{timestep}.img",
FilePath = Path.Combine(paths),
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_SOC);
}
if (SoilNitrogenMapNames != null)
{
string[] paths = { @"NECN", "SON-{timestep}.img" };
OutputMetadata mapOut_SON = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Soil Organic Nitrogen",
//FilePath = @"NECN\SON-{timestep}.img",
FilePath = Path.Combine(paths),
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_N_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_SON);
}
if (TotalCMapNames != null)
{
string[] paths = { @"NECN", "TotalC-{timestep}.img" };
OutputMetadata mapOut_TotalC = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Total Carbon",
//FilePath = @"NECN\TotalC-{timestep}.img",
FilePath = Path.Combine(paths),
Map_DataType = MapDataType.Continuous,
Map_Unit = FieldUnits.g_C_m2,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_TotalC);
}
// if (LAImapnames != null) //These are new maps for testing and analysis purposes
// {
// OutputMetadata mapOut_LAI = new OutputMetadata()
// {
// Type = OutputType.Map,
// Name = "LAI",
// FilePath = @"century\LAI-{timestep}.gis", //century
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.g_C_m2, //Not sure
// Visualize = true,
// };
// Extension.OutputMetadatas.Add(mapOut_LAI);
// }
// if (ShadeClassmapnames != null)
// {
// OutputMetadata mapOut_ShadeClass = new OutputMetadata()
// {
// Type = OutputType.Map,
// Name = "ShadeClass",
// FilePath = @"century\ShadeClass-{timestep}.gis", //century
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.g_C_m2, //NOt sure
// Visualize = true,
// };
// Extension.OutputMetadatas.Add(mapOut_LAI);
// }
//---------------------------------------
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 Initialize(int Timestep, string outputMapName)
{
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(summaryLogName);
//PlugIn.summaryLog = new MetadataTable<SummaryLog>(summaryLogName);
//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);
//2 kinds of maps: species and pool maps, maybe multiples of each?
//---------------------------------------
// map outputs:
//---------------------------------------
OutputMetadata mapOut_Community = new OutputMetadata()
{
Type = OutputType.Map,
Name = "biomass removed",
FilePath = MapNames.ReplaceTemplateVars(outputMapName, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
//Map_Unit = FieldUnits.Mg_ha,
//Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Community);
//foreach(ISpecies species in PlugIn.speciesToMap)
//{
// OutputMetadata mapOut_Species = new OutputMetadata()
// {
// Type = OutputType.Map,
// Name = species.Name,
// FilePath = SpeciesMapNames.ReplaceTemplateVars(PlugIn.speciesTemplateToMap,
// species.Name,
// PlugIn.ModelCore.CurrentTime),
// Map_DataType = MapDataType.Continuous,
// Visualize = true,
// //Map_Unit = "categorical",
// };
// Extension.OutputMetadatas.Add(mapOut_Species);
//}
//OutputMetadata mapOut_TotalBiomass = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "TotalBiomass",
// FilePath = SpeciesMapNames.ReplaceTemplateVars(PlugIn.speciesTemplateToMap,
// "TotalBiomass",
// PlugIn.ModelCore.CurrentTime),
// Map_DataType = MapDataType.Continuous,
// Visualize = true,
// //Map_Unit = "categorical",
//};
//Extension.OutputMetadatas.Add(mapOut_TotalBiomass);
//if(PlugIn.poolsToMap == "both" || PlugIn.poolsToMap == "woody")
//{
// OutputMetadata mapOut_WoodyDebris = new OutputMetadata()
// {
// Type = OutputType.Map,
// Name = "WoodyDebrisMap",
// FilePath = PoolMapNames.ReplaceTemplateVars(PlugIn.poolsTemplateToMap,
// "woody",
// PlugIn.ModelCore.CurrentTime),
// Map_DataType = MapDataType.Continuous,
// Visualize = true,
// //Map_Unit = "categorical",
// };
// Extension.OutputMetadatas.Add(mapOut_WoodyDebris);
//}
//if(PlugIn.poolsToMap == "non-woody" || PlugIn.poolsToMap == "both")
//{
// OutputMetadata mapOut_NonWoodyDebris = new OutputMetadata()
// {
// Type = OutputType.Map,
// Name = "NonWoodyDebrisMap",
// FilePath = PoolMapNames.ReplaceTemplateVars(PlugIn.poolsTemplateToMap,
// "non-woody",
// PlugIn.ModelCore.CurrentTime),
// Map_DataType = MapDataType.Continuous,
// Visualize = true,
// //Map_Unit = "categorical",
// };
// Extension.OutputMetadatas.Add(mapOut_NonWoodyDebris);
//}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(string mapNameTemplate, 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 = PlugIn.ModelCore.CurrentTime,
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_fire_severity = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Fire_Severity_Map",
FilePath = MapNames.ReplaceTemplateVars(mapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_fire_severity);
OutputMetadata mapOut_last_fire = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Time_Of_Last_Fire",
FilePath = MapNames.ReplaceTemplateVars("./DFFS-output/TimeOfLastFire-{timestep}.img", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_last_fire);
//---------------------------------------
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 = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime
};
Extension = new ExtensionMetadata(mCore)
{
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
PlugIn.ignitionsLog = new MetadataTable <IgnitionsLog>("scrapple-ignitions-log.csv");
OutputMetadata tblOut_igns = new OutputMetadata()
{
Type = OutputType.Table,
Name = "ClimateFireIgnitionsLog",
FilePath = PlugIn.ignitionsLog.FilePath,
Visualize = false,
};
tblOut_igns.RetriveFields(typeof(IgnitionsLog));
Extension.OutputMetadatas.Add(tblOut_igns);
PlugIn.eventLog = new MetadataTable <EventsLog>("scrapple-events-log.csv");
OutputMetadata tblOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "ClimateFireEventsLog",
FilePath = PlugIn.eventLog.FilePath,
Visualize = false,
};
tblOut_events.RetriveFields(typeof(EventsLog));
Extension.OutputMetadatas.Add(tblOut_events);
PlugIn.summaryLog = new MetadataTable <SummaryLog>("scrapple-summary-log.csv");
OutputMetadata tblSummaryOut_events = new OutputMetadata()
{
Type = OutputType.Table,
Name = "ClimateFireSummaryLog",
FilePath = PlugIn.summaryLog.FilePath,
Visualize = false,
};
tblSummaryOut_events.RetriveFields(typeof(SummaryLog));
Extension.OutputMetadatas.Add(tblSummaryOut_events);
//---------------------------------------
// map outputs:
//---------------------------------------
string intensityMapFileName = "scrapple-intensity.img";
OutputMetadata mapOut_Intensity = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Intensity",
FilePath = @intensityMapFileName,
Map_DataType = MapDataType.Ordinal,
Map_Unit = FieldUnits.Severity_Rank,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Intensity);
//string specialDeadWoodMapFileName = "scrapple-dead-wood.img";
//OutputMetadata mapOut_SpecialDead = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "SpecialDeadWood",
// FilePath = @specialDeadWoodMapFileName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.g_C_m2,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_Intensity);
//OutputMetadata mapOut_Time = new OutputMetadata()
//{
// Type = OutputType.Map,
// Name = "TimeLastFire",
// FilePath = @TimeMapFileName,
// Map_DataType = MapDataType.Continuous,
// Map_Unit = FieldUnits.Year,
// Visualize = true,
//};
//Extension.OutputMetadatas.Add(mapOut_Time);
//---------------------------------------
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 summaryLogName, bool makeTable)
{
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:
//---------------------------------------
if (makeTable)
{
CreateDirectory(summaryLogName);
PlugIn.summaryLog = new MetadataTable <SummaryLog>(summaryLogName);
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);
}
//2 kinds of maps: species and pool maps, maybe multiples of each?
//---------------------------------------
// map outputs:
//---------------------------------------
foreach (ISpecies species in PlugIn.speciesToMap)
{
OutputMetadata mapOut_Species = new OutputMetadata()
{
Type = OutputType.Map,
Name = species.Name,
FilePath = SpeciesMapNames.ReplaceTemplateVars(PlugIn.speciesTemplateToMap,
species.Name,
PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Species);
}
OutputMetadata mapOut_TotalBiomass = new OutputMetadata()
{
Type = OutputType.Map,
Name = "TotalBiomass",
FilePath = SpeciesMapNames.ReplaceTemplateVars(PlugIn.speciesTemplateToMap,
"TotalBiomass",
PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_TotalBiomass);
if (PlugIn.poolsToMap == "both" || PlugIn.poolsToMap == "woody")
{
OutputMetadata mapOut_WoodyDebris = new OutputMetadata()
{
Type = OutputType.Map,
Name = "WoodyDebrisMap",
FilePath = PoolMapNames.ReplaceTemplateVars(PlugIn.poolsTemplateToMap,
"woody",
PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_WoodyDebris);
}
if (PlugIn.poolsToMap == "non-woody" || PlugIn.poolsToMap == "both")
{
OutputMetadata mapOut_NonWoodyDebris = new OutputMetadata()
{
Type = OutputType.Map,
Name = "NonWoodyDebrisMap",
FilePath = PoolMapNames.ReplaceTemplateVars(PlugIn.poolsTemplateToMap,
"non-woody",
PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_NonWoodyDebris);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
public static void InitializeMetadata(string mapNameTemplate, string pctConiferMapNameTemplate, string pctDeadFirMapNameTemplate)
{
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 = PlugIn.ModelCore.CurrentTime,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// map outputs:
//---------------------------------------
OutputMetadata mapOut_fuel = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Fuel_Map",
FilePath = MapNames.ReplaceTemplateVars(mapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_fuel);
OutputMetadata mapOut_pctCon = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Percent_Connifer",
FilePath = MapNames.ReplaceTemplateVars(pctConiferMapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_pctCon);
OutputMetadata mapOut_pctFir = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Percent_Dead_Fir",
FilePath = MapNames.ReplaceTemplateVars(pctDeadFirMapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_pctFir);
//---------------------------------------
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",
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);
}
// TODO: Fix this
static ShaderGraphVfxAsset GenerateVfxShaderGraphAsset(GraphData graph)
{
var target = graph.activeTargets.FirstOrDefault(x => x is VFXTarget) as VFXTarget;
if (target == null)
{
return(null);
}
var nl = Environment.NewLine;
var indent = new string(' ', 4);
var asset = ScriptableObject.CreateInstance <ShaderGraphVfxAsset>();
var result = asset.compilationResult = new GraphCompilationResult();
var mode = GenerationMode.ForReals;
asset.lit = target.lit;
asset.alphaClipping = target.alphaTest;
var assetGuid = graph.assetGuid;
var assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
var hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
var ports = new List <MaterialSlot>();
var nodes = new List <AbstractMaterialNode>();
foreach (var vertexBlock in graph.vertexContext.blocks)
{
vertexBlock.value.GetInputSlots(ports);
NodeUtils.DepthFirstCollectNodesFromNode(nodes, vertexBlock);
}
foreach (var fragmentBlock in graph.fragmentContext.blocks)
{
fragmentBlock.value.GetInputSlots(ports);
NodeUtils.DepthFirstCollectNodesFromNode(nodes, fragmentBlock);
}
//Remove inactive blocks from generation
{
var tmpCtx = new TargetActiveBlockContext(new List <BlockFieldDescriptor>(), null);
target.GetActiveBlocks(ref tmpCtx);
ports.RemoveAll(materialSlot =>
{
return(!tmpCtx.activeBlocks.Any(o => materialSlot.RawDisplayName() == o.displayName));
});
}
var bodySb = new ShaderStringBuilder(1);
var registry = new FunctionRegistry(new ShaderStringBuilder(), true);
foreach (var properties in graph.properties)
{
properties.ValidateConcretePrecision(graph.concretePrecision);
}
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode bodyGenerator)
{
bodySb.currentNode = node;
bodyGenerator.GenerateNodeCode(bodySb, mode);
bodySb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
if (node is IGeneratesFunction generatesFunction)
{
registry.builder.currentNode = node;
generatesFunction.GenerateNodeFunction(registry, mode);
}
}
bodySb.currentNode = null;
var portNodeSets = new HashSet <AbstractMaterialNode> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
var nodeSet = new HashSet <AbstractMaterialNode>();
NodeUtils.CollectNodeSet(nodeSet, port);
portNodeSets[portIndex] = nodeSet;
}
var portPropertySets = new HashSet <string> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertySets[portIndex] = new HashSet <string>();
}
foreach (var node in nodes)
{
if (!(node is PropertyNode propertyNode))
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(node))
{
portPropertySets[portIndex].Add(propertyNode.property.objectId);
}
}
}
var shaderProperties = new PropertyCollector();
foreach (var node in nodes)
{
node.CollectShaderProperties(shaderProperties, GenerationMode.ForReals);
}
asset.SetTextureInfos(shaderProperties.GetConfiguredTexutres());
var codeSnippets = new List <string>();
var portCodeIndices = new List <int> [ports.Count];
var sharedCodeIndices = new List <int>();
for (var i = 0; i < portCodeIndices.Length; i++)
{
portCodeIndices[i] = new List <int>();
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"#include \"Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl\"{nl}");
for (var registryIndex = 0; registryIndex < registry.names.Count; registryIndex++)
{
var name = registry.names[registryIndex];
var source = registry.sources[name];
var precision = source.nodes.First().concretePrecision;
var hasPrecisionMismatch = false;
var nodeNames = new HashSet <string>();
foreach (var node in source.nodes)
{
nodeNames.Add(node.name);
if (node.concretePrecision != precision)
{
hasPrecisionMismatch = true;
break;
}
}
if (hasPrecisionMismatch)
{
var message = new StringBuilder($"Precision mismatch for function {name}:");
foreach (var node in source.nodes)
{
message.AppendLine($"{node.name} ({node.objectId}): {node.concretePrecision}");
}
throw new InvalidOperationException(message.ToString());
}
var code = source.code.Replace(PrecisionUtil.Token, precision.ToShaderString());
code = $"// Node: {string.Join(", ", nodeNames)}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code + nl);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
foreach (var node in source.nodes)
{
if (portNodeSet.Contains(node))
{
portCodeIndices[portIndex].Add(codeIndex);
break;
}
}
}
}
foreach (var property in graph.properties)
{
if (property.isExposable && property.generatePropertyBlock)
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.objectId))
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
}
ShaderStringBuilder builder = new ShaderStringBuilder();
property.ForeachHLSLProperty(h => h.AppendTo(builder));
codeSnippets.Add($"// Property: {property.displayName}{nl}{builder.ToCodeBlock()}{nl}{nl}");
}
var inputStructName = $"SG_Input_{assetGuid}";
var outputStructName = $"SG_Output_{assetGuid}";
var evaluationFunctionName = $"SG_Evaluate_{assetGuid}";
#region Input Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {inputStructName}{nl}{{{nl}");
#region Requirements
var portRequirements = new ShaderGraphRequirements[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var requirementsNodes = portNodeSets[portIndex].ToList();
requirementsNodes.Add(ports[portIndex].owner);
portRequirements[portIndex] = ShaderGraphRequirements.FromNodes(requirementsNodes, ports[portIndex].stageCapability);
}
var portIndices = new List <int>();
portIndices.Capacity = ports.Count;
void AddRequirementsSnippet(Func <ShaderGraphRequirements, bool> predicate, string snippet)
{
portIndices.Clear();
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
if (predicate(portRequirements[portIndex]))
{
portIndices.Add(portIndex);
}
}
if (portIndices.Count > 0)
{
foreach (var portIndex in portIndices)
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
codeSnippets.Add($"{indent}{snippet};{nl}");
}
}
void AddCoordinateSpaceSnippets(InterpolatorType interpolatorType, Func <ShaderGraphRequirements, NeededCoordinateSpace> selector)
{
foreach (var space in EnumInfo <CoordinateSpace> .values)
{
var neededSpace = space.ToNeededCoordinateSpace();
AddRequirementsSnippet(r => (selector(r) & neededSpace) > 0, $"float3 {space.ToVariableName(interpolatorType)}");
}
}
// TODO: Rework requirements system to make this better
AddCoordinateSpaceSnippets(InterpolatorType.Normal, r => r.requiresNormal);
AddCoordinateSpaceSnippets(InterpolatorType.Tangent, r => r.requiresTangent);
AddCoordinateSpaceSnippets(InterpolatorType.BiTangent, r => r.requiresBitangent);
AddCoordinateSpaceSnippets(InterpolatorType.ViewDirection, r => r.requiresViewDir);
AddCoordinateSpaceSnippets(InterpolatorType.Position, r => r.requiresPosition);
AddRequirementsSnippet(r => r.requiresVertexColor, $"float4 {ShaderGeneratorNames.VertexColor}");
AddRequirementsSnippet(r => r.requiresScreenPosition, $"float4 {ShaderGeneratorNames.ScreenPosition}");
AddRequirementsSnippet(r => r.requiresFaceSign, $"float4 {ShaderGeneratorNames.FaceSign}");
foreach (var uvChannel in EnumInfo <UVChannel> .values)
{
AddRequirementsSnippet(r => r.requiresMeshUVs.Contains(uvChannel), $"half4 {uvChannel.GetUVName()}");
}
AddRequirementsSnippet(r => r.requiresTime, $"float3 {ShaderGeneratorNames.TimeParameters}");
#endregion
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"}};{nl}{nl}");
#endregion
// VFX Code heavily relies on the slotId from the original MasterNodes
// Since we keep these around for upgrades anyway, for now it is simpler to use them
// Therefore we remap the output blocks back to the original Ids here
var originialPortIds = new int[ports.Count];
for (int i = 0; i < originialPortIds.Length; i++)
{
if (!VFXTarget.s_BlockMap.TryGetValue((ports[i].owner as BlockNode).descriptor, out var originalId))
{
continue;
}
// In Master Nodes we had a different BaseColor/Color slot id between Unlit/Lit
// In the stack we use BaseColor for both cases. Catch this here.
if (asset.lit && originalId == ShaderGraphVfxAsset.ColorSlotId)
{
originalId = ShaderGraphVfxAsset.BaseColorSlotId;
}
originialPortIds[i] = originalId;
}
#region Output Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {outputStructName}{nl}{{");
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}{port.concreteValueType.ToShaderString(graph.concretePrecision)} {port.shaderOutputName}_{originialPortIds[portIndex]};");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}}};{nl}{nl}");
#endregion
#region Graph Function
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{outputStructName} {evaluationFunctionName}({nl}{indent}{inputStructName} IN");
var inputProperties = new List <AbstractShaderProperty>();
var portPropertyIndices = new List <int> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertyIndices[portIndex] = new List <int>();
}
foreach (var property in graph.properties)
{
if (!property.isExposable || !property.generatePropertyBlock)
{
continue;
}
var propertyIndex = inputProperties.Count;
var codeIndex = codeSnippets.Count;
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.objectId))
{
portCodeIndices[portIndex].Add(codeIndex);
portPropertyIndices[portIndex].Add(propertyIndex);
}
}
inputProperties.Add(property);
codeSnippets.Add($",{nl}{indent}/* Property: {property.displayName} */ {property.GetPropertyAsArgumentString()}");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"){nl}{{");
#region Node Code
for (var mappingIndex = 0; mappingIndex < bodySb.mappings.Count; mappingIndex++)
{
var mapping = bodySb.mappings[mappingIndex];
var code = bodySb.ToString(mapping.startIndex, mapping.count);
if (string.IsNullOrWhiteSpace(code))
{
continue;
}
code = $"{nl}{indent}// Node: {mapping.node.name}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(mapping.node))
{
portCodeIndices[portIndex].Add(codeIndex);
}
}
}
#endregion
#region Output Mapping
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}// VFXMasterNode{nl}{indent}{outputStructName} OUT;{nl}");
// Output mapping
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{indent}OUT.{port.shaderOutputName}_{originialPortIds[portIndex]} = {port.owner.GetSlotValue(port.id, GenerationMode.ForReals, graph.concretePrecision)};{nl}");
}
#endregion
// Function end
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{indent}return OUT;{nl}}}{nl}");
#endregion
result.codeSnippets = codeSnippets.ToArray();
result.sharedCodeIndices = sharedCodeIndices.ToArray();
result.outputCodeIndices = new IntArray[ports.Count];
for (var i = 0; i < ports.Count; i++)
{
result.outputCodeIndices[i] = portCodeIndices[i].ToArray();
}
var outputMetadatas = new OutputMetadata[ports.Count];
for (int portIndex = 0; portIndex < outputMetadatas.Length; portIndex++)
{
outputMetadatas[portIndex] = new OutputMetadata(portIndex, ports[portIndex].shaderOutputName, originialPortIds[portIndex]);
}
asset.SetOutputs(outputMetadatas);
asset.evaluationFunctionName = evaluationFunctionName;
asset.inputStructName = inputStructName;
asset.outputStructName = outputStructName;
asset.portRequirements = portRequirements;
asset.concretePrecision = graph.concretePrecision;
asset.SetProperties(inputProperties);
asset.outputPropertyIndices = new IntArray[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
asset.outputPropertyIndices[portIndex] = portPropertyIndices[portIndex].ToArray();
}
return(asset);
}
public static void InitializeMetadata(int Timestep, string MapFileName)
{
ScenarioReplicationMetadata scenRep = new ScenarioReplicationMetadata()
{
RasterOutCellArea = PlugIn.ModelCore.CellArea,
TimeMin = PlugIn.ModelCore.StartTime,
TimeMax = PlugIn.ModelCore.EndTime //,
//ProjectionFilePath = "Projection.?"
};
Extension = new ExtensionMetadata(PlugIn.ModelCore)
{
Name = PlugIn.ExtensionName,
TimeInterval = Timestep,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
PlugIn.eventLog = new MetadataTable <EventsLog>("wind-events-log.csv");
PlugIn.summaryLog = new MetadataTable <SummaryLog>("wind-summary-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);
PlugIn.ModelCore.UI.WriteLine(" Generating summary table...");
OutputMetadata tblOut_summary = new OutputMetadata()
{
Type = OutputType.Table,
Name = "WindSummaryLog",
FilePath = PlugIn.summaryLog.FilePath,
Visualize = true,
};
tblOut_summary.RetriveFields(typeof(SummaryLog));
Extension.OutputMetadatas.Add(tblOut_summary);
//---------------------------------------
// 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 mapNameTemplate,
string pctConiferMapNameTemplate,
string pctDeadFirMapNameTemplate
)
{
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,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// 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_Fuel = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Fuel Map",
FilePath = MapNames.ReplaceTemplateVars(mapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
};
OutputMetadata mapOut_Confir = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Conifer Map",
FilePath = MapNames.ReplaceTemplateVars(pctConiferMapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
};
OutputMetadata mapOut_Dead = new OutputMetadata()
{
Type = OutputType.Map,
Name = "Dead Fir Map",
FilePath = MapNames.ReplaceTemplateVars(pctDeadFirMapNameTemplate, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
};
Extension.OutputMetadatas.Add(mapOut_Fuel);
Extension.OutputMetadatas.Add(mapOut_Confir);
Extension.OutputMetadatas.Add(mapOut_Dead);
//---------------------------------------
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 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, OutputVariable LAI, OutputVariable Biomass, OutputVariable AbovegroundBiomass, OutputVariable EstablishmentProbability, ISiteVar <Landis.Library.Parameters.Species.AuxParm <bool> > SpeciesWasThere, OutputVariable AnnualPsn, OutputVariable BelowGround, OutputVariable CohortsPerSpc, OutputVariable Water, OutputVariable SubCanopyPAR, OutputVariable NonWoodyDebris, OutputVariable WoodyDebris, OutputVariable AgeDistribution, OutputVariable MonthlyFolResp, OutputVariable MonthlyGrossPsn, OutputVariable MonthlyNetPsn, OutputVariable MonthlyMaintResp, OutputVariable SpeciesEstablishment, ISiteVar <Library.Parameters.Species.AuxParm <int> > LastBiom, OutputAggregatedTable overalloutputs, string OutputTableMap)
{
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,
ScenarioReplicationMetadata = scenRep
};
//---------------------------------------
// table outputs:
//---------------------------------------
if (overalloutputs != null)
{
PlugIn.ModelCore.UI.WriteLine(" Generating summary table...");
CreateDirectory(OutputTableMap);
OutputMetadata tblOut_OverallOutputs = new OutputMetadata()
{
Type = OutputType.Table,
Name = Path.GetFileName(OutputTableMap),
FilePath = OutputTableMap,
Map_DataType = MapDataType.Continuous,
Visualize = true,
};
tblOut_OverallOutputs.RetriveFields(typeof(OutputAggregatedTable));
Extension.OutputMetadatas.Add(tblOut_OverallOutputs);
}
//---------------------------------------
// 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);
if (LAI != null)
{
OutputMetadata mapOut_LAI = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(LAI.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(LAI.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_LAI);
}
if (Biomass != null)
{
foreach (ISpecies spc in PlugIn.SelectedSpecies)
{
OutputMetadata mapOut_Biomass = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(Biomass.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(Biomass.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Biomass);
}
}
if (AbovegroundBiomass != null)
{
foreach (ISpecies spc in PlugIn.SelectedSpecies)
{
OutputMetadata mapOut_AbvBiomass = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(AbovegroundBiomass.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(AbovegroundBiomass.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_AbvBiomass);
}
}
if (MonthlyFolResp != null)
{
OutputMetadata mapOut_Monthly = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(MonthlyFolResp.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(MonthlyFolResp.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Monthly);
}
if (MonthlyGrossPsn != null)
{
OutputMetadata mapOut_Monthly = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(MonthlyGrossPsn.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(MonthlyGrossPsn.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Monthly);
}
if (MonthlyNetPsn != null)
{
OutputMetadata mapOut_Monthly = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(MonthlyNetPsn.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(MonthlyNetPsn.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Monthly);
}
if (MonthlyMaintResp != null)
{
OutputMetadata mapOut_Monthly = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(MonthlyMaintResp.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(MonthlyMaintResp.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Monthly);
}
if (BelowGround != null)
{
OutputMetadata mapOut_BelowGround = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(BelowGround.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(BelowGround.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_BelowGround);
}
if (CohortsPerSpc != null)
{
foreach (ISpecies spc in PlugIn.ModelCore.Species)
{
OutputMetadata mapOut_LAI = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(CohortsPerSpc.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(CohortsPerSpc.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_LAI);
}
}
if (EstablishmentProbability != null)
{
foreach (ISpecies spc in PlugIn.SelectedSpecies)
{
OutputMetadata mapOut_EProb = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(EstablishmentProbability.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(EstablishmentProbability.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_EProb);
}
}
if (SpeciesEstablishment != null)
{
if (SpeciesWasThere != null)
{
foreach (ISpecies spc in PlugIn.ModelCore.Species)
{
OutputMetadata mapOut_SpeciesE = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(SpeciesEstablishment.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(SpeciesEstablishment.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_SpeciesE);
}
}
OutputMetadata mapOut_SpeciesE2 = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(SpeciesEstablishment.MapNameTemplate).Replace(".img", ".txt"),
FilePath = FileNames.ReplaceTemplateVars(SpeciesEstablishment.MapNameTemplate).Replace(".img", ".txt"),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_SpeciesE2);
}
if (AnnualPsn != null)
{
if (LastBiom != null)
{
foreach (ISpecies spc in PlugIn.ModelCore.Species)
{
OutputMetadata mapOut_AnnualPsn = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(AnnualPsn.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(AnnualPsn.MapNameTemplate, spc.Name, PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_AnnualPsn);
}
}
}
if (Water != null)
{
OutputMetadata mapOut_Water = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(Water.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(Water.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_Water);
}
if (SubCanopyPAR != null)
{
OutputMetadata mapOut_SubCanopyPAR = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(SubCanopyPAR.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(SubCanopyPAR.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_SubCanopyPAR);
}
if (NonWoodyDebris != null)
{
OutputMetadata mapOut_NonWoodyDebris = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(NonWoodyDebris.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(NonWoodyDebris.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_NonWoodyDebris);
}
if (WoodyDebris != null)
{
OutputMetadata mapOut_WoodyDebris = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(WoodyDebris.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(WoodyDebris.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_WoodyDebris);
}
if (AgeDistribution != null)
{
OutputMetadata mapOut_AgeDistribution = new OutputMetadata()
{
Type = OutputType.Map,
Name = FileNames.ReplaceTemplateVars(AgeDistribution.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
FilePath = FileNames.ReplaceTemplateVars(AgeDistribution.MapNameTemplate, "", PlugIn.ModelCore.CurrentTime),
Map_DataType = MapDataType.Continuous,
Visualize = true,
//Map_Unit = "categorical",
};
Extension.OutputMetadatas.Add(mapOut_AgeDistribution);
}
//---------------------------------------
MetadataProvider mp = new MetadataProvider(Extension);
mp.WriteMetadataToXMLFile("Metadata", Extension.Name, Extension.Name);
}
