public InputSpatialSurrogate(ITimeSpaceInput input) { _inputOriginal = input; if (input == null) { SetDescribes(new Describes("Unspecified Input")); ValueDefinition = new ValueDefinition(); SpatialDefinition = new SpatialDefinition(); Component = null; } else { SetDescribes(input); ValueDefinition = input.ValueDefinition; Component = input.Component; var inputTime = input as BaseInputSpaceTime; SpatialDefinition = inputTime != null ? inputTime.SpatialDefinition : new SpatialDefinition(); } }
public ExchangeItem(IBaseExchangeItem openMIItem, bool useBufferedValues) { if (openMIItem is ITimeSpaceOutput) { _openMIItem = _openMIOutputItem = (ITimeSpaceOutput)openMIItem; } else if (openMIItem is ITimeSpaceInput) { _openMIItem = _openMIInputItem = (ITimeSpaceInput)openMIItem; } else { throw new Exception("Unknown exchange item type: " + openMIItem.GetType()); } if (_openMIItem.TimeSet != null && _openMIItem.TimeSet.HasDurations) { throw new Exception("\"" + Id + ": OpenDA Time Spans not covered by OpenDA Exchange items"); } _useBufferedValues = useBufferedValues; if (_useBufferedValues) { _bufferedValues = new List <List <double> > { new List <double>() }; _bufferedTimes = new List <double>(); } }
public static IIdentifiable[] GetAvailableMethods(IBaseOutput adaptee, IBaseInput target) { ITimeSpaceOutput tsadaptee = adaptee as ITimeSpaceOutput; // Only works with timespace output as adaptee, and element set as spatial definition if (tsadaptee == null || !(tsadaptee.SpatialDefinition is IElementSet)) { return(new IIdentifiable[0]); } IList <IIdentifiable> methods = new List <IIdentifiable>(); GetAvailableOperationMethods(ref methods, tsadaptee.ElementSet().ElementType); // Check if the target is there and is a timespace input ITimeSpaceInput tstarget = target as ITimeSpaceInput; if (target == null || tstarget == null || !(tstarget.SpatialDefinition is IElementSet)) { return(((List <IIdentifiable>)methods).ToArray()); } GetAvailableMappingMethods(ref methods, tsadaptee.ElementSet().ElementType, tstarget.ElementSet().ElementType); return(((List <IIdentifiable>)methods).ToArray()); }
public static bool ConsumerCanBeAdded(IList<ITimeSpaceInput> existingConsumers, ITimeSpaceInput consumer) { bool canBeAdded = true; if (existingConsumers.Count > 0) { // TODO (JG): make instead check on exchangeItem.ElementSet instead of an arbitray elementSet // check if #elements are consistent if (consumer.ElementSet() != null && existingConsumers[0].ElementSet() != null && consumer.ElementSet().ElementCount != existingConsumers[0].ElementSet().ElementCount ) { canBeAdded = false; } // TODO (JG): Is this a requirement? if (consumer.TimeSet != null && existingConsumers[0].TimeSet != null && consumer.TimeSet.HasDurations != existingConsumers[0].TimeSet.HasDurations ) { canBeAdded = false; } // check if #time stamps are consistent } return canBeAdded; }
public void AddIn(IBaseExchangeItem openMIo) { if (openMIo is ITimeSpaceInput) { _openMIItem = _openMIInputItem = (ITimeSpaceInput)openMIo; } }
public void CreatePolygon2PointAdaptedOutput2Consumers() { ITimeSpaceOutput adaptee = new Output(xyPolygon.Caption + ".Flow") { SpatialDefinition = xyPolygon, ValueDefinition = waterLevelQuantity }; ITimeSpaceInput consumerA = new Input(xyPointA.Caption + ".Flow") { SpatialDefinition = xyPointA, ValueDefinition = waterLevelQuantity }; ITimeSpaceInput consumerB = new Input(xyPointB.Caption + ".Flow") { SpatialDefinition = xyPointB, ValueDefinition = waterLevelQuantity }; ITimeSpaceInput consumer = consumerB; IIdentifiable selectedAvailableAdaptedOutputId = adaptedOutputFactory.GetAvailableAdaptedOutputIds(adaptee, consumer)[1]; ITimeSpaceAdaptedOutput adaptedOutput = (ITimeSpaceAdaptedOutput)adaptedOutputFactory.CreateAdaptedOutput(selectedAvailableAdaptedOutputId, adaptee, consumer); adaptedOutput.AddConsumer(consumer); Assert.IsTrue(adaptedOutput.ElementSet().ElementType == ElementType.Point, "Consumer's ElementSet TYPE"); Assert.AreEqual(2, adaptedOutput.ElementSet().ElementCount, "ElementSet of consumer"); Assert.IsTrue(adaptedOutput.ValueDefinition == adaptee.ValueDefinition, "Adaptee's ValueDefinition"); }
public virtual void AddConsumer(IBaseInput consumer) { ITimeSpaceInput timeSpaceConsumer = consumer as ITimeSpaceInput; if (timeSpaceConsumer == null) { throw new ArgumentException("Must be a ITimeSpaceInput - may need to add adaptor"); } // Create list of consumers if (_consumers == null) { _consumers = new List <ITimeSpaceInput>(); } // consumer should not be already added if (_consumers.Contains(timeSpaceConsumer)) { //throw new Exception("consumer \"" + consumer.Caption + // "\" has already been added to \"" + Caption); } else { _consumers.Add(timeSpaceConsumer); if (consumer.Provider != this) { consumer.Provider = this; } } }
protected DecoratorBase(IIdentifiable identifiable, string caption, string description, ITimeSpaceOutput decorated, ITimeSpaceInput target) { _identifiable = identifiable; _description = description; _caption = caption; _decorated = decorated; _target = target; }
public Input(ITimeSpaceInput iInput) : base(iInput) { if (iInput.Provider != null) { _provider = iInput.Provider.Caption; } }
private static void ConnectItems(ITimeSpaceComponent sourceComponentInstance, string outputItemId, ITimeSpaceComponent targetComponentInstance, string inputItemId) { ITimeSpaceOutput output = FindOutputItem(sourceComponentInstance, outputItemId); ITimeSpaceInput input = FindInputItem(targetComponentInstance, inputItemId); output.AddConsumer(input); }
public void CreateInitializeTest() { ITimeSpaceComponent gwModel = new GWModelLC(); IBaseLinkableComponent lc = gwModel; Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Created); List<IArgument> gwArguments = CreateTestArguments(); gwModel.Arguments.ApplyArguments(gwArguments); gwModel.Initialize(); Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Initialized); Assert.AreEqual("GWModelLC", gwModel.Id); Assert.AreEqual(3, gwModel.Inputs.Count); Assert.AreEqual(3, gwModel.Outputs.Count); { // Check the ground water level output ITimeSpaceOutput gwLevel = lc.Outputs[2] as ITimeSpaceOutput; Assert.IsNotNull(gwLevel); Assert.AreEqual("Grid.gwLevel", gwLevel.Id); // Check quantity IQuantity quantity = gwLevel.ValueDefinition as IQuantity; Assert.IsNotNull(quantity); Assert.AreEqual("Ground water level", quantity.Caption); Assert.AreEqual("gw level", quantity.Unit.Caption); Assert.AreEqual(1, quantity.Unit.Dimension.GetPower(DimensionBase.Length)); Assert.AreEqual(0, quantity.Unit.Dimension.GetPower(DimensionBase.Time)); Assert.AreEqual(1, quantity.Unit.ConversionFactorToSI); // Check element set IElementSet gridSet = gwLevel.ElementSet(); CheckRegularGridElmtSet(gridSet); } { // Check the ground water inflow input ITimeSpaceInput gwInput = lc.Inputs[2] as ITimeSpaceInput; Assert.IsNotNull(gwInput); Assert.AreEqual("Grid.Inflow", gwInput.Id); // Check quantity IQuantity quantity = gwInput.ValueDefinition as IQuantity; Assert.IsNotNull(quantity); Assert.AreEqual("Inflow", quantity.Caption); Assert.AreEqual("Discharge", quantity.Unit.Caption); Assert.AreEqual(3, quantity.Unit.Dimension.GetPower(DimensionBase.Length)); Assert.AreEqual(-1, quantity.Unit.Dimension.GetPower(DimensionBase.Time)); Assert.AreEqual(0.001, quantity.Unit.ConversionFactorToSI); // Check element set IElementSet gridSet = gwInput.ElementSet(); CheckRegularGridElmtSet(gridSet); } }
public DecoratorWave(IIdentifiable identifiable, ITimeSpaceOutput decorated, ITimeSpaceInput target) : base(identifiable, "Wave: A*sin(F*t + P)", "Wave transformation y = Amplitude * sin(frequancy * time + phase)", decorated, target) { _arguments.Add(Argument.Create("Amplitude", "0.0", false, "A in A*sin(F*t + P)")); _arguments.Add(Argument.Create("Phase", "0.0", false, "P in y = A*sin(F*t + P)")); _arguments.Add(Argument.Create("Frequency", "0.0", false, "F in y = A*sin(F*t + P)")); }
public AddapterBase(IIdentifiable identifier, IDescribable described, ITimeSpaceOutput adapted, ITimeSpaceInput target) { _identifier = identifier; _described = described; _target = target; _adapted = adapted; if (!_adapted.AdaptedOutputs.Contains(this)) { _adapted.AddAdaptedOutput(this); } }
private static void ConnectItemsWithTimeInterpolator(ITimeSpaceComponent sourceComponentInstance, string outputItemId, ITimeSpaceComponent targetComponentInstance, string inputItemId) { ITimeSpaceOutput output = FindOutputItem(sourceComponentInstance, outputItemId); ITimeSpaceInput input = FindInputItem(targetComponentInstance, inputItemId); IAdaptedOutputFactory derivedOutputFactory = sourceComponentInstance.AdaptedOutputFactories[0]; IIdentifiable[] derivedOutputIdentifiers = derivedOutputFactory.GetAvailableAdaptedOutputIds(output, input); IBaseAdaptedOutput timeInterpolator = derivedOutputFactory.CreateAdaptedOutput(derivedOutputIdentifiers[0], output, input); }
public static void ConnectItemsUsingAdaptedOutput(ITimeSpaceComponent sourceComponentInstance, string outputItemId, ITimeSpaceComponent targetComponentInstance, string inputItemId, string derivedOutputName) { ITimeSpaceOutput output = FindOutputItem(sourceComponentInstance, outputItemId); ITimeSpaceInput input = FindInputItem(targetComponentInstance, inputItemId); ConnectItemsUsingAdaptedOutput(sourceComponentInstance, output, input, derivedOutputName); }
public static ITimeSpaceAdaptedOutput CreateAdaptedOutputMethod(IIdentifiable adaptedOutputId, IBaseOutput adaptee, IBaseInput target) { IElementSet elmtSet = null; ITimeSpaceInput tsTarget = target as ITimeSpaceInput; if (tsTarget != null && tsTarget.SpatialDefinition is IElementSet) { elmtSet = tsTarget.ElementSet(); } return(CreateAdaptedOutputMethod(adaptedOutputId, adaptee, elmtSet)); }
public virtual void RemoveConsumer(IBaseInput consumer) { ITimeSpaceInput timeSpaceConsumer = consumer as ITimeSpaceInput; if (timeSpaceConsumer == null || _consumers == null || !_consumers.Contains(timeSpaceConsumer)) { throw new Exception("consumer \"" + consumer.Caption + "\" can not be removed from \"" + Caption + "\", because it was not added"); } _consumers.Remove(timeSpaceConsumer); consumer.Provider = null; }
public virtual void AddConsumer(IBaseInput consumer) { ITimeSpaceInput timeSpaceConsumer = consumer as ITimeSpaceInput; if (timeSpaceConsumer == null) { throw new ArgumentException("Must be a ITimeSpaceInput - may need to add adaptor"); } // Create list of consumers if (_consumers == null) { _consumers = new List <ITimeSpaceInput>(); } // consumer should not be already added if (_consumers.Contains(timeSpaceConsumer)) { throw new Exception("consumer \"" + consumer.Caption + "\" has already been added to \"" + Caption); } // Check if this consumer can be added if (!ExchangeItemHelper.ConsumerCanBeAdded(_consumers, timeSpaceConsumer)) { throw new Exception("consumer \"" + consumer.Caption + "\" can not be added to \"" + Caption + "\", because it is incompatible with existing consumers"); } _consumers.Add(timeSpaceConsumer); if (consumer.Provider != this) { consumer.Provider = this; } //// TODO (JG): EXPERIMENTAL CODE //if (consumer is IBaseMultiInput) //{ // ((IBaseMultiInput)consumer).AddProvider(this); //} //else //{ // if (consumer.Provider != this) // { // consumer.Provider = this; // } //} }
private void LogIncomingValues(ITimeSpaceInput inputItem, ITimeSpaceValueSet providedValues) { string message = Caption + " " + inputItem.Caption + " values:"; foreach (IList valuesArray in providedValues.Values2D) { foreach (object value in valuesArray) { message += " " + value; } } message += " <= " + inputItem.Provider.Caption + " from " + inputItem.Provider.Component.Caption + ")"; log.Info(message); }
private void GetExchangeItemsFromOpenMIComponent() { // ZZZ // Match the Input and Output Exchange Items foreach (IBaseInput baseInput in _openMIComponent.Inputs) { foreach (IBaseOutput baseOutput in _openMIComponent.Outputs) { if (baseInput.Id.CompareTo(baseOutput.Id) == 0) { ITimeSpaceInput timeSpaceInput = baseInput as ITimeSpaceInput; ITimeSpaceOutput timeSpaceOutput = baseOutput as ITimeSpaceOutput; var IO = new ExchangeItem(timeSpaceOutput); IO.AddIn(timeSpaceInput); if (IO != null && !_inout.ContainsKey(timeSpaceOutput.Id)) { _inout.Add(timeSpaceOutput.Id, IO); } } } } foreach (IBaseInput baseIn in _openMIComponent.Inputs) { ITimeSpaceInput timeSpaceIn = baseIn as ITimeSpaceInput; if (timeSpaceIn != null && !_inout.ContainsKey(baseIn.Id)) { _inputs.Add(timeSpaceIn.Id, new ExchangeItem(timeSpaceIn)); } } foreach (IBaseOutput baseOut in _openMIComponent.Outputs) { ITimeSpaceOutput timeSpaceOut = baseOut as ITimeSpaceOutput; if (timeSpaceOut != null && !_inout.ContainsKey(baseOut.Id)) { //ZZZ var I = new ExchangeItem(timeSpaceOut); if (I != null) { _outputs.Add(timeSpaceOut.Id, I); } } } }
private static bool ConsumersCompatibleForTimeAndOrElementSet(IBaseOutput outputItem, IBaseInput consumer, bool doCheckTime, bool doCheckSpace) { // Check which time/space consumers are already there bool canBeAdded = true; if (outputItem.Consumers.Count > 0) { if (doCheckSpace) { // TODO (JG): make instead check on exchangeItem.ElementSet instead of an arbitray elementSet // check if #elements are consistent if (consumer.ElementSet() != null && outputItem.Consumers[0].ElementSet() != null && consumer.ElementSet().ElementCount != outputItem.Consumers[0].ElementSet().ElementCount) { canBeAdded = false; } } if (doCheckTime) { ITimeSpaceInput consumerAsTimeSpace = consumer as ITimeSpaceInput; if (consumerAsTimeSpace != null) { List <ITimeSpaceInput> existingConsumers = new List <ITimeSpaceInput>(); foreach (IBaseInput existingConsumer in outputItem.Consumers) { if (existingConsumer is ITimeSpaceOutput) { existingConsumers.Add((ITimeSpaceInput)existingConsumer); } } if (existingConsumers.Count > 0) { // TODO (JG): Is this a requirement? if (consumerAsTimeSpace.TimeSet != null && existingConsumers[0].TimeSet != null && consumerAsTimeSpace.TimeSet.HasDurations != existingConsumers[0].TimeSet.HasDurations ) { canBeAdded = false; } } } } } return(canBeAdded); }
/// <summary> /// Find the input item with the provided id. /// </summary> /// <param name="component">Component to find input item in</param> /// <param name="id">Id of input item to search for</param> /// <returns>Returns input item with id, or null if not found</returns> public static ITimeSpaceInput FindInputItem(this ITimeSpaceComponent component, string id) { foreach (IBaseInput input in component.Inputs) { if (string.Equals(input.Id, id, StringComparison.OrdinalIgnoreCase)) { ITimeSpaceInput timeSpaceInput = input as ITimeSpaceInput; if (timeSpaceInput == null) { throw new Exception("Found exchange item, but it was not a TimeSpaceInput, id = '" + id + "'"); } return(timeSpaceInput); } } return(null); //throw new Exception("Could not find input item with id = '" + id + "'"); }
public static ITime GetEarliestConsumerTime(IBaseOutput output) { ITime earliestRequiredTime = null; foreach (IBaseAdaptedOutput adaptedOutput in output.AdaptedOutputs) { earliestRequiredTime = CheckTimeHorizonMinimum(earliestRequiredTime, GetEarliestConsumerTime(adaptedOutput)); } foreach (IBaseInput input in output.Consumers) { ITimeSpaceInput timeSpaceInput = input as ITimeSpaceInput; if (timeSpaceInput != null && timeSpaceInput.TimeSet != null) { earliestRequiredTime = CheckTimeHorizonMinimum(earliestRequiredTime, timeSpaceInput.TimeSet.TimeHorizon); } } return(earliestRequiredTime); }
// Called from source public ITimeSpaceValueSet GetValues(IBaseExchangeItem exchange) { if (!(exchange is ITimeSpaceInput)) { throw new InvalidOperationException(); } ITimeSpaceInput source = (ITimeSpaceInput)exchange; ValidTimeSet(source.TimeSet); // TODO Check Component.Status befor update ? gridlock issues? // this.GetValues(source) should bool unavailable = false; bool forceCacheUpdate = false; while (!CacheUpdateSource(source, forceCacheUpdate)) { // TODO Multithreading sleep and retry unavailable = Component.Status != LinkableComponentStatus.Initialized && Component.Status != LinkableComponentStatus.Updated && Component.Status != LinkableComponentStatus.Valid; if (unavailable) { forceCacheUpdate = true; } else { Component.Update(new ITimeSpaceOutput[] { this }); } } if (ItemChanged != null) { ItemChanged(this, new ExchangeItemChangeEventArgs { ExchangeItem = this, Message = CurrentState() }); } return(((ITimeSpaceInput)source).Values); }
private void GetExchangeItemsFromOpenMIComponent() { string message = ""; foreach (IBaseInput baseInput in _openMIComponent.Inputs) { ITimeSpaceInput timeSpaceInput = baseInput as ITimeSpaceInput; if (timeSpaceInput != null) { if (_inputs.ContainsKey(timeSpaceInput.Id)) { string mess = "Input item " + timeSpaceInput.Id + " defined more then once"; ModelFactory.AppendLogMessage(mess); message += "\n" + mess; } else { _inputs.Add(timeSpaceInput.Id, new ExchangeItem(timeSpaceInput)); } } } foreach (IBaseOutput baseOutput in _openMIComponent.Outputs) { ITimeSpaceOutput timeSpaceOutput = baseOutput as ITimeSpaceOutput; if (timeSpaceOutput != null) { if (_outputs.ContainsKey(timeSpaceOutput.Id)) { string mess = "Output item " + timeSpaceOutput.Id + " defined more then once"; ModelFactory.AppendLogMessage(mess); message += "\n" + mess; } else { _outputs.Add(timeSpaceOutput.Id, new ExchangeItem(timeSpaceOutput, true)); } } } if (message.Length > 0) { throw new Exception("Multiple Input and/or Output items:" + message); } }
public Linear(ITimeSpaceOutput itemOut, ITimeSpaceInput itemIn) : base(_identifer, _describable, itemOut, itemIn) { IArgument arg = new ArgumentDouble("A", 1.0) { Caption = "A", Description = "A [double] in y = A*x + B" }; _arguments.Add(arg); arg = new ArgumentDouble("B", 0.0) { Caption = "B", Description = "B [double] in y = A*x + B" }; _arguments.Add(arg); }
public IIdentifiable[] GetAvailableAdaptedOutputIds(IBaseOutput adaptee, IBaseInput target) { ITimeSpaceOutput tsadaptee = adaptee as ITimeSpaceOutput; ITimeSpaceInput tstarget = target as ITimeSpaceInput; // This inly works with time space items, and target can not be null if (tsadaptee == null || tstarget == null) { return(new IIdentifiable[0]); } // This only works with element sets if (!(tsadaptee.SpatialDefinition is IElementSet && tstarget.SpatialDefinition is IElementSet)) { return(new IIdentifiable[0]); } return(ElementMapper.GetAvailableMethods(tsadaptee.ElementSet().ElementType, tstarget.ElementSet().ElementType)); }
public virtual void AddConsumer(IBaseInput consumer) { ITimeSpaceInput timeSpaceConsumer = consumer as ITimeSpaceInput; if (timeSpaceConsumer == null) { throw new ArgumentException("Must be a ITimeSpaceInput - may need to add adaptor"); } // Create list of consumers if (_consumers == null) { _consumers = new List <ITimeSpaceInput>(); } // consumer should not be already added if (_consumers.Contains(timeSpaceConsumer)) { throw new Exception("consumer \"" + consumer.Caption + "\" has already been added to \"" + Caption); } _consumers.Add(timeSpaceConsumer); if (consumer.Provider != this) { consumer.Provider = this; } //// TODO (JG): EXPERIMENTAL CODE //if (consumer is IBaseMultiInput) //{ // ((IBaseMultiInput)consumer).AddProvider(this); //} //else //{ // if (consumer.Provider != this) // { // consumer.Provider = this; // } //} }
private static bool ProviderConsumerConnectableForTimeAndOrElementSet(IBaseOutput provider, IBaseInput consumer, bool doCheckTime, bool doCheckSpace) { // Check which time/space consumers are already there if (doCheckSpace) { // check if #elements and elementType are consistent if (consumer.ElementSet() != null && provider.ElementSet() != null ) { if (consumer.ElementSet().ElementCount != provider.ElementSet().ElementCount) { return(false); } if (consumer.ElementSet().ElementType != provider.ElementSet().ElementType&& consumer.ElementSet().ElementCount != 1) { return(false); } } } if (doCheckTime) { ITimeSpaceInput consumerAsTimeSpace = consumer as ITimeSpaceInput; ITimeSpaceInput providerAsTimeSpace = provider as ITimeSpaceInput; if (consumerAsTimeSpace != null && providerAsTimeSpace != null) { if (consumerAsTimeSpace.TimeSet != null && providerAsTimeSpace.TimeSet != null && consumerAsTimeSpace.TimeSet.HasDurations != providerAsTimeSpace.TimeSet.HasDurations) { return(false); } } } return(true); }
/// <summary> /// Connect the output defined by the <paramref name="outputId"/> with the input /// defined by the <paramref name="inputId"/>, and put the adaptors /// listed by the id's <paramref name="adaptorIds"/> in between. /// <para> /// If any of the adaptors needs custom parameters, this method can not be used. /// </para> /// </summary> /// <param name="outputComponent">Component that has the output</param> /// <param name="outputId">Id of output</param> /// <param name="inputComponent">Component that has the input</param> /// <param name="inputId">Id of input</param> /// <param name="adaptorIds">Id of adaptors. They must be available from the output component</param> /// <param name="scale">If scale is different from 0, a linear operation adaptor is also added.</param> public static void Connect(ITimeSpaceComponent outputComponent, string outputId, ITimeSpaceComponent inputComponent, string inputId, IList <string> adaptorIds, double scale) { ITimeSpaceInput input = inputComponent.FindInputItem(inputId); ITimeSpaceOutput output = outputComponent.FindOutputItem(outputId); // End point of connection ITimeSpaceOutput leaf = output; // Add all adaptors foreach (string adaptorID in adaptorIds) { ITimeSpaceAdaptedOutput adaptor = outputComponent.FindAdaptor(adaptorID, leaf, input); if (adaptor == null) { throw new Exception("Coult not find output adaptor with id: " + adaptorID); } adaptor.Initialize(); leaf = adaptor; } // Add a linear conversion adaptor if (scale != 0) { ITimeSpaceAdaptedOutput adaptor = outputComponent.FindAdaptor("LinearOperation", leaf, input); if (adaptor == null) { throw new Exception("Coult not find output linear conversion adaptor"); } adaptor.Arguments[0].Value = scale; adaptor.Initialize(); leaf = adaptor; } // Connect leaf adaptor/output to input leaf.AddConsumer(input); }
public override bool CacheUpdateSource(ITimeSpaceInput source, bool forceCacheUpdate) { ValidTimeSet(source.TimeSet); double required = source.TimeSet.Times[0].StampAsModifiedJulianDay; int nAbove = -1; for (int n = 0; n < _cache.Count; ++n) { if (_cache[n].Time > required) { nAbove = n; break; } } double timeRatio, extrapolated, value; int nValues = ValueSet.GetElementCount(source.Values); Debug.Assert(nValues == _initial.Values.Length); if (nAbove == -1) { if (!forceCacheUpdate) { return(false); } if (_cache.Count == 0) { for (int n = 0; n < nValues; ++n) { source.Values.SetValue(0, n, _initial.Values[n]); } } else if (_cache.Count == 1) { for (int n = 0; n < nValues; ++n) { source.Values.SetValue(0, n, _cache[0].Values[n]); } } else { DataPair prev = _cache[_cache.Count - 2]; DataPair last = _cache[_cache.Count - 1]; timeRatio = (required - prev.Time) / (last.Time - prev.Time); for (int n = 0; n < nValues; ++n) { extrapolated = prev.Values[n] + timeRatio * (last.Values[n] - prev.Values[n]); value = last.Values[n] + (1 - _relaxation) * (extrapolated - last.Values[n]); source.Values.SetValue(0, n, value); } } return(true); } DataPair above = _cache[nAbove]; DataPair below = nAbove > 0 ? _cache[nAbove - 1] : _initial; if (below == null) { throw new NotImplementedException(); } timeRatio = (required - below.Time) / (above.Time - below.Time); for (int n = 0; n < nValues; ++n) { value = below.Values[n] + timeRatio * (above.Values[n] - below.Values[n]); source.Values.SetValue(0, n, value); } return(true); }
public void InputOutputTests() { GWModelLC gwlc = new GWModelLC(); IBaseLinkableComponent lc = gwlc; List<IArgument> arguments = CreateTestArguments(); lc.Initialize(arguments); IElementSet elementSet = ((ITimeSpaceExchangeItem)lc.Inputs[2]).ElementSet(); Quantity dischargeQuantity = new Quantity(new Unit(PredefinedUnits.CubicMeterPerSecond), null, "Discharge"); Quantity waterlevelQuantity = new Quantity(new Unit(PredefinedUnits.Meter), null, "Water Level"); ElementSet idBasedElementSetA = new ElementSet(null, "ElmSet-A", ElementType.IdBased); idBasedElementSetA.AddElement(new Element("elm-1")); Input waterLevelTriggerInput = new Input("Water level, to be retrieved from some output item", waterlevelQuantity, elementSet); waterLevelTriggerInput.TimeSet = new TimeSet(); SimpleOutput dischargeOutput = new SimpleOutput("Discharge, to be sent to GW model", dischargeQuantity, elementSet); dischargeOutput.ConstOutput = 6; dischargeOutput.TimeSet = new TimeSet(); ITimeSpaceInput gwInflow = UTHelper.FindInputItem(lc, "Grid.Inflow"); ITimeSpaceOutput gwLevel = UTHelper.FindOutputItem(lc, "Grid.gwLevel"); // Connect discharge gwInflow.Provider = dischargeOutput; dischargeOutput.AddConsumer(gwInflow); // Connect triggering input gwLevel.AddConsumer(waterLevelTriggerInput); lc.Validate(); lc.Prepare(); // specify query times double firstTriggerGetValuesTime = gwLevel.TimeSet.Times[0].StampAsModifiedJulianDay; double secondTriggerGetValuesTime = firstTriggerGetValuesTime + 3; double thirdTriggerGetValuesTime = firstTriggerGetValuesTime + 5; // check initial values Assert.AreEqual(8, gwLevel.Values.Values2D[0].Count); Assert.AreEqual(-10, (double)gwLevel.Values.GetValue(0, 0)); ITimeSpaceValueSet values; // get values for initial time, therefor intial values waterLevelTriggerInput.TimeSet.SetSingleTime(new Time(firstTriggerGetValuesTime)); values = gwLevel.GetValues(waterLevelTriggerInput); Assert.AreEqual(-10, values.GetValue(0, 0), "value for first query time"); // get values for second query time: -10 : base gw level. // 10 : storageHeight is multiplied by a factor of 10 // 3 days, 6 constant inflow, 3600*24 seconds in a day, 1000 L/M3, (100 x 200) grid cell size waterLevelTriggerInput.TimeSet.SetSingleTime(new Time(secondTriggerGetValuesTime)); values = gwLevel.GetValues(waterLevelTriggerInput); Assert.AreEqual(-10.0 + 10 * 3 * 6.0 * 60 * 60 * 24 / 1000 / (100 * 200), values.GetValue(0, 0), "value for first query time"); // get values for second query time: // 10 : storageHeight is multiplied by a factor of 10 // 5 days, 6 constant inflow, 3600*24 seconds in a day, 1000 L/M3, (100 x 200) grid cell size waterLevelTriggerInput.TimeSet.SetSingleTime(new Time(thirdTriggerGetValuesTime)); values = gwLevel.GetValues(waterLevelTriggerInput); Assert.AreEqual(-10.0 + 10 * 5 * 6.0 * 60 * 60 * 24 / 1000 / (100 * 200), values.GetValue(0, 0), "value for first query time"); lc.Finish(); }