Beispiel #1
0
        override public bool UpdateRequired(ITimeSet request, ITimeSet current)
        {
            if (Values == null || ValueSet.GetElementCount(Values) * ValueSet.GetTimesCount(Values) != 1)
            {
                return(true);
            }

            ValidTimeSet(request);
            ValidTimeSet(current);

            double dRequest = request.Times[0].StampAsModifiedJulianDay;
            double dCurrent = current.Times[0].StampAsModifiedJulianDay;

            if (Math.Abs(dCurrent - dRequest) <= _timeTolerance)
            {
                return(false); // Equal within tolerance
            }
            // TODO Could check cache and just throw if cache inadequate

            if (dRequest < dCurrent)
            {
                throw new InvalidOperationException("Earlier time request");
            }

            return(true);
        }
Beispiel #2
0
        protected override void EngineUpdateFromTargets()
        {
            TimeSet timeSet = new TimeSet();

            timeSet.SetSingleTimeStamp(_gwEngine.CurrentTime);

            foreach (ITimeSpaceInput item in ActiveTargets)
            {
                if (item is ItemInBase)
                {
                    ((ItemInBase)item).Update(timeSet);
                }
                else
                {
                    throw new InvalidCastException("InputItemBase");
                }

                // TODO (ADH) Presumption is item contains 1 and only 1
                // set of values, at the update time, when is this false?
                Debug.Assert(item.TimeSet.Times.Count == 1);

                double[] v = new double[ValueSet.GetElementCount(item.Values)];
                item.Values.GetElementValuesForTime(0).CopyTo(v, 0);

                if (item is Inflow)
                {
                    _gwEngine.SetInflows(v);
                }
                else
                {
                    throw new NotImplementedException("EngineUpdateFromTargets");
                }
            }
        }
Beispiel #3
0
        public void Polygon2PointAdaptedOutputGetValues2Consumers()
        {
            Output adaptee = new Output(xyPolygon.Caption + ".Flow")
            {
                SpatialDefinition = xyPolygon, ValueDefinition = waterLevelQuantity
            };
            ITimeSpaceInput consumerA = new Input(xyPointA.Caption + ".Flow")
            {
                SpatialDefinition = xyPointA, ValueDefinition = waterLevelQuantity
            };

            IIdentifiable           selectedAvailableAdaptedOutputId = adaptedOutputFactory.GetAvailableAdaptedOutputIds(adaptee, consumerA)[1];
            ITimeSpaceAdaptedOutput adaptedOutput = (ITimeSpaceAdaptedOutput)adaptedOutputFactory.CreateAdaptedOutput(selectedAvailableAdaptedOutputId, adaptee, consumerA);

            adaptedOutput.AddConsumer(consumerA);

            IList <IList> values2D = new List <IList>();

            values2D.Add(new List <double> {
                0.444
            });
            adaptee.Values = new ValueSet(values2D);

            ITimeSpaceValueSet adaptedValuesA = adaptedOutput.GetValues(consumerA);

            Assert.AreEqual(1, ValueSet.GetTimesCount(adaptedValuesA), "adaptedValuesA.TimesCount");
            Assert.AreEqual(consumerA.ElementSet().ElementCount, ValueSet.GetElementCount(adaptedValuesA), "adaptedValuesA.ElementCount");
        }
        public override void SetEngineValues(EngineInputItem inputItem, ITimeSpaceValueSet values)
        {
            int elementCount = ValueSet.GetElementCount(values);

            double[] avalues = new double[elementCount];
            for (int i = 0; i < elementCount; i++)
            {
                avalues[i] = (double)values.GetValue(0, i);
            }
            ScalarSet scalarSet = new ScalarSet(avalues);

            _engineApiAccess.SetValues(inputItem.ValueDefinition.Caption, inputItem.SpatialDefinition.Caption, scalarSet);
        }
Beispiel #5
0
        /// <summary>
        /// MapValues calculates for each set of timestep data
        /// a resulting IValueSet through multiplication of an inputValues IValueSet
        /// vector with the mapping maprix.
        /// </summary>
        /// <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 TimeSpaceValueSet <double> MapValues(ref ITimeSpaceValueSet inputValues)
        {
            if (!_isInitialised)
            {
                throw new Exception(
                          "ElementMapper objects needs to be initialised before the MapValue method can be used");
            }
            if (!ValueSet.GetElementCount(inputValues).Equals(_numberOfFromColumns))
            {
                throw new Exception("Dimension mismatch between inputValues and mapping matrix");
            }

            // Make a time-space value set of the correct size
            ITimeSpaceValueSet <double> result = CreateResultValueSet(inputValues.TimesCount(), _numberOfToRows);

            MapValues(ref result, ref inputValues);

            return((TimeSpaceValueSet <double>)result);
        }
