Page History

The comments in the code explain the different parts of the DrainageBasin implementation.

using System;
using System.Linq;
using DelftTools.Functions;
using DelftTools.Functions.Generic;
using DelftTools.Shell.Core.Workflow;
using DelftTools.Shell.Core.Workflow.DataItems;
using GeoAPI.Extensions.Feature;
using GeoAPI.Geometries;
using NetTopologySuite.Extensions.Coverages;
namespace DeltaShell.Plugins.VolumeModel.Models
{
    public class VolumeModel : ModelBase
    {
        private readonly DrainageBasin basin;/// Time-dependent feature coverage containing the volume of water per catchment: V = V(t, c) [L3/T]. Output of the model.
        /// </summary>
        public FeatureCoverage Volume
        {
        private readonly TimeSeries precipitation;
 get { return volume; }
   private readonly FeatureCoverage   }volume;
        /// <summary>
        /// TheCreates initializationa ofvolume model runs
        /// </summary>
        protected override void OnInitializepublic VolumeModel()
        {
            // Clear any previous outputCreate the input items of the volume model
            volume.Clearbasin = new DrainageBasin();
            precipitation //= Ensurenew theTimeSeries coordinate{ systemComponents of= the{ volume output is the same as the catchments input (basin)
new Variable<double>("Precipitation") } };
            // Create the output item of the volume.CoordinateSystem = basin.CoordinateSystem; model
            //volume Ensure= at least one catchment and one precipitation value is present
new FeatureCoverage("Output data")
            {
       ValidateInputData();
         IsTimeDependent = true,
 // Initialize the output feature coverage
          Arguments  volume.Features.AddRange(basin.Catchments);
      = { new Variable<IFeature>("Catchment") { FixedSize = 0 } },
      volume.FeatureVariable.FixedSize = basin.Catchments.Count();
        Components = { new volume.FeatureVariable.AddValues(basin.Catchments);
Variable<double>("Volume") },
            };
        ///  <summary>
        /// TheWrap actualfields calculationas duringinput/output modeldata runitems
        /// </summary>
   DataItems.Add(new DataItem(precipitation, "Precipitation", typeof(TimeSeries),  protected override void OnExecute()DataItemRole.Input, "PrecipitationTag"));
        {
    DataItems.Add(new DataItem(basin, "Basin", typeof(DrainageBasin),     // Loop all timesDataItemRole.Input, "BasinTag"));
            foreachDataItems.Add(new DataItem(var time in precipitation.Time.Values)volume, "Volume", typeof(FeatureCoverage), DataItemRole.Output, "VolumeTag"));
        }
    {     /// <summary>
        /// The precipitation time series: P = P(t) // Obtain[L/T]. Input of the precipitationmodel.
  value for the current time
  /// </summary>
        public TimeSeries Precipitation
   var p = (double)precipitation[time];
  {
            get { //return Calculateprecipitation; a}
 volume value for every catchment based on catchment}
 area and precipitation value
    /// <summary>
        /// The drainage varbasin volumes(set = basin.Catchments.Select(f => f.Geometry).OfType<IPolygon>().Select(pol => pol.Area * p);
of catchments). Input of the model.
        /// </summary>
        public //DrainageBasin AddBasin
 the calculated volume values to the output feature coverage{
            get { return  volume[time] = volumes;
    basin; }
        }
         /// <summary>
  Status = ActivityStatus.Done;
    /// Time-dependent feature coverage }
containing the volume of water per catchment: V private void ValidateInputData()
        {
= V(t, c) [L3/T]. Output of the model.
        /// </summary>
      var hasCatchments = basin.Catchments.Any();public FeatureCoverage Volume
         {
   var hasPrecipitationData = precipitation.Time.Values.Any();
      get { return volume; }
  if (!hasCatchments && !hasPrecipitationData)
   }
        /// {<summary>
        /// The initialization of model runs
   throw new InvalidOperationException("At least one catchment and one precipitation value should be present"); /// </summary>
        protected override void OnInitialize()
        {
    }
        // Clear any  if (!hasCatchments)previous output
            {volume.Clear();
            // Ensure the coordinate throwsystem new InvalidOperationException("At least one catchment should be present");
    of the volume output is the same as the catchments input (basin)
        }
    volume.CoordinateSystem        if (! basin.Catchments.All(c => c.Geometry is IPolygon))= (GeoAPI.Extensions.CoordinateSystems.ICoordinateSystem) basin.CoordinateSystem;
            {
// Ensure at least one catchment and one precipitation value is present
     throw new InvalidOperationException("All catchment features should be polygons"ValidateInputData();
            }
// Initialize the output feature coverage
       if (!hasPrecipitationData)
    volume.Features.AddRange(basin.Catchments);
        {
    volume.FeatureVariable.FixedSize = basin.Catchments.Count();
          throw new InvalidOperationException("At least one precipitation value should be present");volume.FeatureVariable.AddValues(basin.Catchments);
        }
        /// <summary>
   }
     /// The actual }
calculation during model run
 }
    public class DrainageBasin
 /// </summary>
  {
      protected override publicvoid DrainageBasinOnExecute()
        {
            Catchments= new List<IFeature>();
// Loop all times
            foreach  }
(var time in precipitation.Time.Values)
         public ICoordinateSystem CoordinateSystem {
 get;   set; }
        public IList<IFeature> Catchments {// get;Obtain privatethe set;precipitation }
value for the current }
} 

The model class is derived from the ModelBase class in order to automatically implement some basic time dependent modeling logic.

The comments in the code explain the different parts of the model implementation.

The model uses some basic data structures like data items, (feature) coverages and timeseries (functions). A description on the background and usage of these data structures is not part of this tutorial.

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

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using DelftTools.Shell.Core;
using DeltaShell.Plugins.VolumeModel.Models;
using GeoAPI.Extensions.Feature;
using NetTopologySuite.Extensions.Features;
using SharpMap.Data.Providers;
namespace DeltaShell.Plugins.VolumeModel.Importers
{
    public class DrainageBasinImporter : IFileImporter
    {
        public string Name { get { return "Shape file importer"; } }
        
        public string Category { get { return "General"; } }
        
        public Bitmap Image { get; private set; }
        public IEnumerable<Type> SupportedItemTypes

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

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

Image Added