Index: dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/FillDamFromXmlInputTests.cs
===================================================================
diff -u -r540 -r545
--- dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/FillDamFromXmlInputTests.cs	(.../FillDamFromXmlInputTests.cs)	(revision 540)
+++ dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/FillDamFromXmlInputTests.cs	(.../FillDamFromXmlInputTests.cs)	(revision 545)
@@ -21,6 +21,7 @@
 
 using System;
 using System.Collections.Generic;
+using Deltares.DamEngine.Data.Design;
 using Deltares.DamEngine.Data.General;
 using Deltares.DamEngine.Data.Geometry;
 using Deltares.DamEngine.Data.Geotechnics;
@@ -171,6 +172,11 @@
                 location.HeadPl3 = 1.0 * i + 0.25;
                 location.HeadPl4 = 1.0 * i + 0.21;
                 location.SurfaceLine2 = dike.SurfaceLines2[i];
+                for (int j = 0; j < 3; j++)
+                {
+                    var designScenario = FillDesignScenario(i * j);
+                    location.Scenarios.Add(designScenario);
+                }
                 dike.Locations.Add(location);
             }
         }
@@ -220,6 +226,29 @@
                 }
             }
         }
+        private static DesignScenario FillDesignScenario(int factor)
+        {
+            var designScenario = new DesignScenario();
+            designScenario.RiverLevel = 1.0 * factor + 0.51;
+            designScenario.RiverLevelLow = 1.0 * factor + 0.52;
+            designScenario.DikeTableHeight = 1.0 * factor + 0.53;
+            designScenario.PlLineOffsetBelowDikeTopAtRiver = 1.0 * factor + 0.54;
+            designScenario.PlLineOffsetBelowDikeTopAtPolder = 1.0 * factor + 0.55;
+            designScenario.PlLineOffsetBelowShoulderBaseInside = 1.0 * factor + 0.56;
+            designScenario.PlLineOffsetBelowDikeToeAtPolder = 1.0 * factor + 0.57;
+            designScenario.PlLineOffsetBelowDikeCrestMiddle = 1.0 * factor + 0.58;
+            designScenario.UsePlLineOffsetBelowDikeCrestMiddle = true;
+            designScenario.PlLineOffsetFactorBelowShoulderCrest = 1.0 * factor + 0.59;
+            designScenario.UsePlLineOffsetFactorBelowShoulderCrest = true;
+            designScenario.HeadPl3 = 1.0 * factor + 0.60;
+            designScenario.HeadPl4 = 1.0 * factor + 0.61;
+            designScenario.UpliftCriterionStability = 1.0 * factor + 0.62;
+            designScenario.UpliftCriterionPiping = 1.0 * factor + 0.63;
+            designScenario.RequiredSafetyFactorStabilityInnerSlope = 1.0 * factor + 0.64;
+            designScenario.RequiredSafetyFactorStabilityOuterSlope = 1.0 * factor + 0.65;
+            designScenario.RequiredSafetyFactorPiping = 1.0 * factor + 0.66;
+            return designScenario;
+        }
 
         private void CompareDamProjectData(DamProjectData actual, DamProjectData expected)
         {
Index: dam engine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs
===================================================================
diff -u -r540 -r545
--- dam engine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs	(.../FillXmlInputFromDam.cs)	(revision 540)
+++ dam engine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs	(.../FillXmlInputFromDam.cs)	(revision 545)
@@ -104,9 +104,11 @@
             for (int i = 0; i < locationCount; i++)
             {
                 var location = dikeLocations[i];
+
                 var inputLocation  = new Io.XmlInput.Location();
-                var waternetOptions = new LocationWaternetOptions();
                 inputLocation.SurfaceLineName = location.SurfaceLine2.Name;
+
+                var waternetOptions = new LocationWaternetOptions();
                 waternetOptions.PhreaticLineCreationMethod = ConversionHelper.ConvertToInputPhreaticLineCreationMethod(location.ModelParametersForPLLines.PLLineCreationMethod);
                 waternetOptions.IntrusionVerticalWaterPressure = ConversionHelper.ConvertToInputIntrusionVerticalWaterPressure(location.IntrusionVerticalWaterPressure ?? IntrusionVerticalWaterPressureType.Standard);
                 waternetOptions.PolderLevel = location.PolderLevel;
@@ -133,6 +135,47 @@
                 waternetOptions.Pl1BelowShoulderCrestPolderside = location.PlLineOffsetBelowShoulderBaseInside;
                 waternetOptions.Pl1BelowToeDikePolderside = location.PlLineOffsetBelowDikeToeAtPolder;
                 inputLocation.WaternetOptions = waternetOptions;
+
+                inputLocation.DesignScenarios = new LocationDesignScenario[location.Scenarios.Count];
+                for (int j = 0; j < location.Scenarios.Count; j++)
+                {
+                    var designScenario = location.Scenarios[j];
+                    var inputDesignScenario = new LocationDesignScenario();
+                    inputDesignScenario.RiverLevel = designScenario.RiverLevel;
+
+                    inputDesignScenario.RiverLevelLowSpecified = designScenario.RiverLevelLow.HasValue;
+                    inputDesignScenario.RiverLevelLow = designScenario.RiverLevelLow ?? 0.0;
+                    inputDesignScenario.DikeTableHeightSpecified = designScenario.DikeTableHeight.HasValue;
+                    inputDesignScenario.DikeTableHeight = designScenario.DikeTableHeight ?? 0.0;
+                    inputDesignScenario.PlLineOffsetBelowDikeTopAtRiverSpecified = designScenario.PlLineOffsetBelowDikeTopAtRiver.HasValue;
+                    inputDesignScenario.PlLineOffsetBelowDikeTopAtRiver = designScenario.PlLineOffsetBelowDikeTopAtRiver ?? 0.0;
+                    inputDesignScenario.PlLineOffsetBelowDikeTopAtPolderSpecified = designScenario.PlLineOffsetBelowDikeTopAtPolder.HasValue;
+                    inputDesignScenario.PlLineOffsetBelowDikeTopAtPolder = designScenario.PlLineOffsetBelowDikeTopAtPolder ?? 0.0;
+                    inputDesignScenario.PlLineOffsetBelowShoulderBaseInsideSpecified = designScenario.PlLineOffsetBelowShoulderBaseInside.HasValue;
+                    inputDesignScenario.PlLineOffsetBelowShoulderBaseInside = designScenario.PlLineOffsetBelowShoulderBaseInside ?? 0.0;
+                    inputDesignScenario.PlLineOffsetBelowDikeToeAtPolderSpecified = designScenario.PlLineOffsetBelowDikeToeAtPolder.HasValue;
+                    inputDesignScenario.PlLineOffsetBelowDikeToeAtPolder = designScenario.PlLineOffsetBelowDikeToeAtPolder ?? 0.0;
+                    inputDesignScenario.PlLineOffsetBelowDikeCrestMiddleSpecified = designScenario.UsePlLineOffsetBelowDikeCrestMiddle.Value;
+                    inputDesignScenario.PlLineOffsetBelowDikeCrestMiddle = designScenario.PlLineOffsetBelowDikeCrestMiddle.Value;
+                    inputDesignScenario.PlLineOffsetFactorBelowShoulderCrestSpecified = designScenario.UsePlLineOffsetFactorBelowShoulderCrest.Value;
+                    inputDesignScenario.PlLineOffsetFactorBelowShoulderCrest = designScenario.PlLineOffsetFactorBelowShoulderCrest.Value;
+                    inputDesignScenario.HeadPl3Specified = designScenario.HeadPl3.HasValue;
+                    inputDesignScenario.HeadPl3 = designScenario.HeadPl3 ?? 0.0;
+                    inputDesignScenario.HeadPl4Specified = designScenario.HeadPl4.HasValue;
+                    inputDesignScenario.HeadPl4 = designScenario.HeadPl4 ?? 0.0;
+                    inputDesignScenario.UpliftCriterionStabilitySpecified = designScenario.UpliftCriterionStability.HasValue;
+                    inputDesignScenario.UpliftCriterionStability = designScenario.UpliftCriterionStability ?? 0.0;
+                    inputDesignScenario.UpliftCriterionPipingSpecified = designScenario.UpliftCriterionPiping.HasValue;
+                    inputDesignScenario.UpliftCriterionPiping = designScenario.UpliftCriterionPiping ?? 0.0;
+                    inputDesignScenario.RequiredSafetyFactorStabilityInnerSlopeSpecified = designScenario.RequiredSafetyFactorStabilityInnerSlope.HasValue;
+                    inputDesignScenario.RequiredSafetyFactorStabilityInnerSlope = designScenario.RequiredSafetyFactorStabilityInnerSlope ?? 0.0;
+                    inputDesignScenario.RequiredSafetyFactorStabilityOuterSlopeSpecified = designScenario.RequiredSafetyFactorStabilityOuterSlope.HasValue;
+                    inputDesignScenario.RequiredSafetyFactorStabilityOuterSlope = designScenario.RequiredSafetyFactorStabilityOuterSlope ?? 0.0;
+                    inputDesignScenario.RequiredSafetyFactorPipingSpecified = designScenario.RequiredSafetyFactorPiping.HasValue;
+                    inputDesignScenario.RequiredSafetyFactorPiping = designScenario.RequiredSafetyFactorPiping ?? 0.0;
+
+                    inputLocation.DesignScenarios[j] = inputDesignScenario;
+                }
                 inputLocations[i] = inputLocation;
             }
         }
