public ElementSetUnoptimisedStorage(OpenMI.Standard.IElementSet es1)
: base(es1)
{
Elements = new List<Element>(ElementCount);
for (int n = 0; n < ElementCount; ++n)
Elements.Add(new Element(es1, n));
ElementCount = Elements.Count;
}
private void MainForm_KeyDown(object sender, KeyEventArgs e)
{
if (e.Control && !(thread != null && thread.IsAlive))
{
switch (e.KeyCode)
{
case Keys.A:
Apply.PerformClick();
break;
case Keys.O:
OpenMI.PerformClick();
break;
case Keys.F:
if (Tabs.SelectedTab != null)
{
int index = int.Parse(Tabs.SelectedTab.Name.Remove(0, 2));
OpenFullsize(index);
}
break;
case Keys.S:
if (Tabs.SelectedTab != null)
{
int index = int.Parse(Tabs.SelectedTab.Name.Remove(0, 2));
Save(index);
}
break;
case Keys.R:
if (Tabs.SelectedTab != null)
{
int index = int.Parse(Tabs.SelectedTab.Name.Remove(0, 2));
Reset(index);
}
break;
}
}
}
public ElementSetProposed(OpenMI.Standard.IElementSet iElementSet1)
: base(iElementSet1)
{
}
protected virtual BaseOutput NewOutputSpaceTime(string engineVariable, string description,
OpenMI.Standard.IOutputExchangeItem output1,
Utilities.Standard1.ExchangeItemV1ModelXml v1Model, int elementCount)
{
return new OutputSpaceTimeComponent1(
new Identity(engineVariable, engineVariable, description),
this,
new Quantity(output1.Quantity, typeof(double), -999.999),
ConvertElementSet(output1.ElementSet, v1Model),
engineVariable, -999.999, elementCount);
}
protected IElementSet ConvertElementSet(OpenMI.Standard.IElementSet elementSet1,
Utilities.Standard1.ExchangeItemV1ModelXml v1Model)
{
if (v1Model != null)
{
if (elementSet1.GetType().ToString() == "FluidEarth.Sdk.ElementSetGridRegular"
&& v1Model.UserVariables["ElementType"] == "XYPoint"
&& v1Model.UserVariables["Storage"] == "RegularGrid")
{
var cellCountX = int.Parse(v1Model.UserVariables["N"]) - 1;
var cellCountY = int.Parse(v1Model.UserVariables["M"]) - 1;
var originX = double.Parse(v1Model.UserVariables["OriginX"]);
var originY = double.Parse(v1Model.UserVariables["OriginY"]);
var deltaX = double.Parse(v1Model.UserVariables["dX"]);
var deltaY = double.Parse(v1Model.UserVariables["dY"]);
var parameters = new ParametersGridRegular(
cellCountX, cellCountY,
new Coord2d(originX, originY),
deltaX, deltaY);
bool fastN = v1Model.UserVariables["Packing"] == "FastN";
return new ElementSetGridRegularPoints(parameters, ElementSetGridRegularPoints.Located.Node, fastN);
}
}
return new ElementSetUnoptimisedStorage(elementSet1);
}
public void PrePrepare(
LinkableComponentV1OpenMI component2,
OpenMI.Standard.ILinkableComponent component1,
double startTime, double updateLinkTimeIncrement,
List<IBaseInput> activeInputs, List<IBaseOutput> activeOutputs)
{
Contract.Requires(component1 != null, "component1 != null");
Contract.Requires(component2 != null, "component2 != null");
Component1 = component1;
Component1.Initialize(component2.Arguments.Select(a => new Utilities.Standard1.Argument1(a)).ToArray());
_currentTime = startTime;
_updateLinkTimeIncrement = updateLinkTimeIncrement;
// Create internal links between components 1 and 2
// T2 --> T1
// S1 --> S2
Utilities.Standard1.TimeSpan timeHorizon1
= new Utilities.Standard1.TimeSpan(component2.TimeExtent.TimeHorizon);
OpenMI.Standard.IInputExchangeItem input;
OpenMI.Standard.IOutputExchangeItem output;
OpenMI.Standard.ILink internalLink;
ITimeSpaceExchangeItem itemTimeSpace;
string idQuantity, idElementSet;
activeInputs.ForEach(i =>
{
idQuantity = i.ValueDefinition.Caption;
itemTimeSpace = i as ITimeSpaceExchangeItem;
idElementSet = itemTimeSpace == null
? i.Caption // what else?
: itemTimeSpace.SpatialDefinition.Caption;
internalLink = null;
for (int n = 0; n < _component1.InputExchangeItemCount; ++n)
{
input = _component1.GetInputExchangeItem(n);
if (input.Quantity.ID != idQuantity
|| input.ElementSet.ID != idElementSet)
continue;
var isVector = input.Quantity.ValueType == OpenMI.Standard.ValueType.Vector;
// Get providers convertor to use directly
Contract.Requires(i.Provider is IHasValueSetConvertor,
"i.Provider is IHasValueSetConvertor");
var convertorProvider = ((IHasValueSetConvertor)i.Provider).ValueSetConverter
as IValueSetConverterTime;
Contract.Requires(convertorProvider != null,
"i.Provider.ValueSetConverter is IValueSetConverterTime");
internalLink = new Utilities.Standard1.InternalLink(
_component1, input, timeHorizon1, convertorProvider, isVector);
_linksIn.Add(internalLink);
_component1.AddLink(internalLink);
break;
}
if (internalLink == null)
throw new Exception(string.Format(
"OpenMI.Standard.IOutputExchangeItem not found with Quality,ElementSet ids if \"{0}\",\"{1}\"",
idQuantity, idElementSet));
});
activeOutputs.ForEach(o =>
{
idQuantity = o.ValueDefinition.Caption;
itemTimeSpace = o as ITimeSpaceExchangeItem;
idElementSet = itemTimeSpace == null
? o.Caption // what else?
: itemTimeSpace.SpatialDefinition.Caption;
internalLink = null;
for (int n = 0; n < _component1.OutputExchangeItemCount; ++n)
{
output = _component1.GetOutputExchangeItem(n);
if (output.Quantity.ID != idQuantity
|| output.ElementSet.ID != idElementSet)
continue;
internalLink = new Utilities.Standard1.InternalLink(_component1, output, timeHorizon1);
_linksOut.Add(internalLink);
_component1.AddLink(internalLink);
if (((IHasValueSetConvertor)o).ValueSetConverter is ValueSetConverterTimeEngineDoubleStandard1)
{
var convertor = (ValueSetConverterTimeEngineDoubleStandard1)((IHasValueSetConvertor)o).ValueSetConverter;
convertor.SetRuntime(this, internalLink);
}
else if (((IHasValueSetConvertor)o).ValueSetConverter is ValueSetConverterTimeEngineDoubleVector3dStandard1)
{
var convertor = (ValueSetConverterTimeEngineDoubleVector3dStandard1)((IHasValueSetConvertor)o).ValueSetConverter;
convertor.SetRuntime(this, internalLink);
}
else
throw new Exception("o.ValueSetConverter as ValueSetConverterTimeEngineDouble?");
break;
}
if (internalLink == null)
throw new Exception(string.Format(
"OpenMI.Standard.IInputExchangeItem not found with Quality,ElementSet ids if \"{0}\",\"{1}\"",
idQuantity, idElementSet));
});
if (_linksOut.Count < 1)
throw new Exception("At least one output link must be specified");
}
protected override IBaseInput Convert(OpenMI.Standard.IInputExchangeItem item1)
{
var engineVariable = string.Format("Input{0}.{1}.{2}",
++_nInputs, item1.Quantity.ID, item1.ElementSet.ID);
var describes = new Describes(engineVariable,
string.Format("{0}\r\n\r\n{1}", item1.Quantity.Description, item1.ElementSet.Description));
var elementSet = new ElementSetUnoptimisedStorage(item1.ElementSet);
return new InputSpaceTimeComponent1(
new Identity(engineVariable, describes),
this,
new Quantity(item1.Quantity, typeof(double), -999.999),
elementSet,
engineVariable, -999.999, elementSet.ElementCount);
}
protected override BaseOutput NewOutputSpaceTime(string engineVariable, string description, OpenMI.Standard.IOutputExchangeItem output1, Utilities.Standard1.ExchangeItemV1ModelXml v1Model, int elementCount)
{
var output = new OutputSpaceTimeUserVariables(
new Identity(engineVariable, engineVariable, description),
this,
new Quantity(output1.Quantity, typeof(double), -999.999),
ConvertElementSet(output1.ElementSet, v1Model),
engineVariable, -999.999, elementCount);
//foreach (var kv in v1Model.UserVariables)
// output.UserVariables.Add(kv.Key, kv.Value);
return output;
}
/// <summary>
/// Extract specific Model 1 output details from v1 XML model file
/// </summary>
/// <param name="item">V1 output exchange item</param>
/// <returns>V1 item details</returns>
Utilities.Standard1.ExchangeItemV1ModelXml V1ModelXmlItem(OpenMI.Standard.IOutputExchangeItem item)
{
return V1ModelOutputs != null
? V1ModelOutputs
.Values
.Where(v =>
v.Quantity.Id == item.Quantity.ID
&& v.ElementSet.Id == item.ElementSet.ID)
.SingleOrDefault()
: null;
}
/// <summary>
/// Convert a OpenMI 1.4 output exchange item into corresponding OpenMI 2.0 base output.
/// </summary>
/// <param name="item1">OpenMI version 1.4 output exchange item</param>
/// <returns>OpenMI 2.0 base output</returns>
protected override IBaseOutput Convert(OpenMI.Standard.IOutputExchangeItem item1)
{
var engineVariable = string.Format("Output{0}.{1}.{2}",
++_nOutputs, item1.Quantity.ID, item1.ElementSet.ID);
var describes = new Describes(engineVariable,
string.Format("{0}\r\n\r\n{1}", item1.Quantity.Description, item1.ElementSet.Description));
var v1Xml = V1ModelXmlItem(item1);
var elementSet = ConvertElementSet(item1.ElementSet, v1Xml);
var output = new OutputSpaceTimeUserVariables(
new Identity(engineVariable, describes),
this,
new Quantity(item1.Quantity, typeof(double), -999.999),
elementSet,
engineVariable, -999.999, elementSet.ElementCount);
if (v1Xml != null)
foreach (var kv in v1Xml.UserVariables)
output.UserVariables.Add(kv.Key, kv.Value);
return output;
}
public Argument1(OpenMI.Standard2.IArgument arg2)
{
Key = arg2.Caption;
Value = arg2.ValueAsString;
ReadOnly = arg2.IsReadOnly;
Description = arg2.Description;
}
/// <summary> /// Convert a OpenMI 1.4 output exchange item into corresponding OpenMI 2.0 base output. /// </summary> /// <param name="item1">OpenMI version 1.4 output exchange item</param> /// <returns>OpenMI 2.0 base output</returns> protected abstract IBaseOutput Convert(OpenMI.Standard.IOutputExchangeItem item1);
/// <summary>
/// Create an instance of OpenMI.Standard.ILinkableComponent
/// </summary>
/// <param name="uriOmiV1">Uri of OMI XML</param>
/// <param name="component1">Instance of OpenMI.Standard.ILinkableComponent</param>
/// <param name="reports">Details about method success</param>
/// <returns>True if successful</returns>
public static bool InstantiateComponent1(Uri uriOmiV1, out OpenMI.Standard.ILinkableComponent component1, List<IReport> reports)
{
component1 = null;
XElement xLinkableComponent;
List<Utilities.Standard1.Argument1> args1;
if (!UpdateArgumentsFromOmiV1(uriOmiV1, out xLinkableComponent, out args1, reports))
return false;
var assembly = Utilities.Xml.GetAttribute(xLinkableComponent, "Assembly");
var type = Utilities.Xml.GetAttribute(xLinkableComponent, "Type");
var omiFile = new DocumentExistingFile(uriOmiV1);
var assemblyUri = new Uri(uriOmiV1, assembly);
var typeV1 = new ExternalType(omiFile);
typeV1.Initialise(assemblyUri.LocalPath, type);
Type tComponentV1;
component1 = typeV1.CreateInstance(out tComponentV1) as OpenMI.Standard.ILinkableComponent;
if (component1 == null)
{
reports.Add(Report.Error(Report.ResourceIds.Instantiation, tComponentV1.ToString(), string.Empty));
return false;
}
return true;
}
public Element(OpenMI.Standard.IElementSet set, int nElement)
{
Identity = new Identity(set.GetElementID(nElement));
int nV = set.GetVertexCount(nElement);
int nF = set.GetFaceCount(nElement);
X = new double[nV];
Y = new double[nV];
bool hasZ = set.ElementType == OpenMI.Standard.ElementType.XYZPoint
|| set.ElementType == OpenMI.Standard.ElementType.XYZLine
|| set.ElementType == OpenMI.Standard.ElementType.XYZPolyLine
|| set.ElementType == OpenMI.Standard.ElementType.XYZPolygon
|| set.ElementType == OpenMI.Standard.ElementType.XYZPolyhedron;
if (hasZ)
Z = new double[nV];
for (int n = 0; n < nV; ++n)
{
X[n] = set.GetXCoordinate(nElement, n);
Y[n] = set.GetYCoordinate(nElement, n);
if (hasZ)
Z[n] = set.GetZCoordinate(nElement, n);
}
if (nF > 0)
{
Faces = new int[nF][];
for (int n = 0; n < nF; ++n)
Faces[n] = set.GetFaceVertexIndices(nElement, n);
}
}
