Index: Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructuresInput.cs
===================================================================
diff -u -r64fea503e6e9cacfb0ff8f22cfdd864b60c95bab -r95e3abaeaafd7cff28c902e0bd9298d0c6b7218a
--- Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructuresInput.cs	(.../ClosingStructuresInput.cs)	(revision 64fea503e6e9cacfb0ff8f22cfdd864b60c95bab)
+++ Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructuresInput.cs	(.../ClosingStructuresInput.cs)	(revision 95e3abaeaafd7cff28c902e0bd9298d0c6b7218a)
@@ -84,8 +84,6 @@
                 Mean = (RoundedDouble) double.NaN,
                 StandardDeviation = (RoundedDouble) 0.1
             };
-
-            UpdateStructureProperties();
         }
         
         #region Structure
Index: Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.Data/StabilityPointStructuresInput.cs
===================================================================
diff -u -rabf027a3519fdb584ae797edd62f2baaab6d6968 -r95e3abaeaafd7cff28c902e0bd9298d0c6b7218a
--- Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.Data/StabilityPointStructuresInput.cs	(.../StabilityPointStructuresInput.cs)	(revision abf027a3519fdb584ae797edd62f2baaab6d6968)
+++ Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.Data/StabilityPointStructuresInput.cs	(.../StabilityPointStructuresInput.cs)	(revision 95e3abaeaafd7cff28c902e0bd9298d0c6b7218a)
@@ -20,27 +20,20 @@
 // All rights reserved.
 
 using System;
-using System.Linq;
-using Core.Common.Base;
 using Core.Common.Base.Data;
-using Core.Common.Base.Geometry;
-using Ringtoets.Common.Data.Calculation;
-using Ringtoets.Common.Data.DikeProfiles;
 using Ringtoets.Common.Data.Probabilistics;
-using Ringtoets.HydraRing.Data;
+using Ringtoets.Common.Data.Structures;
 using RingtoetsDataCommonProperties = Ringtoets.Common.Data.Properties.Resources;
 
 namespace Ringtoets.StabilityPointStructures.Data
 {
     /// <summary>
     /// Class that holds all stability point structures calculation specific input parameters.
     /// </summary>
-    public class StabilityPointStructuresInput : Observable, ICalculationInput
+    public class StabilityPointStructuresInput : StructuresInputBase<StabilityPointStructure>
     {
         private readonly NormalDistribution insideWaterLevelFailureConstruction;
         private readonly NormalDistribution insideWaterLevel;
-        private readonly VariationCoefficientLogNormalDistribution stormDuration;
-        private readonly NormalDistribution modelFactorSuperCriticalFlow;
         private readonly NormalDistribution drainCoefficient;
         private readonly NormalDistribution levelCrestStructure;
         private readonly NormalDistribution thresholdHeightOpenWeir;
@@ -52,34 +45,24 @@
         private readonly VariationCoefficientLogNormalDistribution failureCollisionEnergy;
         private readonly VariationCoefficientNormalDistribution shipMass;
         private readonly VariationCoefficientNormalDistribution shipVelocity;
-        private readonly LogNormalDistribution allowedLevelIncreaseStorage;
-        private readonly VariationCoefficientLogNormalDistribution storageStructureArea;
-        private readonly LogNormalDistribution flowWidthAtBottomProtection;
-        private readonly VariationCoefficientLogNormalDistribution criticalOvertoppingDischarge;
-        private readonly VariationCoefficientNormalDistribution widthFlowApertures;
         private readonly NormalDistribution bankWidth;
         private readonly NormalDistribution flowVelocityStructureClosable;
-        private ForeshoreProfile foreshoreProfile;
-        private RoundedDouble structureNormalOrientation;
         private RoundedDouble volumicWeightWater;
         private RoundedDouble factorStormDurationOpenStructure;
         private RoundedDouble evaluationLevel;
         private RoundedDouble verticalDistance;
         private double failureProbabilityRepairClosure;
         private double probabilityCollisionSecondaryStructure;
-        private double failureProbabilityStructureWithErosion;
 
         /// <summary>
         /// Creates a new instance of <see cref="StabilityPointStructuresInput"/>.
         /// </summary>
         public StabilityPointStructuresInput()
         {
             volumicWeightWater = new RoundedDouble(2, 9.81);
-            structureNormalOrientation = new RoundedDouble(2, double.NaN);
             factorStormDurationOpenStructure = new RoundedDouble(2, double.NaN);
             failureProbabilityRepairClosure = double.NaN;
             probabilityCollisionSecondaryStructure = double.NaN;
-            failureProbabilityStructureWithErosion = double.NaN;
             evaluationLevel = new RoundedDouble(2, 0);
             verticalDistance = new RoundedDouble(2, double.NaN);
 
@@ -95,18 +78,6 @@
                 StandardDeviation = (RoundedDouble) 0.1
             };
 
-            stormDuration = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) 6.0,
-                CoefficientOfVariation = (RoundedDouble) 0.25
-            };
-
-            modelFactorSuperCriticalFlow = new NormalDistribution(2)
-            {
-                Mean = (RoundedDouble) 1.1,
-                StandardDeviation = (RoundedDouble) 0.03
-            };
-
             drainCoefficient = new NormalDistribution(2)
             {
                 Mean = (RoundedDouble) 1.0,
@@ -179,58 +150,16 @@
                 CoefficientOfVariation = (RoundedDouble) 0.2
             };
 
-            allowedLevelIncreaseStorage = new LogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                StandardDeviation = (RoundedDouble) 0.1
-            };
-
-            storageStructureArea = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                CoefficientOfVariation = (RoundedDouble) 0.1
-            };
-
-            flowWidthAtBottomProtection = new LogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                StandardDeviation = (RoundedDouble) 0.05
-            };
-
-            criticalOvertoppingDischarge = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                CoefficientOfVariation = (RoundedDouble) 0.15
-            };
-
-            widthFlowApertures = new VariationCoefficientNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                CoefficientOfVariation = (RoundedDouble) 0.05
-            };
-
             bankWidth = new NormalDistribution(2)
             {
                 Mean = (RoundedDouble) double.NaN,
                 StandardDeviation = (RoundedDouble) double.NaN
             };
