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);
			}
		}
Exemple #8
0
 /// <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);
            }
        }
Exemple #10
0
 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;
 }
Exemple #15
0
		/// <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;
		}
Exemple #16
0
		/// <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();
        }
Exemple #18
0
 public Output(string id, IValueDefinition valueDefinition, IElementSet elementSet) :
     base(id, valueDefinition, elementSet)
 {
 }
	  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;
 }
Exemple #34
0
 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));
        }