Index: dam engine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs
===================================================================
diff -u -r542 -r545
--- dam engine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs	(.../FillDamFromXmlInput.cs)	(revision 542)
+++ dam engine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs	(.../FillDamFromXmlInput.cs)	(revision 545)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Deltares.DamEngine.Data.Design;
 using Deltares.DamEngine.Data.General;
 using Deltares.DamEngine.Data.Geometry;
 using Deltares.DamEngine.Data.Geotechnics;
@@ -95,7 +96,7 @@
                 var soil = new Data.Geotechnics.Soil();
                 var inputSoil = inputSoils[i];
                 soil.Name = inputSoil.Name;
-                soil.BeddingAngle = inputSoil.BeddingAngleSpecified ? inputSoil.BeddingAngle  : Double.NaN;
+                soil.BeddingAngle = inputSoil.BeddingAngleSpecified ? inputSoil.BeddingAngle : Double.NaN;
                 soil.DiameterD70 = inputSoil.DiameterD70Specified ? inputSoil.DiameterD70 : Double.NaN;
                 soil.DiameterD90 = inputSoil.DiameterD90Specified ? inputSoil.DiameterD90 : Double.NaN;
                 soil.PermeabKx = inputSoil.PermeabKxSpecified ? inputSoil.PermeabKx : Double.NaN;