-
-            UpdateForeshoreProperties();
         }
 
-        private static bool ValidProbabilityValue(double probability)
-        {
-            return !double.IsNaN(probability) && probability >= 0 && probability <= 1;
-        }
-
         #region Structure / calculation
-
+        
         /// <summary>
-        /// Gets or sets the stability point structure.
-        /// </summary>
-        public StabilityPointStructure StabilityPointStructure { get; set; }
-
-        /// <summary>
         /// Gets or sets the type of stability point structure inflow model.
         /// </summary>
         public StabilityPointStructureInflowModelType InflowModelType { get; set; }
@@ -245,82 +174,6 @@
         #region Hydraulic data
 
         /// <summary>
-        /// Gets or sets the hydraulic boundary location from which to use the assessment level.
-        /// </summary>
-        public HydraulicBoundaryLocation HydraulicBoundaryLocation { get; set; }
-
-        #region Foreshore profile
-
-        /// <summary>
-        /// Gets or sets the foreshore profile.
-        /// </summary>
-        public ForeshoreProfile ForeshoreProfile
-        {
-            get
-            {
-                return foreshoreProfile;
-            }
-            set
-            {
-                foreshoreProfile = value;
-                UpdateForeshoreProperties();
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets whether the <see cref="BreakWater"/> needs to be taken into account.
-        /// </summary>
-        public bool UseBreakWater { get; set; }
-
-        /// <summary>
-        /// Gets or sets whether the <see cref="ForeshoreProfile"/> needs to be taken into account.
-        /// </summary>
-        public bool UseForeshore { get; set; }
-
-        /// <summary>
-        /// Gets the geometry of the foreshore.
-        /// </summary>
-        public RoundedPoint2DCollection ForeshoreGeometry
-        {
-            get
-            {
-                return foreshoreProfile != null
-                           ? foreshoreProfile.Geometry
-                           : new RoundedPoint2DCollection(2, Enumerable.Empty<Point2D>());
-            }
-        }
-
-        /// <summary>
-        /// Gets the <see cref="BreakWater"/>.
-        /// </summary>
-        public BreakWater BreakWater { get; private set; }
-
-        private void UpdateForeshoreProperties()
-        {
-            if (foreshoreProfile == null)
-            {
-                UseForeshore = false;
-                UseBreakWater = false;
-                BreakWater = GetDefaultBreakWaterProperties();
-            }
-            else
-            {
-                UseForeshore = foreshoreProfile.Geometry.Count() > 1;
-                UseBreakWater = foreshoreProfile.HasBreakWater;
-                BreakWater = foreshoreProfile.HasBreakWater ?
-                                 new BreakWater(foreshoreProfile.BreakWater.Type, foreshoreProfile.BreakWater.Height) :
-                                 GetDefaultBreakWaterProperties();
-            }
-        }
-
-        private BreakWater GetDefaultBreakWaterProperties()
-        {
-            return new BreakWater(BreakWaterType.Dam, 0.0);
-        }
-
-        #endregion
-
-        /// <summary>
         /// Gets or sets the volumic weight of water.
         /// [kN/m^3]
         /// </summary>
@@ -370,44 +223,11 @@
             }
         }
 
-        /// <summary>
-        /// Gets or sets the storm duration.
-        /// [h]
-        /// </summary>
-        /// <remarks>Only sets the mean.</remarks>
-        public VariationCoefficientLogNormalDistribution StormDuration
-        {
-            get
-            {
-                return stormDuration;
-            }
-            set
-            {
-                stormDuration.Mean = value.Mean;
-            }
-        }
-
         #endregion
 
         #region Model Inputs and critical values
-
+        
         /// <summary>
-        /// Gets or sets the model factor for super critical flow.
-        /// </summary>
-        /// <remarks>Only sets the mean.</remarks>
-        public NormalDistribution ModelFactorSuperCriticalFlow
-        {
-            get
-            {
-                return modelFactorSuperCriticalFlow;
-            }
-            set
-            {
-                modelFactorSuperCriticalFlow.Mean = value.Mean;
-            }
-        }
-
-        /// <summary>
         /// Gets or sets the factor for the storm duration open structure.
         /// </summary>
         public RoundedDouble FactorStormDurationOpenStructure
@@ -477,34 +297,6 @@
         }
 
         /// <summary>
-        /// Gets or sets the orientation of the normal of the structure.
-        /// [degrees]
-        /// </summary>
-        /// <exception cref="ArgumentOutOfRangeException">Thrown when the value of the orientation is not between [0, 360] degrees.</exception>
-        public RoundedDouble StructureNormalOrientation
-        {
-            get
-            {
-                return structureNormalOrientation;
-            }
-            set
-            {
-                if (double.IsNaN(value))
-                {
-                    structureNormalOrientation = value.ToPrecision(structureNormalOrientation.NumberOfDecimalPlaces);
-                    return;
-                }
-
-                RoundedDouble newOrientation = value.ToPrecision(structureNormalOrientation.NumberOfDecimalPlaces);
-                if (newOrientation < 0 || newOrientation > 360)
-                {
-                    throw new ArgumentOutOfRangeException("value", RingtoetsDataCommonProperties.Orientation_Value_needs_to_be_between_0_and_360);
-                }
-                structureNormalOrientation = newOrientation;
-            }
-        }
-
-        /// <summary>
         /// Gets or sets the threshold height of the open weir.
         /// [m+NAP]
         /// </summary>
@@ -706,112 +498,6 @@
         }
 
         /// <summary>
