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 output
 Create the input items of the volume model
            basin  volume.Clear= new DrainageBasin();
            //precipitation Ensure= thenew coordinateTimeSeries system{ ofComponents 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 =  // Initialize the output feature coverage
true,
                Arguments = { new volume.Features.AddRange(basin.Catchments);
      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  protected override void OnExecute()
  DataItem(precipitation, "Precipitation", typeof(TimeSeries), 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 Obtain the precipitation value for the current time= P(t) [L/T]. Input of the model.
        /// </summary>
       var ppublic = (double)precipitation[time];
TimeSeries Precipitation
        {
          // Calculate aget volume{ valuereturn forprecipitation; every}
 catchment based on catchment area and precipitation value}
        /// <summary>
       var volumes = basin.Catchments.Select(f => f.Geometry).Select(pol => pol.Area * p);
 /// The drainage basin (set of catchments). Input of the model.
        /// </summary>
        //public AddDrainageBasin theBasin
 calculated volume values to the output feature coverage{
            get { return  volume[time] = volumes;basin; }
        }
    }
    /// <summary>
       Status = ActivityStatus.Done;
        }
        private void ValidateInputData()
/// 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
   var   hasCatchments = basin.Catchments.Any(); {
            varget hasPrecipitationData{ = precipitation.Time.Values.Any();return volume; }
        }
    if   (!hasCatchments && !hasPrecipitationData) /// <summary>
        /// The initialization of model {runs
        /// </summary>
       throw new InvalidOperationException("At least one catchment and one precipitation value should be present");protected override void OnInitialize()
        {
            }// Clear any previous output
            if (!hasCatchments)volume.Clear();
            {
// Ensure the coordinate system of the volume output is the same as the catchments input throw(basin)
 new InvalidOperationException("At least one catchment should be present");
    volume.CoordinateSystem = (GeoAPI.Extensions.CoordinateSystems.ICoordinateSystem) basin.CoordinateSystem;
     }
       // Ensure at least one ifcatchment (! basin.Catchments.All(c => c.Geometry is IPolygon || c.Geometry is IMultiPolygon))and one precipitation value is present
            {ValidateInputData();
            // Initialize the output throw new InvalidOperationException("All catchment features should be polygons");feature coverage
            }
volume.Features.AddRange(basin.Catchments);
            volume.FeatureVariable.FixedSize if= basin.Catchments.Count(!hasPrecipitationData);
            {
  volume.FeatureVariable.AddValues(basin.Catchments);
        }
        /// <summary>
     throw new InvalidOperationException("At least one precipitation value should be present"); /// The actual calculation during model run
        /// </summary>
   }
     protected override void }OnExecute()
    }
} 

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 override IEnumerable<ModelInfo> GetModelInfos()
{
    yield return new ModelInfo
        {
        public string Name { Nameget ={ "Volumereturn Model",
Shape file importer"; } }
        Category = "Volume models",
        public string Category { CreateModelget ={ o => new Models.VolumeModel()return "General"; } }
        };
}