@@ -160,8 +161,39 @@
                 location.PlLineOffsetBelowDikeTopAtPolder = waternetOptions.Pl1BelowCrestPolderside;
                 location.PlLineOffsetBelowShoulderBaseInside = waternetOptions.Pl1BelowShoulderCrestPolderside;
                 location.PlLineOffsetBelowDikeToeAtPolder = waternetOptions.Pl1BelowToeDikePolderside;
+
                 SurfaceLine2 surfaceLine = dikeSurfaceLines.First(n => n.Name.Equals(inputLocation.SurfaceLineName));
                 location.SurfaceLine2 = surfaceLine;
+
+                if (inputLocation.DesignScenarios != null)
+                {
+                    for (int j = 0; j < inputLocation.DesignScenarios.Length; j++)
+                    {
+                        var designScenario = new DesignScenario();
+                        var inputLocationDesignScenario = inputLocation.DesignScenarios[j];
+                        designScenario.RiverLevel = inputLocationDesignScenario.RiverLevel;
+                        designScenario.RiverLevelLow = (inputLocationDesignScenario.RiverLevelLowSpecified ? (double?)inputLocationDesignScenario.RiverLevelLow : null);
+                        designScenario.DikeTableHeight = (inputLocationDesignScenario.DikeTableHeightSpecified ? (double?)inputLocationDesignScenario.DikeTableHeight : null);
+                        designScenario.PlLineOffsetBelowDikeTopAtRiver = (inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtRiverSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtRiver : null);
+                        designScenario.PlLineOffsetBelowDikeTopAtPolder = (inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtPolderSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeTopAtPolder : null);
+                        designScenario.PlLineOffsetBelowShoulderBaseInside = (inputLocationDesignScenario.PlLineOffsetBelowShoulderBaseInsideSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowShoulderBaseInside : null);
+                        designScenario.PlLineOffsetBelowDikeToeAtPolder = (inputLocationDesignScenario.PlLineOffsetBelowDikeToeAtPolderSpecified ? (double?)inputLocationDesignScenario.PlLineOffsetBelowDikeToeAtPolder : null);
+                        designScenario.UsePlLineOffsetBelowDikeCrestMiddle = inputLocationDesignScenario.PlLineOffsetBelowDikeCrestMiddleSpecified;
+                        designScenario.PlLineOffsetBelowDikeCrestMiddle = inputLocationDesignScenario.PlLineOffsetBelowDikeCrestMiddle;
+                        designScenario.UsePlLineOffsetFactorBelowShoulderCrest = inputLocationDesignScenario.PlLineOffsetFactorBelowShoulderCrestSpecified;
+                        designScenario.PlLineOffsetFactorBelowShoulderCrest = inputLocationDesignScenario.PlLineOffsetFactorBelowShoulderCrest;
+                        designScenario.HeadPl3 = (inputLocationDesignScenario.HeadPl3Specified ? (double?)inputLocationDesignScenario.HeadPl3 : null);
+                        designScenario.HeadPl4 = (inputLocationDesignScenario.HeadPl4Specified ? (double?)inputLocationDesignScenario.HeadPl4 : null);
+                        designScenario.UpliftCriterionStability = (inputLocationDesignScenario.UpliftCriterionStabilitySpecified ? (double?)inputLocationDesignScenario.UpliftCriterionStability : null);
+                        designScenario.UpliftCriterionPiping = (inputLocationDesignScenario.UpliftCriterionStabilitySpecified ? (double?)inputLocationDesignScenario.UpliftCriterionPiping : null);
+                        designScenario.RequiredSafetyFactorStabilityInnerSlope = (inputLocationDesignScenario.RequiredSafetyFactorStabilityInnerSlopeSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorStabilityInnerSlope : null);
+                        designScenario.RequiredSafetyFactorStabilityOuterSlope = (inputLocationDesignScenario.RequiredSafetyFactorStabilityOuterSlopeSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorStabilityOuterSlope : null);
+                        designScenario.RequiredSafetyFactorPiping = (inputLocationDesignScenario.RequiredSafetyFactorPipingSpecified ? (double?)inputLocationDesignScenario.RequiredSafetyFactorPiping : null);
+
+                        location.Scenarios.Add(designScenario);
+                    }
+                }
+
                 dikeLocations.Add(location);
             }
         }