Beispiel #6
0
 override public void ValidValue(ITimeSpaceValueSet valueSet)
 {
     // TODO Standard move ValidValue into IExchangeItem?
     if (valueSet == null)
     {
         throw new ArgumentException("value == null");
     }
     if (ValueSet.GetElementCount(valueSet) != 1)
     {
         throw new ArgumentException("valueSet.ElementCount != 1");
     }
     if (ValueSet.GetTimesCount(valueSet) != 1)
     {
         throw new ArgumentException("valueSet.TimesCount != 1");
     }
     if (!(valueSet.GetValue(0, 0) is double))
     {
         throw new ArgumentException("!(valueSet.GetValue(0,0) is double)");
     }
 }
        protected override void EngineUpdateFromTargets()
        {
            TimeSet timeSet = new TimeSet();

            timeSet.SetSingleTimeStamp(_engine.GetCurrentTime());

            foreach (ITimeSpaceInput item in ActiveTargets)
            {
                if (item is ItemInBase)
                {
                    ((ItemInBase)item).Update(timeSet);
                }
                else
                {
                    throw new InvalidCastException("InputItemBase");
                }

                // TODO (ADH) Presumption is item contains 1 and only 1
                // set of values, at the update time, when is this false?
                Debug.Assert(item.TimeSet.Times.Count == 1);
                Debug.Assert(ValueSet.GetElementCount(item.Values) == 1);

                if (item is InflowAtNode)
                {
                    _engine.SetExternalNodeInflow(
                        _nodeIndexs[item],
                        (double)item.Values.GetElementValuesForTime(0)[0]);
                }
                else if (item is GroundWaterLevelAtNode)
                {
                    _engine.SetGroundWaterLevel(
                        _nodeIndexs[item],
                        (double)item.Values.GetElementValuesForTime(0)[0]);
                }
                else
                {
                    throw new NotImplementedException("EngineUpdateFromTargets");
                }
            }
        }
Beispiel #8
0
        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);
        }
Beispiel #9
0
    public void GetValuesFromGwModel()
    {
      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 queryItem1 = new Input("discharge, to be retrieved from some output item", dischargeQuantity, idBasedElementSetA);
      queryItem1.TimeSet = new TimeSet();

      Input queryItem2 = new Input("water level, to be retrieved from some output item", waterlevelQuantity, idBasedElementSetA);
      queryItem2.TimeSet = new TimeSet();

      // Connect query item(s) to output item(s)
      // Take care that component becomes valid (and has produced initial output for connected items)

      ITimeSpaceComponent gwModel = new GWModelLC();
      gwModel.Initialize();

      ITimeSpaceOutput storageOnGrid = UTHelper.FindOutputItem(gwModel, "Grid.Storage");
      storageOnGrid.AddConsumer(queryItem1);
      gwModel.Validate();
      Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Valid);
      gwModel.Prepare();
      Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Updated);

      // check initial values
      Assert.AreEqual(4, ValueSet.GetElementCount(storageOnGrid.Values), "#values for " + storageOnGrid.Id);
      Assert.AreEqual(0.0, (double)storageOnGrid.Values.GetValue(0, 0), "Value[0] as property");

      // get values for specified query times
      queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 1, 3, 0, 0, 0));
      ITimeSpaceValueSet values = storageOnGrid.GetValues(queryItem1);
      Assert.IsNotNull(values, "values != null");
      Assert.AreEqual(0.0, (double)values.GetValue(0, 0), "value[0] from GetValues 1");

      // set next query time
      queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 2, 4, 0, 0, 0));
      values = storageOnGrid.GetValues(queryItem1);
      Assert.IsNotNull(values, "values != null");
      Assert.AreEqual(0.0, (double)values.GetValue(0, 0), "value[0] from GetValues 1");

      // ask for same time again
      values = storageOnGrid.GetValues(queryItem1);
      Assert.IsNotNull(values, "values != null");
      Assert.AreEqual(0.0, (double)values.GetValue(0, 0), "value[0] from GetValues 1");

      try
      {
        // set query time back in time
        queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 2, 3, 0, 0, 0));
        storageOnGrid.GetValues(queryItem1);
      }
      catch (Exception e)
      {
        Assert.IsTrue(e.Message.StartsWith("Could not update engine \""));
      }

      try
      {
        // set query time beyond time horizon
        queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 2, 28, 0, 0, 0));
        storageOnGrid.GetValues(queryItem1);
      }
      catch (Exception e)
      {
        Assert.IsTrue(e.Message.StartsWith("Could not update engine \""));
      }
    }