-        /// Gets or sets the allowed level increase of the storage volume.
-        /// [m]
-        /// </summary>
-        public LogNormalDistribution AllowedLevelIncreaseStorage
-        {
-            get
-            {
-                return allowedLevelIncreaseStorage;
-            }
-            set
-            {
-                allowedLevelIncreaseStorage.Mean = value.Mean;
-                allowedLevelIncreaseStorage.StandardDeviation = value.StandardDeviation;
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the storage structure area.
-        /// [m^2]
-        /// </summary>
-        public VariationCoefficientLogNormalDistribution StorageStructureArea
-        {
-            get
-            {
-                return storageStructureArea;
-            }
-            set
-            {
-                storageStructureArea.Mean = value.Mean;
-                storageStructureArea.CoefficientOfVariation = value.CoefficientOfVariation;
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the flow width at the bottom protection.
-        /// [m]
-        /// </summary>
-        public LogNormalDistribution FlowWidthAtBottomProtection
-        {
-            get
-            {
-                return flowWidthAtBottomProtection;
-            }
-            set
-            {
-                flowWidthAtBottomProtection.Mean = value.Mean;
-                flowWidthAtBottomProtection.StandardDeviation = value.StandardDeviation;
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the critical overtopping discharge.
-        /// [m^2/s]
-        /// </summary>
-        public VariationCoefficientLogNormalDistribution CriticalOvertoppingDischarge
-        {
-            get
-            {
-                return criticalOvertoppingDischarge;
-            }
-            set
-            {
-                criticalOvertoppingDischarge.Mean = value.Mean;
-                criticalOvertoppingDischarge.CoefficientOfVariation = value.CoefficientOfVariation;
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the failure probability of a structure with erosion.
-        /// [1/year]
-        /// </summary>
-        /// <exception cref="ArgumentOutOfRangeException">Thrown when the probability is not in interval [0,1].</exception>
-        public double FailureProbabilityStructureWithErosion
-        {
-            get
-            {
-                return failureProbabilityStructureWithErosion;
-            }
-            set
-            {
-                if (!ValidProbabilityValue(value))
-                {
-                    throw new ArgumentOutOfRangeException("value", RingtoetsDataCommonProperties.FailureProbability_Value_needs_to_be_between_0_and_1);
-                }
-                failureProbabilityStructureWithErosion = value;
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the width of the flow apertures.
-        /// [m]
-        /// </summary>
-        public VariationCoefficientNormalDistribution WidthFlowApertures
-        {
-            get
-            {
-                return widthFlowApertures;
-            }
-            set
-            {
-                widthFlowApertures.Mean = value.Mean;
-                widthFlowApertures.CoefficientOfVariation = value.CoefficientOfVariation;
-            }
-        }
-
-        /// <summary>
         /// Gets or sets the bank width.
         /// [m]
         /// </summary>
@@ -861,5 +547,37 @@
         }
 
         #endregion
+
+        protected override void UpdateStructureProperties()
+        {
+            if (Structure != null)
+            {
+                AllowedLevelIncreaseStorage = Structure.AllowedLevelIncreaseStorage;
+                AreaFlowApertures = Structure.AreaFlowApertures;
+                BankWidth = Structure.BankWidth;
+                ConstructiveStrengthLinearLoadModel = Structure.ConstructiveStrengthLinearLoadModel;
+                ConstructiveStrengthQuadraticLoadModel = Structure.ConstructiveStrengthQuadraticLoadModel;
+                CriticalOvertoppingDischarge = Structure.CriticalOvertoppingDischarge;
+                EvaluationLevel = Structure.EvaluationLevel;
+                FailureCollisionEnergy = Structure.FailureCollisionEnergy;
+                FailureProbabilityRepairClosure = Structure.FailureProbabilityRepairClosure;
+                FlowVelocityStructureClosable = Structure.FlowVelocityStructureClosable;
+                FlowWidthAtBottomProtection = Structure.FlowWidthAtBottomProtection;
+                InflowModelType = Structure.InflowModelType;
+                InsideWaterLevel = Structure.InsideWaterLevel;
+                InsideWaterLevelFailureConstruction = Structure.InsideWaterLevelFailureConstruction;
+                LevelCrestStructure = Structure.LevelCrestStructure;
+                LevellingCount = Structure.LevellingCount;
+                ProbabilityCollisionSecondaryStructure = Structure.ProbabilityCollisionSecondaryStructure;
+                ShipMass = Structure.ShipMass;
+                ShipVelocity = Structure.ShipVelocity;
+                StabilityLinearLoadModel = Structure.StabilityLinearLoadModel;
+                StabilityQuadraticLoadModel = Structure.StabilityQuadraticLoadModel;
+                StorageStructureArea = Structure.StorageStructureArea;
+                ThresholdHeightOpenWeir = Structure.ThresholdHeightOpenWeir;
+                VerticalDistance = Structure.VerticalDistance;
+                WidthFlowApertures = Structure.WidthFlowApertures;
+            }
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Data.Test/Ringtoets.StabilityPointStructures.Data.Test.csproj
===================================================================
diff -u -r2efa0fbe22fee2482e1583a7d6f5ccfdf168f660 -r95e3abaeaafd7cff28c902e0bd9298d0c6b7218a
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Data.Test/Ringtoets.StabilityPointStructures.Data.Test.csproj	(.../Ringtoets.StabilityPointStructures.Data.Test.csproj)	(revision 2efa0fbe22fee2482e1583a7d6f5ccfdf168f660)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Data.Test/Ringtoets.StabilityPointStructures.Data.Test.csproj	(.../Ringtoets.StabilityPointStructures.Data.Test.csproj)	(revision 95e3abaeaafd7cff28c902e0bd9298d0c6b7218a)
@@ -91,6 +91,10 @@
       <Project>{3D4B9740-8348-4434-8D77-B611FC6EE57F}</Project>
       <Name>Ringtoets.StabilityPointStructures.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Ringtoets.StabilityPointStructures.Data.TestUtil\Ringtoets.StabilityPointStructures.Data.TestUtil.csproj">
+      <Project>{E9AC095B-8F10-41D2-9456-4A85E3BA91AD}</Project>
+      <Name>Ringtoets.StabilityPointStructures.Data.TestUtil</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Data.Test/StabilityPointStructuresInputTest.cs
===================================================================
diff -u -rb1f6e4c40ced255c35ce19e174048c96000b9a43 -r95e3abaeaafd7cff28c902e0bd9298d0c6b7218a
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Data.Test/StabilityPointStructuresInputTest.cs	(.../StabilityPointStructuresInputTest.cs)	(revision b1f6e4c40ced255c35ce19e174048c96000b9a43)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Data.Test/StabilityPointStructuresInputTest.cs	(.../StabilityPointStructuresInputTest.cs)	(revision 95e3abaeaafd7cff28c902e0bd9298d0c6b7218a)
@@ -20,17 +20,13 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using Core.Common.Base;
 using Core.Common.Base.Data;
-using Core.Common.Base.Geometry;
 using Core.Common.TestUtil;
 using NUnit.Framework;
-using Ringtoets.Common.Data.Calculation;
-using Ringtoets.Common.Data.DikeProfiles;
 using Ringtoets.Common.Data.Probabilistics;
+using Ringtoets.Common.Data.Structures;
 using Ringtoets.Common.Data.TestUtil;
-using Ringtoets.HydraRing.Data;
+using Ringtoets.StabilityPointStructures.Data.TestUtil;
 
 namespace Ringtoets.StabilityPointStructures.Data.Test
 {
@@ -53,18 +49,6 @@
                 StandardDeviation = (RoundedDouble) 0.1
             };
 
-            var stormDuration = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) 6.0,
-                CoefficientOfVariation = (RoundedDouble) 0.25
-            };
-
-            var modelFactorSuperCriticalFlow = new NormalDistribution(2)
-            {
-                Mean = (RoundedDouble) 1.1,
-                StandardDeviation = (RoundedDouble) 0.03
-            };
-
             var drainCoefficient = new NormalDistribution(2)
             {
                 Mean = (RoundedDouble) 1,
@@ -137,36 +121,6 @@
                 CoefficientOfVariation = (RoundedDouble) 0.2
             };
 
-            var allowedLevelIncreaseStorage = new LogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                StandardDeviation = (RoundedDouble) 0.1
-            };
-
-            var storageStructureArea = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                CoefficientOfVariation = (RoundedDouble) 0.1
-            };
-
-            var flowWidthAtBottomProtection = new LogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                StandardDeviation = (RoundedDouble) 0.05
-            };
-
-            var criticalOvertoppingDischarge = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                CoefficientOfVariation = (RoundedDouble) 0.15
-            };
-
-            var widthFlowApertures = new VariationCoefficientNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) double.NaN,
-                CoefficientOfVariation = (RoundedDouble) 0.05
-            };
-
             var bankWidth = new NormalDistribution(2)
             {
                 Mean = (RoundedDouble) double.NaN,
@@ -177,30 +131,13 @@
             var input = new StabilityPointStructuresInput();
 
             // Assert
-            Assert.IsInstanceOf<Observable>(input);
-            Assert.IsInstanceOf<ICalculationInput>(input);
-            Assert.IsNull(input.HydraulicBoundaryLocation);
+            Assert.IsInstanceOf<StructuresInputBase<StabilityPointStructure>>(input);
 
-            Assert.IsNull(input.StabilityPointStructure);
-
-            Assert.IsNull(input.ForeshoreProfile);
-            Assert.IsFalse(input.UseBreakWater);
-            Assert.AreEqual(BreakWaterType.Dam, input.BreakWater.Type);
-            AssertEqualValue(0, input.BreakWater.Height);
-            Assert.AreEqual(2, input.BreakWater.Height.NumberOfDecimalPlaces);
-            Assert.IsFalse(input.UseForeshore);
-            CollectionAssert.IsEmpty(input.ForeshoreGeometry);
-
-            Assert.IsNaN(input.StructureNormalOrientation);
-            Assert.AreEqual(2, input.StructureNormalOrientation.NumberOfDecimalPlaces);
-
             AssertEqualValue(9.81, input.VolumicWeightWater);
             Assert.AreEqual(2, input.VolumicWeightWater.NumberOfDecimalPlaces);
             DistributionAssert.AreEqual(insideWaterLevelFailureConstruction, input.InsideWaterLevelFailureConstruction);
             DistributionAssert.AreEqual(insideWaterLevel, input.InsideWaterLevel);
-            DistributionAssert.AreEqual(stormDuration, input.StormDuration);
 
-            DistributionAssert.AreEqual(modelFactorSuperCriticalFlow, input.ModelFactorSuperCriticalFlow);
             Assert.IsNaN(input.FactorStormDurationOpenStructure);
             Assert.AreEqual(2, input.FactorStormDurationOpenStructure.NumberOfDecimalPlaces);
             DistributionAssert.AreEqual(drainCoefficient, input.DrainCoefficient);
@@ -219,12 +156,6 @@
             DistributionAssert.AreEqual(shipVelocity, input.ShipVelocity);
             Assert.AreEqual(0, input.LevellingCount);
             Assert.AreEqual(double.NaN, input.ProbabilityCollisionSecondaryStructure);
-            DistributionAssert.AreEqual(allowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
-            DistributionAssert.AreEqual(storageStructureArea, input.StorageStructureArea);
-            DistributionAssert.AreEqual(flowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
-            DistributionAssert.AreEqual(criticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
-            Assert.IsNaN(input.FailureProbabilityStructureWithErosion);
-            DistributionAssert.AreEqual(widthFlowApertures, input.WidthFlowApertures);
             DistributionAssert.AreEqual(bankWidth, input.BankWidth);
             Assert.AreEqual(2, input.EvaluationLevel.NumberOfDecimalPlaces);
             AssertEqualValue(0, input.EvaluationLevel);
@@ -269,121 +200,6 @@
         #region Hydraulic data
 
         [Test]
-        public void Properties_HydraulicBoundaryLocation_ExpectedValues()
-        {
-            // Setup
-            var input = new StabilityPointStructuresInput();
-            var location = new HydraulicBoundaryLocation(0, "test", 0, 0);
-
-            // Call
-            input.HydraulicBoundaryLocation = location;
-
-            // Assert
-            Assert.AreSame(location, input.HydraulicBoundaryLocation);
-        }
-
-        [Test]
-        [Combinatorial]
-        public void ForeshoreProfile_SetNewValue_InputSyncedAccordingly(
-            [Values(true, false)] bool withBreakWater,
-            [Values(true, false)] bool withValidForeshore)
-        {
-            // Setup
-            var input = new StabilityPointStructuresInput();
-            BreakWaterType originalBreakWaterType = input.BreakWater.Type;
-            RoundedDouble originalBreakWaterHeight = input.BreakWater.Height;
-            HydraulicBoundaryLocation originalHydraulicBoundaryLocation = input.HydraulicBoundaryLocation;
-
-            var foreshoreGeometry = new List<Point2D>
-            {
-                new Point2D(2.2, 3.3)
-            };
-
-            if (withValidForeshore)
-            {
-                foreshoreGeometry.Add(new Point2D(4.4, 5.5));
-            }
-
-            BreakWater breakWater = null;
-            if (withBreakWater)
-            {
-                var nonDefaultBreakWaterType = BreakWaterType.Wall;
-                var nonDefaultBreakWaterHeight = 5.5;
-
-                // Precondition
-                Assert.AreNotEqual(nonDefaultBreakWaterType, input.BreakWater.Type);
-                Assert.AreNotEqual(nonDefaultBreakWaterHeight, input.BreakWater.Height);
-
-                breakWater = new BreakWater(nonDefaultBreakWaterType, nonDefaultBreakWaterHeight);
-            }
-
-            double orientation = 96;
-            var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0),
-                                                        foreshoreGeometry.ToArray(),
-                                                        breakWater,
-                                                        new ForeshoreProfile.ConstructionProperties
-                                                        {
-                                                            Orientation = orientation
-                                                        });
-
-            // Call
-            input.ForeshoreProfile = foreshoreProfile;
-
-            // Assert
-            Assert.AreSame(foreshoreProfile, input.ForeshoreProfile);
-            Assert.AreEqual(withBreakWater, input.UseBreakWater);
-            Assert.AreEqual(withBreakWater ? foreshoreProfile.BreakWater.Type : originalBreakWaterType, input.BreakWater.Type);
-            Assert.AreEqual(withBreakWater ? foreshoreProfile.BreakWater.Height : originalBreakWaterHeight, input.BreakWater.Height);
-            Assert.AreEqual(withValidForeshore, input.UseForeshore);
-            CollectionAssert.AreEqual(foreshoreProfile.Geometry, input.ForeshoreGeometry);
-            Assert.AreEqual(originalHydraulicBoundaryLocation, input.HydraulicBoundaryLocation);
-        }
-
-        [Test]
-        public void Foreshore_SetNullValue_InputSyncedToDefaults()
-        {
-            // Setup
-            var input = new StabilityPointStructuresInput();
-            BreakWaterType originalBreakWaterType = input.BreakWater.Type;
-            RoundedDouble originalBreakWaterHeight = input.BreakWater.Height;
-            HydraulicBoundaryLocation originalHydraulicBoundaryLocation = input.HydraulicBoundaryLocation;
-
-            var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0),
-                                                        new[]
-                                                        {
-                                                            new Point2D(3.3, 4.4),
-                                                            new Point2D(5.5, 6.6)
-                                                        },
-                                                        new BreakWater(BreakWaterType.Caisson, 2.2),
-                                                        new ForeshoreProfile.ConstructionProperties
-                                                        {
-                                                            Orientation = 96
-                                                        });
-
-            input.ForeshoreProfile = foreshoreProfile;
-
-            // Precondition
-            Assert.AreSame(foreshoreProfile, input.ForeshoreProfile);
-            Assert.IsTrue(input.UseBreakWater);
-            Assert.AreNotEqual(originalBreakWaterType, input.BreakWater.Type);
-            Assert.AreNotEqual(originalBreakWaterHeight, input.BreakWater.Height);
-            Assert.IsTrue(input.UseForeshore);
-            CollectionAssert.IsNotEmpty(input.ForeshoreGeometry);
-            Assert.AreEqual(originalHydraulicBoundaryLocation, input.HydraulicBoundaryLocation);
-
-            // Call
-            input.ForeshoreProfile = null;
-
-            // Assert
-            Assert.IsFalse(input.UseBreakWater);
-            Assert.AreEqual(originalBreakWaterType, input.BreakWater.Type);
-            Assert.AreEqual(originalBreakWaterHeight, input.BreakWater.Height);
-            Assert.IsFalse(input.UseForeshore);
-            CollectionAssert.IsEmpty(input.ForeshoreGeometry);
-            Assert.AreEqual(originalHydraulicBoundaryLocation, input.HydraulicBoundaryLocation);
-        }
-
-        [Test]
         public void Properties_VolumicWeightWater_ExpectedValues()
         {
             // Setup
@@ -454,67 +270,11 @@
             AssertDistributionCorrectlySet(input.InsideWaterLevel, distributionToSet, expectedDistribution);
         }
 
-        [Test]
-        public void Properties_StormDuration_ExpectedValues()
-        {
-            // Setup
-            var random = new Random(22);
-            var input = new StabilityPointStructuresInput();
-            
-            var mean = (RoundedDouble)(0.01 + random.NextDouble());
-            var variation = (RoundedDouble)(0.01 + random.NextDouble());
-            RoundedDouble initialVariation = input.StormDuration.CoefficientOfVariation;
-            var expectedDistribution = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = mean,
-                CoefficientOfVariation = initialVariation
-            };
-            var distributionToSet = new VariationCoefficientLogNormalDistribution(5)
-            {
-                Mean = mean,
-                CoefficientOfVariation = variation
-            };
-
-            // Call
-            input.StormDuration = distributionToSet;
-
-            // Assert
-            AssertDistributionCorrectlySet(input.StormDuration, distributionToSet, expectedDistribution);
-        }
-
         #endregion
 
         #region Model inputs
 
         [Test]
-        public void Properties_ModelFactorSuperCriticalFlow_ExpectedValues()
-        {
-            // Setup
-            var random = new Random(22);
-            var input = new StabilityPointStructuresInput();
-
-            var mean = (RoundedDouble)(0.01 + random.NextDouble());
-            var standardDeviation = (RoundedDouble)(0.01 + random.NextDouble());
-            RoundedDouble initialStd = input.ModelFactorSuperCriticalFlow.StandardDeviation;
-            var expectedDistribution = new NormalDistribution(2)
-            {
-                Mean = mean,
-                StandardDeviation = initialStd
-            };
-            var distributionToSet = new NormalDistribution(5)
-            {
-                Mean = mean,
-                StandardDeviation = standardDeviation
-            };
-
-            // Call
-            input.ModelFactorSuperCriticalFlow = distributionToSet;
-
-            // Assert
-            AssertDistributionCorrectlySet(input.ModelFactorSuperCriticalFlow, distributionToSet, expectedDistribution);
-        }
-
-        [Test]
         public void Properties_FactorStormDurationOpenStructure_ExpectedValues()
         {
             // Setup
@@ -618,44 +378,6 @@
         }
 
         [Test]
-        [TestCase(360.004)]
-        [TestCase(300)]
-        [TestCase(0)]
-        [TestCase(-0.004)]
-        [TestCase(double.NaN)]
-        public void Properties_StructureNormalOrientationValidValues_NewValueSet(double orientation)
-        {
-            // Setup
-            var input = new StabilityPointStructuresInput();
-
-            // Call
-            input.StructureNormalOrientation = (RoundedDouble) orientation;
-
-            // Assert
-            Assert.AreEqual(2, input.StructureNormalOrientation.NumberOfDecimalPlaces);
-            AssertEqualValue(orientation, input.StructureNormalOrientation);
-        }
-
-        [Test]
-        [TestCase(400)]
-        [TestCase(360.05)]
-        [TestCase(-0.005)]
-        [TestCase(-23)]
-        [TestCase(double.NegativeInfinity)]
-        [TestCase(double.PositiveInfinity)]
-        public void Properties_StructureNormalOrientationInvalidValues_ThrowArgumentOutOfRangeException(double invalidValue)
-        {
-            // Setup
-            var input = new StabilityPointStructuresInput();
-
-            // Call
-            TestDelegate call = () => input.StructureNormalOrientation = (RoundedDouble) invalidValue;
-
-            // Assert
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, "De waarde voor de oriëntatie moet in het bereik tussen [0, 360] graden liggen.");
-        }
-
-        [Test]
         public void Properties_ThresholdHeightOpenWeir_ExpectedValues()
         {
             // Setup
@@ -979,239 +701,162 @@
         }
 
         [Test]
