Create model

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

namespace DeltaShell.Plugin.DemoApp.Models
{
    public class VolumeModel : ModelBase
    {
        private readonly DrainageBasin basin;
        private readonly TimeSeries precipitation;
        private readonly FeatureCoverage volume;

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

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

            // Actually add the input/output items to the model by wrapping them with data items
            DataItems.Add(new DataItem(basin, "Basin", typeof(DrainageBasin), DataItemRole.Input, "BasinTag"));
            DataItems.Add(new DataItem(precipitation, "Precipitation", typeof(TimeSeries), DataItemRole.Input, "PrecipitationTag"));
            DataItems.Add(new DataItem(volume, "Volume", typeof(FeatureCoverage), DataItemRole.Output, "VolumeTag"));
        }

        /// <summary>
        /// The basin of the volume model
        /// </summary>
        public DrainageBasin Basin { get { return basin; } }

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

        protected override void OnInitialize()
        {
            // Clear any previous output
            volume.Clear();

            // Ensure the coordinate system of the volume output is the same as the catchments input (basin)
            volume.CoordinateSystem = basin.CoordinateSystem;

            // Initialize the volume output feature coverage
            volume.Features.AddRange(basin.Catchments);
            volume.FeatureVariable.FixedSize = basin.Catchments.Count;
            volume.FeatureVariable.AddValues(basin.Catchments);
        }

        protected override bool OnExecute()
        {
            // Obtain all times of the precipitation time series
            var times = precipitation.Time.GetValues();

            // Loop all times
            foreach (var time in times)
            {
                // Obtain the precipitation for the current time
                var timeSeriesValue = (double) precipitation[time];

                // Loop all catchments
                foreach (var catchment in basin.Catchments)
                {
                    // Calculate (a dummy) volume value based on catchment area and precipitation value
                    var volumeValue = catchment.AreaSize * timeSeriesValue;

                    // Add the calculated volume value to the output feature coverage
                    volume[time, catchment] = volumeValue;
                }
            }

            return true;
        }
    }
}

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