Beispiel #10
0
        public void CouplingGwRiver2()
        {
            /// runNumber 0: Using MultiInput
            /// runNumber 1: Using MultiInputAdaptor
            /// runNumber 2: Using MultiInputAdaptorFactory

            for (int runNumber = 0; runNumber < 3; runNumber++)
            {
                Console.Out.WriteLine("runNumber: " + runNumber);

                // Create trigger inputs
                Input queryDischargeItem = CreateDischargeInput();
                Input queryVolume        = CreateVolumeInput();

                // Create models
                LinkableEngine      riverModel  = CreateRiverModel();
                LinkableEngine      riverModel2 = CreateRiverModel();
                ITimeSpaceComponent gwModel     = CreateGwModel();

                // Add arguments and initialize
                IDictionary <string, IArgument> gwArgs = gwModel.Arguments.Dictionary();
                // Increasing model grid size (otherwise GW model runs full too fast)
                gwArgs.UpdateValue("dx", 50.0);
                gwArgs.UpdateValue("dy", 50.0);
                gwArgs.UpdateValue("x0", 0.0);
                gwArgs.UpdateValue("y0", 200.0);
                gwArgs.UpdateValue("XCount", 24);
                gwArgs.UpdateValue("ycount", 16);
                if (runNumber == 0)
                {
                    gwArgs.UpdateValue("UseMultiInput", true);
                }
                gwModel.Initialize();
                int gwGridSize = 24 * 16;

                IDictionary <string, IArgument> riverArgs = riverModel.Arguments.Dictionary();
                // Increasing model grid size (otherwise GW model runs full too fast)
                riverArgs.UpdateValue("xyscale", 100.0);
                riverModel.Initialize();

                IDictionary <string, IArgument> river2Args = riverModel2.Arguments.Dictionary();
                // Increasing model grid size (otherwise GW model runs full too fast)
                river2Args.UpdateValue("xyscale", 100.0);
                // Move river2 sligthly away from river1
                river2Args.UpdateValue("xoffset", -220.0);
                river2Args.UpdateValue("yoffset", 180.0);
                riverModel2.Initialize();

                // Connect triggering inputs
                ITimeSpaceOutput flowOnBranch  = UTHelper.FindOutputItem(riverModel, "Branch:2:Flow");
                TimeInterpolator flowOnBranch2 = new TimeInterpolator(flowOnBranch);
                flowOnBranch.AddAdaptedOutput(flowOnBranch2);
                flowOnBranch2.AddConsumer(queryDischargeItem);

                ITimeSpaceOutput storageInGw  = UTHelper.FindOutputItem(gwModel, "Grid.Storage");
                TimeInterpolator storageInGw2 = new TimeInterpolator(storageInGw);
                storageInGw.AddAdaptedOutput(storageInGw2);
                storageInGw2.AddConsumer(queryVolume);

                //========== Couple leakage items ==========
                ITimeSpaceInput gwInflowInput = UTHelper.FindInputItem(gwModel, "Grid.Inflow");


                //========== IBaseMultiInput linking ==========
                if (runNumber == 0)
                {
                    /// Example of adding up two outputs into one input, by the use of
                    /// an IBaseMultiInput implementation

                    Assert.IsTrue(gwInflowInput is IBaseMultiInput);
                    Assert.IsTrue(gwInflowInput is ITimeSpaceMultiInput);

                    // put leakage from river1 into ground water model
                    {
                        ITimeSpaceOutput riverLeakageOutput = UTHelper.FindOutputItem(riverModel, "WholeRiver:Leakage");

                        // Two adaptors are added: Time buffer and line-to-grid adaptor
                        // they can be added in any order (though time buffer first will use less memory)

                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutput);
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput2,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput2.AddAdaptedOutput(riverLeakageOutputGrid);

                        // Note !!!: No special action
                        riverLeakageOutputGrid.AddConsumer(gwInflowInput);
                    }

                    // put leakage from river2 into ground water model
                    {
                        ITimeSpaceOutput riverLeakageOutput = UTHelper.FindOutputItem(riverModel2, "WholeRiver:Leakage");

                        // Two adaptors are added: Time buffer and line-to-grid adaptor
                        // they can be added in any order (though time buffer first will use less memory)

                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutput);
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput2,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput2.AddAdaptedOutput(riverLeakageOutputGrid);

                        // Note !!!: No special action
                        riverLeakageOutputGrid.AddConsumer(gwInflowInput);
                    }
                }

                //========== MultiInputAdaptor linking ==========
                if (runNumber == 1)
                {
                    /// Example of adding up two outputs into one input, by the use of
                    /// a MultiInputAdaptor class

                    // Note !!!: Creating a MultiInputAdaptor
                    MultiInputAdaptor sourceAdder = new MultiInputAdaptor("SomeId")
                    {
                        SpatialDefinition = gwInflowInput.SpatialDefinition
                    };

                    // put leakage from river1 into ground water model
                    // Two adaptors are added: Time buffer and line-to-grid adaptor
                    {
                        ITimeSpaceOutput riverLeakageOutput = UTHelper.FindOutputItem(riverModel, "WholeRiver:Leakage");

                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutput);
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput2,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput2.AddAdaptedOutput(riverLeakageOutputGrid);

                        // Note !!!: Adding to the list of adaptees
                        sourceAdder.Adaptees.Add(riverLeakageOutputGrid);
                        riverLeakageOutputGrid.AddAdaptedOutput(sourceAdder);
                    }

                    // put leakage from river2 into ground water model
                    // Two adaptors are added: Time buffer and line-to-grid adaptor
                    {
                        ITimeSpaceOutput riverLeakageOutput = UTHelper.FindOutputItem(riverModel2, "WholeRiver:Leakage");

                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutput);
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput2,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput2.AddAdaptedOutput(riverLeakageOutputGrid);

                        // Note !!!: Adding to the list of adaptees
                        sourceAdder.Adaptees.Add(riverLeakageOutputGrid);
                        riverLeakageOutputGrid.AddAdaptedOutput(sourceAdder);
                    }

                    // Note !!!: Connect the gwInflowInput and the multiInputAdaptor
                    sourceAdder.AddConsumer(gwInflowInput);
                }

                //========== MultiInputAdaptorFactory linking ==========
                if (runNumber == 2)
                {
                    /// Example of adding up two outputs into one input, by the use of
                    /// an MultiInputAdaptorFactory implementation

                    var factory = new MultiInputAdaptorFactory(gwModel);

                    // put leakage from river1 into ground water model
                    // Two adaptors are added: Time buffer and line-to-grid adaptor
                    {
                        ITimeSpaceOutput riverLeakageOutput = UTHelper.FindOutputItem(riverModel, "WholeRiver:Leakage");

                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutput);
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput2,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput2.AddAdaptedOutput(riverLeakageOutputGrid);

                        // Note !!!: Creating a new AdaptedOutput and adding it
                        IIdentifiable[]    identifiables = factory.GetAvailableAdaptedOutputIds(riverLeakageOutputGrid, gwInflowInput);
                        IBaseAdaptedOutput myOutput      = factory.CreateAdaptedOutput(identifiables[0], riverLeakageOutputGrid, gwInflowInput);

                        myOutput.AddConsumer(gwInflowInput);
                    }

                    // put leakage from river2 into ground water model
                    // Two adaptors are added: Time buffer and line-to-grid adaptor
                    {
                        ITimeSpaceOutput riverLeakageOutput = UTHelper.FindOutputItem(riverModel2, "WholeRiver:Leakage");

                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutput);
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput2,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput2.AddAdaptedOutput(riverLeakageOutputGrid);

                        // Note !!!: Creating a new AdaptedOutput and adding it
                        IIdentifiable[]    identifiables = factory.GetAvailableAdaptedOutputIds(riverLeakageOutputGrid, gwInflowInput);
                        IBaseAdaptedOutput myOutput      = factory.CreateAdaptedOutput(identifiables[0], riverLeakageOutputGrid, gwInflowInput);

                        myOutput.AddConsumer(gwInflowInput);
                    }
                }


                //========== Run ==========

                // Validate
                riverModel.Validate();
                Assert.IsTrue(riverModel.Status == LinkableComponentStatus.Valid);
                riverModel2.Validate();
                Assert.IsTrue(riverModel2.Status == LinkableComponentStatus.Valid);
                gwModel.Validate();
                Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Valid);

                // Prepare
                riverModel.Prepare();
                Assert.IsTrue(riverModel.Status == LinkableComponentStatus.Updated);
                riverModel2.Prepare();
                Assert.IsTrue(riverModel2.Status == LinkableComponentStatus.Updated);
                gwModel.Prepare();
                Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Updated);


                // specify query times
                double triggerTime0 = riverModel.CurrentTime.StampAsModifiedJulianDay;
                double triggerTime1 = triggerTime0 + 1;
                double triggerTime2 = triggerTime0 + 2;
                double triggerTime3 = triggerTime0 + 12.1;
                double triggerTime4 = triggerTime0 + 16.7;

                /// Properties of the river, without gw-level input
                /// Inflow into each node from rainfall runoff is 10 L/s
                /// Inflow to node 1: 10        L/s - leaking  5   L/s on branch 1
                /// Inflow to node 2: 10 +    5 L/s - leaking 15/2 L/s on branch 2
                /// Inflow to node 3: 10 + 15/2 L/s - leaking 35/4 L/s on branch 3
                /// Total leakage 5+15/2+35/4 = (20+30+35)/4 = 85/4 L/s
                ///
                /// Number of seconds in a day: 60*60*24 = 86400

                // check initial values
                Assert.AreEqual(1, ValueSet.GetElementCount(flowOnBranch.Values), "#values for " + flowOnBranch.Id);
                Assert.AreEqual(7.0, (double)flowOnBranch.Values.GetValue(0, 0), "Value[0] as property");

                Assert.AreEqual(gwGridSize, ValueSet.GetElementCount(storageInGw.Values), "#values for " + storageInGw.Id);
                Assert.AreEqual(0, SumTimeStep(storageInGw.Values, 0));

                // get values for specified query times, 1 days
                // Totally leaking: 86400 * 85/4 = 1.836e6
                // For the bi-directional coupling:
                // the entire first day the river uses extrapolated values from the
                // gwModel, which gives a gwLevel of -10, hence same value as for the uni-directional
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime1);
                ITimeSpaceValueSet valuesV = storageInGw2.GetValues(queryDischargeItem);
                ITimeSpaceValueSet valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                Assert.AreEqual(2 * 1.836e6, SumTimeStep(valuesV, 0), 1e-4);

                // Print out, to load in a plotting program for verification
                StringBuilder b = new StringBuilder();

                IList valV   = valuesV.GetElementValuesForTime(0);
                int   ivalvV = 0;
                for (int i = 0; i < 16; i++)
                {
                    for (int j = 0; j < 24; j++)
                    {
                        b.Append(((double)valV[ivalvV++]).ToString(NumberFormatInfo.InvariantInfo));
                        b.Append(" ");
                    }
                    b.AppendLine();
                }
                //Console.Out.WriteLine(b.ToString());

                // get values for specified query times, 2 days
                // 2 * 86400 * 85/4 = 3.672e6
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime2);
                valuesV = storageInGw2.GetValues(queryDischargeItem);
                valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                Assert.AreEqual(2 * 3.672e6, SumTimeStep(valuesV, 0), 1e-4);

                // get values for specified query times, 12.1 days
                // 12.1 * 86400 * 85/4 = 2.22156e7
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime3);
                valuesV = storageInGw2.GetValues(queryDischargeItem);
                valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                Assert.AreEqual(2 * 2.22156e7, SumTimeStep(valuesV, 0), 1e-4);

                // get values for specified query times, 16.7 days
                // 16.7 * 86400 * 85/4 = 3.06612e7
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime4);
                valuesV = storageInGw2.GetValues(queryDischargeItem);
                valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                Assert.AreEqual(2 * 3.06612e7, SumTimeStep(valuesV, 0), 1e-4);
            }
        }
