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
    /// </summary>
        public VolumeModel()
        {
    public class VolumeModel : ModelBase
    //{
 Create the input items of the volume model
private readonly DrainageBasin basin;
        private basinreadonly = new DrainageBasin()TimeSeries precipitation;
        private readonly FeatureCoverage volume;
 precipitation = new TimeSeries { Components = { new Variable<double>("Precipitation") } };
/// <summary>
        /// Creates a volume model
   // Create the output item of the volume model
 /// </summary>
        public VolumeModel()
        volume{
 = new FeatureCoverage("Output data")
        // Create the input {
items of the volume model
            IsTimeDependentbasin = true,new DrainageBasin();
            precipitation = new TimeSeries Arguments{ Components = { new Variable<IFeature>Variable<double>("CatchmentPrecipitation") { FixedSize = 0 } },
    } };
            // Create the output item of the volume model
            Componentsvolume = { new Variable<double>FeatureCoverage("VolumeOutput data") },
            };{
            // Wrap fields as input/outputIsTimeDependent data= itemstrue,
            DataItems.Add(new DataItem(precipitation, "Precipitation", typeof(TimeSeries), DataItemRole.Input, "PrecipitationTag"));
         Arguments = { new Variable<IFeature>("Catchment") { FixedSize = 0 } },
      DataItems.Add(new DataItem(basin, "Basin", typeof(DrainageBasin), DataItemRole.Input, "BasinTag"));
     Components = {     DataItems.Add(new DataItem(volume, new Variable<double>("Volume") },
  typeof(FeatureCoverage), DataItemRole.Output, "VolumeTag"));
        };
            /// <summary>
    Wrap fields as input/output data items
     /// The precipitation time series: P = P(t) [L/T]. Input of the model.DataItems.Add(new DataItem(precipitation, "Precipitation", typeof(TimeSeries), DataItemRole.Input, "PrecipitationTag"));
        /// </summary>
   DataItems.Add(new DataItem(basin, "Basin", typeof(DrainageBasin),  public TimeSeries Precipitation
DataItemRole.Input, "BasinTag"));
          {
  DataItems.Add(new DataItem(volume, "Volume", typeof(FeatureCoverage),       get { return precipitation; }DataItemRole.Output, "VolumeTag"));
        }
        /// <summary>
        /// The drainage basin (set of catchments)precipitation time series: P = P(t) [L/T]. Input of the model.
        /// </summary>
        public DrainageBasinTimeSeries BasinPrecipitation
        {
            get { return basinprecipitation; }
        }
        /// <summary>
        /// Time-dependentThe featuredrainage coverage containing the volume of water per catchment: V = V(t, c) [L3/T]. Outputbasin (set of catchments). Input of the model.
        /// </summary>
        public FeatureCoverageDrainageBasin VolumeBasin
        {
            get { return volumebasin; }
        }
        /// <summary>
        /// TheTime-dependent initializationfeature ofcoverage modelcontaining runs
the volume of water per catchment: V = V(t, c) [L3/T]. Output of the model.
        /// </summary>
        protectedpublic override void OnInitialize()FeatureCoverage Volume
        {
            //get Clear{ anyreturn previousvolume; output}
        }
    volume.Clear();
    /// <summary>
        // Ensure the coordinate system of the volume output is the same as the catchments input (basin)
      / The initialization of model runs
        /// </summary>
        protected override void OnInitialize()
      volume.CoordinateSystem = basin.CoordinateSystem;{
            // EnsureClear atany leastprevious oneoutput
 catchment and one precipitation value is present
            ValidateInputDatavolume.Clear();
            // InitializeEnsure the outputcoordinate featuresystem coverage
of the volume output is the same as the catchments  input volume.Features.AddRange(basin.Catchments);
            volume.FeatureVariable.FixedSizeCoordinateSystem = basin.Catchments.Count()(GeoAPI.Extensions.CoordinateSystems.ICoordinateSystem) basin.CoordinateSystem;
            volume.FeatureVariable.AddValues(basin.Catchments);
        }// Ensure at least one catchment and one precipitation value is present
        /// <summary>
   ValidateInputData();
     /// The actual calculation during model run
    // Initialize the output /// </summary>feature coverage
        protected  override void OnExecute()
 volume.Features.AddRange(basin.Catchments);
       {
     volume.FeatureVariable.FixedSize = basin.Catchments.Count();
     // Loop all times
    volume.FeatureVariable.AddValues(basin.Catchments);
        foreach}
 (var time in precipitation.Time.Values)
    /// <summary>
       {
 /// The actual calculation during model run
         /// Obtain the precipitation value for the current time
   </summary>
        protected override void OnExecute()
        {
     var p = (double)precipitation[time];
    // Loop all times
         // Calculate a volumeforeach value(var fortime every catchment based on catchment area and precipitation value
in precipitation.Time.Values)
            {
           var volumes = basin.Catchments.Select(f => f.Geometry).Select(pol => pol.Area * p);
     // Obtain the precipitation value for the current time
            // Add the calculated volumevar valuesp to the output feature coverage
= (double)precipitation[time];
                // Calculate a volume[time] = volumes;
        value for every catchment based on catchment area and precipitation value
     }
           var Statusvolumes = ActivityStatus.Done;
        }basin.Catchments.Select(f => f.Geometry).Select(pol => pol.Area * p);
        private void ValidateInputData()
      // Add {
the calculated volume values to the output feature coverage
    var hasCatchments = basin.Catchments.Any();
            var hasPrecipitationData = precipitation.Time.Values.Any()volume[time] = volumes;
            if}
 (!hasCatchments && !hasPrecipitationData)
         Status   {= ActivityStatus.Done;
        }
        throwprivate newvoid InvalidOperationExceptionValidateInputData("At least one catchment and one precipitation value should be present");
)
        {
            var hasCatchments = basin.Catchments.Any();
             }var hasPrecipitationData = precipitation.Time.Values.Any();
            if (!hasCatchments && !hasPrecipitationData)
            {
                throw new InvalidOperationException("At least one catchment and one precipitation value should be present");
            }
            if (! basin.Catchments.All(c => c.Geometry is IPolygon || c.Geometry is IMultiPolygon))
            hasCatchments)
            {
                throw new InvalidOperationException("AllAt least one catchment features should be polygonspresent");
            }
            if (!hasPrecipitationData)
             basin.Catchments.All(c => c.Geometry is IPolygon || c.Geometry is IMultiPolygon))
            {
                throw new InvalidOperationException("AtAll leastcatchment onefeatures precipitation value should be presentpolygons");
            }
          }
  if (!hasPrecipitationData)
     }
} 

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"; } }
      };
}