Index: Demo/Ringtoets/src/Demo.Ringtoets/Commands/AddNewDemoAssessmentSectionCommand.cs
===================================================================
diff -u -r30144d2713912eb55a3106a18dc3f86dd1e86860 -r6345fd6a8fffc7852289a9c0e7ed2e0aad96c908
--- Demo/Ringtoets/src/Demo.Ringtoets/Commands/AddNewDemoAssessmentSectionCommand.cs	(.../AddNewDemoAssessmentSectionCommand.cs)	(revision 30144d2713912eb55a3106a18dc3f86dd1e86860)
+++ Demo/Ringtoets/src/Demo.Ringtoets/Commands/AddNewDemoAssessmentSectionCommand.cs	(.../AddNewDemoAssessmentSectionCommand.cs)	(revision 6345fd6a8fffc7852289a9c0e7ed2e0aad96c908)
@@ -187,118 +187,119 @@
 
             var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation);
-            calculation.InputParameters.HydraulicBoundaryLocation = failureMechanism.HydraulicBoundaryLocations.First(hl => hl.Id == 1300001);
+            calculation.InputParameters.HydraulicBoundaryLocation = demoAssessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001);
             calculation.InputParameters.NotifyObservers();
         }
 
         private static void SetGrassCoverErosionOutwardsHydraulicBoundaryLocationDesignWaterLevelOutputValues(GrassCoverErosionOutwardsFailureMechanism failureMechanism)
         {
             const double targetProbability = 1.0 / 200000;
-            ObservableList<HydraulicBoundaryLocation> locations = failureMechanism.HydraulicBoundaryLocations;
+            IObservableEnumerable<HydraulicBoundaryLocationCalculation> calculations = failureMechanism.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm;
+
             GeneralResult<TopLevelSubMechanismIllustrationPoint> generalResult = null;
-            locations.ElementAt(0).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(0).Output = new HydraulicBoundaryLocationOutput(
                 7.19,
                 targetProbability, 4.79014,
                 1.0 / 1196727, 4.78959,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(1).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(1).Output = new HydraulicBoundaryLocationOutput(
                 7.19,
                 targetProbability, 4.79014,
                 1.0 / 1196727, 4.78959,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(2).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(2).Output = new HydraulicBoundaryLocationOutput(
                 7.18,
                 targetProbability, 4.79014,
                 1.0 / 1196727, 4.78959,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(3).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(3).Output = new HydraulicBoundaryLocationOutput(
                 7.18,
                 targetProbability, 4.79014,
                 1.0 / 1196787, 4.78960,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(4).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(4).Output = new HydraulicBoundaryLocationOutput(
                 7.18,
                 targetProbability, 4.79014,
                 1.0 / 1196787, 4.78960,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(5).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(5).Output = new HydraulicBoundaryLocationOutput(
                 7.39,
                 targetProbability, 4.79014,
                 1.0 / 1196489, 4.78955,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(6).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(6).Output = new HydraulicBoundaryLocationOutput(
                 7.39,
                 targetProbability, 4.79014,
                 1.0 / 1196489, 4.78955,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(7).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(7).Output = new HydraulicBoundaryLocationOutput(
                 7.39,
                 targetProbability, 4.79014,
                 1.0 / 1196489, 4.78955,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(8).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(8).Output = new HydraulicBoundaryLocationOutput(
                 7.40,
                 targetProbability, 4.79014,
                 1.0 / 1196489, 4.78955,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(9).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(9).Output = new HydraulicBoundaryLocationOutput(
                 7.40,
                 targetProbability, 4.79014,
                 1.0 / 1196429, 4.78954,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(10).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(10).Output = new HydraulicBoundaryLocationOutput(
                 7.40,
                 targetProbability, 4.79014,
                 1.0 / 1196429, 4.78954,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(11).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(11).Output = new HydraulicBoundaryLocationOutput(
                 7.40,
                 targetProbability, 4.79014,
                 1.0 / 1196429, 4.78954,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(12).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(12).Output = new HydraulicBoundaryLocationOutput(
                 7.40,
                 targetProbability, 4.79014,
                 1.0 / 1196429, 4.78954,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(13).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(13).Output = new HydraulicBoundaryLocationOutput(
                 7.41,
                 targetProbability, 4.79014,
                 1.0 / 1196429, 4.78954,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(14).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(14).Output = new HydraulicBoundaryLocationOutput(
                 7.41,
                 targetProbability, 4.79014,
                 1.0 / 1196429, 4.78954,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(15).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(15).Output = new HydraulicBoundaryLocationOutput(
                 6.91,
                 targetProbability, 4.79014,
                 1.0 / 1197264, 4.78968,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(16).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(16).Output = new HydraulicBoundaryLocationOutput(
                 7.53,
                 targetProbability, 4.79014,
                 1.0 / 1195476, 4.78938,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(17).DesignWaterLevelCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(17).Output = new HydraulicBoundaryLocationOutput(
                 7.80,
                 targetProbability, 4.79014,
                 1.0 / 1194761, 4.78926,
@@ -309,111 +310,111 @@
         private static void SetGrassCoverErosionOutwardsHydraulicBoundaryLocationWaveHeightOutputValues(GrassCoverErosionOutwardsFailureMechanism failureMechanism)
         {
             const double targetProbability = 1.0 / 200000;
-            ObservableList<HydraulicBoundaryLocation> locations = failureMechanism.HydraulicBoundaryLocations;
+            IObservableEnumerable<HydraulicBoundaryLocationCalculation> calculations = failureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm;
             GeneralResult<TopLevelSubMechanismIllustrationPoint> generalResult = null;
-            locations.ElementAt(0).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(0).Output = new HydraulicBoundaryLocationOutput(
                 4.99,
                 targetProbability, 4.79014,
                 1.0 / 1199892, 4.79012,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(1).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(1).Output = new HydraulicBoundaryLocationOutput(
                 5.04,
                 targetProbability, 4.79014,
                 1.0 / 1199892, 4.79012,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(2).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(2).Output = new HydraulicBoundaryLocationOutput(
                 4.87,
                 targetProbability, 4.79014,
                 1.0 / 1199892, 4.79012,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(3).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(3).Output = new HydraulicBoundaryLocationOutput(
                 4.73,
                 targetProbability, 4.79014,
                 1.0 / 1199892, 4.79012,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(4).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(4).Output = new HydraulicBoundaryLocationOutput(
                 4.59,
                 targetProbability, 4.79014,
                 1.0 / 1199833, 4.79011,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(5).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(5).Output = new HydraulicBoundaryLocationOutput(
                 3.35,
                 targetProbability, 4.79014,
                 1.0 / 1197264, 4.78968,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(6).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(6).Output = new HydraulicBoundaryLocationOutput(
                 3.83,
                 targetProbability, 4.79014,
                 1.0 / 1196906, 4.78962,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(7).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(7).Output = new HydraulicBoundaryLocationOutput(
                 4.00,
                 targetProbability, 4.79014,
                 1.0 / 1197264, 4.78968,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(8).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(8).Output = new HydraulicBoundaryLocationOutput(
                 4.20,
                 targetProbability, 4.79014,
                 1.0 / 1197324, 4.78969,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(9).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(9).Output = new HydraulicBoundaryLocationOutput(
                 4.41,
                 targetProbability, 4.79014,
                 1.0 / 1197324, 4.78969,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(10).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(10).Output = new HydraulicBoundaryLocationOutput(
                 4.50,
                 targetProbability, 4.79014,
                 1.0 / 1197622, 4.78974,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(11).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(11).Output = new HydraulicBoundaryLocationOutput(
                 4.57,
                 targetProbability, 4.79014,
                 1.0 / 1197145, 4.78966,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(12).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(12).Output = new HydraulicBoundaryLocationOutput(
                 4.63,
                 targetProbability, 4.79014,
                 1.0 / 1196608, 4.78957,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(13).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(13).Output = new HydraulicBoundaryLocationOutput(
                 4.68,
                 targetProbability, 4.79014,
                 1.0 / 1196549, 4.78956,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(14).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(14).Output = new HydraulicBoundaryLocationOutput(
                 4.17,
                 targetProbability, 4.79014,
                 1.0 / 1199713, 4.79009,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(15).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(15).Output = new HydraulicBoundaryLocationOutput(
                 11.13,
                 targetProbability, 4.79014,
                 1.0 / 201269, 4.79035,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(16).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(16).Output = new HydraulicBoundaryLocationOutput(
                 9.24,
                 targetProbability, 4.79014,
                 1.0 / 197742, 4.78976,
                 CalculationConvergence.CalculatedConverged,
                 generalResult);
-            locations.ElementAt(17).WaveHeightCalculation1.Output = new HydraulicBoundaryLocationOutput(
+            calculations.ElementAt(17).Output = new HydraulicBoundaryLocationOutput(
                 5.34,
                 targetProbability, 4.79014,
                 1.0 / 199056, 4.78998,
@@ -804,7 +805,6 @@
             SetHydraulicBoundaryLocationWaveHeightOutputValues(demoAssessmentSection);
 
             demoAssessmentSection.GrassCoverErosionOutwards.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
-            demoAssessmentSection.GrassCoverErosionOutwards.SetGrassCoverErosionOutwardsHydraulicBoundaryLocations(hydraulicBoundaryLocations);
             SetGrassCoverErosionOutwardsHydraulicBoundaryLocationDesignWaterLevelOutputValues(demoAssessmentSection.GrassCoverErosionOutwards);
             SetGrassCoverErosionOutwardsHydraulicBoundaryLocationWaveHeightOutputValues(demoAssessmentSection.GrassCoverErosionOutwards);
         }
Index: Demo/Ringtoets/test/Demo.Ringtoets.Test/Commands/AddNewDemoAssessmentSectionCommandTest.cs
===================================================================
diff -u -r3b833e2aad1f0986fbdd0e5645a7303e1a62efcc -r6345fd6a8fffc7852289a9c0e7ed2e0aad96c908
--- Demo/Ringtoets/test/Demo.Ringtoets.Test/Commands/AddNewDemoAssessmentSectionCommandTest.cs	(.../AddNewDemoAssessmentSectionCommandTest.cs)	(revision 3b833e2aad1f0986fbdd0e5645a7303e1a62efcc)
+++ Demo/Ringtoets/test/Demo.Ringtoets.Test/Commands/AddNewDemoAssessmentSectionCommandTest.cs	(.../AddNewDemoAssessmentSectionCommandTest.cs)	(revision 6345fd6a8fffc7852289a9c0e7ed2e0aad96c908)
@@ -158,17 +158,16 @@
         private static void AssertGrassCoverErosionOutwardsFailureMechanism(AssessmentSection demoAssessmentSection)
         {
             ObservableList<HydraulicBoundaryLocation> hydraulicBoundaryLocations = demoAssessmentSection.HydraulicBoundaryDatabase.Locations;
-            ObservableList<HydraulicBoundaryLocation> hydraulicBoundaryLocationsGrassOutwards = demoAssessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations;
+            GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism = demoAssessmentSection.GrassCoverErosionOutwards;
 
-            Assert.AreEqual(hydraulicBoundaryLocations.Count, hydraulicBoundaryLocationsGrassOutwards.Count);
-            AssertHydraulicBoundaryLocationCalculations(demoAssessmentSection.GrassCoverErosionOutwards, hydraulicBoundaryLocations);
-            AssertDesignWaterLevelsForGrassCoverErosionOutwards(hydraulicBoundaryLocationsGrassOutwards);
-            AssertCalculationConvergence(hydraulicBoundaryLocationsGrassOutwards.Select(l => l.DesignWaterLevelCalculation1));
-            AssertWaveHeightsForGrassCoverErosionOutwards(hydraulicBoundaryLocationsGrassOutwards);
-            AssertCalculationConvergence(hydraulicBoundaryLocationsGrassOutwards.Select(l => l.WaveHeightCalculation1));
+            AssertHydraulicBoundaryLocationCalculations(grassCoverErosionOutwardsFailureMechanism, hydraulicBoundaryLocations);
+            AssertDesignWaterLevelsForGrassCoverErosionOutwards(grassCoverErosionOutwardsFailureMechanism.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm);
+            AssertCalculationConvergence(grassCoverErosionOutwardsFailureMechanism.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm);
+            AssertWaveHeightsForGrassCoverErosionOutwards(grassCoverErosionOutwardsFailureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm);
+            AssertCalculationConvergence(grassCoverErosionOutwardsFailureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm);
 
             Assert.AreEqual(1, demoAssessmentSection.GrassCoverErosionInwards.CalculationsGroup.Children.Count);
-            GrassCoverErosionOutwardsWaveConditionsCalculation calculation = demoAssessmentSection.GrassCoverErosionOutwards
+            GrassCoverErosionOutwardsWaveConditionsCalculation calculation = grassCoverErosionOutwardsFailureMechanism
                                                                                                   .WaveConditionsCalculationGroup.GetCalculations()
                                                                                                   .OfType<GrassCoverErosionOutwardsWaveConditionsCalculation>()
                                                                                                   .First();
@@ -185,64 +184,50 @@
             CollectionAssert.AreEqual(hydraulicBoundaryLocations, failureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm.Select(hblc => hblc.HydraulicBoundaryLocation));
         }
 
-        private static void AssertDesignWaterLevelsForGrassCoverErosionOutwards(ObservableList<HydraulicBoundaryLocation> locations)
+        private static void AssertDesignWaterLevelsForGrassCoverErosionOutwards(IObservableEnumerable<HydraulicBoundaryLocationCalculation> calculations)
         {
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.19, locations[0]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.19, locations[1]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.18, locations[2]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.18, locations[3]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.18, locations[4]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.39, locations[5]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.39, locations[6]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.39, locations[7]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.40, locations[8]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.40, locations[9]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.40, locations[10]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.40, locations[11]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.40, locations[12]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.41, locations[13]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.41, locations[14]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(6.91, locations[15]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.53, locations[16]);
-            AssertDesignWaterLevelForGrassCoverErosionOutwards(7.80, locations[17]);
+            AssertHydraulicBoundaryCalculationResult(7.19, calculations, 0);
+            AssertHydraulicBoundaryCalculationResult(7.19, calculations, 1);
+            AssertHydraulicBoundaryCalculationResult(7.18, calculations, 2);
+            AssertHydraulicBoundaryCalculationResult(7.18, calculations, 3);
+            AssertHydraulicBoundaryCalculationResult(7.18, calculations, 4);
+            AssertHydraulicBoundaryCalculationResult(7.39, calculations, 5);
+            AssertHydraulicBoundaryCalculationResult(7.39, calculations, 6);
+            AssertHydraulicBoundaryCalculationResult(7.39, calculations, 7);
+            AssertHydraulicBoundaryCalculationResult(7.40, calculations, 8);
+            AssertHydraulicBoundaryCalculationResult(7.40, calculations, 9);
+            AssertHydraulicBoundaryCalculationResult(7.40, calculations, 10);
+            AssertHydraulicBoundaryCalculationResult(7.40, calculations, 11);
+            AssertHydraulicBoundaryCalculationResult(7.40, calculations, 12);
+            AssertHydraulicBoundaryCalculationResult(7.41, calculations, 13);
+            AssertHydraulicBoundaryCalculationResult(7.41, calculations, 14);
+            AssertHydraulicBoundaryCalculationResult(6.91, calculations, 15);
+            AssertHydraulicBoundaryCalculationResult(7.53, calculations, 16);
+            AssertHydraulicBoundaryCalculationResult(7.80, calculations, 17);
         }
 
-        private static void AssertDesignWaterLevelForGrassCoverErosionOutwards(double expectedValue, HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        private static void AssertWaveHeightsForGrassCoverErosionOutwards(IObservableEnumerable<HydraulicBoundaryLocationCalculation> calculations)
         {
-            RoundedDouble designWaterLevel = hydraulicBoundaryLocation.DesignWaterLevelCalculation1.Output.Result;
-
-            Assert.AreEqual(expectedValue, designWaterLevel, designWaterLevel.GetAccuracy());
+            AssertHydraulicBoundaryCalculationResult(4.99, calculations, 0);
+            AssertHydraulicBoundaryCalculationResult(5.04, calculations, 1);
+            AssertHydraulicBoundaryCalculationResult(4.87, calculations, 2);
+            AssertHydraulicBoundaryCalculationResult(4.73, calculations, 3);
+            AssertHydraulicBoundaryCalculationResult(4.59, calculations, 4);
+            AssertHydraulicBoundaryCalculationResult(3.35, calculations, 5);
+            AssertHydraulicBoundaryCalculationResult(3.83, calculations, 6);
+            AssertHydraulicBoundaryCalculationResult(4.00, calculations, 7);
+            AssertHydraulicBoundaryCalculationResult(4.20, calculations, 8);
+            AssertHydraulicBoundaryCalculationResult(4.41, calculations, 9);
+            AssertHydraulicBoundaryCalculationResult(4.50, calculations, 10);
+            AssertHydraulicBoundaryCalculationResult(4.57, calculations, 11);
+            AssertHydraulicBoundaryCalculationResult(4.63, calculations, 12);
+            AssertHydraulicBoundaryCalculationResult(4.68, calculations, 13);
+            AssertHydraulicBoundaryCalculationResult(4.17, calculations, 14);
+            AssertHydraulicBoundaryCalculationResult(11.13, calculations, 15);
+            AssertHydraulicBoundaryCalculationResult(9.24, calculations, 16);
+            AssertHydraulicBoundaryCalculationResult(5.34, calculations, 17);
         }
 
-        private static void AssertWaveHeightsForGrassCoverErosionOutwards(ObservableList<HydraulicBoundaryLocation> locations)
-        {
-            AssertWaveHeightForGrassCoverErosionOutwards(4.99, locations[0]);
-            AssertWaveHeightForGrassCoverErosionOutwards(5.04, locations[1]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.87, locations[2]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.73, locations[3]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.59, locations[4]);
-            AssertWaveHeightForGrassCoverErosionOutwards(3.35, locations[5]);
-            AssertWaveHeightForGrassCoverErosionOutwards(3.83, locations[6]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.00, locations[7]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.20, locations[8]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.41, locations[9]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.50, locations[10]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.57, locations[11]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.63, locations[12]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.68, locations[13]);
-            AssertWaveHeightForGrassCoverErosionOutwards(4.17, locations[14]);
-            AssertWaveHeightForGrassCoverErosionOutwards(11.13, locations[15]);
-            AssertWaveHeightForGrassCoverErosionOutwards(9.24, locations[16]);
-            AssertWaveHeightForGrassCoverErosionOutwards(5.34, locations[17]);
-        }
-
-        private static void AssertWaveHeightForGrassCoverErosionOutwards(double expectedValue, HydraulicBoundaryLocation hydraulicBoundaryLocation)
-        {
-            RoundedDouble waveHeight = hydraulicBoundaryLocation.WaveHeightCalculation1.Output.Result;
-
-            Assert.AreEqual(expectedValue, waveHeight, waveHeight.GetAccuracy());
-        }
-
         private static void AssertExpectedGrassCoverErosionOutwardsWaveConditionsInput(WaveConditionsInput inputParameters)
         {
             Assert.AreEqual(1300001, inputParameters.HydraulicBoundaryLocation.Id);