Index: dam engine/trunk/src/Deltares.DamEngine.Io/DamInput.cs
===================================================================
diff -u -r540 -r545
--- dam engine/trunk/src/Deltares.DamEngine.Io/DamInput.cs	(.../DamInput.cs)	(revision 540)
+++ dam engine/trunk/src/Deltares.DamEngine.Io/DamInput.cs	(.../DamInput.cs)	(revision 545)
@@ -138,6 +138,8 @@
         
         private LocationPipingProbabilisticParameters pipingProbabilisticParametersField;
         
+        private LocationDesignScenario[] designScenariosField;
+        
         private string surfaceLineNameField;
         
         private string segmentNameField;
@@ -223,6 +225,17 @@
         }
         
         /// <remarks/>
+        [System.Xml.Serialization.XmlArrayItemAttribute("DesignScenario", IsNullable=false)]
+        public LocationDesignScenario[] DesignScenarios {
+            get {
+                return this.designScenariosField;
+            }
+            set {
+                this.designScenariosField = value;
+            }
+        }
+        
+        /// <remarks/>
         [System.Xml.Serialization.XmlAttributeAttribute()]
         public string SurfaceLineName {
             get {
@@ -1802,7 +1815,419 @@
     /// <remarks/>
     [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
     [System.SerializableAttribute()]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
     [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
+    public partial class LocationDesignScenario {
+        
+        private double riverLevelField;
+        
+        private double riverLevelLowField;
+        
+        private bool riverLevelLowFieldSpecified;
+        
+        private double dikeTableHeightField;
+        
+        private bool dikeTableHeightFieldSpecified;
+        
+        private double plLineOffsetBelowDikeTopAtRiverField;
+        
+        private bool plLineOffsetBelowDikeTopAtRiverFieldSpecified;
+        
+        private double plLineOffsetBelowDikeTopAtPolderField;
+        
+        private bool plLineOffsetBelowDikeTopAtPolderFieldSpecified;
+        
+        private double plLineOffsetBelowShoulderBaseInsideField;
+        
+        private bool plLineOffsetBelowShoulderBaseInsideFieldSpecified;
+        
+        private double plLineOffsetBelowDikeToeAtPolderField;
+        
+        private bool plLineOffsetBelowDikeToeAtPolderFieldSpecified;
+        
+        private double plLineOffsetBelowDikeCrestMiddleField;
+        
+        private bool plLineOffsetBelowDikeCrestMiddleFieldSpecified;
+        
+        private double plLineOffsetFactorBelowShoulderCrestField;
+        
+        private bool plLineOffsetFactorBelowShoulderCrestFieldSpecified;
+        
+        private double headPl3Field;
+        
+        private bool headPl3FieldSpecified;
+        
+        private double headPl4Field;
+        
+        private bool headPl4FieldSpecified;
+        
+        private double upliftCriterionStabilityField;
+        
+        private bool upliftCriterionStabilityFieldSpecified;
+        
+        private double upliftCriterionPipingField;
+        
+        private bool upliftCriterionPipingFieldSpecified;
+        
+        private double requiredSafetyFactorStabilityInnerSlopeField;
+        
+        private bool requiredSafetyFactorStabilityInnerSlopeFieldSpecified;
+        
+        private double requiredSafetyFactorStabilityOuterSlopeField;
+        
+        private bool requiredSafetyFactorStabilityOuterSlopeFieldSpecified;
+        
+        private double requiredSafetyFactorPipingField;
+        
+        private bool requiredSafetyFactorPipingFieldSpecified;
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double RiverLevel {
+            get {
+                return this.riverLevelField;
+            }
+            set {
+                this.riverLevelField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double RiverLevelLow {
+            get {
+                return this.riverLevelLowField;
+            }
+            set {
+                this.riverLevelLowField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool RiverLevelLowSpecified {
+            get {
+                return this.riverLevelLowFieldSpecified;
+            }
+            set {
+                this.riverLevelLowFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double DikeTableHeight {
+            get {
+                return this.dikeTableHeightField;
+            }
+            set {
+                this.dikeTableHeightField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool DikeTableHeightSpecified {
+            get {
+                return this.dikeTableHeightFieldSpecified;
+            }
+            set {
+                this.dikeTableHeightFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double PlLineOffsetBelowDikeTopAtRiver {
+            get {
+                return this.plLineOffsetBelowDikeTopAtRiverField;
+            }
+            set {
+                this.plLineOffsetBelowDikeTopAtRiverField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool PlLineOffsetBelowDikeTopAtRiverSpecified {
+            get {
+                return this.plLineOffsetBelowDikeTopAtRiverFieldSpecified;
+            }
+            set {
+                this.plLineOffsetBelowDikeTopAtRiverFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double PlLineOffsetBelowDikeTopAtPolder {
+            get {
+                return this.plLineOffsetBelowDikeTopAtPolderField;
+            }
+            set {
+                this.plLineOffsetBelowDikeTopAtPolderField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool PlLineOffsetBelowDikeTopAtPolderSpecified {
+            get {
+                return this.plLineOffsetBelowDikeTopAtPolderFieldSpecified;
+            }
+            set {
+                this.plLineOffsetBelowDikeTopAtPolderFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double PlLineOffsetBelowShoulderBaseInside {
+            get {
+                return this.plLineOffsetBelowShoulderBaseInsideField;
+            }
+            set {
+                this.plLineOffsetBelowShoulderBaseInsideField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool PlLineOffsetBelowShoulderBaseInsideSpecified {
+            get {
+                return this.plLineOffsetBelowShoulderBaseInsideFieldSpecified;
+            }
+            set {
+                this.plLineOffsetBelowShoulderBaseInsideFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double PlLineOffsetBelowDikeToeAtPolder {
+            get {
+                return this.plLineOffsetBelowDikeToeAtPolderField;
+            }
+            set {
+                this.plLineOffsetBelowDikeToeAtPolderField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool PlLineOffsetBelowDikeToeAtPolderSpecified {
+            get {
+                return this.plLineOffsetBelowDikeToeAtPolderFieldSpecified;
+            }
+            set {
+                this.plLineOffsetBelowDikeToeAtPolderFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double PlLineOffsetBelowDikeCrestMiddle {
+            get {
+                return this.plLineOffsetBelowDikeCrestMiddleField;
+            }
+            set {
+                this.plLineOffsetBelowDikeCrestMiddleField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool PlLineOffsetBelowDikeCrestMiddleSpecified {
+            get {
+                return this.plLineOffsetBelowDikeCrestMiddleFieldSpecified;
+            }
+            set {
+                this.plLineOffsetBelowDikeCrestMiddleFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double PlLineOffsetFactorBelowShoulderCrest {
+            get {
+                return this.plLineOffsetFactorBelowShoulderCrestField;
+            }
+            set {
+                this.plLineOffsetFactorBelowShoulderCrestField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool PlLineOffsetFactorBelowShoulderCrestSpecified {
+            get {
+                return this.plLineOffsetFactorBelowShoulderCrestFieldSpecified;
+            }
+            set {
+                this.plLineOffsetFactorBelowShoulderCrestFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double HeadPl3 {
+            get {
+                return this.headPl3Field;
+            }
+            set {
+                this.headPl3Field = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool HeadPl3Specified {
+            get {
+                return this.headPl3FieldSpecified;
+            }
+            set {
+                this.headPl3FieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double HeadPl4 {
+            get {
+                return this.headPl4Field;
+            }
+            set {
+                this.headPl4Field = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool HeadPl4Specified {
+            get {
+                return this.headPl4FieldSpecified;
+            }
+            set {
+                this.headPl4FieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double UpliftCriterionStability {
+            get {
+                return this.upliftCriterionStabilityField;
+            }
+            set {
+                this.upliftCriterionStabilityField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool UpliftCriterionStabilitySpecified {
+            get {
+                return this.upliftCriterionStabilityFieldSpecified;
+            }
+            set {
+                this.upliftCriterionStabilityFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double UpliftCriterionPiping {
+            get {
+                return this.upliftCriterionPipingField;
+            }
+            set {
+                this.upliftCriterionPipingField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool UpliftCriterionPipingSpecified {
+            get {
+                return this.upliftCriterionPipingFieldSpecified;
+            }
+            set {
+                this.upliftCriterionPipingFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double RequiredSafetyFactorStabilityInnerSlope {
+            get {
+                return this.requiredSafetyFactorStabilityInnerSlopeField;
+            }
+            set {
+                this.requiredSafetyFactorStabilityInnerSlopeField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool RequiredSafetyFactorStabilityInnerSlopeSpecified {
+            get {
+                return this.requiredSafetyFactorStabilityInnerSlopeFieldSpecified;
+            }
+            set {
+                this.requiredSafetyFactorStabilityInnerSlopeFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double RequiredSafetyFactorStabilityOuterSlope {
+            get {
+                return this.requiredSafetyFactorStabilityOuterSlopeField;
+            }
+            set {
+                this.requiredSafetyFactorStabilityOuterSlopeField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool RequiredSafetyFactorStabilityOuterSlopeSpecified {
+            get {
+                return this.requiredSafetyFactorStabilityOuterSlopeFieldSpecified;
+            }
+            set {
+                this.requiredSafetyFactorStabilityOuterSlopeFieldSpecified = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlAttributeAttribute()]
+        public double RequiredSafetyFactorPiping {
+            get {
+                return this.requiredSafetyFactorPipingField;
+            }
+            set {
+                this.requiredSafetyFactorPipingField = value;
+            }
+        }
+        
+        /// <remarks/>
+        [System.Xml.Serialization.XmlIgnoreAttribute()]
+        public bool RequiredSafetyFactorPipingSpecified {
+            get {
+                return this.requiredSafetyFactorPipingFieldSpecified;
+            }
+            set {
+                this.requiredSafetyFactorPipingFieldSpecified = value;
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
+    [System.SerializableAttribute()]
+    [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
     public enum InputDamProjectType {
         
         /// <remarks/>
Index: dam engine/trunk/src/Deltares.DamEngine.Io.Tests/DamXmlSerializationTests.cs
===================================================================
diff -u -r461 -r545
--- dam engine/trunk/src/Deltares.DamEngine.Io.Tests/DamXmlSerializationTests.cs	(.../DamXmlSerializationTests.cs)	(revision 461)
+++ dam engine/trunk/src/Deltares.DamEngine.Io.Tests/DamXmlSerializationTests.cs	(.../DamXmlSerializationTests.cs)	(revision 545)
@@ -27,6 +27,12 @@
 
 namespace Deltares.DamEngine.Io.Tests
 {
+    /// <summary>
+    /// This class test just if the (generated) Input an Output class can be used for serializing to and from XML
+    /// A check, whether the dat itself is correctly written and read is done in 
+    /// - FillDamFromXmlInputTests.CanWriteAndReadDamProjectDataToXml 
+    /// - FillXmlOutputFromDamTests.CanWriteAndReadDamProjectDataToXml
+    /// </summary>
     [TestFixture]
     public class DamXmlSerializationTests
     {