Beispiel #11
0
        public void CouplingGwRiver()
        {
            /// bit 1: Decides whether the timeInterpolator or grid-to-line adaptor comes first
            /// bit 2: when true, using a 16x16 gw grid (instead of 2x2)
            /// bit 3: when true, bi-directinal: adds a link from gwModel to river, with the gw-level

            for (int runNumber = 0; runNumber < 8; runNumber++)
            {
                //if (runNumber != 3)
                //  continue;

                Console.Out.WriteLine("runNumber: " + runNumber);

                // Create trigger inputs
                Input queryDischargeItem = CreateDischargeInput();
                Input queryVolume        = CreateVolumeInput();

                // Create models
                LinkableEngine      riverModel = CreateRiverModel();
                ITimeSpaceComponent gwModel    = CreateGwModel();

                // Add arguments and initialize
                IDictionary <string, IArgument> gwArgs = gwModel.Arguments.Dictionary();
                // Increasing model grid size (otherwise GW model runs full too fast)
                gwArgs.UpdateValue("dx", 400.0);
                gwArgs.UpdateValue("dy", 400.0);
                gwArgs.UpdateValue("x0", 200.0);
                gwArgs.UpdateValue("y0", 200.0);
                int gwGridSize = 2 * 2;
                if ((runNumber & 2) == 2) // set 16 x 16 grid
                {
                    gwArgs.UpdateValue("dx", 50.0);
                    gwArgs.UpdateValue("dy", 50.0);
                    gwArgs.UpdateValue("XCount", 16);
                    gwArgs.UpdateValue("ycount", 16);
                    gwGridSize = 16 * 16;
                }
                gwModel.Initialize();

                IDictionary <string, IArgument> riverArgs = riverModel.Arguments.Dictionary();
                // Increasing model grid size (otherwise GW model runs full too fast)
                riverArgs.UpdateValue("xyscale", 100.0);
                riverModel.Initialize();

                // Connect triggering inputs
                ITimeSpaceOutput flowOnBranch  = UTHelper.FindOutputItem(riverModel, "Branch:2:Flow");
                TimeInterpolator flowOnBranch2 = new TimeInterpolator(flowOnBranch);
                flowOnBranch.AddAdaptedOutput(flowOnBranch2);
                flowOnBranch2.AddConsumer(queryDischargeItem);

                ITimeSpaceOutput storageInGw  = UTHelper.FindOutputItem(gwModel, "Grid.Storage");
                TimeInterpolator storageInGw2 = new TimeInterpolator(storageInGw);
                storageInGw.AddAdaptedOutput(storageInGw2);
                storageInGw2.AddConsumer(queryVolume);

                //========== Couple leakage items ==========
                // put leakage from river into ground water model
                {
                    ITimeSpaceOutput riverLeakageOutput = UTHelper.FindOutputItem(riverModel, "WholeRiver:Leakage");
                    ITimeSpaceInput  gwInflowInput      = UTHelper.FindInputItem(gwModel, "Grid.Inflow");

                    // Two adaptors are added: Time buffer and line-to-grid adaptor
                    // they can be added in any order (though time buffer first will use less memory)
                    if ((runNumber & 1) == 1)
                    {
                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutput);
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput2,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput2.AddAdaptedOutput(riverLeakageOutputGrid);

                        riverLeakageOutputGrid.AddConsumer(gwInflowInput);
                    }
                    else
                    {
                        // Element mapper from polyline to polygon, weighted sum version
                        ElementMapperAdaptedOutput riverLeakageOutputGrid =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper501"), riverLeakageOutput,
                                                           gwInflowInput.ElementSet());
                        riverLeakageOutput.AddAdaptedOutput(riverLeakageOutputGrid);

                        // Time interpolator
                        TimeInterpolator riverLeakageOutput2 = new TimeInterpolator(riverLeakageOutputGrid);
                        riverLeakageOutputGrid.AddAdaptedOutput(riverLeakageOutput2);

                        riverLeakageOutput2.AddConsumer(gwInflowInput);
                    }
                }
                //========== Couple ground water level items ==========

                if ((runNumber & 4) == 4)
                {
                    // put ground water level from ground water model into river
                    ITimeSpaceInput  riverGwleveInput = UTHelper.FindInputItem(riverModel, "WholeRiver:GroundWaterLevel");
                    ITimeSpaceOutput gwLevelOutput    = UTHelper.FindOutputItem(gwModel, "Grid.gwLevel");

                    // Two adaptors are added: Time buffer and grid-to-line adaptor
                    // they can be added in any order (though time buffer last will use less memory)
                    if ((runNumber & 1) == 1)
                    {
                        // Time interpolator
                        var gwLevelOutput2 = new TimeExtrapolator(gwLevelOutput);
                        gwLevelOutput.AddAdaptedOutput(gwLevelOutput2);

                        // Element mapper from polyline to polygon, weighted sum version
                        var gwLevelOutputLine =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper700"), gwLevelOutput2,
                                                           riverGwleveInput.ElementSet());
                        gwLevelOutput2.AddAdaptedOutput(gwLevelOutputLine);

                        gwLevelOutputLine.AddConsumer(riverGwleveInput);
                    }
                    else
                    {
                        // Element mapper from polyline to polygon, weighted sum version
                        var gwLevelOutputLine =
                            new ElementMapperAdaptedOutput(new Identifier("ElementMapper700"), gwLevelOutput,
                                                           riverGwleveInput.ElementSet());
                        gwLevelOutput.AddAdaptedOutput(gwLevelOutputLine);

                        // Time interpolator
                        var gwLevelOutput2 = new TimeExtrapolator(gwLevelOutputLine);
                        gwLevelOutputLine.AddAdaptedOutput(gwLevelOutput2);

                        gwLevelOutput2.AddConsumer(riverGwleveInput);
                    }
                }

                //========== Run ==========

                // Validate
                riverModel.Validate();
                Assert.IsTrue(riverModel.Status == LinkableComponentStatus.Valid);
                gwModel.Validate();
                Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Valid);

                // Prepare
                riverModel.Prepare();
                Assert.IsTrue(riverModel.Status == LinkableComponentStatus.Updated);
                gwModel.Prepare();
                Assert.IsTrue(gwModel.Status == LinkableComponentStatus.Updated);


                // specify query times
                double triggerTime0 = riverModel.CurrentTime.StampAsModifiedJulianDay;
                double triggerTime1 = triggerTime0 + 1;
                double triggerTime2 = triggerTime0 + 2;
                double triggerTime3 = triggerTime0 + 12.1;
                double triggerTime4 = triggerTime0 + 16.7;

                /// Properties of the river, without gw-level input
                /// Inflow into each node from rainfall runoff is 10 L/s
                /// Inflow to node 1: 10        L/s - leaking  5   L/s on branch 1
                /// Inflow to node 2: 10 +    5 L/s - leaking 15/2 L/s on branch 2
                /// Inflow to node 3: 10 + 15/2 L/s - leaking 35/4 L/s on branch 3
                /// Total leakage 5+15/2+35/4 = (20+30+35)/4 = 85/4 L/s
                ///
                /// Number of seconds in a day: 60*60*24 = 86400

                // check initial values
                Assert.AreEqual(1, ValueSet.GetElementCount(flowOnBranch.Values), "#values for " + flowOnBranch.Id);
                Assert.AreEqual(7.0, (double)flowOnBranch.Values.GetValue(0, 0), "Value[0] as property");

                Assert.AreEqual(gwGridSize, ValueSet.GetElementCount(storageInGw.Values), "#values for " + storageInGw.Id);
                Assert.AreEqual(0, SumTimeStep(storageInGw.Values, 0));

                // get values for specified query times, 1 days
                // Totally leaking: 86400 * 85/4 = 1.836e6
                // For the bi-directional coupling:
                // the entire first day the river uses extrapolated values from the
                // gwModel, which gives a gwLevel of -10, hence same value as for the uni-directional
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime1);
                ITimeSpaceValueSet valuesV = storageInGw2.GetValues(queryDischargeItem);
                ITimeSpaceValueSet valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                Assert.AreEqual(1.836e6, SumTimeStep(valuesV, 0), 1e-4);

                // Print out, to load in a plotting program for verification
                //StringBuilder b = new StringBuilder();
                //foreach (double val in valuesV.GetElementValuesForTime(0))
                //  b.AppendLine(val.ToString(NumberFormatInfo.InvariantInfo));
                //Console.Out.WriteLine(b.ToString());

                // get values for specified query times, 2 days
                // 2 * 86400 * 85/4 = 3.672e6
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime2);
                valuesV = storageInGw2.GetValues(queryDischargeItem);
                valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                if ((runNumber & 4) != 4) // unidirectional
                {
                    Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                    Assert.AreEqual(3.672e6, SumTimeStep(valuesV, 0), 1e-4);
                }
                else if ((runNumber & 2) != 2) // bi-directional 2x2 grid
                {
                    Assert.AreEqual(8.843648, (double)valuesQ.GetValue(0, 0), 1e-4);
                    Assert.AreEqual(3.66390879366e6, SumTimeStep(valuesV, 0), 1e-4);
                }
                else                    // bi-directional 16x16 grid
                {
                    Assert.AreEqual(9.65307, (double)valuesQ.GetValue(0, 0), 1e-4);
                    Assert.AreEqual(3.59397465219e6, SumTimeStep(valuesV, 0), 1e-4);
                }

                // get values for specified query times, 12.1 days
                // 12.1 * 86400 * 85/4 = 2.22156e7
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime3);
                valuesV = storageInGw2.GetValues(queryDischargeItem);
                valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                if ((runNumber & 4) != 4) // unidirectional
                {
                    Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                    Assert.AreEqual(2.22156e7, SumTimeStep(valuesV, 0), 1e-4);
                }
                else if ((runNumber & 2) != 2) // bi-directional 2x2 grid
                {
                    Assert.AreEqual(9.87828, (double)valuesQ.GetValue(0, 0), 1e-4);
                    Assert.AreEqual(2.16704019338e7, SumTimeStep(valuesV, 0), 1e-4);
                }
                else                    // bi-directional 16x16 grid
                {
                    Assert.AreEqual(18.546999, (double)valuesQ.GetValue(0, 0), 1e-4);
                    Assert.AreEqual(1.722400002557e7, SumTimeStep(valuesV, 0), 1e-4);
                }

                // get values for specified query times, 16.7 days
                // 16.7 * 86400 * 85/4 = 3.06612e7
                queryDischargeItem.TimeSet.SetSingleTimeStamp(triggerTime4);
                valuesV = storageInGw2.GetValues(queryDischargeItem);
                valuesQ = flowOnBranch2.GetValues(queryDischargeItem);
                if ((runNumber & 4) != 4) // unidirectional
                {
                    Assert.AreEqual(35.0 / 4.0, (double)valuesQ.GetValue(0, 0));
                    Assert.AreEqual(3.06612e7, SumTimeStep(valuesV, 0), 1e-4);
                }
                else if ((runNumber & 2) != 2) // bi-directional 2x2 grid
                {
                    Assert.AreEqual(10.255535, (double)valuesQ.GetValue(0, 0), 1e-4);
                    Assert.AreEqual(2.9595872035072e7, SumTimeStep(valuesV, 0), 1e-4);
                }
                else                    // bi-directional 16x16 grid
                {
                    Assert.AreEqual(20.98699, (double)valuesQ.GetValue(0, 0), 1e-4);
                    Assert.AreEqual(2.12991179998e7, SumTimeStep(valuesV, 0), 1e-4);
                }
            }
        }
