/// <summary> /// Retrieves data from the providing LinkableComponent as defined /// in the Link and sets this data in the engine /// </summary> public virtual void UpdateInput() { ITime inputTime = this._engine.GetInputTime(link.TargetQuantity.ID, link.TargetElementSet.ID); if (inputTime != null) { SendEvent(EventType.TargetBeforeGetValuesCall, this.link.TargetComponent); IScalarSet sourceValueSet = (IScalarSet)link.SourceComponent.GetValues(inputTime, link.ID); //The input values set is copied in ordet to avoid the risk that it is changed be the provider. double targetMissValDef = this._engine.GetMissingValueDefinition(); ScalarSet targetValueSet = new ScalarSet(sourceValueSet); for (int i = 0; i < sourceValueSet.Count; i++) { if (!sourceValueSet.IsValid(i)) { targetValueSet.data[i] = targetMissValDef; } } targetValueSet.MissingValueDefinition = targetMissValDef; targetValueSet.CompareDoublesEpsilon = targetMissValDef / 1.0e+10; SendEvent(EventType.TargetAfterGetValuesReturn, this.link.TargetComponent); this.Engine.SetValues(link.TargetQuantity.ID, link.TargetElementSet.ID, targetValueSet); } }
public void CopyConstructorSpeed() { var random = new Random(); var values = new double[5000000]; for (var i = 0; i < 5000000; i++) { values[i] = random.Next(); } var scalarSet = new ScalarSet(values); // copying values var stopwatch = new Stopwatch(); stopwatch.Start(); values.Clone(); stopwatch.Stop(); var copyArrayTime = stopwatch.ElapsedMilliseconds; Trace.WriteLine("Copying array with 1M values took: " + copyArrayTime + " ms"); stopwatch.Reset(); stopwatch.Start(); new ScalarSet(scalarSet); stopwatch.Stop(); Trace.WriteLine("Copying scalar set with 1M values took: " + stopwatch.ElapsedMilliseconds + " ms"); var fraction = stopwatch.ElapsedMilliseconds/copyArrayTime; Assert.IsTrue(fraction < 1.1); }
public void Equals() { double[] values={1.0,2.0,3.0}; ScalarSet scalarSet2 = new ScalarSet(values); Assert.IsTrue(scalarSet.Equals(scalarSet2)); scalarSet2.data[1] = 2.5; Assert.IsFalse(scalarSet.Equals(scalarSet2)); }
public void AddValues_01() { try { SmartBuffer smartBuffer = new SmartBuffer(); smartBuffer.DoExtendedDataVerification = true; ScalarSet scalarSet = new ScalarSet(new double[3] { 0, 1, 2 }); TimeStamp timeStamp = new TimeStamp(1); smartBuffer.AddValues(timeStamp, scalarSet); timeStamp.ModifiedJulianDay = 2; scalarSet.data[0] = 10; scalarSet.data[1] = 11; scalarSet.data[2] = 12; smartBuffer.AddValues(timeStamp, scalarSet); smartBuffer.AddValues(new TimeStamp(3), new ScalarSet(new double[3] { 110, 111, 112 })); smartBuffer.AddValues(new TimeStamp(4), new ScalarSet(new double[3] { 1110, 1111, 1112 })); Assert.AreEqual(0,((IScalarSet) smartBuffer.GetValuesAt(0)).GetScalar(0)); Assert.AreEqual(1,((IScalarSet) smartBuffer.GetValuesAt(0)).GetScalar(1)); Assert.AreEqual(2,((IScalarSet) smartBuffer.GetValuesAt(0)).GetScalar(2)); Assert.AreEqual(10,((IScalarSet) smartBuffer.GetValuesAt(1)).GetScalar(0)); Assert.AreEqual(11,((IScalarSet) smartBuffer.GetValuesAt(1)).GetScalar(1)); Assert.AreEqual(12,((IScalarSet) smartBuffer.GetValuesAt(1)).GetScalar(2)); Assert.AreEqual(110,((IScalarSet) smartBuffer.GetValuesAt(2)).GetScalar(0)); Assert.AreEqual(111,((IScalarSet) smartBuffer.GetValuesAt(2)).GetScalar(1)); Assert.AreEqual(112,((IScalarSet) smartBuffer.GetValuesAt(2)).GetScalar(2)); Assert.AreEqual(1110,((IScalarSet) smartBuffer.GetValuesAt(3)).GetScalar(0)); Assert.AreEqual(1111,((IScalarSet) smartBuffer.GetValuesAt(3)).GetScalar(1)); Assert.AreEqual(1112,((IScalarSet) smartBuffer.GetValuesAt(3)).GetScalar(2)); Assert.AreEqual(4,smartBuffer.TimesCount); Assert.AreEqual(3,smartBuffer.ValuesCount); } catch (System.Exception e) { WriteException(e); throw (e); } }
///<summary> /// Check if the current instance equals another instance of this class. ///</summary> ///<param name="obj">The instance to compare the current instance with.</param> ///<returns><code>true</code> if the instances are the same instance or have the same content.</returns> public override bool Equals(Object obj) { if (obj is ScalarSet) { ScalarSet sourceSet = (ScalarSet)obj; if (sourceSet.Count != Count) { return(false); } for (int i = 0; i < Count; i++) { if (sourceSet.GetScalar(i) != GetScalar(i)) { return(false); } } return(true); } return(base.Equals(obj)); }
public global::OpenMI.Standard.IValueSet GetValues(string QuantityID, string ElementSetID) { if (QuantityID != ElementSetID) { throw new ApplicationException("Element sets should be named after quantities"); } if (!_elementSets.Contains(ElementSetID)) { throw new ApplicationException("Unknown element set '" + ElementSetID + "'"); } ElementSet elementSet = (ElementSet)_elementSets[ElementSetID]; int count = elementSet.ElementCount; double[] returnValues = new double[count]; // This is O (e * s * q) instead of O (1). for (int e = 0; e < count; e++) { Element element = elementSet.GetElement(e); string ColumnID = element.ID; if (!_elementScopes.Contains(element)) { throw new ApplicationException("Unknown element for '" + ColumnID + "'/'" + QuantityID + "'"); } Scope scope = (Scope)_elementScopes[element]; if (scope.HasNumber(QuantityID)) { returnValues[e] = scope.Number(QuantityID); } else { returnValues[e] = GetMissingValueDefinition(); } } Oatc.OpenMI.Sdk.Backbone.ScalarSet values = new Oatc.OpenMI.Sdk.Backbone.ScalarSet(returnValues); return(values); }
/// <summary> /// Add corresponding values for time and values to the SmartBuffer. /// </summary> /// <param name="time"> Description of the time parameter</param> /// <param name="valueSet">Description of the values parameter</param> /// <remarks> /// The AddValues method will internally make a copy of the added times and values. The reason for /// doing this is that the times and values arguments are references, and the correspondign values /// could be changed by the owner of the classes /// </remarks> public void AddValues(ITime time, IValueSet valueSet) { if (time is ITimeStamp) { _times.Add(new TimeStamp( ((ITimeStamp) time).ModifiedJulianDay )); } else if(time is ITimeSpan) { TimeStamp newStartTime = new TimeStamp(((ITimeSpan) time).Start.ModifiedJulianDay); TimeStamp newEndTime = new TimeStamp(((ITimeSpan) time).End.ModifiedJulianDay); Backbone.TimeSpan newTimeSpan = new Backbone.TimeSpan(newStartTime, newEndTime); _times.Add(newTimeSpan); } else { throw new Exception("Invalid datatype used for time argument in method AddValues"); } if (valueSet is IScalarSet) { double[] x = new double[(valueSet).Count]; for (int i = 0; i < x.Length; i++) { x[i] = ((IScalarSet) valueSet).GetScalar(i); } ScalarSet newScalarSet = new ScalarSet(x); if (valueSet is ScalarSet) { newScalarSet.MissingValueDefinition = ((ScalarSet)valueSet).MissingValueDefinition; newScalarSet.CompareDoublesEpsilon = ((ScalarSet)valueSet).CompareDoublesEpsilon; } _values.Add(newScalarSet); } else if (valueSet is IVectorSet) { Vector[] vectors = new Vector[valueSet.Count]; for (int i = 0; i < vectors.Length; i++) { vectors[i] = new Vector(((IVectorSet) valueSet).GetVector(i).XComponent, ((IVectorSet) valueSet).GetVector(i).YComponent, ((IVectorSet) valueSet).GetVector(i).ZComponent); } VectorSet newVectorSet = new VectorSet(vectors); _values.Add(newVectorSet); } else { throw new Exception("Invalid datatype used for values argument in method AddValues"); } if (_doExtendedDataVerification) { CheckBuffer(); } }
public void Run(ITimeStamp time) { //IScalarSet scalarSet = new ScalarSet(); ScalarSet scalarSet = new ScalarSet((IScalarSet) _link.SourceComponent.GetValues(time,_link.ID)); _earliestInputTime.ModifiedJulianDay = time.ModifiedJulianDay; _resultsBuffer.AddValues(time,scalarSet); }
/// <summary> /// Implementation of the same method in /// OpenMI.Standard.ILInkableComponent /// </summary> /// <param name="time">Time (ITimeSpan or ITimeStamp) for which values are requested</param> /// <param name="LinkID">LinkID associated to the requested values</param> /// <returns>The values</returns> public override IValueSet GetValues(ITime time, string LinkID) { try { CheckTimeArgumentInGetvaluesMethod(time); SendSourceAfterGetValuesCallEvent(time, LinkID); IValueSet engineResult = new ScalarSet(); int outputLinkIndex = -999; for (int i = 0; i < _smartOutputLinks.Count; i++) { if (((SmartOutputLink)_smartOutputLinks[i]).link.ID == LinkID) { outputLinkIndex = i; break; } } RunToTime(time, outputLinkIndex); engineResult = ((SmartOutputLink)_smartOutputLinks[outputLinkIndex]).GetValue(time); SendEvent(EventType.SourceBeforeGetValuesReturn); return engineResult; } catch (System.Exception e) { string message = "Exception in LinkableComponent. ComponentID: "; message += this.ComponentID; throw new System.Exception(message, e); } }
/// <summary> /// A ValueSet corresponding to a TimeSpan is calculated using interpolation or /// extrapolation in corresponding lists of ValueSets and TimeStamps. /// </summary> /// <param name="requestedTime">Time for which the ValueSet is requested</param> /// <returns>ValueSet that corresponds to requestedTime</returns> private IValueSet MapFromTimeStampsToTimeSpan(ITimeSpan requestedTime) { try { int m = ((IValueSet)_values[0]).Count; //int N = _times.Count; // Number of time steps in buffer double[][] xr = new double[m][]; // Values to return double trb = requestedTime.Start.ModifiedJulianDay; // Begin time in requester time interval double tre = requestedTime.End.ModifiedJulianDay; // End time in requester time interval int nk; // number of components (scalars has only 1 and vectors has 3 (3 axis)) if (_values[0] is IVectorSet) { nk = 3; } else { nk = 1; } for (int i = 0; i < m; i++) { xr[i] = new double[nk]; } for (int i = 0; i < m; i++) { for (int k = 0; k < nk; k++) { xr[i][k] = 0; } } for (int n = 0; n < _times.Count-1; n++) { double tbn = ((ITimeStamp) _times[n]).ModifiedJulianDay; double tbnp1 = ((ITimeStamp) _times[n+1]).ModifiedJulianDay; //--------------------------------------------------------------------------- // B: <--------------------------> // R: <-------------------------------------> // -------------------------------------------------------------------------- if (trb <= tbn && tre >= tbnp1 ) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += 0.5 * (sbin + sbinp1) * (tbnp1 - tbn)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbn <= trb && tre <= tbnp1) //cover all { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += sbin + ((sbinp1 - sbin)/(tbnp1 - tbn))*((tre + trb)/2 - tbn); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbn < trb && trb < tbnp1 && tre > tbnp1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += (sbinp1 - (sbinp1 - sbin)/(tbnp1 - tbn)*((tbnp1 - trb)/2))* (tbnp1 - trb)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (trb < tbn && tre > tbn && tre < tbnp1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); double sbinp1 = Support.GetVal((IValueSet)_values[n+1], i, k); xr[i][k-1] += (sbin + (sbinp1 - sbin)/(tbnp1 - tbn)*((tre - tbn)/2)) * (tre - tbn)/(tre - trb); } } } } //-------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //--------------------------------------------------------------------------- double tb0 = ((ITimeStamp) _times[0]).ModifiedJulianDay; //double tb1 = ((ITimeStamp) _times[0]).ModifiedJulianDay; double tb1 = ((ITimeStamp) _times[1]).ModifiedJulianDay; // line above was corrected to this Gregersen Sep 15 2004 double tbN_1 = ((ITimeStamp) _times[_times.Count-1]).ModifiedJulianDay; double tbN_2 = ((ITimeStamp) _times[_times.Count-2]).ModifiedJulianDay; if (trb < tb0 && tre > tb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] += ((tb0 - trb)/(tre - trb)) * (sbi0 - (1 - _relaxationFactor) * 0.5 * ((tb0 - trb)*(sbi1 - sbi0)/(tb1 - tb0))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (tre > tbN_1 && trb < tbN_1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); xr[i][k-1] += ((tre - tbN_1)/(tre - trb)) * (sbiN_1 + (1 - _relaxationFactor) * 0.5 * ((tre - tbN_1)*(sbiN_1 - sbiN_2)/(tbN_1 - tbN_2))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (trb >= tbN_1) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); xr[i][k-1] = sbiN_1 + (1 - _relaxationFactor) * ((sbiN_1 - sbiN_2)/(tbN_1 - tbN_2)) * ( 0.5 * (trb + tre) - tbN_1); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (tre <= tb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] = sbi0 - (1 - _relaxationFactor) * ((sbi1 - sbi0)/(tb1- tb0))*(tb0 - 0.5 * (trb + tre)); } } } //------------------------------------------------------------------------------------- if (_values[0] is IVectorSet) { Vector [] vectors = new Vector[m]; for (int i = 0; i < m; i++) { vectors[i] = new Vector(xr[i][0],xr[i][1],xr[i][2]); } VectorSet vectorSet = new VectorSet(vectors); return vectorSet; } else { double[] xx = new double[m]; for (int i = 0; i < m; i++) { xx[i] = xr[i][0]; } ScalarSet scalarSet = new ScalarSet(xx); return scalarSet; } } catch (Exception e) { throw new Exception("MapFromTimeStampsToTimeSpan Failed",e); } }
/// <summary> /// Get values for: /// flow at outlet /// concentrations at outlet /// ponded water column /// </summary> public IValueSet GetValues(string QuantityID, string ElementSetID) { getValuesWatch.Start(); double[] returnValues; if (QuantityID == qtdOutflow.ID) { returnValues = new double[1]; returnValues[0] = mohidLandEngine.GetOutletFlow(drainageNetworkInstanceID); } else if (QuantityID == qtdWaterColumn.ID) { returnValues = new double[numberOfWaterPoints]; mohidLandEngine.GetPondedWaterColumn(runoffInstanceID, numberOfWaterPoints, ref returnValues); } else if (QuantityID == qtdFlowToStorm.ID) { int numberOfOutflowNodes = mohidLandEngine.GetNumberOfStormWaterOutFlowNodes(drainageNetworkInstanceID); returnValues = new double[numberOfOutflowNodes]; mohidLandEngine.GetStormWaterOutflow(drainageNetworkInstanceID, numberOfOutflowNodes, ref returnValues); } else //Concentration of properties { returnValues = new double[1]; int propertyID = Convert.ToInt32(QuantityID); returnValues[0] = mohidLandEngine.GetOutletFlowConcentration(drainageNetworkInstanceID, propertyID); } ScalarSet values = new ScalarSet(returnValues); getValuesWatch.Stop(); return values; }
public override IValueSet GetValues(ITime time, string LinkID) { // synchronize access to this method to ensure serial execution // in case it is called in parallel lock (syncLock) { try { CheckTimeArgumentInGetvaluesMethod(time); SendSourceAfterGetValuesCallEvent(time, LinkID); IValueSet engineResult = new ScalarSet(); int outputLinkIndex = -999; for (int i = 0; i < _smartOutputLinks.Count; i++) { if (((SmartOutputLink)_smartOutputLinks[i]).link.ID == LinkID) { outputLinkIndex = i; break; } } if (_isBusy == false) { //while(IsLater(time,_engineApiAccess.GetCurrentTime())) while (IsLater(time, ((SmartOutputLink)_smartOutputLinks[outputLinkIndex]).GetLastBufferedTime())) { _isBusy = true; //Update input links // new parallel code var threadList = new ArrayList(); foreach (SmartInputLink smartInputLink in _smartInputLinks) { var thread = new Thread(delegate() { smartInputLink.UpdateInput(); }); thread.IsBackground = true; threadList.Add(thread); thread.Start(); } foreach (Thread thread in threadList) { thread.Join(); } // original serial code //foreach(SmartInputLink smartInputLink in _smartInputLinks) //{ // smartInputLink.UpdateInput(); //} _isBusy = false; //Perform Timestep if (_engineApiAccess.PerformTimeStep()) { //Update buffer with engine values, Time is timestamp foreach (SmartOutputLink smartOutputLink in _smartOutputLinks) { smartOutputLink.UpdateBuffer(); } SendEvent(EventType.DataChanged); } } } engineResult = ((SmartOutputLink)_smartOutputLinks[outputLinkIndex]).GetValue(time); SendEvent(EventType.SourceBeforeGetValuesReturn); return engineResult; } catch (System.Exception e) { string message = "Exception in LinkableComponent. ComponentID: "; message += this.ComponentID; throw new System.Exception(message, e); } } }
public global::OpenMI.Standard.IValueSet GetValues(string QuantityID, string ElementSetID) { if (QuantityID != ElementSetID) throw new ApplicationException("Element sets should be named after quantities"); if (!_elementSets.Contains(ElementSetID)) throw new ApplicationException("Unknown element set '" + ElementSetID + "'"); ElementSet elementSet = (ElementSet) _elementSets[ElementSetID]; int count = elementSet.ElementCount; double[] returnValues = new double[count]; // This is O (e * s * q) instead of O (1). for (int e = 0; e < count; e++) { Element element = elementSet.GetElement(e); string ColumnID = element.ID; if (!_elementScopes.Contains (element)) throw new ApplicationException("Unknown element for '" + ColumnID + "'/'" + QuantityID + "'"); Scope scope = (Scope) _elementScopes[element]; if (scope.HasNumber(QuantityID)) returnValues[e] = scope.Number(QuantityID); else returnValues[e] = GetMissingValueDefinition(); } Oatc.OpenMI.Sdk.Backbone.ScalarSet values = new Oatc.OpenMI.Sdk.Backbone.ScalarSet(returnValues); return values; }
[Test] // testing the Initialise method public void MapValues() { ElementSet gridElementSet = new ElementSet("RegularGrid","RegularGrid",ElementType.XYPolygon, new SpatialReference("ref")); ElementSet fourPointsElementSet = new ElementSet("4 points","4P",ElementType.XYPoint,new SpatialReference("DummyID")); Vertex v_0_20 = new Vertex(0,20,0); Vertex v_0_10 = new Vertex(0,10,0); Vertex v_0_0 = new Vertex(0, 0,0); Vertex v_0_15 = new Vertex(0,15,0); Vertex v_5_15 = new Vertex(5,15,0); Vertex v_10_20 = new Vertex(10,20,0); Vertex v_10_15 = new Vertex(10,15,0); Vertex v_10_10 = new Vertex(10,10,0); Vertex v_10_0 = new Vertex(10, 0,0); Vertex v_15_15 = new Vertex(15,15,0); Vertex v_15_5 = new Vertex(15,5,0); Vertex v_20_20 = new Vertex(20,20,0); Vertex v_20_10 = new Vertex(20,10,0); Element square1 = new Element("square1"); Element square2 = new Element("square2"); Element square3 = new Element("square3"); square1.AddVertex(v_0_20); square1.AddVertex(v_0_10); square1.AddVertex(v_10_10); square1.AddVertex(v_10_20); square2.AddVertex(v_10_20); square2.AddVertex(v_10_10); square2.AddVertex(v_20_10); square2.AddVertex(v_20_20); square3.AddVertex(v_0_10); square3.AddVertex(v_0_0); square3.AddVertex(v_10_0); square3.AddVertex(v_10_10); gridElementSet.AddElement(square1); gridElementSet.AddElement(square2); gridElementSet.AddElement(square3); Element point_5_15 = new Element("point 5, 15"); Element point_10_15 = new Element("point 10, 15"); Element point_15_15 = new Element("point 15, 15"); Element point_15_5 = new Element("point 15, 5"); point_5_15.AddVertex(v_5_15); point_10_15.AddVertex(v_10_15); point_15_15.AddVertex(v_15_15); point_15_5.AddVertex(v_15_5); fourPointsElementSet.AddElement(point_5_15); fourPointsElementSet.AddElement(point_10_15); fourPointsElementSet.AddElement(point_15_15); fourPointsElementSet.AddElement(point_15_5); ScalarSet fourPointsScalarSet = new ScalarSet(); ScalarSet gridScalarSet = new ScalarSet(); ElementMapper elementMapper = new ElementMapper(); // point to polygon ArrayList methodDescriptions = elementMapper.GetAvailableMethods(fourPointsElementSet.ElementType, gridElementSet.ElementType); elementMapper.Initialise(methodDescriptions[0].ToString(), fourPointsElementSet, gridElementSet); fourPointsScalarSet.data = new double[4] { 0, 10, 20, 30 }; gridScalarSet = (ScalarSet)elementMapper.MapValues(fourPointsScalarSet); Assert.AreEqual(5, gridScalarSet.data[0]); Assert.AreEqual(20, gridScalarSet.data[1]); Assert.AreEqual(0, gridScalarSet.data[2]); // polygon to point methodDescriptions = elementMapper.GetAvailableMethods(gridElementSet.ElementType, fourPointsElementSet.ElementType); elementMapper.Initialise(methodDescriptions[0].ToString(), gridElementSet, fourPointsElementSet); fourPointsScalarSet = (ScalarSet)elementMapper.MapValues(gridScalarSet); Assert.AreEqual(5, fourPointsScalarSet.data[0]); Assert.AreEqual(5, fourPointsScalarSet.data[1]); Assert.AreEqual(20, fourPointsScalarSet.data[2]); Assert.AreEqual(0, fourPointsScalarSet.data[3]); }
/// <summary> /// Returns the ValueSet that corresponds to requestTime. The ValueSet may be found by /// interpolation, extrapolation and/or aggregation. /// </summary> /// <param name="requestedTime">time for which the value is requested</param> /// <returns>valueSet that corresponds to requestTime</returns> public IValueSet GetValues(ITime requestedTime) { if (_doExtendedDataVerification) { CheckTime(requestedTime); CheckBuffer(); } IValueSet returnValueSet; if (_values.Count == 0) { returnValueSet = new ScalarSet(); } else if (_values.Count == 1) { returnValueSet = MakeCopyOfValues(); } else if (requestedTime is ITimeStamp && _times[0] is ITimeStamp) { returnValueSet = MapFromTimeStampsToTimeStamp((ITimeStamp) requestedTime); } else if (requestedTime is ITimeSpan && _times[0] is ITimeSpan) { returnValueSet = MapFromTimeSpansToTimeSpan((ITimeSpan) requestedTime); } else if (requestedTime is ITimeSpan && _times[0] is ITimeStamp) { returnValueSet = MapFromTimeStampsToTimeSpan((ITimeSpan) requestedTime); } else if (requestedTime is ITimeStamp && _times[0] is ITimeSpan) { returnValueSet = MapFromTimeSpansToTimeStamp((ITimeStamp) requestedTime); } else { throw new Exception("Requested TimeMapping not available in SmartWrapper Class"); } return returnValueSet; }
public IValueSet GetValues(string QuantityID, string ElementSetID) { char[] separator = new char[]{':'}; double[] x; if(ElementSetID.Split(separator)[0] == "Branch") { x = new double[1]; int branchIndex = Convert.ToInt32(ElementSetID.Split(separator)[1]); if (QuantityID == "Flow") { x[0] = _flow[branchIndex]; } else if (QuantityID == "Leakage") { x[0] = _leakage[branchIndex]; } else { throw new Exception("Quanity ID not recognized in GetValues method"); } } else if(ElementSetID.Split(separator)[0] == "WholeRiver") { x = new double[_leakage.Length]; for (int i = 0; i < _leakage.Length; i++) { x[i] = _leakage[i]; } } else { throw new Exception("Failed to recognize ElementSetID in method GetValues"); } ScalarSet scalarSet = new ScalarSet(x); return scalarSet; }
/// <summary> /// This method is used to extract values from an upstream component. /// </summary> /// <param name="QuantityID">The input Quantity ID</param> /// <param name="ElementSetID">The input Element Set ID</param> /// <returns>the values saved under the matching QuantityID and ElementSetID, from an upstream component</returns> public IValueSet GetValues(string QuantityID, string ElementSetID) { var rows = _values.Select("QuantityID = '" + QuantityID + "' AND ElementSetID = '" + ElementSetID + "'"); if (rows.Length == 1) return (IValueSet)rows[0].ItemArray[2]; var es = _elementSets[ElementSetID]; var ss = new ScalarSet(); ss.data = new double[es.ElementCount]; return ss; }
/// <summary> /// A ValueSet corresponding to a TimeSpan is calculated using interpolation or /// extrapolation in corresponding lists of ValueSets and TimeSpans. /// </summary> /// <param name="requestedTimeStamp">Time for which the ValueSet is requested</param> /// <returns>ValueSet that corresponds to requestedTime</returns> private IValueSet MapFromTimeSpansToTimeStamp(ITimeStamp requestedTimeStamp) { try { int m = ((IValueSet)_values[0]).Count; double[][] xr = new double[m][]; // Values to return double tr = requestedTimeStamp.ModifiedJulianDay; // Requested TimeStamp int nk; // number of components (scalars has only 1 and vectors has 3 (3 axis)) if (_values[0] is IVectorSet) { nk = 3; } else { nk = 1; } for (int i = 0; i < m; i++) { xr[i] = new double[nk]; } //--------------------------------------------------------------------------- // Buffered TimesSpans: | >tbb0< .......... >tbbN< // Requested TimeStamp: | >tr< // -----------------------------------------> t // -------------------------------------------------------------------------- if (tr <= ((ITimeSpan)_times[0]).Start.ModifiedJulianDay ) { double tbb0 = ((ITimeSpan) _times[0]).Start.ModifiedJulianDay; double tbb1 = ((ITimeSpan) _times[1]).Start.ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m ; i++) //For each Vector in buffered VectorSet [0] { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] = ((sbi0 - sbi1)/(tbb0 - tbb1))*(tr - tbb0) * (1 - _relaxationFactor) + sbi0; } } } //--------------------------------------------------------------------------- // Buffered TimesSpans: | >tbb0< ................. >tbbN_1< // Requested TimeStamp: | >tr< // ---------------------------------------------------> t // -------------------------------------------------------------------------- else if (tr >= ((ITimeSpan) _times[_times.Count - 1]).End.ModifiedJulianDay) { double tbeN_2 = ((ITimeSpan) _times[_times.Count - 2]).End.ModifiedJulianDay; double tbeN_1 = ((ITimeSpan) _times[_times.Count - 1]).End.ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) //For each Vector in buffered VectorSet [N-1] { double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); xr[i][k-1] = ((sbiN_1 - sbiN_2)/(tbeN_1 - tbeN_2))*(tr - tbeN_1)*(1 - _relaxationFactor) + sbiN_1; } } } //--------------------------------------------------------------------------- // Availeble TimesSpans: | >tbb0< ...................... >tbbN_1< // Requested TimeStamp: | >tr< // -------------------------------------------------> t // -------------------------------------------------------------------------- else { for (int n = _times.Count - 1; n >= 0 ; n--) { double tbbn = ((ITimeSpan) _times[n]).Start.ModifiedJulianDay; double tben = ((ITimeSpan) _times[n]).End.ModifiedJulianDay; if ( tbbn <= tr && tr < tben) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) //For each Vector in buffered VectorSet [n] { xr[i][k-1] = Support.GetVal((IValueSet)_values[n], i, k); } } break; } } } //---------------------------------------------------------------------------------------------- if (_values[0] is IVectorSet) { Vector [] vectors = new Vector[m]; for (int i = 0; i < m; i++) { vectors[i] = new Vector(xr[i][0],xr[i][1],xr[i][2]); } VectorSet vectorSet = new VectorSet(vectors); return vectorSet; } else { double[] xx = new double[m]; for (int i = 0; i < m; i++) { xx[i] = xr[i][0]; } ScalarSet scalarSet = new ScalarSet(xx); return scalarSet; } } catch (Exception e) { throw new Exception("MapFromTimeSpansToTimeStamp Failed",e); } }
/// <summary> /// A ValueSet corresponding to a TimeStamp is calculated using interpolation or /// extrapolation in corresponding lists of ValueSets and TimeStamps. /// </summary> /// <param name="requestedTimeStamp">TimeStamp for which the values are requested</param> /// <returns>ValueSet that corresponds to the requested time stamp</returns> private IValueSet MapFromTimeStampsToTimeStamp(ITimeStamp requestedTimeStamp) { try { int m = ((IValueSet)_values[0]).Count; double[][] xr = new double[m][]; // Values to return double tr = requestedTimeStamp.ModifiedJulianDay; // Requested TimeStamp int nk; // number of components (scalars has only 1 and vectors has 3 (3 axis)) if (_values[0] is IVectorSet) { nk = 3; } else { nk = 1; } for (int i = 0; i < m; i++) { xr[i] = new double[nk]; } //--------------------------------------------------------------------------- // Buffered TimesStamps: | >tb0< >tb1< >tb2< >tbN< // Requested TimeStamp: | >tr< // -----------------------------------------> t // -------------------------------------------------------------------------- if (tr <= ((ITimeStamp)_times[0]).ModifiedJulianDay ) { double tb0 = ((ITimeStamp) _times[0]).ModifiedJulianDay; double tb1 = ((ITimeStamp) _times[1]).ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m ; i++) //For each Vector in buffered VectorSet [0] { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] = ((sbi0 - sbi1)/(tb0 - tb1))*(tr - tb0) * (1 - _relaxationFactor) + sbi0; } } } //--------------------------------------------------------------------------- // Buffered TimesStamps: | >tb0< >tb1< >tb2< >tbN_2< >tbN_1< // Requested TimeStamp: | >tr< // ---------------------------------------------------> t // -------------------------------------------------------------------------- else if (tr > ((ITimeStamp) _times[_times.Count - 1]).ModifiedJulianDay) { double tbN_2 = ((ITimeStamp) _times[_times.Count - 2]).ModifiedJulianDay; double tbN_1 = ((ITimeStamp) _times[_times.Count - 1]).ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) //For each Vector in buffered VectorSet [N-1] { double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); xr[i][k-1] = ((sbiN_1 - sbiN_2)/(tbN_1 - tbN_2))*(tr - tbN_1)*(1 - _relaxationFactor) + sbiN_1; } } } //--------------------------------------------------------------------------- // Availeble TimesStamps: | >tb0< >tb1< >tbna< >tnb< >tbN_1< >tbN_2< // Requested TimeStamp: | >tr< // -------------------------------------------------> t // -------------------------------------------------------------------------- else { for (int n = _times.Count - 2; n >= 0 ; n--) { double tbn1 = ((ITimeStamp) _times[n]).ModifiedJulianDay; double tbn2 = ((ITimeStamp) _times[n+1]).ModifiedJulianDay; if ( tbn1 <= tr && tr <= tbn2) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) //For each Vector in buffered VectorSet [n] { IValueSet valueSet_n = (IValueSet)_values[n]; double sbin1 = Support.GetVal(valueSet_n, i, k); IValueSet valueSet_nPlus1 = (IValueSet)_values[n+1]; double sbin2 = Support.GetVal(valueSet_nPlus1, i, k);; if ( valueSet_n.IsValid(i) && valueSet_nPlus1.IsValid(i)) { xr[i][k-1] = ((sbin2 - sbin1)/(tbn2 - tbn1)) * (tr - tbn1) + sbin1; } else if ( valueSet_n.IsValid(i) ) { xr[i][k-1] = sbin1; } else if ( valueSet_nPlus1.IsValid(i) ) { xr[i][k-1] = sbin2; } else { // both invalid, set to one of the (==invalid) values xr[i][k-1] = sbin1; } } } break; } } } //---------------------------------------------------------------------------------------------- if (_values[0] is IVectorSet) { Vector [] vectors = new Vector[m]; for (int i = 0; i < m; i++) { vectors[i] = new Vector(xr[i][0],xr[i][1],xr[i][2]); } VectorSet vectorSet = new VectorSet(vectors); return vectorSet; } else { double[] xx = new double[m]; for (int i = 0; i < m; i++) { xx[i] = xr[i][0]; } ScalarSet scalarSet = new ScalarSet(xx); return scalarSet; } } catch (Exception e) { throw new Exception("MapFromTimeStampsToTimeStamp Failed",e); } }
/// <summary> /// Makes a copy of the first ValueSet in the list of valueSets /// </summary> /// <returns></returns> private IValueSet MakeCopyOfValues() { if (_values[0] is IScalarSet) { int NumberOfScalarsInEachScalarSet = ((IScalarSet) _values[0]).Count; double[] x = new Double[NumberOfScalarsInEachScalarSet]; for (int i = 0; i < NumberOfScalarsInEachScalarSet; i++) { x[i] = ((IScalarSet) _values[0]).GetScalar(i); } ScalarSet scalarSet = new ScalarSet(x); return scalarSet; } else // _values[0] is VectorSet { int NumberOfVectorsInEachVectorSet = ((IVectorSet) _values[0]).Count; Vector[] vectors = new Vector[NumberOfVectorsInEachVectorSet]; for (int i = 0; i < NumberOfVectorsInEachVectorSet; i++) { Vector vector; double x = ((IVectorSet)_values[0]).GetVector(i).XComponent; double y = ((IVectorSet) _values[0]).GetVector(i).YComponent; double z = ((IVectorSet) _values[0]).GetVector(i).ZComponent; vector = new Vector(x, y, z); vectors[i] = vector; } VectorSet vectorSet = new VectorSet(vectors); return vectorSet; } }
public void Init() { double[] values = {1.0,2.0,3.0}; scalarSet = new ScalarSet(values); }
/// <summary> /// MapValues calculates a IValueSet through multiplication of an inputValues IValueSet /// vector or matrix (ScalarSet or VectorSet) on to the mapping maprix. IScalarSets maps /// to IScalarSets and IVectorSets maps to IVectorSets. /// </summary> /// /// <remarks> /// Mapvalues is called every time a georeferenced link is evaluated. /// </remarks> /// /// <param name="inputValues">IValueSet of values to be mapped.</param> /// /// <returns> /// A IValueSet found by mapping of the inputValues on to the toElementSet. /// </returns> public IValueSet MapValues(IValueSet inputValues) { if (!_isInitialised) { throw new System.Exception("ElementMapper objects needs to be initialised before the MapValue method can be used"); } if (!inputValues.Count.Equals(_numberOfColumns)) { throw new System.Exception("Dimension mismatch between inputValues and mapping matrix"); } if (inputValues is IScalarSet) { double[] outValues = new double[_numberOfRows]; //--- Multiply the Values vector with the MappingMatrix --- for (int i = 0; i < _numberOfRows; i++) { outValues[i] = 0; for (int n = 0; n < _numberOfColumns; n++) { outValues[i] += _mappingMatrix[i,n] * ((IScalarSet) inputValues).GetScalar(n); //(remove)inValues[n]; } } ScalarSet outputValues = new ScalarSet(outValues); return outputValues; } else if (inputValues is IVectorSet) { Vector[] outValues = new Vector[_numberOfRows]; //--- Multiply the Values vector with the MappingMatrix --- for (int i = 0; i < _numberOfRows; i++) { outValues[i].XComponent = 0; outValues[i].YComponent = 0; outValues[i].ZComponent = 0; for (int n = 0; n < _numberOfColumns; n++) { outValues[i].XComponent += _mappingMatrix[i,n] * ((IVectorSet) inputValues).GetVector(n).XComponent; outValues[i].YComponent += _mappingMatrix[i,n] * ((IVectorSet) inputValues).GetVector(n).YComponent; outValues[i].ZComponent += _mappingMatrix[i,n] * ((IVectorSet) inputValues).GetVector(n).ZComponent; } } VectorSet outputValues = new VectorSet(outValues); return outputValues; } else { throw new System.Exception("Invalid datatype used for inputValues parameter. MapValues failed"); } }
public void Constructor() { ScalarSet scalarSet2 = new ScalarSet(scalarSet); Assert.AreEqual(scalarSet,scalarSet2); }
/// <summary> /// Implementation of the same method in /// OpenMI.Standard.ILInkableComponent /// </summary> /// <param name="time">Time (ITimeSpan or ITimeStamp) for which values are requested</param> /// <param name="LinkID">LinkID associated to the requested values</param> /// <returns>The values</returns> public override IValueSet GetValues(ITime time, string LinkID) { try { CheckTimeArgumentInGetvaluesMethod(time); SendSourceAfterGetValuesCallEvent(time, LinkID); IValueSet engineResult = new ScalarSet(); int outputLinkIndex = -999; for (int i = 0; i < _smartOutputLinks.Count; i++) { if ( ((SmartOutputLink) _smartOutputLinks[i]).link.ID == LinkID) { outputLinkIndex = i; break; } } if (_isBusy==false) { //while(IsLater(time,_engineApiAccess.GetCurrentTime())) while(IsLater(time, ((SmartOutputLink) _smartOutputLinks[outputLinkIndex]).GetLastBufferedTime())) { _isBusy=true; //Update input links foreach(SmartInputLink smartInputLink in _smartInputLinks) { smartInputLink.UpdateInput(); } _isBusy=false; //Perform Timestep if(_engineApiAccess.PerformTimeStep()) { //Update buffer with engine values, Time is timestamp foreach (SmartOutputLink smartOutputLink in _smartOutputLinks) { smartOutputLink.UpdateBuffer(); } SendEvent(EventType.DataChanged); } } } engineResult = ((SmartOutputLink)_smartOutputLinks[outputLinkIndex]).GetValue(time); SendEvent(EventType.SourceBeforeGetValuesReturn); return engineResult; } catch (System.Exception e) { string message = "Exception in LinkableComponent. ComponentID: "; message += this.ComponentID; throw new System.Exception(message,e); } }
public void RunSimulationWithInputAndOutput() { ITimeSpan modelSpan = mohidWaterEngineWrapper.GetTimeHorizon(); double now = modelSpan.Start.ModifiedJulianDay; Stopwatch win = new Stopwatch(); Stopwatch wout = new Stopwatch(); Stopwatch wengine = new Stopwatch(); while (now < modelSpan.End.ModifiedJulianDay) { DateTime currentTime = CalendarConverter.ModifiedJulian2Gregorian(now); DateTime intitalTime = CalendarConverter.ModifiedJulian2Gregorian( mohidWaterEngineWrapper.GetTimeHorizon().Start.ModifiedJulianDay); Console.WriteLine(currentTime.ToString()); wengine.Start(); mohidWaterEngineWrapper.PerformTimeStep(); wengine.Stop(); wout.Start(); //Gets outputs Items for (int i = 0; i < mohidWaterEngineWrapper.GetOutputExchangeItemCount(); i++) { OutputExchangeItem ouputItem = mohidWaterEngineWrapper.GetOutputExchangeItem(i); IValueSet values = mohidWaterEngineWrapper.GetValues(ouputItem.Quantity.ID, ouputItem.ElementSet.ID); } wout.Stop(); //Sets Input Items win.Start(); for (int i = 0; i < mohidWaterEngineWrapper.GetInputExchangeItemCount(); i++) { InputExchangeItem inputItem = mohidWaterEngineWrapper.GetInputExchangeItem(i); double[] aux = new double[inputItem.ElementSet.ElementCount]; for (int j = 0; j < inputItem.ElementSet.ElementCount; j++) { aux[j] = 0; } IValueSet values = new ScalarSet(aux); //mohidLandEngineWrapper.SetValues(inputItem.Quantity.ID, inputItem.ElementSet.ID, values); } win.Stop(); now = mohidWaterEngineWrapper.GetEarliestNeededTime().ModifiedJulianDay; } Console.WriteLine("Input Exchange: " + win.ElapsedMilliseconds.ToString()); Console.WriteLine("Output Exchange: " + wout.ElapsedMilliseconds.ToString()); Console.WriteLine("Engine: " + wengine.ElapsedMilliseconds.ToString()); }
public override IValueSet GetValues(ITime time, string LinkID) { try { CheckTimeArgumentInGetvaluesMethod(time); SendSourceAfterGetValuesCallEvent(time, LinkID); IValueSet engineResult = new ScalarSet(); // find the output link being requested var link = FindLinkWithId(LinkID); // log this call traceFile.Append("GetValues:" + link.link.SourceQuantity.ID + "@" + ((TimeStamp)time).ModifiedJulianDay); // update our link monitor prefetchHelper.updateLastRequestedTime(link.link, (TimeStamp)time); // retrieve the result from the link engineResult = link.GetValue(time, prefetchHelper); SendEvent(EventType.SourceBeforeGetValuesReturn); return engineResult; } catch (Exception e) { var message = "Exception in LinkableComponent:ID: "; message += ComponentID; throw new Exception(message, e); } }
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)); } }
/// <summary> /// A ValueSet corresponding to a TimeSpan is calculated using interpolation or /// extrapolation in corresponding lists of ValueSets and TimeSpans. /// </summary> /// <param name="requestedTime">Time for which the ValueSet is requested</param> /// <returns>ValueSet that corresponds to requestedTime</returns> private IValueSet MapFromTimeSpansToTimeSpan(ITimeSpan requestedTime) { try { int m = ((IValueSet)_values[0]).Count; double[][] xr = new double[m][]; // Values to return double trb = requestedTime.Start.ModifiedJulianDay; // Begin time in requester time interval double tre = requestedTime.End.ModifiedJulianDay; // End time in requester time interval int nk; // number of components (scalars has only 1 and vectors has 3 (3 axis)) if (_values[0] is IVectorSet) { nk = 3; } else { nk = 1; } for (int i = 0; i < m; i++) { xr[i] = new double[nk]; } for (int i = 0; i < m; i++) { for (int k = 0; k < nk; k++) { xr[i][k] = 0; } } for (int n = 0; n < _times.Count; n++) { double tbbn = ((ITimeSpan) _times[n]).Start.ModifiedJulianDay; double tben = ((ITimeSpan) _times[n]).End.ModifiedJulianDay; //--------------------------------------------------------------------------- // B: <--------------------------> // R: <-------------------------------------> // -------------------------------------------------------------------------- if (trb <= tbbn && tre >= tben ) //Buffered TimeSpan fully included in requested TimeSpan { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); xr[i][k-1] += sbin * (tben - tbbn)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbbn <= trb && tre <= tben) //cover all { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { xr[i][k-1] += Support.GetVal((IValueSet)_values[n], i, k); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (tbbn < trb && trb < tben && tre > tben) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); xr[i][k-1] += sbin * (tben - trb)/(tre - trb); } } } //--------------------------------------------------------------------------- // Times[i] Interval: t1|-----------------|t2 // Requested Interval: rt1|--------------|rt2 // -------------------------------------------------------------------------- else if (trb < tbbn && tre > tbbn && tre < tben) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) // for all values coorsponding to the same time interval { double sbin = Support.GetVal((IValueSet)_values[n], i, k); xr[i][k-1] += sbin * (tre - tbbn)/(tre - trb); } } } } //-------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //--------------------------------------------------------------------------- double tbb0 = ((ITimeSpan) _times[0]).Start.ModifiedJulianDay; double tbe0 = ((ITimeSpan) _times[0]).End.ModifiedJulianDay; //double tbb1 = ((ITimeSpan) _times[1]).Start.ModifiedJulianDay; double tbe1 = ((ITimeSpan) _times[1]).End.ModifiedJulianDay; if (trb < tbb0 && tre > tbb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] += ((tbb0 - trb)/(tre - trb)) * (sbi0 - (1 - _relaxationFactor) * ((tbb0 - trb)*(sbi1 - sbi0)/(tbe1 - tbe0))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- double tbeN_1 = ((ITimeSpan) _times[_times.Count-1]).End.ModifiedJulianDay; double tbbN_2 = ((ITimeSpan) _times[_times.Count-2]).Start.ModifiedJulianDay; if (tre > tbeN_1 && trb < tbeN_1) { //double tbeN_2 = ((ITimeSpan) _times[_times.Count-2]).End.ModifiedJulianDay; double tbbN_1 = ((ITimeSpan) _times[_times.Count-1]).Start.ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i,k); xr[i][k-1] += ((tre - tbeN_1)/(tre - trb)) * (sbiN_1 + (1 - _relaxationFactor) * ((tre - tbbN_1)*(sbiN_1 - sbiN_2)/(tbeN_1 - tbbN_2))); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (trb >= tbeN_1) { double tbeN_2 = ((ITimeSpan) _times[_times.Count-2]).End.ModifiedJulianDay; //double tbbN_1 = ((ITimeSpan) _times[_times.Count-1]).Start.ModifiedJulianDay; for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbiN_1 = Support.GetVal((IValueSet)_values[_times.Count-1], i, k); double sbiN_2 = Support.GetVal((IValueSet)_values[_times.Count-2], i, k); xr[i][k-1] = sbiN_1 + (1 - _relaxationFactor) * ((sbiN_1 - sbiN_2)/(tbeN_1 - tbbN_2)) * (trb + tre - tbeN_1 - tbeN_2); } } } //------------------------------------------------------------------------------------- // |--------|---------|--------| B // |----------------| R //------------------------------------------------------------------------------------- if (tre <= tbb0) { for (int k = 1; k <= nk; k++) { for (int i = 0; i < m; i++) { double sbi0 = Support.GetVal((IValueSet)_values[0], i, k); double sbi1 = Support.GetVal((IValueSet)_values[1], i, k); xr[i][k-1] = sbi0 - (1 - _relaxationFactor) * ((sbi1 - sbi0)/(tbe1- tbb0))*(tbe0 + tbb0 - tre - trb); } } } //------------------------------------------------------------------------------------- if (_values[0] is IVectorSet) { Vector [] vectors = new Vector[m]; for (int i = 0; i < m; i++) { vectors[i] = new Vector(xr[i][0],xr[i][1],xr[i][2]); } VectorSet vectorSet = new VectorSet(vectors); return vectorSet; } else { double[] xx = new double[m]; for (int i = 0; i < m; i++) { xx[i] = xr[i][0]; } ScalarSet scalarSet = new ScalarSet(xx); return scalarSet; } } catch (Exception e) { throw new Exception("MapFromTimeSpansToTimeSpan Failed",e); } }