public override IOutputExchangeItem GetOutputExchangeItem(int outputExchangeItemIndex)
{
Quantity quantity = new Quantity(new Unit("literprSecond",0.001,0,"lprsec"),"flow","flow", global::OpenMI.Standard.ValueType.Scalar,new Dimension());
ElementSet elementSet = new ElementSet("oo","ID",ElementType.IDBased,new SpatialReference("no"));
Element element = new Element("ElementID");
elementSet.AddElement(element);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.ElementSet = elementSet;
outputExchangeItem.Quantity = quantity;
return outputExchangeItem;
}
public void Init()
{
eventSent = false;
testComponent1 = new TestComponent();
testComponent2 = new TestComponent2();
Link link1 = new Link();
link1.ID ="Link1";
link1.SourceComponent = testComponent1;
link1.TargetComponent = testComponent2;
Link link2 = new Link();
link2.ID ="Link2";
link2.SourceComponent = testComponent2;
link2.TargetComponent = testComponent1;
Link link3 = new Link();
link3.ID = "Link3";
link3.SourceComponent = link3.TargetComponent = testComponent1;
testComponent1.AddLink(link1);
testComponent1.AddLink(link2);
testComponent1.AddLink(link3);
testComponent2.AddLink(link1);
testComponent2.AddLink(link2);
testComponent1.RemoveLink("Link3");
testComponent1.Subscribe(this,EventType.Informative);
Quantity q = new Quantity("Q");
ElementSet elementSet = new ElementSet();
elementSet.ID = "ES";
InputExchangeItem inputExchangeItem = new InputExchangeItem();
inputExchangeItem.Quantity = q;
inputExchangeItem.ElementSet = elementSet;
testComponent1.AddInputExchangeItem(inputExchangeItem);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.Quantity = new Quantity("Q2");
ElementSet elementSet2 = new ElementSet();
elementSet2.ID = "ES2";
outputExchangeItem.ElementSet = elementSet;
testComponent1.AddOutputExchangeItem(outputExchangeItem);
}
public double[] GetValues(OutputExchangeItem output)
{
//IronPython.Runtime.PythonDictionary dict = GetValuesFunc(output.Quantity.ID);
/*double[] values = new double[dict.Count];
int v = 0;
foreach (double value in dict.Values)
{
values[v] = value;
v++;
}*/
//return values;
var list = GetValuesFunc(output.Quantity.ID);
var values = new double[list.Count];
for (var i = 0; i < values.Length; i++)
values[i] = (double)list[i];
return values;
}
//part of System.Collections
public void Initialize(Hashtable properties)
{
_inputExchangeItems = new ArrayList();
_outputExchangeItems = new ArrayList();
_elementSets = new Hashtable();
_elementScopes = new Hashtable();
FilePath = ((string)properties["FilePath"]);
InitializeDaisy((string)properties["FilePath"]);
ModelDescription = ((string)GetDescription());
for (int i = 0; i < _daisyEngine.ScopeSize(); i++)
{
Scope scope = _daisyEngine.GetScope(i);
// Attribut column?
if (!scope.HasString("column"))
continue;
// Create element.
string columnID = scope.String("column");
Element element = new Element (columnID);
_elementScopes[element] = scope;
if (_daisyEngine.HasColumn(columnID))
{
Column column = _daisyEngine.GetColumn(columnID);
for (uint ii = 0; ii < column.LocationSize(); ii++)
{
double x = column.LocationX(ii);
double y = column.LocationY(ii);
double z = 0.0;
element.AddVertex(new Vertex(x, y, z));
}
}
// Add exchange items.
for (uint j = 0; j < scope.NumberSize(); j++)
{
string name = scope.NumberName(j);
ElementSet elementSet;
// Find or create element set.
if (_elementSets.Contains(name))
{
elementSet = (ElementSet)_elementSets[name];
elementSet.Description += " " + columnID;
// TODO: We should test the type matches here.
}
else
{
switch (element.VertexCount)
{
case 0:
// ID based
elementSet = new ElementSet(columnID, name, ElementType.XYPoint, new SpatialReference(""));
break;
case 1:
// Point based
elementSet = new ElementSet(columnID, name, ElementType.XYPoint, new SpatialReference(""));
break;
case 2:
// Error
throw new ApplicationException("Error: Column must not contain exactly two (X Y)-points!");
default:
// Polygon
elementSet = new ElementSet(columnID, name, ElementType.XYPolygon, new SpatialReference(""));
break;
}
_elementSets[name] = elementSet;
string dim = scope.Dimension(name);
string description = scope.Description(name);
Quantity quantity = Quantity(dim, description, name);
if (scope.Writeable())
{
InputExchangeItem input = new InputExchangeItem();
input.Quantity = quantity;
input.ElementSet = elementSet;
_inputExchangeItems.Add(input);
}
else
{
OutputExchangeItem output = new OutputExchangeItem();
output.Quantity = quantity;
output.ElementSet = elementSet;
_outputExchangeItems.Add(output);
}
}
// Add it.
elementSet.AddElement(element);
}
}
}
public double[] GetValues(OutputExchangeItem output)
{
Array r = new double[output.ElementSet.ElementCount];
Array i = new double[output.ElementSet.ElementCount];
matlab.GetFullMatrix(GetValueArrayName(output), "base", ref r, ref i);
return (double[])r;
}
private static List<OutputExchangeItem> readOutputExchangeItems(XmlNode aNode, ILinkableComponent component,
Dictionary<String, IElementSet> elementSets)
{
var items = new List<OutputExchangeItem>();
foreach (XmlNode node in aNode.ChildNodes)
{
if (node.Name == "OutputExchangeItem")
{
var item = new OutputExchangeItem();
// see what the element set id is and lookup the actual
// object and assign it to the exchange item
var elementSetId = Utils.findChildNodeValue(node, "ElementSetID");
item.ElementSet = elementSets[elementSetId];
// make sure we found the element set
if (item.ElementSet == null)
throw new Exception("Failed to find element set");
// read the quantity details
var quantity = readQuantity(Utils.findChildNode(node, "Quantity"));
item.Quantity = quantity;
items.Add(item);
}
}
return items;
}
public void Initialize(System.Collections.Hashtable properties)
{
_dt = 1.0;
_dx = 0.0;
_initialValue = 100;
if (properties.ContainsKey("modelID"))
{
_modelID = (string) properties["ModelID"];
}
if (properties.ContainsKey("dt"))
{
_dt = (double) properties["dt"];
}
if (properties.ContainsKey("dx"))
{
_dx = (double) properties["dx"];
}
_values = new double[3];
for (int i = 0; i < _values.Length; i++)
{
_values[i] = _initialValue;
}
_startTime = 4000;
_currentTime = _startTime;
Element element = new Element("ElementID");
ElementSet elementSet = new ElementSet("Description","ID",ElementType.IDBased,new SpatialReference(" no "));
elementSet.AddElement(element);
Quantity quantity = new Quantity(new Unit("Flow",1,0,"flow"),"Flow","ID",global::OpenMI.Standard.ValueType.Scalar,new Dimension());
_outputExchangeItem = new OutputExchangeItem();
_inputExchangeItem = new InputExchangeItem();
_outputExchangeItem.Quantity = quantity;
_outputExchangeItem.ElementSet = elementSet;
_inputExchangeItem.Quantity = quantity;
_inputExchangeItem.ElementSet = elementSet;
}
public void Initialize(System.Collections.Hashtable properties)
{
getValuesWatch = new Stopwatch();
setValuesWatch = new Stopwatch();
performStepWatch = new Stopwatch();
//List of exchange Items
inputExchangeItems = new List<InputExchangeItem>();
outputExchangeItems = new List<OutputExchangeItem>();
//Initializes Engine
mohidLandEngine = new MohidLandEngineDotNetAccess();
mohidLandEngine.Initialize(properties["FilePath"].ToString());
//
//Dimensions
//
Dimension dimFlow = new Dimension();
dimFlow.SetPower(DimensionBase.Length, 3);
dimFlow.SetPower(DimensionBase.Time, -1);
Dimension dimWaterlevel = new Dimension();
dimWaterlevel.SetPower(DimensionBase.Length, 1);
Dimension dimWaterColumn = new Dimension();
dimWaterColumn.SetPower(DimensionBase.Length, 1);
Dimension dimConcentration = new Dimension();
dimConcentration.SetPower(DimensionBase.Mass, 1);
dimConcentration.SetPower(DimensionBase.Length, -3);
//
//Units
//
Unit unitFlow = new Unit("m3/sec", 1, 0, "cubic meter per second");
Unit unitWaterLevel = new Unit("m", 1, 0, "meters above mean sea level");
Unit unitWaterColumn = new Unit("m", 1, 0, "meters above ground");
Unit unitConcentration = new Unit("mg/l", 1, 0, "miligram per liter");
//
//Quantities
//
qtdOutflow = new Quantity(unitFlow, "Flow discharge at the outlet", "Outlet Flow", ValueType.Scalar, dimFlow);
qtdOutletLevel = new Quantity(unitWaterLevel, "Waterlevel at the outlet", "OutletLevel",
ValueType.Scalar, dimWaterlevel);
qtdWaterColumn = new Quantity(unitWaterColumn, "Ponded Water Column", "WaterColumn",
ValueType.Scalar, dimWaterColumn);
qtdDischarges = new Quantity(unitFlow, "Distributed discharges (sewer sinks)", "Discharges", ValueType.Scalar,
dimFlow);
qtdFlowToStorm = new Quantity(unitFlow, "Flow from the network to the storm water system (inlets)",
"Storm Water Out Flow", ValueType.Scalar, dimFlow);
qtdFlowFromStrom = new Quantity(unitFlow, "Flow from the storm water system to the network (discharges)",
"Storm Water In Flow", ValueType.Scalar, dimFlow);
//
//Spatial Reference
//
SpatialReference spatialReference = new SpatialReference("spatial reference");
//
//Element Sets
//
//Model Grid
ElementSet modelGrid = new ElementSet("Model Grid Points of all Compute Points", "Model Grid",
ElementType.XYPolygon, spatialReference);
//Output exchange items - properties in each grid cell (surface only)
numberOfWaterPoints = 0;
for (int j = 1; j <= mohidLandEngine.GetJUB(horizontalGridInstanceID); j++)
{
for (int i = 1; i <= mohidLandEngine.GetIUB(horizontalGridInstanceID); i++)
{
if (mohidLandEngine.IsWaterPoint(horizontalMapInstanceID, i, j))
{
String name = "i=" + i.ToString() + "/j=" + j.ToString();
double[] xCoords = new double[5];
double[] yCoords = new double[5];
mohidLandEngine.GetGridCellCoordinates(horizontalGridInstanceID, i, j, ref xCoords, ref yCoords);
Element element = new Element(name);
element.AddVertex(new Vertex(xCoords[0], yCoords[0], 0));
element.AddVertex(new Vertex(xCoords[1], yCoords[1], 0));
element.AddVertex(new Vertex(xCoords[2], yCoords[2], 0));
element.AddVertex(new Vertex(xCoords[3], yCoords[3], 0));
modelGrid.AddElement(element);
numberOfWaterPoints++;
}
}
}
//Outlet Node
ElementSet outletNode = new ElementSet("Outlet node", "Outlet", ElementType.XYPoint, spatialReference);
Element outletElement = new Element("Outlet");
int outletNodeID = mohidLandEngine.GetOutletNodeID(drainageNetworkInstanceID);
outletElement.AddVertex(new Vertex(mohidLandEngine.GetXCoordinate(drainageNetworkInstanceID, outletNodeID),
mohidLandEngine.GetYCoordinate(drainageNetworkInstanceID, outletNodeID),
0));
outletNode.AddElement(outletElement);
//Outflow to Storm Water Model
ElementSet stormWaterOutflowNodes = new ElementSet("Nodes which provide flow to the Storm Water System",
"Storm Water Inlets", ElementType.XYPoint, spatialReference);
int numberOfOutflowNodes = mohidLandEngine.GetNumberOfStormWaterOutFlowNodes(drainageNetworkInstanceID);
int[] outflowNodeIDs = new int[numberOfOutflowNodes];
mohidLandEngine.GetStormWaterOutflowIDs(drainageNetworkInstanceID, numberOfOutflowNodes, ref outflowNodeIDs);
for (int i = 1; i <= numberOfOutflowNodes; i++)
{
int nodeID = outflowNodeIDs[i - 1];
Element element = new Element(nodeID.ToString());
element.AddVertex(new Vertex(mohidLandEngine.GetXCoordinate(drainageNetworkInstanceID, nodeID),
mohidLandEngine.GetYCoordinate(drainageNetworkInstanceID, nodeID),
0));
stormWaterOutflowNodes.AddElement(element);
}
//Inflow from Storm Water Model
ElementSet stormWaterInflowNodes = new ElementSet("Nodes which receive flow to the Storm Water System",
"Storm Water Outlets", ElementType.XYPoint, spatialReference);
int numberOfInflowNodes = mohidLandEngine.GetNumberOfStormWaterInFlowNodes(drainageNetworkInstanceID);
if (numberOfInflowNodes > 0)
{
int[] inflowNodeIDs = new int[numberOfInflowNodes];
mohidLandEngine.GetStormWaterInflowIDs(drainageNetworkInstanceID, numberOfOutflowNodes,
ref inflowNodeIDs);
for (int i = 1; i <= numberOfInflowNodes; i++)
{
int nodeID = inflowNodeIDs[i - 1];
Element element = new Element(nodeID.ToString());
element.AddVertex(new Vertex(mohidLandEngine.GetXCoordinate(drainageNetworkInstanceID, nodeID),
mohidLandEngine.GetYCoordinate(drainageNetworkInstanceID, nodeID),
0));
stormWaterInflowNodes.AddElement(element);
}
}
//
//Output Exchange Items
//
//Flow at the outlet
OutputExchangeItem outletFlow = new OutputExchangeItem();
outletFlow.Quantity = qtdOutflow;
outletFlow.ElementSet = outletNode;
outputExchangeItems.Add(outletFlow);
//Overland water column
OutputExchangeItem overlandWaterColumn = new OutputExchangeItem();
overlandWaterColumn.Quantity = qtdWaterColumn;
overlandWaterColumn.ElementSet = modelGrid;
outputExchangeItems.Add(overlandWaterColumn);
//Flow to the Storm Water Model
if (stormWaterOutflowNodes.ElementCount > 0)
{
OutputExchangeItem stormWaterOutFlow = new OutputExchangeItem();
stormWaterOutFlow.Quantity = qtdFlowToStorm;
stormWaterOutFlow.ElementSet = stormWaterOutflowNodes;
outputExchangeItems.Add(stormWaterOutFlow);
}
//
//Input Exchange Items
//
//Water level at the outlet
InputExchangeItem outletLevel = new InputExchangeItem();
outletLevel.Quantity = qtdOutletLevel;
outletLevel.ElementSet = outletNode;
inputExchangeItems.Add(outletLevel);
//Distributed discharges
InputExchangeItem dischargeInflow = new InputExchangeItem();
dischargeInflow.Quantity = qtdDischarges;
dischargeInflow.ElementSet = modelGrid;
inputExchangeItems.Add(dischargeInflow);
//Flow from the Storm Water Model
if (stormWaterInflowNodes.ElementCount > 0)
{
InputExchangeItem stormWaterInFlow = new InputExchangeItem();
stormWaterInFlow.Quantity = qtdFlowFromStrom;
stormWaterInFlow.ElementSet = stormWaterInflowNodes;
inputExchangeItems.Add(stormWaterInFlow);
}
//
//Properties
//
//Properties input / output exchange items
for (int i = 1; i <= mohidLandEngine.GetNumberOfProperties(drainageNetworkInstanceID); i++)
{
int propertyIDNumber = mohidLandEngine.GetPropertyIDNumber(drainageNetworkInstanceID, i);
string propertyName = mohidLandEngine.GetPropertyNameByIDNumber(propertyIDNumber);
Quantity concentrationQuantity = new Quantity(unitConcentration, "Concentration of " + propertyName,
propertyIDNumber.ToString(), ValueType.Scalar, dimConcentration);
OutputExchangeItem outletConc = new OutputExchangeItem();
outletConc.Quantity = concentrationQuantity;
outletConc.ElementSet = outletNode;
outputExchangeItems.Add(outletConc);
InputExchangeItem boundaryConc = new InputExchangeItem();
boundaryConc.Quantity = concentrationQuantity;
boundaryConc.ElementSet = outletNode;
inputExchangeItems.Add(boundaryConc);
}
}
public void Init()
{
exchangeItem = new OutputExchangeItem();
exchangeItem.AddDataOperation(new DataOperation("DataOperation"));
}
public void Initialize(System.Collections.Hashtable properties)
{
//List of exchange Items
inputExchangeItems = new List<InputExchangeItem>();
outputExchangeItems = new List<OutputExchangeItem>();
//Initializes Engine
MohidWaterEngine = new MohidWaterEngineDotNetAccess();
MohidWaterEngine.Initialize(properties["FilePath"].ToString());
//
//Dimensions
//
Dimension dimFlow = new Dimension();
dimFlow.SetPower(DimensionBase.Length, 3);
dimFlow.SetPower(DimensionBase.Time, -1);
Dimension dimWaterlevel = new Dimension();
dimWaterlevel.SetPower(DimensionBase.Length, 1);
Dimension dimConcentration = new Dimension();
dimConcentration.SetPower(DimensionBase.Mass, 1);
dimConcentration.SetPower(DimensionBase.Length, -3);
//
//Units
//
Unit unitFlow = new Unit("m3/sec", 1, 0, "cubic meter per second");
Unit unitWaterLevel = new Unit("m", 1, 0, "sea water level");
Unit unitConcentration = new Unit("mg/l", 1, 0, "miligram per liter");
//
//Quantities
//
qtdDischargeFlow = new Quantity(unitFlow, "Input Discharge Flow", "Discharge Flow",
global::OpenMI.Standard.ValueType.Scalar, dimFlow);
qtdWaterLevel = new Quantity(unitWaterLevel, "Waterlevel of the water surface", "Waterlevel",
global::OpenMI.Standard.ValueType.Scalar, dimWaterlevel);
//
//Spatial Reference
//
SpatialReference spatialReference = new SpatialReference("spatial reference");
//
//Element Sets
//
//Model Grid
ElementSet modelGrid = new ElementSet("Model Grid Points of all Compute Points", "Model Grid",
ElementType.XYPolygon, spatialReference);
//Output exchange items - properties in each grid cell (surface only)
numberOfWaterPoints = 0;
for (int i = 1; i <= MohidWaterEngine.GetIUB(horizontalGridInstanceID); i++)
{
for (int j = 1; j <= MohidWaterEngine.GetJUB(horizontalGridInstanceID); j++)
{
if (MohidWaterEngine.IsWaterPoint(horizontalMapInstanceID, i, j))
{
String name = "i=" + i.ToString() + "/j=" + j.ToString();
double[] xCoords = new double[5];
double[] yCoords = new double[5];
MohidWaterEngine.GetGridCellCoordinates(horizontalGridInstanceID, i, j, ref xCoords, ref yCoords);
Element element = new Element(name);
element.AddVertex(new Vertex(xCoords[0], yCoords[0], 0));
element.AddVertex(new Vertex(xCoords[1], yCoords[1], 0));
element.AddVertex(new Vertex(xCoords[2], yCoords[2], 0));
element.AddVertex(new Vertex(xCoords[3], yCoords[3], 0));
modelGrid.AddElement(element);
numberOfWaterPoints++;
}
}
}
//allocates waterlevels1D
modelGridValues1D = new double[numberOfWaterPoints];
//Discharge Points
ElementSet dischargePoints = new ElementSet("Discharge Points", "Discharge Points", ElementType.XYPoint,
spatialReference);
//Flow input exchange to discharges configured as OpenMI Discharges
for (int i = 1; i <= MohidWaterEngine.GetNumberOfDischarges(dischargeInstanceID); i++)
{
if (MohidWaterEngine.GetDischargeType(dischargeInstanceID, i) == 4)
{
Element dischargeElement = new Element(MohidWaterEngine.GetDischargeName(dischargeInstanceID, i));
dischargeElement.AddVertex(
new Vertex(MohidWaterEngine.GetDischargeXCoordinate(dischargeInstanceID, i),
MohidWaterEngine.GetDischargeYCoordinate(dischargeInstanceID, i), 0));
dischargePoints.AddElement(dischargeElement);
}
}
//
//Output Exchange Items
//
//Water Level of the Hydrodynamic model
OutputExchangeItem waterlevel = new OutputExchangeItem();
waterlevel.Quantity = qtdWaterLevel;
waterlevel.ElementSet = modelGrid;
outputExchangeItems.Add(waterlevel);
//Properties of the Water properties model
for (int idx = 1; idx <= MohidWaterEngine.GetNumberOfProperties(waterPropertiesInstanceID); idx++)
{
int propertyID = MohidWaterEngine.GetPropertyIDNumber(waterPropertiesInstanceID, idx);
string propertyName = MohidWaterEngine.GetPropertyNameByIDNumber(propertyID);
Quantity concentrationQuantity = new Quantity(unitConcentration, "Concentration of " + propertyName, propertyID.ToString(),
ValueType.Scalar, dimConcentration);
qtdProperties.Add(concentrationQuantity);
OutputExchangeItem concExchangeItem = new OutputExchangeItem();
concExchangeItem.Quantity = concentrationQuantity;
concExchangeItem.ElementSet = modelGrid;
outputExchangeItems.Add(concExchangeItem);
}
//Flow input exchange to discharges configured as OpenMI Discharges
for (int i = 1; i <= MohidWaterEngine.GetNumberOfDischarges(dischargeInstanceID); i++)
{
if (MohidWaterEngine.GetDischargeType(dischargeInstanceID, i) == 4)
{
String pointName = MohidWaterEngine.GetDischargeName(dischargeInstanceID, i);
ElementSet dischargePoint = new ElementSet("Discharge Point of MOHID Water", i.ToString(), ElementType.XYPoint, spatialReference);
InputExchangeItem inputDischarge = new InputExchangeItem();
inputDischarge.Quantity = qtdDischargeFlow;
Element element = new Element("Point: " + pointName);
element.AddVertex(new Vertex(MohidWaterEngine.GetDischargeXCoordinate(dischargeInstanceID, i), MohidWaterEngine.GetDischargeYCoordinate(dischargeInstanceID, i), 0));
dischargePoint.AddElement(element);
inputDischarge.ElementSet = dischargePoint;
inputExchangeItems.Add(inputDischarge);
for (int idx = 1; idx <= MohidWaterEngine.GetNumberOfDischargeProperties(dischargeInstanceID, i); idx++)
{
int propertyID = MohidWaterEngine.GetDischargePropertyID(dischargeInstanceID, i, idx);
string propertyName = MohidWaterEngine.GetPropertyNameByIDNumber(propertyID);
Quantity concentrationQuantity = new Quantity(unitConcentration, propertyName, propertyID.ToString(), global::OpenMI.Standard.ValueType.Scalar, dimConcentration);
InputExchangeItem inputExchangeItem = new InputExchangeItem();
inputExchangeItem.ElementSet = dischargePoint;
inputExchangeItem.Quantity = concentrationQuantity;
inputExchangeItems.Add(inputExchangeItem);
}
}
}
}
/// <summary>
/// Runs a test of basic functionality on a language adapter.
/// </summary>
/// <param name="adapter"></param>
private void RunTest(ILanguageAdapter adapter)
{
// create holders for our exchange items
List<InputExchangeItem> _inputs = new List<InputExchangeItem>();
List<OutputExchangeItem> _outputs = new List<OutputExchangeItem>();
// read the element sets from the xml file
List<XmlElementSet> elementSets = XmlElementSet.Read(@"..\..\Data\ElementSets.xml");
// create an input exchange item
InputExchangeItem inItem = new InputExchangeItem();
inItem.Quantity = new Quantity("initem");
inItem.ElementSet = elementSets[0];
_inputs.Add(inItem);
// create some fake input data
double[] values = new double[inItem.ElementSet.ElementCount];
for (int i = 0; i < values.Length; i++)
values[i] = 1.0;
// create an output exchange item
OutputExchangeItem outItem = new OutputExchangeItem();
outItem.Quantity = new Quantity("outitem");
outItem.ElementSet = elementSets[0];
_outputs.Add(outItem);
// fake some times
DateTime startTime = new DateTime(1982, 01, 01, 00, 00, 00);
double timeStep = 3600;
DateTime currentTime = startTime;
// call initialize
adapter.Start(_inputs, _outputs, startTime, timeStep);
// set some values and perform a time step
adapter.SetValues(inItem, values);
adapter.PerformTimeStep(currentTime);
currentTime = currentTime.AddSeconds(timeStep);
// get some values and change them
values = adapter.GetValues(outItem);
for (int i = 0; i < values.Length; i++)
values[i] += 0.1;
// set some values and perform a time step
adapter.SetValues(inItem, values);
adapter.PerformTimeStep(currentTime);
currentTime = currentTime.AddSeconds(timeStep);
// get some values and change them
values = adapter.GetValues(outItem);
for (int i = 0; i < values.Length; i++)
values[i] += 0.1;
// set some values and perform a time step
adapter.SetValues(inItem, values);
adapter.PerformTimeStep(currentTime);
currentTime = currentTime.AddSeconds(timeStep);
// call finish
adapter.Stop();
}
public void ExchangeItems()
{
Assert.AreEqual(1,testComponent1.InputExchangeItemCount);
Assert.AreEqual(1,testComponent1.OutputExchangeItemCount);
Quantity q = new Quantity("Q");
ElementSet elementSet = new ElementSet();
elementSet.ID = "ES";
InputExchangeItem inputExchangeItem = new InputExchangeItem();
inputExchangeItem.Quantity = q;
inputExchangeItem.ElementSet = elementSet;
Assert.AreEqual(testComponent1.GetInputExchangeItem(0),inputExchangeItem);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.Quantity = new Quantity("Q2");
ElementSet elementSet2 = new ElementSet();
elementSet2.ID = "ES2";
outputExchangeItem.ElementSet = elementSet;
Assert.AreEqual(testComponent1.GetOutputExchangeItem(0),outputExchangeItem);
}
private void CreateExchangeItemsFromXMLNode(XmlNode ExchangeItem, string Identifier)
{
//Create Dimensions
var omiDimensions = new Dimension();
var dimensions = ExchangeItem.SelectNodes("//Dimensions/Dimension"); // You can filter elements here using XPath
if (dimensions != null)
{
foreach (XmlNode dimension in dimensions)
{
if (dimension["Base"].InnerText == "Length")
{
omiDimensions.SetPower(DimensionBase.Length, Convert.ToDouble(dimension["Power"].InnerText));
}
else if (dimension["Base"].InnerText == "Time")
{
omiDimensions.SetPower(DimensionBase.Time, Convert.ToDouble(dimension["Power"].InnerText));
}
else if (dimension["Base"].InnerText == "AmountOfSubstance")
{
omiDimensions.SetPower(DimensionBase.AmountOfSubstance, Convert.ToDouble(dimension["Power"].InnerText));
}
else if (dimension["Base"].InnerText == "Currency")
{
omiDimensions.SetPower(DimensionBase.Currency, Convert.ToDouble(dimension["Power"].InnerText));
}
else if (dimension["Base"].InnerText == "ElectricCurrent")
{
omiDimensions.SetPower(DimensionBase.ElectricCurrent, Convert.ToDouble(dimension["Power"].InnerText));
}
else if (dimension["Base"].InnerText == "LuminousIntensity")
{
omiDimensions.SetPower(DimensionBase.LuminousIntensity, Convert.ToDouble(dimension["Power"].InnerText));
}
else if (dimension["Base"].InnerText == "Mass")
{
omiDimensions.SetPower(DimensionBase.Mass, Convert.ToDouble(dimension["Power"].InnerText));
}
else if (dimension["Base"].InnerText == "Temperature")
{
omiDimensions.SetPower(DimensionBase.Temperature, Convert.ToDouble(dimension["Power"].InnerText));
}
}
}
//Create Units
_omiUnits = new Unit();
var units = ExchangeItem.SelectSingleNode("Quantity/Unit");
if (units != null)
{
_omiUnits.ID = units["ID"].InnerText;
if (units["Description"] != null) _omiUnits.Description = units["Description"].InnerText;
if (units["ConversionFactorToSI"] != null) _omiUnits.ConversionFactorToSI = Convert.ToDouble(units["ConversionFactorToSI"].InnerText);
if (units["OffSetToSI"] != null) _omiUnits.OffSetToSI = Convert.ToDouble(units["OffSetToSI"].InnerText);
}
//Create Quantity
var omiQuantity = new Quantity();
var quantity = ExchangeItem.SelectSingleNode("Quantity");
omiQuantity.ID = quantity["ID"].InnerText;
if (quantity["Description"] != null) omiQuantity.Description = quantity["Description"].InnerText;
omiQuantity.Dimension = omiDimensions;
omiQuantity.Unit = _omiUnits;
omiQuantity.ValueType = ValueType.Scalar;
if (quantity["ValueType"] != null)
{
if (quantity["ValueType"].InnerText == "Scalar")
{
omiQuantity.ValueType = ValueType.Scalar;
}
else if (quantity["ValueType"].InnerText == "Vector")
{
omiQuantity.ValueType = ValueType.Vector;
}
}
//Create Element Set
var omiElementSet = new ElementSet();
var elementSet = ExchangeItem.SelectSingleNode("ElementSet");
omiElementSet.ID = elementSet["ID"].InnerText;
if (elementSet["Description"] != null) omiElementSet.Description = elementSet["Description"].InnerText;
try
{
//add elements from shapefile to element set
var utils = new Utilities();
_shapefilepath = elementSet["ShapefilePath"].InnerText;
omiElementSet = utils.AddElementsFromShapefile(omiElementSet, _shapefilepath);
}
catch (Exception)
{
Debug.WriteLine("An Element Set has not been declared using AddElementsFromShapefile");
}
try
{
// add elements from xml file to element set
var utils = new Utilities();
_xmlFilePath = elementSet["XmlFilePath"].InnerText;
omiElementSet = utils.AddElementsFromXmlFile(omiElementSet, _xmlFilePath);
}
catch (Exception)
{
Debug.WriteLine("An Element Set has not been declared using AddElementsFromXmlFile");
}
if (Identifier == "OutputExchangeItem")
{
//create exchange item
var omiOutputExchangeItem = new OutputExchangeItem();
omiOutputExchangeItem.Quantity = omiQuantity;
omiOutputExchangeItem.ElementSet = omiElementSet;
//add the output exchange item to the list of output exchange items for the component
_outputs.Add(omiOutputExchangeItem);
if (!_quantities.ContainsKey(omiQuantity.ID)) _quantities.Add(omiQuantity.ID, omiQuantity);
if (!_elementSets.ContainsKey(omiElementSet.ID)) _elementSets.Add(omiElementSet.ID, omiElementSet);
}
else if (Identifier == "InputExchangeItem")
{
//create exchange item
var omiInputExchangeItem = new InputExchangeItem();
omiInputExchangeItem.Quantity = omiQuantity;
omiInputExchangeItem.ElementSet = omiElementSet;
//add the output exchange item to the list of output exchange items for the component
_inputs.Add(omiInputExchangeItem);
if (!_quantities.ContainsKey(omiQuantity.ID)) _quantities.Add(omiQuantity.ID, omiQuantity);
if (!_elementSets.ContainsKey(omiElementSet.ID)) _elementSets.Add(omiElementSet.ID, omiElementSet);
}
}
public void Initialize(System.Collections.Hashtable properties)
{
if (properties.ContainsKey("ModelID"))
{
_modelID = (string) properties["ModelID"];
}
if (properties.ContainsKey("TimeStepLength"))
{
_timeStepLength = Convert.ToDouble((string) properties["TimeStepLength"]);
}
// -- create a flow quanitity --
Dimension flowDimension = new Dimension();
flowDimension.SetPower(DimensionBase.Length,3);
flowDimension.SetPower(DimensionBase.Time,-1);
Unit literPrSecUnit = new Unit("LiterPrSecond",0.001,0,"Liters pr Second");
Quantity flowQuantity = new Quantity(literPrSecUnit,"Flow","Flow",global::OpenMI.Standard.ValueType.Scalar,flowDimension);
// -- create leakage quantity --
Quantity leakageQuantity = new Quantity(literPrSecUnit,"Leakage","Leakage",global::OpenMI.Standard.ValueType.Scalar,flowDimension);
// -- create and populate elementset to represente the whole river network --
ElementSet fullRiverElementSet = new ElementSet("WholeRiver","WholeRiver",ElementType.XYPolyLine,new SpatialReference("no reference"));
for (int i = 0; i < _numberOfNodes -1; i++)
{
Element element = new Element();
element.ID = "Branch:" + i.ToString();
element.AddVertex(new Vertex(_xCoordinate[i],_yCoordinate[i],-999));
element.AddVertex(new Vertex(_xCoordinate[i+1],_yCoordinate[i+1],-999));
fullRiverElementSet.AddElement(element);
}
// --- populate input exchange items for flow to individual nodes ---
for ( int i = 0; i < _numberOfNodes; i++)
{
Element element = new Element();
element.ID = "Node:" + i.ToString();
ElementSet elementSet = new ElementSet("Individual nodes","Node:" + i.ToString(), ElementType.IDBased,new SpatialReference("no reference"));
elementSet.AddElement(element);
InputExchangeItem inputExchangeItem = new InputExchangeItem();
inputExchangeItem.ElementSet = elementSet;
inputExchangeItem.Quantity = flowQuantity;
_inputExchangeItems.Add(inputExchangeItem);
}
// --- Populate input exchange item for flow to the whole georeferenced river ---
InputExchangeItem wholeRiverInputExchangeItem = new InputExchangeItem();
wholeRiverInputExchangeItem.ElementSet = fullRiverElementSet;
wholeRiverInputExchangeItem.Quantity = flowQuantity;
_inputExchangeItems.Add(wholeRiverInputExchangeItem);
// --- Populate output exchange items for flow in river branches ---
for (int i = 0; i < _numberOfNodes - 1; i++)
{
Element element = new Element();
element.ID = "Branch:" + i.ToString();
ElementSet elementSet = new ElementSet("Individual nodes","Branch:" + i.ToString(),ElementType.IDBased,new SpatialReference("no reference"));
elementSet.AddElement(element);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.ElementSet = elementSet;
outputExchangeItem.Quantity = flowQuantity;
_outputExchangeItems.Add(outputExchangeItem);
}
// --- polulate output exchange items for leakage for individual branches --
for (int i = 0; i < _numberOfNodes - 1; i++)
{
Element element = new Element();
element.ID = "Branch:" + i.ToString();
ElementSet elementSet = new ElementSet("Individual nodes","Branch:" + i.ToString(),ElementType.IDBased,new SpatialReference("no reference"));
elementSet.AddElement(element);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.ElementSet = elementSet;
outputExchangeItem.Quantity = leakageQuantity;
_outputExchangeItems.Add(outputExchangeItem);
}
// --- Populate output exchange item for leakage from the whole georeferenced river ---
OutputExchangeItem wholeRiverOutputExchangeItem = new OutputExchangeItem();
wholeRiverOutputExchangeItem.ElementSet = fullRiverElementSet;
wholeRiverOutputExchangeItem.Quantity = leakageQuantity;
_outputExchangeItems.Add(wholeRiverOutputExchangeItem);
// --- populate with initial state variables ---
for (int i = 0; i < _numberOfNodes -1; i++)
{
_flow[i] = 7;
}
_currentTimeStepNumber = 1;
_initializeMethodWasInvoked = true;
}
public void Initialize(System.Collections.Hashtable properties)
{
double ox = 2.0;
double oy = 2.0;
double dx = 4.0;
double dy = 4.0;
// -- Populate Input Exchange Items ---
Element element0 = new Element("element:0");
element0.AddVertex(new Vertex(ox ,oy ,0));
element0.AddVertex(new Vertex(ox+dx ,oy ,0));
element0.AddVertex(new Vertex(ox+dx ,oy+dy ,0));
element0.AddVertex(new Vertex(ox ,oy+dy ,0));
Element element1 = new Element("element:1");
element1.AddVertex(new Vertex(ox + dx ,oy ,0));
element1.AddVertex(new Vertex(ox+2*dx ,oy ,0));
element1.AddVertex(new Vertex(ox+2*dx ,oy+dy ,0));
element1.AddVertex(new Vertex(ox+dx ,oy+dy ,0));
Element element2 = new Element("element:2");
element2.AddVertex(new Vertex(ox ,oy+dy ,0));
element2.AddVertex(new Vertex(ox+dx ,oy+dy ,0));
element2.AddVertex(new Vertex(ox+dx ,oy+2*dy ,0));
element2.AddVertex(new Vertex(ox ,oy+2*dy ,0));
Element element3 = new Element("element:3");
element3.AddVertex(new Vertex(ox + dx ,oy+dy ,0));
element3.AddVertex(new Vertex(ox+2*dx ,oy+dy ,0));
element3.AddVertex(new Vertex(ox+2*dx ,oy+2*dy ,0));
element3.AddVertex(new Vertex(ox+dx ,oy+2*dy ,0));
ElementSet elementSet = new ElementSet("RegularGrid","RegularGrid",ElementType.XYPolygon,new SpatialReference(" "));
elementSet.AddElement(element0);
elementSet.AddElement(element1);
elementSet.AddElement(element2);
elementSet.AddElement(element3);
Quantity storageQuantity = new Quantity(new Unit("Storage",1.0,0.0,"Storage"),"Storage","Storage",global::OpenMI.Standard.ValueType.Scalar,new Dimension());
InputExchangeItem inputExchangeItem = new InputExchangeItem();
inputExchangeItem.ElementSet = elementSet;
inputExchangeItem.Quantity = storageQuantity;
_inputExchangeItems.Add(inputExchangeItem);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.ElementSet = elementSet;
outputExchangeItem.Quantity = storageQuantity;
_outputExchangeItems.Add(outputExchangeItem);
}