Beispiel #12
0
        public void GetValues()
        {
            // Connect query item(s) to output item(s)
            // Take care that component becomes valid (and has produced initial output for connected items)

            ITimeSpaceComponent riverModel = CreateRiverModel();
            List <IArgument>    arguments  = CreateRiverModelArguments(riverModel);

            arguments.Add(new ArgumentBool("flowItemsAsSpan", _flowItemsAsSpan));
            riverModel.Arguments.ApplyArguments(arguments);
            riverModel.Initialize();

            ITimeSpaceOutput flowOnBranch = UTHelper.FindOutputItem(riverModel, "Branch:2:Flow");

            flowOnBranch.AddConsumer(_queryItem1);
            riverModel.Validate();
            Assert.IsTrue(riverModel.Status == LinkableComponentStatus.Valid);
            riverModel.Prepare();
            Assert.IsTrue(riverModel.Status == LinkableComponentStatus.Updated);

            // check initial values
            Assert.AreEqual(1, ValueSet.GetElementCount(flowOnBranch.Values), "#values for " + flowOnBranch.Id);
            Assert.AreEqual(7.0, (double)flowOnBranch.Values.GetValue(0, 0), "Value[0] as property");

            // get values for specified query times
            _queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 1, 3, 0, 0, 0));
            ITimeSpaceValueSet values = flowOnBranch.GetValues(_queryItem1);

            Assert.IsNotNull(values, "values != null");
            double flow3 = 35.0 / 4.0; // = 10 * (1.0 / 2.0 + 1.0 / 4.0 + 1.0 / 8.0) = 8.75

            Assert.AreEqual(flow3, (double)values.GetValue(0, 0), "value[0] from GetValues 1");

            // set next query time
            _queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 2, 4, 0, 0, 0));
            values = flowOnBranch.GetValues(_queryItem1);
            Assert.IsNotNull(values, "values != null");
            flow3 = 10 * (1.0 / 2.0 + 1.0 / 4.0 + 1.0 / 8.0); // = 8.75
            Assert.AreEqual(flow3, (double)values.GetValue(0, 0), "value[0] from GetValues 1");

            // ask for same time again
            values = flowOnBranch.GetValues(_queryItem1);
            Assert.IsNotNull(values, "values != null");
            Assert.AreEqual(flow3, (double)values.GetValue(0, 0), "value[0] from GetValues 1");

            try
            {
                // set query time back in time
                _queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 2, 3, 0, 0, 0));
                flowOnBranch.GetValues(_queryItem1);
            }
            catch (Exception e)
            {
                Assert.IsTrue(e.Message.StartsWith("Could not update engine \""));
            }

            try
            {
                // set query time beyond time horizon
                _queryItem1.TimeSet.SetSingleTimeStamp(new DateTime(2005, 2, 28, 0, 0, 0));
                flowOnBranch.GetValues(_queryItem1);
            }
            catch (Exception e)
            {
                Assert.IsTrue(e.Message.StartsWith("Could not update engine \""));
            }
        }