-        public void Properties_AllowedLevelIncreaseStorage_ExpectedValues()
+        public void Properties_BankWidth_ExpectedValues()
         {
             // Setup 
             var random = new Random(22);
             var input = new StabilityPointStructuresInput();
 
             var mean = (RoundedDouble)(0.01 + random.NextDouble());
             var standardDeviation = (RoundedDouble)(0.01 + random.NextDouble());
-            var expectedDistribution = new LogNormalDistribution(2)
+            var expectedDistribution = new NormalDistribution(2)
             {
                 Mean = mean,
                 StandardDeviation = standardDeviation
             };
-            var distributionToSet = new LogNormalDistribution(5)
+            var distributionToSet = new NormalDistribution(5)
             {
                 Mean = mean,
                 StandardDeviation = standardDeviation
             };
 
             // Call
-            input.AllowedLevelIncreaseStorage = distributionToSet;
+            input.BankWidth = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(input.AllowedLevelIncreaseStorage, distributionToSet, expectedDistribution);
+            AssertDistributionCorrectlySet(input.BankWidth, distributionToSet, expectedDistribution);
         }
 
         [Test]
-        public void Properties_StorageStructureArea_ExpectedValues()
+        public void Properties_EvaluationLevel_ExpectedValues()
         {
             // Setup
-            var random = new Random(22);
             var input = new StabilityPointStructuresInput();
 
-            var mean = (RoundedDouble)(0.01 + random.NextDouble());
-            var variation = (RoundedDouble)(0.01 + random.NextDouble());
-            var expectedDistribution = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = mean,
-                CoefficientOfVariation = variation
-            };
-            var distributionToSet = new VariationCoefficientLogNormalDistribution(5)
-            {
-                Mean = mean,
-                CoefficientOfVariation = variation
-            };
+            var random = new Random(22);
+            var evaluationLevel = new RoundedDouble(5, random.NextDouble());
 
             // Call
