Page History

using System;
using System.Linq;
using DelftTools.Functions;
using DelftTools.Functions.Generic;
using DelftTools.Hydro;
using DelftTools.Shell.Core.Workflow;
using DelftTools.Shell.Core.Workflow.DataItems;
using log4net;
using NetTopologySuite.Extensions.Coverages;

namespace DeltaShell.PluginPlugins.DemoAppVolumeModel.Models
{
    public class VolumeModel : ModelBase
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof(VolumeModel)); // Handle for writing log messages

        private readonly DrainageBasin basin;
        private readonly TimeSeries precipitation;
        private readonly FeatureCoverage volume;

        /// <summary>
        /// Creates a volume model
        /// </summary>
        public VolumeModel()
        {
            // Create the input items of the volume model
            basin = new DrainageBasin();
            precipitation = new TimeSeries { Components = { new Variable<double>("Precipitation") } };

            // Create the output item of the volume model
            volume = new FeatureCoverage("Output data")
                {
                    IsTimeDependent = true,
                Arguments = {  Arguments = { new Variable<Catchment>("Catchment") { FixedSize = 0 } },
                    Components = { new Variable<double>("Volume") },
                };

            // ActuallyWrap addfields theas input/output items to the model after wrapping them with data items
            DataItems.Add(new DataItem(basinprecipitation, "BasinPrecipitation", typeof(DrainageBasinTimeSeries), DataItemRole.Input, "BasinTagPrecipitationTag"));
            DataItems.Add(new DataItem(precipitationbasin, "PrecipitationBasin", typeof(TimeSeriesDrainageBasin), DataItemRole.Input, "PrecipitationTagBasinTag"));
            DataItems.Add(new DataItem(volume, "Volume", typeof(FeatureCoverage), DataItemRole.Output, "VolumeTag"));
        }

        /// <summary>
        /// The basin precipitation time series: P = P(t) [L/T]. Input of the volume model.
        /// </summary>
        public DrainageBasinTimeSeries Precipitation
 Basin { get { return basin; } }{

        /// <summary>
   get { return precipitation; }
 /// The precipitation time series of the volume model}

        /// </summary><summary>
        public TimeSeries Precipitation { get { return precipitation; } }
/// The drainage basin (set of catchments). Input of the model.
        /// <summary></summary>
        ///public TheDrainageBasin initializationBasin
  of model runs
    {
    /// </summary>
       get protected{ overridereturn void OnInitialize()basin; }
        {}

            /// Clear<summary>
 any previous output
      /// Time-dependent feature coverage containing the volume.Clear();

     of water per catchment: V = V(t, c) [L3/T]. Output of the model.
        /// Ensure</summary>
 the coordinate system of the volume output ispublic theFeatureCoverage sameVolume
 as the    catchments input (basin){
            volume.CoordinateSystem = basin.CoordinateSystem;

get { return volume; }
        }

        /// <summary>
 Check if at least one catchment is present
/// The initialization of model runs
       if (!basin.Catchments.Any()) /// </summary>
        protected override void  {OnInitialize()
          {
      Log.Error("At least one catchment should be present");

     // Clear any previous output
            Status = ActivityStatus.Failed; // Cancels the model run
volume.Clear();

            // Ensure the coordinate system }

of the volume output is the same as the catchments input (basin)
 // Check if at least one precipitation value is present
  volume.CoordinateSystem = basin.CoordinateSystem;

        if (precipitation.Time.Values.Count == 0)
 // Ensure at least one catchment and one precipitation value is {present
            ValidateInputData();

     Log.Error("At least one precipitation value should be present");

      // Initialize the output feature coverage
           Status = ActivityStatus.Failed; // Cancels the model run
 volume.Features.AddRange(basin.Catchments);
            volume.FeatureVariable.FixedSize    }
= basin.Catchments.Count;
            if (Status == ActivityStatus.Failed)volume.FeatureVariable.AddValues(basin.Catchments);
        }

    {
    /// <summary>
        /// The actual return;
calculation during model run
         }
/// </summary>
        protected override bool OnExecute()
 // Initialize the volume output feature  coverage{
            // Loop  volume.Features.AddRange(basin.Catchments);
all times
             volume.FeatureVariable.FixedSize = basin.Catchments.Count;foreach (var time in precipitation.Time.Values)
            volume.FeatureVariable.AddValues(basin.Catchments);{
        }

        /// <summary>
Obtain the precipitation      /// The actual calculation during the model runsvalue for the current time
        /// </summary>
       var protectedp override bool= OnExecute(double) precipitation[time];

        {
        // Calculate a volume value for every //catchment Obtainbased allon timescatchment ofarea theand precipitation value
   time series
            var timesvolumes = precipitationbasin.TimeCatchments.GetValues(Select(c => c.AreaSize * p);

                // LoopAdd allthe times
calculated volume values to the output feature coverage
     foreach (var time in times)
       volume[time] = volumes;
   {
         }

       // Obtain the precipitation value forreturn thetrue;
 current time
      }

        private  var timeSeriesValue = (double) precipitation[time];

void ValidateInputData()
        {
         // Loop all catchmentsvar andhasCatchments calculate= (a dummy) volume value based on catchment area and precipitation value
basin.Catchments.Any();
            var hasPrecipitationData         var volumeValues = basin.Catchments.Select(c => c.AreaSize * timeSeriesValue= precipitation.Time.Values.Any();

            if (!hasCatchments && !hasPrecipitationData)
  // Add the calculated volume values to the output feature coverage{
                volume[time] = volumeValuesthrow new InvalidOperationException("At least one catchment and one precipitation value should be present");
            }

            return true;
if (!hasCatchments)
            }{
    }
}

                throw new InvalidOperationException("At least one catchment should be present");
            }

            if (!hasPrecipitationData)
            {
                throw new InvalidOperationException("At least one precipitation value should be present");
            }
        }
    }
}

        public override IEnumerable<ModelInfo> GetModelInfos()
        {
            yield return new ModelInfo
            {
                Name = "Volume Model",
                Category = "DemoAppVolume models",
                CreateModel = o => new Models.VolumeModel()
            };
        }

In order to inspect time dependent (output) data, open the Time Navigator window and move the slider or click one of the auto play buttons.:

Image Added