public SpatialExtensionElementSetAdaptor(ITimeSpaceOutput adaptee, IElementSet elementSet, string id) : base(adaptee, id) { _elementSet = elementSet; _caption = elementSet.Caption; _description = elementSet.Description; }
public Element(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]; if (set.HasZ) Z = new double[nV]; if (set.HasM) M = new double[nV]; for (int n = 0; n < nV; ++n) { X[n] = set.GetVertexXCoordinate(nElement, n); Y[n] = set.GetVertexYCoordinate(nElement, n); if (set.HasZ) Z[n] = set.GetVertexZCoordinate(nElement, n); if (set.HasM) M[n] = set.GetVertexMCoordinate(nElement, n); } if (nF > 0) { Faces = new int[nF][]; for (int n = 0; n < nF; ++n) Faces[n] = set.GetFaceVertexIndices(nElement, n); } }
public static bool IsSinglePolyLine(IElementSet elementSet, out string whyNot) { whyNot = string.Empty; if (elementSet is ElementSetPolyLineSingle) return true; if (elementSet.ElementType != ElementType.PolyLine) { whyNot = "elementSet.ElementType != ElementType.PolyLine"; return false; } for (int nElement = 0; nElement < elementSet.ElementCount; ++nElement) { if (elementSet.GetVertexCount(nElement) != 2) { whyNot = "For at least one nElement elementSet.GetVertexCount(nElement) != 2"; return false; } } for (int nElement = 1; nElement < elementSet.ElementCount; ++nElement) { var len = Distance(elementSet, nElement, 0, nElement - 1, 1); if (len > 10.0 * double.Epsilon) { whyNot = "adjacent element vertices > 10.0 * double.Epsilon apart"; return false; } } return true; }
public static double Distance(IElementSet elementSet, int nElement1, int nVertex1, int nElement2, int nVertex2) { var dx = elementSet.GetVertexXCoordinate(nElement2, nVertex2) - elementSet.GetVertexXCoordinate(nElement1, nVertex1); var dy = elementSet.GetVertexYCoordinate(nElement2, nVertex2) - elementSet.GetVertexYCoordinate(nElement1, nVertex1); var dz = elementSet.HasZ ? elementSet.GetVertexZCoordinate(nElement2, nVertex2) - elementSet.GetVertexZCoordinate(nElement1, nVertex1) : 0.0; return Math.Sqrt(dx * dx + dy * dy + dz * dz); }
public ElementSetEntry(IElementSet elementSet) { ElementSetId = elementSet.ID; // pack the element id's into an array var ids = new String[elementSet.ElementCount]; for (var i = 0; i < ids.Length; i++) ids[i] = elementSet.GetElementID(i); // serialize the array into a byte array DataBytes = ByteUtil.toByta(ids); DataLength = DataBytes.Length; }
/// <summary> /// Copy constructor /// </summary> /// <param name="source">The element set to copy</param> public ElementSet(IElementSet source) { _description = source.Description; _caption = source.Caption; _elementType = source.ElementType; _spatialReferenceWKT = source.SpatialReferenceSystemWkt; for (int i = 0; i < source.ElementCount; i++) { Element element = new Element(source.GetElementId(i).Id); for (int j = 0; j < source.GetVertexCount(i); j++) { Coordinate vertex = new Coordinate(source.GetVertexXCoordinate(i, j), source.GetVertexYCoordinate(i, j), source.GetVertexZCoordinate(i, j)); element.AddVertex(vertex); } elements.Add(element); } }
/// <summary> /// Copy constructor /// </summary> /// <param name="source">The element set to copy</param> public ElementSet(IElementSet source) { _description = source.Description; _id = source.ID; _elementType = source.ElementType; _spatialReference = source.SpatialReference; for (int i=0;i<source.ElementCount;i++) { Element element = new Element(source.GetElementID(i)); for (int j=0;j<source.GetVertexCount(i);j++) { double x = source.GetXCoordinate(i,j); double y = source.GetYCoordinate(i,j); double z = source.GetZCoordinate(i,j); element.AddVertex(new Vertex(x,y,z)); } _elements.Add(element); } }
/// <summary> /// Creates new instance of <see cref="TriggerExchangeItem">TriggerExchangeItem</see> /// </summary> public TriggerExchangeItem() { quantity = new Oatc.OpenMI.Sdk.Backbone.Quantity(new Oatc.OpenMI.Sdk.Backbone.Unit("Dummy", 1, 0, "dummy"), "Anything", "TriggerQuantityID", global::OpenMI.Standard.ValueType.Scalar, new Oatc.OpenMI.Sdk.Backbone.Dimension()); elementSet = new Oatc.OpenMI.Sdk.Backbone.ElementSet("Dummy Element", "TriggerElementID", ElementType.IDBased, new Oatc.OpenMI.Sdk.Backbone.SpatialReference()); }
public override void UpdateGeometry(IElementSet elementSetEdits) { Contract.Requires(UpdateGeometryAvailable(elementSetEdits), "updateGeometryAvailable(elementSetEdits)"); base.UpdateGeometry(elementSetEdits); X = new double[elementSetEdits.ElementCount]; Y = new double[elementSetEdits.ElementCount]; Z = elementSetEdits.HasZ ? new double[elementSetEdits.ElementCount] : null; M = elementSetEdits.HasM ? new double[elementSetEdits.ElementCount] : null; int nVertex = 0; for (int nElement = 0; nElement < elementSetEdits.ElementCount; ++nElement) { X[nElement] = elementSetEdits.GetVertexXCoordinate(nElement, nVertex); Y[nElement] = elementSetEdits.GetVertexYCoordinate(nElement, nVertex); if (HasZ) Z[nElement] = elementSetEdits.GetVertexZCoordinate(nElement, nVertex); if (HasM) M[nElement] = elementSetEdits.GetVertexMCoordinate(nElement, nVertex); } }
public Output(string id, IValueDefinition valueDefinition, IElementSet elementSet) : base(id, valueDefinition, elementSet) { }
public virtual void UpdateGeometry(IElementSet elementSetEdits) { Contract.Requires(UpdateGeometryAvailable(elementSetEdits), "updateGeometryAvailable(elementSetEdits)"); Version = elementSetEdits.Version; ElementType = elementSetEdits.ElementType; SpatialReferenceSystemWkt = elementSetEdits.SpatialReferenceSystemWkt; ElementCount = elementSetEdits.ElementCount; }
public ITime GetDiscreteTime(IQuantity quantity, IElementSet elementSet, int discreteTimeIndex) { if (!initializeWasInvoked) { throw new Exception("Method \"GetDiscreteTime\" in LinkableTimeSeriesGroup class was invoked before the Initialize method was invoked"); } if (((TsQuantity)quantity).BaseTimeSeries is TimestampSeries) { DateTime time = ((TimestampSeries)((TsQuantity)quantity).BaseTimeSeries).Items[discreteTimeIndex].Time; return new HydroNumerics.OpenMI.Sdk.Backbone.TimeStamp(time); } else if (((TsQuantity)quantity).BaseTimeSeries is TimespanSeries) { DateTime startTime = ((TimespanSeries)((TsQuantity)quantity).BaseTimeSeries).Items[discreteTimeIndex].StartTime; DateTime endTime = ((TimespanSeries)((TsQuantity)quantity).BaseTimeSeries).Items[discreteTimeIndex].EndTime; return new HydroNumerics.OpenMI.Sdk.Backbone.TimeSpan(new HydroNumerics.OpenMI.Sdk.Backbone.TimeStamp(startTime), new HydroNumerics.OpenMI.Sdk.Backbone.TimeStamp(endTime)); } else { throw new Exception("undefined time series type"); } }
public bool HasDiscreteTimes(IQuantity quantity, IElementSet elementSet) { return true; }
/// <summary> /// Initialises the ElementMapper. The initialisation includes setting the _isInitialised /// flag and calls UpdateMappingMatrix for claculation of the mapping matrix. /// </summary> /// /// <param name="methodDescription">String description of mapping method</param> /// <param name="fromElements">The IElementSet to map from.</param> /// <param name="toElements">The IElementSet to map to</param> /// /// <returns> /// The method has no return value. /// </returns> public void Initialise(string methodDescription, IElementSet fromElements, IElementSet toElements) { UpdateMappingMatrix(methodDescription, fromElements, toElements); _isInitialised = true; }
/// <summary> /// Constructor /// </summary> /// <param name="SourceComponent">The source component</param> /// <param name="SourceElementSet">The source element set</param> /// <param name="SourceQuantity">The source quantity</param> /// <param name="TargetComponent">The target component</param> /// <param name="TargetElementSet">The target element set</param> /// <param name="TargetQuantity">The target quantity</param> /// <param name="Description">The description</param> /// <param name="ID">The ID</param> /// <param name="DataOperations">Data operations to be carried out by the provider</param> public Link(ILinkableComponent SourceComponent, IElementSet SourceElementSet, IQuantity SourceQuantity, ILinkableComponent TargetComponent, IElementSet TargetElementSet, IQuantity TargetQuantity, string Description, string ID, ArrayList DataOperations) { _sourceComponent = SourceComponent; _sourceElementSet = SourceElementSet; _sourceQuantity = SourceQuantity; _targetComponent = TargetComponent; _targetElementSet = TargetElementSet; _targetQuantity = TargetQuantity; _description = Description; _id = ID; _dataOperations = DataOperations; }
/// <summary> /// Constructor /// </summary> /// <param name="SourceComponent">The source component</param> /// <param name="SourceElementSet">The source element set</param> /// <param name="SourceQuantity">The source quantity</param> /// <param name="TargetComponent">The target component</param> /// <param name="TargetElementSet">The target element set</param> /// <param name="TargetQuantity">The target quantity</param> /// <param name="ID">The ID</param> public Link(ILinkableComponent SourceComponent, IElementSet SourceElementSet, IQuantity SourceQuantity, ILinkableComponent TargetComponent, IElementSet TargetElementSet, IQuantity TargetQuantity, string ID) { _sourceComponent = SourceComponent; _sourceElementSet = SourceElementSet; _sourceQuantity = SourceQuantity; _targetComponent = TargetComponent; _targetElementSet = TargetElementSet; _targetQuantity = TargetQuantity; _description = Description; _id = ID; }
/// <summary> /// Creates the tree based on element sets and quantities in exchange items /// passed with <see cref="PopulateExchangeItemTree">PopulateExchangeItemTree</see> method. /// </summary> public void CreateTree() { treeView1.BeginUpdate(); treeView1.Nodes.Clear(); string lastQuantityID = null; // fill tree with exchange items (if there are any because DrawTree could be called // before _exchangeItems was assigned ) if (_exchangeItems != null) { foreach (IExchangeItem exchangeItem in _exchangeItems) { TreeNode elementSetNode = null; // newly added node (if any) // apply filters (if any) if (_filterDimension != null && !Utils.CompareDimensions(_filterDimension, exchangeItem.Quantity.Dimension)) { continue; } if (_filterElementSet != null && _filterElementSet.ElementType != ElementType.IDBased && (exchangeItem.ElementSet.ElementType != ElementType.IDBased || exchangeItem.ElementSet.ElementCount != _filterElementSet.ElementCount)) { continue; } TreeNode quantityNode; if (lastQuantityID != exchangeItem.Quantity.ID) { // adding new quantity node quantityNode = treeView1.Nodes.Add(exchangeItem.Quantity.ID); quantityNode.Tag = exchangeItem.Quantity; if (exchangeItem.Quantity.ValueType == global::OpenMI.Standard.ValueType.Scalar) { quantityNode.ImageIndex = quantityNode.SelectedImageIndex = 0; } else { quantityNode.ImageIndex = quantityNode.SelectedImageIndex = 1; } lastQuantityID = exchangeItem.Quantity.ID; } else { // last node corresponds to quantity with same ID quantityNode = treeView1.Nodes[treeView1.Nodes.Count - 1]; } // Add ElementSet node elementSetNode = quantityNode.Nodes.Add(exchangeItem.ElementSet.ID); Debug.Assert(0 <= (int)exchangeItem.ElementSet.ElementType && (int)exchangeItem.ElementSet.ElementType <= 9); elementSetNode.ImageIndex = elementSetNode.SelectedImageIndex = (int)exchangeItem.ElementSet.ElementType + 2; elementSetNode.Tag = exchangeItem.ElementSet; // add DataOperation subnodes only if newly added node is IOutputExchangeItem if (exchangeItem is IOutputExchangeItem) { IOutputExchangeItem item = (IOutputExchangeItem)exchangeItem; for (int j = 0; j < item.DataOperationCount; j++) { TreeNode dataOperationNode = elementSetNode.Nodes.Add(item.GetDataOperation(j).ID); dataOperationNode.ImageIndex = dataOperationNode.SelectedImageIndex = 12; dataOperationNode.Tag = item.GetDataOperation(j); } } } } treeView1.CollapseAll(); treeView1.EndUpdate(); _checkedQuantity = null; _checkedElementSet = null; _checkedDataOperations = new ArrayList(); }
private XYPolyline CreateXYPolyline(IElementSet elementSet, int index) { if (!(elementSet.ElementType == ElementType.XYPolyLine || elementSet.ElementType == ElementType.XYLine)) { throw new System.Exception("Cannot create XYPolyline"); } XYPolyline xyPolyline = new XYPolyline(); for (int i = 0; i < elementSet.GetVertexCount(index); i++) { xyPolyline.Points.Add(new XYPoint(elementSet.GetXCoordinate(index,i), elementSet.GetYCoordinate(index,i))); } return xyPolyline; }
/// <summary> /// Static method that validates an object with an IElementSet interface. The method /// raises an Exception in case IElementSet does not describe a valid ElementSet. /// The checks made are: /// <p>ElementType: Check</p> /// <p>XYPoint: Only one vertex in each element.</p> /// <p>XYPolyline: At least two vertices in each element.</p> /// <p> All line segments in each element has length > 0</p> /// <p>XYPolygon: At least three vertices in each element.</p> /// <p> Area of each element is larger than 0</p> /// <p> All line segments in each element has length > 0</p> /// <p> No line segments within an element crosses.</p> /// </summary> /// /// <param name="elementSet">Object that implement the IElementSet interface</param> /// /// <returns> /// The method has no return value. /// </returns> public static void CheckElementSet(IElementSet elementSet) { try { if(elementSet.ElementType == ElementType.XYPoint) { for (int i = 0; i < elementSet.ElementCount; i++) { try { if(elementSet.GetVertexCount(i) != 1) { throw new System.Exception("Number of vertices in point element is different from 1."); } } catch (System.Exception e) { throw new System.Exception("ElementID = "+elementSet.GetElementID(i),e); } } } else if(elementSet.ElementType == ElementType.XYPolyLine) { for (int i = 0; i < elementSet.ElementCount; i++) { try { XYPolyline xypolyline = new XYPolyline(); for (int j = 0; j < elementSet.GetVertexCount(i); j++) { XYPoint xypoint = new XYPoint(elementSet.GetXCoordinate(i,j),elementSet.GetYCoordinate(i,j)); xypolyline.Points.Add(xypoint); } xypolyline.Validate(); } catch (System.Exception e) { throw new System.Exception("ElementID = "+elementSet.GetElementID(i),e); } } } else if(elementSet.ElementType == ElementType.XYPolygon) { for (int i = 0; i < elementSet.ElementCount; i++) { try { XYPolygon xypolygon = new XYPolygon(); for (int j = 0; j < elementSet.GetVertexCount(i); j++) { XYPoint xypoint = new XYPoint(elementSet.GetXCoordinate(i,j),elementSet.GetYCoordinate(i,j)); xypolygon.Points.Add(xypoint); } xypolygon.Validate(); } catch (System.Exception e) { throw new System.Exception("ElementID = "+elementSet.GetElementID(i),e); } } } } catch (System.Exception e) { throw new System.Exception("ElementSet with ID = "+elementSet.ID+" is invalid",e); } }
private XYPolygon CreateXYPolygon(IElementSet elementSet, int index) { if (elementSet.ElementType != ElementType.XYPolygon) { throw new System.Exception("Cannot create XYPolyline"); } XYPolygon xyPolygon = new XYPolygon(); for (int i = 0; i < elementSet.GetVertexCount(index); i++) { xyPolygon.Points.Add(new XYPoint(elementSet.GetXCoordinate(index,i), elementSet.GetYCoordinate(index,i))); } return xyPolygon; }
public override void UpdateGeometry(IElementSet elementSet) { Contract.Requires(UpdateGeometryAvailable(elementSet), "updateGeometryAvailable(elementSet)"); base.UpdateGeometry(elementSet); var es = elementSet as ElementSetVerticesNonUnique; if (es != null) { X = es.X.Select(a => a.ToArray()).ToArray(); Y = es.Y.Select(a => a.ToArray()).ToArray(); Z = es.Z == null ? null : es.Z.Select(a => a.ToArray()).ToArray(); M = es.M == null ? null : es.M.Select(a => a.ToArray()).ToArray(); return; } X = new double[elementSet.ElementCount][]; Y = new double[elementSet.ElementCount][]; Z = HasZ ? new double[elementSet.ElementCount][] : null; M = HasM ? new double[elementSet.ElementCount][] : null; for (int nElement = 0; nElement < elementSet.ElementCount; ++nElement) { var nVertexLength = elementSet.GetVertexCount(nElement); X[nElement] = new double[nVertexLength]; Y[nElement] = new double[nVertexLength]; if (HasZ) Z[nElement] = new double[nVertexLength]; if (HasM) M[nElement] = new double[nVertexLength]; var vertexIndexs = Enumerable.Range(0, nVertexLength).ToArray(); foreach (var nVertex in vertexIndexs) { X[nElement][nVertex] = elementSet.GetVertexXCoordinate(nElement, nVertex); Y[nElement][nVertex] = elementSet.GetVertexYCoordinate(nElement, nVertex); if (HasZ) Z[nElement][nVertex] = elementSet.GetVertexZCoordinate(nElement, nVertex); if (HasM) M[nElement][nVertex] = elementSet.GetVertexMCoordinate(nElement, nVertex); } } }
/// <summary> /// Calculates the mapping matrix between fromElements and toElements. The mapping method /// is decided from the combination of methodDescription, fromElements.ElementType and /// toElements.ElementType. /// The valid values for methodDescription is obtained through use of the /// GetAvailableMethods method. /// </summary> /// /// <remarks> /// UpdateMappingMatrix is called during initialisation. UpdateMappingMatrix must be called prior /// to Mapvalues. /// </remarks> /// /// <param name="methodDescription">String description of mapping method</param> /// <param name="fromElements">The IElementset to map from.</param> /// <param name="toElements">The IElementset to map to</param> /// /// <returns> /// The method has no return value. /// </returns> public void UpdateMappingMatrix(string methodDescription, IElementSet fromElements, IElementSet toElements) { try { ElementSetChecker.CheckElementSet(fromElements); ElementSetChecker.CheckElementSet(toElements); _methodID = GetMethodID(methodDescription, fromElements.ElementType, toElements.ElementType); _numberOfRows = toElements.ElementCount; _numberOfColumns = fromElements.ElementCount; _mappingMatrix = new double[_numberOfRows, _numberOfColumns]; if (fromElements.ElementType == ElementType.XYPoint && toElements.ElementType == ElementType.XYPoint) // Point to Point { #region try { for (int i = 0; i < _numberOfRows; i++) { XYPoint ToPoint = CreateXYPoint(toElements,i); for (int j = 0; j < _numberOfColumns; j++) { XYPoint FromPoint = CreateXYPoint(fromElements,j); _mappingMatrix[i,j] = XYGeometryTools.CalculatePointToPointDistance(ToPoint, FromPoint); } } if (_methodID.Equals((int) eMethods.PointToPoint.Nearest)) { for (int i = 0; i < _numberOfRows; i++) { double MinDist = _mappingMatrix[i,0]; for (int j = 1; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] < MinDist) { MinDist = _mappingMatrix[i,j]; } } int Denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] == MinDist) { _mappingMatrix[i,j] = 1; Denominator++; } else { _mappingMatrix[i,j] = 0; } } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/Denominator; } } } // if (_methodID.Equals((int) eMethods.PointToPoint.Nearest)) else if (_methodID.Equals((int) eMethods.PointToPoint.Inverse)) { for (int i = 0; i < _numberOfRows; i++) { double MinDist = _mappingMatrix[i,0]; for (int j = 1; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] < MinDist) { MinDist = _mappingMatrix[i,j]; } } if (MinDist == 0) { int Denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] == MinDist) { _mappingMatrix[i,j] = 1; Denominator++; } else { _mappingMatrix[i,j] = 0; } } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/Denominator; } } else { double Denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = 1/_mappingMatrix[i,j]; Denominator = Denominator + _mappingMatrix[i,j]; } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/Denominator; } } } } // else if (_methodID.Equals((int) eMethods.PointToPoint.Inverse)) else { throw new System.Exception("methodDescription unknown for point point mapping"); } // else if (_methodID.Equals((int) eMethods.PointToPoint.Nearest)) and else if (_methodID.Equals((int) eMethods.PointToPoint.Inverse)) } catch (System.Exception e) // Catch for all of the Point to Point part { throw new System.Exception("Point to point mapping failed",e); } #endregion } else if (fromElements.ElementType == ElementType.XYPoint && ((toElements.ElementType == ElementType.XYPolyLine) || (toElements.ElementType == ElementType.XYLine))) // Point to PolyLine/Line { #region try { for (int i = 0; i < _numberOfRows; i++) { XYPolyline toPolyLine = CreateXYPolyline(toElements,i); for (int j = 0; j < _numberOfColumns; j++) { XYPoint fromPoint = CreateXYPoint(fromElements,j); _mappingMatrix[i,j] = XYGeometryTools.CalculatePolylineToPointDistance(toPolyLine, fromPoint); } } if (_methodID.Equals((int)eMethods.PointToPolyline.Nearest) || _methodID.Equals((int)eMethods.PointToLine.Nearest)) { for (int i = 0; i < _numberOfRows; i++) { double MinDist = _mappingMatrix[i,0]; for (int j = 1; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] < MinDist) { MinDist = _mappingMatrix[i,j]; } } int denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] == MinDist) { _mappingMatrix[i,j] = 1; denominator++; } else { _mappingMatrix[i,j] = 0; } } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/denominator; } } } // if (_methodID.Equals((int) eMethods.PointToPolyline.Nearest)) else if ((_methodID.Equals((int)eMethods.PointToPolyline.Inverse)) || (_methodID.Equals((int)eMethods.PointToLine.Inverse))) { for (int i = 0; i < _numberOfRows; i++) { double minDist = _mappingMatrix[i,0]; for (int j = 1; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] < minDist) { minDist = _mappingMatrix[i,j]; } } if (minDist == 0) { int denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] == minDist) { _mappingMatrix[i,j] = 1; denominator++; } else { _mappingMatrix[i,j] = 0; } } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/denominator; } } else { double denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = 1/_mappingMatrix[i,j]; denominator = denominator + _mappingMatrix[i,j]; } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/denominator; } } } } // else if (_methodID.Equals((int) eMethods.PointToPolyline.Inverse)) else // if _methodID != Nearest and Inverse { throw new System.Exception("methodDescription unknown for point to polyline mapping"); } } catch (System.Exception e)// Catch for all of the Point to Polyline part { throw new System.Exception("Point to polyline mapping failed",e); } #endregion } else if(fromElements.ElementType == ElementType.XYPoint && toElements.ElementType == ElementType.XYPolygon) // Point to Polygon { #region try { XYPolygon polygon; XYPoint point; int count; for (int i = 0; i < _numberOfRows; i++) { polygon = CreateXYPolygon(toElements,i); count = 0; for (int n = 0; n < _numberOfColumns; n++) { point = CreateXYPoint(fromElements, n); if(XYGeometryTools.IsPointInPolygon(point, polygon)) { if (_methodID.Equals((int) eMethods.PointToPolygon.Mean)) { count = count+1; } else if (_methodID.Equals((int) eMethods.PointToPolygon.Sum)) { count = 1; } else { throw new System.Exception("methodDescription unknown for point to polygon mapping"); } } } for (int n = 0; n < _numberOfColumns; n++) { point = CreateXYPoint(fromElements,n); if(XYGeometryTools.IsPointInPolygon(point, polygon)) { _mappingMatrix[i,n]=1.0/count; } } } } catch (System.Exception e)// Catch for all of the Point to Polyline part { throw new System.Exception("Point to polygon mapping failed",e); } #endregion } else if (((fromElements.ElementType == ElementType.XYPolyLine) || (fromElements.ElementType == ElementType.XYLine)) && toElements.ElementType == ElementType.XYPoint) // Polyline/Line to Point { #region try { for (int i = 0; i < _numberOfRows; i++) { XYPoint toPoint = CreateXYPoint(toElements,i); for (int j = 0; j < _numberOfColumns; j++) { XYPolyline fromPolyLine = CreateXYPolyline(fromElements,j); _mappingMatrix[i,j] = XYGeometryTools.CalculatePolylineToPointDistance(fromPolyLine, toPoint); } } if (_methodID.Equals((int)eMethods.PolylineToPoint.Nearest) || _methodID.Equals((int)eMethods.LineToPoint.Nearest)) { for (int i = 0; i < _numberOfRows; i++) { double minDist = _mappingMatrix[i,0]; for (int j = 1; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] < minDist) { minDist = _mappingMatrix[i,j]; } } int denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] == minDist) { _mappingMatrix[i,j] = 1; denominator++; } else { _mappingMatrix[i,j] = 0; } } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/denominator; } } } // if (_methodID.Equals((int) eMethods.PolylineToPoint.Nearest)) else if (_methodID.Equals((int)eMethods.PolylineToPoint.Inverse) || _methodID.Equals((int)eMethods.LineToPoint.Inverse)) { for (int i = 0; i < _numberOfRows; i++) { double minDist = _mappingMatrix[i,0]; for (int j = 1; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] < minDist) { minDist = _mappingMatrix[i,j]; } } if (minDist == 0) { int denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { if (_mappingMatrix[i,j] == minDist) { _mappingMatrix[i,j] = 1; denominator++; } else { _mappingMatrix[i,j] = 0; } } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/denominator; } } else { double denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = 1/_mappingMatrix[i,j]; denominator = denominator + _mappingMatrix[i,j]; } for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/denominator; } } } } // if (_methodID.Equals((int) eMethods.PolylineToPoint.Inverse)) else // MethodID != Nearest and Inverse { throw new System.Exception("methodDescription unknown for polyline to point mapping"); } } catch (System.Exception e)// Catch for all of the Point to Polyline part { throw new System.Exception("Polyline to point mapping failed",e); } #endregion } else if (((fromElements.ElementType == ElementType.XYPolyLine) || (fromElements.ElementType == ElementType.XYLine)) && toElements.ElementType == ElementType.XYPolygon) // PolyLine to Polygon { #region try { for (int i = 0; i < _numberOfRows; i++) { XYPolygon polygon = CreateXYPolygon(toElements,i); if (_methodID.Equals((int)eMethods.PolylineToPolygon.WeightedMean) || _methodID.Equals((int)eMethods.LineToPolygon.WeightedMean)) { double totalLineLengthInPolygon = 0; for (int n = 0; n < _numberOfColumns; n++) { XYPolyline polyline = CreateXYPolyline(fromElements,n); _mappingMatrix[i,n] = XYGeometryTools.CalculateLengthOfPolylineInsidePolygon(polyline,polygon); totalLineLengthInPolygon += _mappingMatrix[i,n]; } if (totalLineLengthInPolygon > 0) { for (int n = 0; n < _numberOfColumns; n++) { _mappingMatrix[i,n] = _mappingMatrix[i,n]/totalLineLengthInPolygon; } } } // if (_methodID.Equals((int) eMethods.PolylineToPolygon.WeightedMean)) else if (_methodID.Equals((int)eMethods.PolylineToPolygon.WeightedSum) || _methodID.Equals((int)eMethods.LineToPolygon.WeightedSum)) { for (int n = 0; n < _numberOfColumns; n++) { XYPolyline polyline = CreateXYPolyline(fromElements,n); _mappingMatrix[i,n] = XYGeometryTools.CalculateLengthOfPolylineInsidePolygon(polyline,polygon)/polyline.GetLength(); } // for (int n = 0; n < _numberOfColumns; n++) } // else if (_methodID.Equals((int) eMethods.PolylineToPolygon.WeightedSum)) else // if MethodID != WeightedMean and WeigthedSum { throw new System.Exception("methodDescription unknown for polyline to polygon mapping"); } } // for (int i = 0; i < _numberOfRows; i++) } catch (System.Exception e) // Catch for all of polyLine to polygon { throw new System.Exception("Polyline to polygon mapping failed",e); } #endregion } else if (fromElements.ElementType == ElementType.XYPolygon && toElements.ElementType == ElementType.XYPoint) // Polygon to Point { #region try { for (int n = 0; n < _numberOfRows; n++) { XYPoint point = CreateXYPoint(toElements,n); for (int i = 0; i < _numberOfColumns; i++) { XYPolygon polygon = CreateXYPolygon(fromElements,i); if(XYGeometryTools.IsPointInPolygon(point, polygon)) { if (_methodID.Equals((int) eMethods.PolygonToPoint.Value)) { _mappingMatrix[n,i]=1.0; } else // if _methodID != Value { throw new System.Exception("methodDescription unknown for polygon to point mapping"); } } } } } catch (System.Exception e) // catch for all of Polygon to Point { throw new System.Exception("Polygon to point mapping failed",e); } #endregion } else if (fromElements.ElementType == ElementType.XYPolygon && ((toElements.ElementType == ElementType.XYPolyLine) || (toElements.ElementType == ElementType.XYLine))) // Polygon to PolyLine { #region try { for (int i = 0; i < _numberOfRows; i++) { XYPolyline polyline = CreateXYPolyline(toElements,i); if (_methodID.Equals((int)eMethods.PolygonToPolyline.WeightedMean) || _methodID.Equals((int)eMethods.PolygonToLine.WeightedMean)) { for (int n = 0; n < _numberOfColumns; n++) { XYPolygon polygon = CreateXYPolygon(fromElements,n); _mappingMatrix[i,n] = XYGeometryTools.CalculateLengthOfPolylineInsidePolygon(polyline,polygon)/polyline.GetLength(); } double sum = 0; for (int n = 0; n < _numberOfColumns; n++) { sum += _mappingMatrix[i,n]; } for (int n = 0; n < _numberOfColumns; n++) { _mappingMatrix[i,n] = _mappingMatrix[i,n]/sum; } } // if (_methodID.Equals((int) eMethods.PolygonToPolyline.WeightedMean)) else if (_methodID.Equals((int)eMethods.PolygonToPolyline.WeightedSum) || _methodID.Equals((int)eMethods.PolygonToLine.WeightedSum)) { for (int n = 0; n < _numberOfColumns; n++) { XYPolygon polygon = CreateXYPolygon(fromElements,n); _mappingMatrix[i,n] = XYGeometryTools.CalculateLengthOfPolylineInsidePolygon(polyline,polygon)/polyline.GetLength(); } } // else if (_methodID.Equals((int) eMethods.PolygonToPolyline.WeightedSum)) else // _methodID != WeightedMean and WeightedSum { throw new System.Exception("methodDescription unknown for polygon to polyline mapping"); } } } catch (System.Exception e) // catch for all of Polygon to PolyLine { throw new System.Exception("Polygon to polyline mapping failed",e); } #endregion } else if(fromElements.ElementType == ElementType.XYPolygon && toElements.ElementType == ElementType.XYPolygon) // Polygon to Polygon { #region try { for (int i = 0; i < _numberOfRows; i++) { XYPolygon toPolygon = CreateXYPolygon(toElements,i); for (int j = 0; j < _numberOfColumns; j++) { XYPolygon fromPolygon = CreateXYPolygon(fromElements,j); _mappingMatrix[i,j] = XYGeometryTools.CalculateSharedArea(toPolygon, fromPolygon); } if (_methodID.Equals((int) eMethods.PolygonToPolygon.WeightedMean)) { double denominator = 0; for (int j = 0; j < _numberOfColumns; j++) { denominator = denominator + _mappingMatrix[i,j]; } for (int j = 0; j < _numberOfColumns; j++) { if (denominator != 0) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/denominator; } } } // if (_methodID.Equals((int) eMethods.PolygonToPolygon.WeightedMean)) else if (_methodID.Equals((int) eMethods.PolygonToPolygon.WeightedSum)) { for (int j = 0; j < _numberOfColumns; j++) { _mappingMatrix[i,j] = _mappingMatrix[i,j]/toPolygon.GetArea(); } } // else if (_methodID.Equals((int) eMethods.PolygonToPolygon.WeightedSum)) else // _methodID != WeightedMean and WeightedSum { throw new System.Exception("methodDescription unknown for polygon to polygon mapping"); } } } catch (System.Exception e) // catch for all of Polygon to Polygon { throw new System.Exception("Polygon to polygon mapping failed",e); } #endregion } else // if the fromElementType, toElementType combination is no implemented { throw new System.Exception("Mapping of specified ElementTypes not included in ElementMapper"); } } catch (System.Exception e) { throw new System.Exception("UpdateMappingMatrix failed to update mapping matrix",e); } }
public override void UpdateGeometry(IElementSet elementSet) { base.UpdateGeometry(elementSet); _indexMap = null; }
public int GetDiscreteTimesCount(IQuantity quantity, IElementSet elementSet) { if (!initializeWasInvoked) { throw new Exception("Method \"GetDiscreteTimesCount\" in LinkableTimeSeriesGroup class was invoked before the Initialize method was invoked"); } if (((TsQuantity)quantity).BaseTimeSeries is TimestampSeries) { return ((TimestampSeries)((TsQuantity)quantity).BaseTimeSeries).Items.Count; } else if (((TsQuantity)quantity).BaseTimeSeries is TimespanSeries) { return ((TimespanSeries)((TsQuantity)quantity).BaseTimeSeries).Items.Count; } else { throw new Exception("undefined time series type"); } }
public override bool UpdateGeometryAvailable(IElementSet elementSetEdits) { string whyNot; return IsSinglePolyLine(elementSetEdits, out whyNot); }
public ElementSetProposed(IElementSet iElementSet) : base(iElementSet) { }
public void AppendValueSet(String quantityId, IElementSet elementSet, ScalarSet valueSet) { Append(quantityId); for (var index = 0; index < elementSet.ElementCount; index++) { var id = elementSet.GetElementID(index); Append(id + ":" + valueSet.GetScalar(index)); } }
public virtual bool UpdateGeometryAvailable(IElementSet elementSetEdits) { return false; }
/// <summary> /// Constructs a new <see cref="PropertyManager">PropertyManager</see> from <c>object</c> /// of known type. /// </summary> /// <param name="obj">Object of known type.</param> /// <param name="allReadOnly">If true, all properties are readonly.</param> /// <returns>Returns new <see cref="PropertyManager">PropertyManager</see> /// or <c>null</c> if object's type isn't known.</returns> /// <remarks>A this time this method knowns following types: /// <list> /// <item><see cref="IQuantity">IQuantity</see></item> /// <item><see cref="IElementSet">IElementSet</see></item> /// <item><see cref="IDataOperation">IDataOperation</see></item> /// <item><see cref="ILinkableComponent">ILinkableComponent</see></item> /// </list> /// Method saves <c>obj</c> parameter to <see cref="Tag">Tag</see> property, but you can /// use it for any purpose. /// </remarks> public static PropertyManager ConstructPropertyManager(object obj, bool allReadOnly) { PropertyManager prop = null; if (obj is IQuantity) { IQuantity quantity = (IQuantity)obj; prop = new PropertyManager(); // General prop.SetProperty("Description", quantity.Description, true, "Description of this Quantity.", "General"); prop.SetProperty("ID", quantity.ID, true, "ID of this Quantity.", "General"); prop.SetProperty("ValueType", quantity.ValueType.ToString(), true, "Type of this Quantity's value.", "General"); // Dimensions prop.SetProperty("AmountOfSubstance", quantity.Dimension.GetPower(DimensionBase.AmountOfSubstance).ToString(), true, "The amount of substance in mole.", "Dimensions"); prop.SetProperty("Currency", quantity.Dimension.GetPower(DimensionBase.Currency).ToString(), true, "Currency in Euro.", "Dimensions"); prop.SetProperty("ElectricCurrent", quantity.Dimension.GetPower(DimensionBase.ElectricCurrent).ToString(), true, "Electric current in ampere.", "Dimensions"); prop.SetProperty("Length", quantity.Dimension.GetPower(DimensionBase.Length).ToString(), true, "Length in meter.", "Dimensions"); prop.SetProperty("LuminousIntensity", quantity.Dimension.GetPower(DimensionBase.LuminousIntensity).ToString(), true, "Luminous intensity in candela.", "Dimensions"); prop.SetProperty("Mass", quantity.Dimension.GetPower(DimensionBase.Mass).ToString(), true, "Mass in kilogram.", "Dimensions"); prop.SetProperty("Temperature", quantity.Dimension.GetPower(DimensionBase.Temperature).ToString(), true, "Temperature in kelvin.", "Dimensions"); prop.SetProperty("Time", quantity.Dimension.GetPower(DimensionBase.Time).ToString(), true, "Time in second.", "Dimensions"); // Unit prop.SetProperty("ConversionFactorToSI", quantity.Unit.ConversionFactorToSI.ToString(), true, "Multiplicative coefficient used to convert this quantity to SI (SiUnit = Unit*ConversionFactorToSI + OffSetToSI).", "Unit"); prop.SetProperty("OffSetToSI", quantity.Unit.OffSetToSI.ToString(), true, "Additive coefficient used to convert this quantity to SI (SiUnit = Unit*ConversionFactorToSI + OffSetToSI).", "Unit"); prop.SetProperty("UnitDescription", quantity.Unit.Description, true, "Description of this unit.", "Unit"); prop.SetProperty("UnitID", quantity.Unit.ID, true, "ID of this unit.", "Unit"); } else if (obj is IElementSet) { IElementSet elementSet = (IElementSet)obj; prop = new PropertyManager(); // General prop.SetProperty("ID", elementSet.ID, true, "ID of this ElementSet", "General"); prop.SetProperty("Version", elementSet.Version.ToString(), true, "Version of this ElementSet.", "General"); string spatialReference = string.Empty; if (elementSet.SpatialReference != null) { spatialReference = elementSet.SpatialReference.ID; } prop.SetProperty("SpatialReferenceID", spatialReference, true, "ID of this ElementSet's SpatialReference", "General"); prop.SetProperty("Description", elementSet.Description, true, "Description of this ElementSet.", "General"); prop.SetProperty("ElementCount", elementSet.ElementCount.ToString(), true, "Count of elements of this ElementSet.", "General"); prop.SetProperty("ElementType", elementSet.ElementType.ToString(), true, "Type of elements in this ElementSet.", "General"); } else if (obj is IDataOperation) { IDataOperation dataOperation = (IDataOperation)obj; prop = new PropertyManager(); string DataOperationID = "DataOperationID"; // small trick to avoid that some argument's name is same as DataOperationID. // it's not quite pure, but it works:-) bool conflict; do { conflict = false; for (int i = 0; i < dataOperation.ArgumentCount; i++) { if (dataOperation.GetArgument(i).Key == DataOperationID) { DataOperationID += " "; conflict = true; break; } } }while(conflict); // General prop.SetProperty(DataOperationID, dataOperation.ID, true, "ID of this DataOperation", "General"); // Arguments for (int i = 0; i < dataOperation.ArgumentCount; i++) { IArgument arg = dataOperation.GetArgument(i); prop.SetProperty(arg.Key, arg.Value, arg.ReadOnly || allReadOnly, arg.Description, "Arguments"); } } else if (obj is ILinkableComponent) { ILinkableComponent linkableComponent = (ILinkableComponent)obj; prop = new PropertyManager(); DateTime timeHorizonStart = DateTime.MinValue; DateTime timeHorizonEnd = DateTime.MaxValue; if (linkableComponent.TimeHorizon != null) { timeHorizonStart = CalendarConverter.ModifiedJulian2Gregorian(linkableComponent.TimeHorizon.Start.ModifiedJulianDay); timeHorizonEnd = CalendarConverter.ModifiedJulian2Gregorian(linkableComponent.TimeHorizon.End.ModifiedJulianDay); } DateTime earliestInputTime = DateTime.MinValue; if (linkableComponent.EarliestInputTime != null) { earliestInputTime = CalendarConverter.ModifiedJulian2Gregorian(linkableComponent.EarliestInputTime.ModifiedJulianDay); } // General prop.SetProperty("ComponentID", linkableComponent.ComponentID, true, "ID the component.", "General"); prop.SetProperty("ComponentDescription", linkableComponent.ComponentDescription, true, "Description of this component.", "General"); prop.SetProperty("InputExchangeItemCount", linkableComponent.InputExchangeItemCount.ToString(), true, "Number of input exchange items.", "General"); prop.SetProperty("OutputExchangeItemCount", linkableComponent.OutputExchangeItemCount.ToString(), true, "Number of output exchange items.", "General"); prop.SetProperty("ModelID", linkableComponent.ModelID, true, "ID of the model (model=component+data).", "General"); prop.SetProperty("ModelDescription", linkableComponent.ModelDescription, true, "Description of the model.", "General"); prop.SetProperty("TimeHorizonStart", timeHorizonStart.ToString(), true, "Start of component's timehorizon.", "General"); prop.SetProperty("TimeHorizonEnd", timeHorizonEnd.ToString(), true, "End of component's timehorizon.", "General"); prop.SetProperty("ValidationMessage", linkableComponent.Validate(), true, "Validation string generated by component. No error ocured if it's empty.", "General"); prop.SetProperty("EarliestInputTime", earliestInputTime.ToString(), true, "Earliest time for which component needs next input.", "General"); string implementsIManageState = obj is IManageState ? "yes" : "no"; prop.SetProperty("ImplementsIManageState", implementsIManageState, true, "Describes whether model implements IManageState interface.", "General"); } if (prop != null) { prop.Tag = obj; } return(prop); }
/** * Returns the ValueSet that corresponds to requestTime. */ public IValueSet GetValues(ITime requestedTime, IQuantity quantity, IElementSet elementSet, PrefetchManager prefetchManager, ILink link) { try { // generate the key of the buffer entry we're looking for var key = ValueSetEntry.CreateKey(webServiceManager.FindServiceIdForQuantity(quantity.ID), quantity.ID, elementSet.ID, requestedTime, scenarioId); traceFile.Append("GetValues: " + key); var mapValueSet = client.getMap<string, ValueSetEntry>("valueSet"); var mapElementSet = client.getMap<string, ElementSetEntry>("elementSet"); var queueValueSetRequest = client.getQueue<ValueSetRequestEntry>("valueSetRequest"); // record this request statistics.Add("GetValuesCount", 1); // measure our wait time var waitStopwatch = Stopwatch.StartNew(); // see if the requested values are in the cache var valueSetEntry = mapValueSet.get(key); // if the value set does not exist then request it if (valueSetEntry == null) { traceFile.Append("Requesting Value Set: " + key); // insert the element set if necessary if (elementSetsPut.Contains(elementSet.ID) == false) { elementSetsPut.Add(elementSet.ID); mapElementSet.put(elementSet.ID, new ElementSetEntry(elementSet)); } while (valueSetEntry == null) { // if we're prefetching, we may have already requested this // value set in a previous prefetch that hasn't been fulfilled // yet in which case we do not want to issue the request again. if (prefetchManager.timeIsFetched(link, (TimeStamp)requestedTime) == false) { // insert the request into the queue var insertRequestStopwatch = Stopwatch.StartNew(); // create the request entry var valueSetRequestEntry = new ValueSetRequestEntry(webServiceManager.FindServiceIdForQuantity(quantity.ID), quantity.ID, elementSet.ID, Utils.ITimeToDateTime(requestedTime), scenarioId); // BLOCKING queueValueSetRequest.put(valueSetRequestEntry); statistics.Add("RequestInsertTimeMS", insertRequestStopwatch.ElapsedMilliseconds); traceFile.Append("RequestInsertTime:" + string.Format("{0:0.0}", insertRequestStopwatch.ElapsedMilliseconds) + "ms"); } // PERFORMANCE STUDY: start delay at 100 and double each time // we check and it's not available // poll for the value set var delay = 1000; while (true) { // we know that the value set is not in the cache since // we just checked that above, so wait immediately after // making the request Thread.Sleep(delay); valueSetEntry = mapValueSet.get(key); if (valueSetEntry != null) { break; } //delay *= 2; traceFile.Append(string.Format("Waiting ({0}) For Value Set: ({1})", delay, key)); if (delay > 20000) { statistics.Add("RequestRetry", 1); break; } } } } statistics.Add("CacheWaitTimeMS", waitStopwatch.ElapsedMilliseconds); traceFile.Append("WaitTime:" + string.Format("{0:0.0}", waitStopwatch.ElapsedMilliseconds) + "ms"); return new ScalarSet(valueSetEntry.Values()); } catch (Exception e) { traceFile.Exception(e); return null; } }
private XYPoint CreateXYPoint(IElementSet elementSet, int index) { if (elementSet.ElementType != ElementType.XYPoint) { throw new System.Exception("Cannot create XYPoint"); } XYPoint xyPoint = new XYPoint(); xyPoint.X = elementSet.GetXCoordinate(index,0); xyPoint.Y = elementSet.GetYCoordinate(index,0); return xyPoint; }
public override bool UpdateGeometryAvailable(IElementSet elementSetEdits) { return elementSetEdits.ElementType == ElementType.Point; }
public InputExchangeItem(string id, IValueDefinition valueDefinition, IElementSet elementSet) : base(id, valueDefinition, elementSet) { }
public static void WriteArrayToFile(string path, string dataName, string header, DateTime dateTime, double[] data, IElementSet elementSet) { // don't write out empty data sets if (IsEmpty(data)) return; var dt = string.Format("{0:0000}{1:00}{2:00}", dateTime.Year, dateTime.Month, dateTime.Day); dataName = dataName.Replace(' ', '_'); var filename = dataName + dt + ".txt"; var writer = new StreamWriter(Path.Combine(path, filename), false); writer.WriteLine(header); for (var i = 0; i < data.Length; i++) { var wellID = elementSet.GetElementID(i); writer.Write(wellID.PadLeft(8, ' ')); var value = String.Format("{0:0.0000}", data[i]); writer.Write(value.PadLeft(12, ' ')); writer.WriteLine(); } writer.Close(); }
public void GetValues() { IQuantity riverModelOutflowQuantity = simpleRiver.Outputs[0].ValueDefinition as IQuantity; IElementSet riverModelNodeElement = ((ITimeSpaceOutput)simpleRiver.Outputs[0]).ElementSet(); Input queryItem1; var dischargeQuantity = new Quantity(new Unit(PredefinedUnits.CubicMeterPerSecond), null, "Discharge"); var waterlevelQuantity = new Quantity(new Unit(PredefinedUnits.Meter), null, "Water Level"); var idBasedElementSetA = new ElementSet(null, "ElmSet-A", ElementType.IdBased); idBasedElementSetA.AddElement(new Element("elm-1")); queryItem1 = new Input("discharge, to be retrieved from some output item", dischargeQuantity, idBasedElementSetA); queryItem1.TimeSet = new TimeSet(); // Connect the queryItem with the first output item using a time interpolator TimeBufferer buffer = new TimeInterpolator((ITimeSpaceOutput)simpleRiver.Outputs[0]); simpleRiver.Outputs[0].AddAdaptedOutput(buffer); buffer.AddConsumer(queryItem1); simpleRiver.Validate(); simpleRiver.Prepare(); //IListener eventListener = new EventListener(); //for (int i = 0; i < eventListener.GetAcceptedEventTypeCount(); i++) //{ // for (int n = 0; n < simpleRiver.GetPublishedEventTypeCount(); n++) // { // if (eventListener.GetAcceptedEventType(i) == simpleRiver.GetPublishedEventType(n)) // { // simpleRiver.Subscribe(eventListener, eventListener.GetAcceptedEventType(i)); // } // } //} double startTime = simpleRiver.TimeExtent.TimeHorizon.StampAsModifiedJulianDay; ITime[] times = new ITime[5]; times[0] = new Time(startTime + 1); times[1] = new Time(startTime + 2); times[2] = new Time(startTime + 3); times[3] = new Time(startTime + 4); times[4] = new Time(startTime + 5); ITimeSpaceValueSet values; queryItem1.TimeSet.SetSingleTimeStamp(times[0].StampAsModifiedJulianDay); values = ((ITimeSpaceOutput)queryItem1.Provider).GetValues(queryItem1); Assert.AreEqual(0.55, values.GetValue(0, 0)); queryItem1.TimeSet.SetSingleTimeStamp(times[1].StampAsModifiedJulianDay); values = ((ITimeSpaceOutput)queryItem1.Provider).GetValues(queryItem1); Assert.AreEqual(1.1, values.GetValue(0, 0)); queryItem1.TimeSet.SetSingleTimeStamp(times[2].StampAsModifiedJulianDay); values = ((ITimeSpaceOutput)queryItem1.Provider).GetValues(queryItem1); Assert.AreEqual(1.6, values.GetValue(0, 0)); queryItem1.TimeSet.SetSingleTimeStamp(times[3].StampAsModifiedJulianDay); values = ((ITimeSpaceOutput)queryItem1.Provider).GetValues(queryItem1); Assert.AreEqual(2.1, values.GetValue(0, 0)); queryItem1.TimeSet.SetSingleTimeStamp(times[4].StampAsModifiedJulianDay); values = ((ITimeSpaceOutput)queryItem1.Provider).GetValues(queryItem1); Assert.AreEqual(2.6, values.GetValue(0, 0)); }