-            input.StorageStructureArea = distributionToSet;
+            input.EvaluationLevel = evaluationLevel;
 
             // Assert
-            AssertDistributionCorrectlySet(input.StorageStructureArea, distributionToSet, expectedDistribution);
+            Assert.AreEqual(2, input.EvaluationLevel.NumberOfDecimalPlaces);
+            AssertEqualValue(evaluationLevel, input.EvaluationLevel);
         }
 
         [Test]
-        public void Properties_FlowWidthAtBottomProtection_ExpectedValues()
+        public void Properties_VerticalDistance_ExpectedValues()
         {
-            // Setup
-            var random = new Random(22);
+            // Setup 
             var input = new StabilityPointStructuresInput();
 
-            var mean = (RoundedDouble)(0.01 + random.NextDouble());
-            var standardDeviation = (RoundedDouble)(0.01 + random.NextDouble());
-            var expectedDistribution = new LogNormalDistribution(2)
-            {
-                Mean = mean,
-                StandardDeviation = standardDeviation
-            };
-            var distributionToSet = new LogNormalDistribution(5)
-            {
-                Mean = mean,
-                StandardDeviation = standardDeviation
-            };
+            var random = new Random(22);
+            var verticalDistance = new RoundedDouble(5, random.NextDouble());
 
             // Call
-            input.FlowWidthAtBottomProtection = distributionToSet;
+            input.VerticalDistance = verticalDistance;
 
             // Assert
-            AssertDistributionCorrectlySet(input.FlowWidthAtBottomProtection, distributionToSet, expectedDistribution);
+            Assert.AreEqual(2, input.VerticalDistance.NumberOfDecimalPlaces);
+            AssertEqualValue(verticalDistance, input.VerticalDistance);
         }
 
         [Test]
-        public void Properties_CriticalOvertoppingDischarge_ExpectedValues()
+        public void Properties_StructureNull_DoesNotChangeValues()
         {
-            // Setup
-            var random = new Random(22);
             var input = new StabilityPointStructuresInput();
 
-            var mean = (RoundedDouble)(0.01 + random.NextDouble());
-            var variation = (RoundedDouble)(0.01 + random.NextDouble());
-            var expectedDistribution = new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = mean,
-                CoefficientOfVariation = variation
-            };
-            var distributionToSet = new VariationCoefficientLogNormalDistribution(5)
-            {
-                Mean = mean,
-                CoefficientOfVariation = variation
-            };
-
             // Call
-            input.CriticalOvertoppingDischarge = distributionToSet;
+            input.Structure = null;
 
             // Assert
-            AssertDistributionCorrectlySet(input.CriticalOvertoppingDischarge, distributionToSet, expectedDistribution);
+            AssertStabilityPointStructure(null, input);
         }
 
         [Test]
-        [TestCase(-1.1)]
-        [TestCase(2)]
-        [TestCase(double.NaN)]
-        public void Properties_FailureProbabilityStructureWithErosion_ThrowArgumentOutOfRangeException(double probability)
+        public void Properties_Structure_UpdateValuesAccordingly()
         {
             // Setup
             var input = new StabilityPointStructuresInput();
+            TestStabilityPointStructure structure = new TestStabilityPointStructure();
 
             // Call
-            TestDelegate call = () => input.FailureProbabilityStructureWithErosion = probability;
+            input.Structure = structure;
 
             // Assert
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, "De waarde voor de faalkans moet in het bereik tussen [0, 1] liggen.");
+            AssertStabilityPointStructure(structure, input);
         }
 
-        [Test]
-        [TestCase(0)]
-        [TestCase(0.5)]
-        [TestCase(1.0)]
-        public void Properties_FailureProbabilityStructureWithErosion_ExpectedValues(double probability)
-        {
-            // Setup
-            var input = new StabilityPointStructuresInput();
+        #endregion
 
-            // Call 
-            input.FailureProbabilityStructureWithErosion = probability;
+        #region Helpers
 
-            // Assert
-            Assert.AreEqual(probability, input.FailureProbabilityStructureWithErosion);
-        }
-
-        [Test]
-        public void Properties_WidthFlowApertures_ExpectedValues()
+        private static void AssertStabilityPointStructure(StabilityPointStructure expectedStructure, StabilityPointStructuresInput input)
         {
-            //Setup 
-            var random = new Random(22);
-            var input = new StabilityPointStructuresInput();
-
-            var mean = (RoundedDouble)(0.01 + random.NextDouble());
-            var variation = (RoundedDouble)(0.01 + random.NextDouble());
-            var expectedDistribution = new VariationCoefficientNormalDistribution(2)
+            if (expectedStructure == null)
             {
-                Mean = mean,
-                CoefficientOfVariation = variation
-            };
-            var distributionToSet = new VariationCoefficientNormalDistribution(5)
-            {
-                Mean = mean,
-                CoefficientOfVariation = variation
-            };
+                Assert.IsNull(input.Structure);
+                var defaultInput = new StabilityPointStructuresInput();
+                AssertEqualValue(defaultInput.StructureNormalOrientation, input.StructureNormalOrientation);
 
-            // Call
-            input.WidthFlowApertures = distributionToSet;
-
-            // Assert
-            AssertDistributionCorrectlySet(input.WidthFlowApertures, distributionToSet, expectedDistribution);
-        }
-
-        [Test]
-        public void Properties_BankWidth_ExpectedValues()
-        {
-            // Setup 
-            var random = new Random(22);
-            var input = new StabilityPointStructuresInput();
-
-            var mean = (RoundedDouble)(0.01 + random.NextDouble());
-            var standardDeviation = (RoundedDouble)(0.01 + random.NextDouble());
-            var expectedDistribution = new NormalDistribution(2)
+                DistributionAssert.AreEqual(defaultInput.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
+                DistributionAssert.AreEqual(defaultInput.AreaFlowApertures, input.AreaFlowApertures);
+                DistributionAssert.AreEqual(defaultInput.BankWidth, input.BankWidth);
+                DistributionAssert.AreEqual(defaultInput.ConstructiveStrengthLinearLoadModel, input.ConstructiveStrengthLinearLoadModel);
+                DistributionAssert.AreEqual(defaultInput.ConstructiveStrengthQuadraticLoadModel, input.ConstructiveStrengthQuadraticLoadModel);
+                DistributionAssert.AreEqual(defaultInput.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
+                AssertEqualValue(defaultInput.EvaluationLevel, input.EvaluationLevel);
+                DistributionAssert.AreEqual(defaultInput.FailureCollisionEnergy, input.FailureCollisionEnergy);
+                Assert.AreEqual(defaultInput.FailureProbabilityRepairClosure, input.FailureProbabilityRepairClosure);
+                DistributionAssert.AreEqual(defaultInput.FlowVelocityStructureClosable, input.FlowVelocityStructureClosable);
+                DistributionAssert.AreEqual(defaultInput.FlowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
+                Assert.AreEqual(defaultInput.InflowModelType, input.InflowModelType);
+                DistributionAssert.AreEqual(defaultInput.InsideWaterLevel, input.InsideWaterLevel);
+                DistributionAssert.AreEqual(defaultInput.InsideWaterLevelFailureConstruction, input.InsideWaterLevelFailureConstruction);
+                DistributionAssert.AreEqual(defaultInput.LevelCrestStructure, input.LevelCrestStructure);
+                Assert.AreEqual(defaultInput.LevellingCount, input.LevellingCount);
+                Assert.AreEqual(defaultInput.ProbabilityCollisionSecondaryStructure, input.ProbabilityCollisionSecondaryStructure);
+                DistributionAssert.AreEqual(defaultInput.ShipMass, input.ShipMass);
+                DistributionAssert.AreEqual(defaultInput.ShipVelocity, input.ShipVelocity);
+                DistributionAssert.AreEqual(defaultInput.StabilityLinearLoadModel, input.StabilityLinearLoadModel);
+                DistributionAssert.AreEqual(defaultInput.StabilityQuadraticLoadModel, input.StabilityQuadraticLoadModel);
+                DistributionAssert.AreEqual(defaultInput.StorageStructureArea, input.StorageStructureArea);
+                DistributionAssert.AreEqual(defaultInput.ThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
+                AssertEqualValue(defaultInput.VerticalDistance, input.VerticalDistance);
+                DistributionAssert.AreEqual(defaultInput.WidthFlowApertures, input.WidthFlowApertures);
+            }
+            else
             {
-                Mean = mean,
-                StandardDeviation = standardDeviation
-            };
-            var distributionToSet = new NormalDistribution(5)
-            {
-                Mean = mean,
-                StandardDeviation = standardDeviation
-            };
-
-            // Call
-            input.BankWidth = distributionToSet;
-
-            // Assert
-            AssertDistributionCorrectlySet(input.BankWidth, distributionToSet, expectedDistribution);
+                DistributionAssert.AreEqual(expectedStructure.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
+                DistributionAssert.AreEqual(expectedStructure.AreaFlowApertures, input.AreaFlowApertures);
+                DistributionAssert.AreEqual(expectedStructure.BankWidth, input.BankWidth);
+                DistributionAssert.AreEqual(expectedStructure.ConstructiveStrengthLinearLoadModel, input.ConstructiveStrengthLinearLoadModel);
+                DistributionAssert.AreEqual(expectedStructure.ConstructiveStrengthQuadraticLoadModel, input.ConstructiveStrengthQuadraticLoadModel);
+                DistributionAssert.AreEqual(expectedStructure.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
+                AssertEqualValue(expectedStructure.EvaluationLevel, input.EvaluationLevel);
+                DistributionAssert.AreEqual(expectedStructure.FailureCollisionEnergy, input.FailureCollisionEnergy);
+                Assert.AreEqual(expectedStructure.FailureProbabilityRepairClosure, input.FailureProbabilityRepairClosure);
+                DistributionAssert.AreEqual(expectedStructure.FlowVelocityStructureClosable, input.FlowVelocityStructureClosable);
+                DistributionAssert.AreEqual(expectedStructure.FlowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
+                Assert.AreEqual(expectedStructure.InflowModelType, input.InflowModelType);
+                DistributionAssert.AreEqual(expectedStructure.InsideWaterLevel, input.InsideWaterLevel);
+                DistributionAssert.AreEqual(expectedStructure.InsideWaterLevelFailureConstruction, input.InsideWaterLevelFailureConstruction);
+                DistributionAssert.AreEqual(expectedStructure.LevelCrestStructure, input.LevelCrestStructure);
+                Assert.AreEqual(expectedStructure.LevellingCount, input.LevellingCount);
+                Assert.AreEqual(expectedStructure.ProbabilityCollisionSecondaryStructure, input.ProbabilityCollisionSecondaryStructure);
+                DistributionAssert.AreEqual(expectedStructure.ShipMass, input.ShipMass);
+                DistributionAssert.AreEqual(expectedStructure.ShipVelocity, input.ShipVelocity);
+                DistributionAssert.AreEqual(expectedStructure.StabilityLinearLoadModel, input.StabilityLinearLoadModel);
+                DistributionAssert.AreEqual(expectedStructure.StabilityQuadraticLoadModel, input.StabilityQuadraticLoadModel);
+                DistributionAssert.AreEqual(expectedStructure.StorageStructureArea, input.StorageStructureArea);
+                DistributionAssert.AreEqual(expectedStructure.ThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
+                AssertEqualValue(expectedStructure.VerticalDistance, input.VerticalDistance);
+                DistributionAssert.AreEqual(expectedStructure.WidthFlowApertures, input.WidthFlowApertures);
+            }
         }
 
-        [Test]
-        public void Properties_EvaluationLevel_ExpectedValues()
+        private static void AssertEqualValue(double expectedValue, RoundedDouble actualValue)
         {
-            // Setup
-            var input = new StabilityPointStructuresInput();
-
-            var random = new Random(22);
-            var evaluationLevel = new RoundedDouble(5, random.NextDouble());
-
-            // Call
-            input.EvaluationLevel = evaluationLevel;
-
-            // Assert
-            Assert.AreEqual(2, input.EvaluationLevel.NumberOfDecimalPlaces);
-            AssertEqualValue(evaluationLevel, input.EvaluationLevel);
-        }
-
-        [Test]
-        public void Properties_VerticalDistance_ExpectedValues()
-        {
-            // Setup 
-            var input = new StabilityPointStructuresInput();
-
-            var random = new Random(22);
-            var verticalDistance = new RoundedDouble(5, random.NextDouble());
-
-            // Call
-            input.VerticalDistance = verticalDistance;
-
-            // Assert
-            Assert.AreEqual(2, input.VerticalDistance.NumberOfDecimalPlaces);
-            AssertEqualValue(verticalDistance, input.VerticalDistance);
-        }
-
-        #endregion
-
-        #region Helpers
-
-        private void AssertEqualValue(double expectedValue, RoundedDouble actualValue)
-        {
             Assert.AreEqual(expectedValue, actualValue, actualValue.GetAccuracy());
         }