Index: Ringtoets/Common/src/Ringtoets.Common.Service/DesignWaterLevelCalculationService.cs
===================================================================
diff -u -rd7f56db6a475e07dd904bd61c0a56346aac4e565 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/src/Ringtoets.Common.Service/DesignWaterLevelCalculationService.cs	(.../DesignWaterLevelCalculationService.cs)	(revision d7f56db6a475e07dd904bd61c0a56346aac4e565)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/DesignWaterLevelCalculationService.cs	(.../DesignWaterLevelCalculationService.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -197,9 +197,9 @@
             }
             catch (ArgumentException e)
             {
-                log.Warn(string.Format(Resources.SetGeneralResult_Error_while_converting_generalresult, designWaterLevelCalculation.Name) +
-                         " " + e.Message +
-                         " " + Resources.SetGeneralResult_Calculating_illustration_points_skipped);
+                log.Warn(string.Format(Resources.CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1,
+                                       designWaterLevelCalculation.Name,
+                                       e.Message));
             }
 
             HydraulicBoundaryLocationOutput hydraulicBoundaryLocationOutput = CreateHydraulicBoundaryLocationOutput(
Index: Ringtoets/Common/src/Ringtoets.Common.Service/Properties/Resources.Designer.cs
===================================================================
diff -u -rd7f56db6a475e07dd904bd61c0a56346aac4e565 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/src/Ringtoets.Common.Service/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision d7f56db6a475e07dd904bd61c0a56346aac4e565)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -100,6 +100,16 @@
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to Fout bij het uitlezen van de illustratiepunten voor berekening {0}: {1} Het uitlezen van illustratiepunten wordt overgeslagen..
+        /// </summary>
+        public static string CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1 {
+            get {
+                return ResourceManager.GetString("CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with" +
+                        "_ErrorMessage_1", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to Er is geen dijkprofiel geselecteerd..
         /// </summary>
         public static string CalculationService_ValidateInput_No_dike_profile_selected {
@@ -292,15 +302,6 @@
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Het uitlezen van illustratiepunten wordt overgeslagen..
-        /// </summary>
-        public static string SetGeneralResult_Calculating_illustration_points_skipped {
-            get {
-                return ResourceManager.GetString("SetGeneralResult_Calculating_illustration_points_skipped", resourceCulture);
-            }
-        }
-        
-        /// <summary>
         ///   Looks up a localized string similar to Het uitlezen van illustratiepunten is mislukt..
         /// </summary>
         public static string SetGeneralResult_Converting_IllustrationPointResult_Failed {
@@ -310,15 +311,6 @@
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Fout bij het uitlezen van de illustratiepunten voor berekening {0}:.
-        /// </summary>
-        public static string SetGeneralResult_Error_while_converting_generalresult {
-            get {
-                return ResourceManager.GetString("SetGeneralResult_Error_while_converting_generalresult", resourceCulture);
-            }
-        }
-        
-        /// <summary>
         ///   Looks up a localized string similar to Er is geen kunstwerk geselecteerd..
         /// </summary>
         public static string StructuresCalculationService_ValidateInput_No_Structure_selected {
Index: Ringtoets/Common/src/Ringtoets.Common.Service/Properties/Resources.resx
===================================================================
diff -u -rd7f56db6a475e07dd904bd61c0a56346aac4e565 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/src/Ringtoets.Common.Service/Properties/Resources.resx	(.../Resources.resx)	(revision d7f56db6a475e07dd904bd61c0a56346aac4e565)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/Properties/Resources.resx	(.../Resources.resx)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -218,10 +218,7 @@
   <data name="WaveHeightCalculationService_Calculate_Error_in_WaveHeightCalculation_0_no_error_report" xml:space="preserve">
     <value>Er is een fout opgetreden tijdens de golfhoogte berekening '{0}'. Er is geen foutrapport beschikbaar.</value>
   </data>
-  <data name="SetGeneralResult_Error_while_converting_generalresult" xml:space="preserve">
-    <value>Fout bij het uitlezen van de illustratiepunten voor berekening {0}:</value>
+  <data name="CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1" xml:space="preserve">
+    <value>Fout bij het uitlezen van de illustratiepunten voor berekening {0}: {1} Het uitlezen van illustratiepunten wordt overgeslagen.</value>
   </data>
-  <data name="SetGeneralResult_Calculating_illustration_points_skipped" xml:space="preserve">
-    <value>Het uitlezen van illustratiepunten wordt overgeslagen.</value>
-  </data>
 </root>
\ No newline at end of file
Index: Ringtoets/Common/src/Ringtoets.Common.Service/Structures/StructuresCalculationServiceBase.cs
===================================================================
diff -u -rd7f56db6a475e07dd904bd61c0a56346aac4e565 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/src/Ringtoets.Common.Service/Structures/StructuresCalculationServiceBase.cs	(.../StructuresCalculationServiceBase.cs)	(revision d7f56db6a475e07dd904bd61c0a56346aac4e565)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/Structures/StructuresCalculationServiceBase.cs	(.../StructuresCalculationServiceBase.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -53,8 +53,9 @@
     /// <typeparam name="TStructure">The structure type.</typeparam>
     /// <typeparam name="TGeneralInput">The general input type.</typeparam>
     /// <typeparam name="TCalculationInput">The calculation input type.</typeparam>
-    public abstract class StructuresCalculationServiceBase<TStructureValidationRules, TStructureInput,
-                                                           TStructure, TGeneralInput, TCalculationInput>
+    public abstract class StructuresCalculationServiceBase
+    <TStructureValidationRules, TStructureInput,
+     TStructure, TGeneralInput, TCalculationInput>
         where TStructureValidationRules : IStructuresValidationRulesRegistry<TStructureInput, TStructure>, new()
         where TStructureInput : StructuresInputBase<TStructure>, new()
         where TStructure : StructureBase
@@ -283,9 +284,9 @@
             }
             catch (ArgumentException e)
             {
-                log.Warn(string.Format(Resources.SetGeneralResult_Error_while_converting_generalresult, calculation.Name) +
-                         " " + e.Message +
-                         " " + Resources.SetGeneralResult_Calculating_illustration_points_skipped);
+                log.Warn(string.Format(Resources.CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1,
+                                       calculation.Name,
+                                       e.Message));
             }
 
             calculation.Output = new StructuresOutput(probabilityAssessmentOutput, generalResult);
Index: Ringtoets/Common/src/Ringtoets.Common.Service/WaveHeightCalculationService.cs
===================================================================
diff -u -rd7f56db6a475e07dd904bd61c0a56346aac4e565 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/src/Ringtoets.Common.Service/WaveHeightCalculationService.cs	(.../WaveHeightCalculationService.cs)	(revision d7f56db6a475e07dd904bd61c0a56346aac4e565)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/WaveHeightCalculationService.cs	(.../WaveHeightCalculationService.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -198,9 +198,9 @@
             }
             catch (ArgumentException e)
             {
-                log.Warn(string.Format(Resources.SetGeneralResult_Error_while_converting_generalresult, waveHeightCalculation.Name) +
-                         " " + e.Message +
-                         " " + Resources.SetGeneralResult_Calculating_illustration_points_skipped);
+                log.Warn(string.Format(Resources.CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1,
+                                       waveHeightCalculation.Name,
+                                       e.Message));
             }
 
             HydraulicBoundaryLocationOutput hydraulicBoundaryLocationOutput = CreateHydraulicBoundaryLocationOutput(
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/DesignWaterLevelCalculationServiceTest.cs
===================================================================
diff -u -r2e944cbf52d124fd501ed4ed8e991aa50299cc69 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/DesignWaterLevelCalculationServiceTest.cs	(.../DesignWaterLevelCalculationServiceTest.cs)	(revision 2e944cbf52d124fd501ed4ed8e991aa50299cc69)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/DesignWaterLevelCalculationServiceTest.cs	(.../DesignWaterLevelCalculationServiceTest.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -295,7 +295,7 @@
         }
 
         [Test]
-        public void Calculate_ValidDesignWaterLevelCalculationButIllustrationPointResultsWithDuplicateStochasts_IllustrationPointNotSetAndLog()
+        public void Calculate_CalculationRanErrorInSettingIllustrationPoints_GeneralResultNotSetAndLogsWarning()
         {
             // Setup
             string validFilePath = Path.Combine(testDataPath, validFile);
@@ -312,8 +312,8 @@
 
             var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
             calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
+            calculation.Stub(c => c.Id).Return(100);
+            calculation.Stub(c => c.CalculateIllustrationPoints).Return(true);
 
             var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
@@ -349,168 +349,6 @@
         }
 
         [Test]
-        public void Calculate_ValidDesignWaterLevelCalculationButIllustrationPointResultsWithIncorrectTopLevelStochasts_IllustrationPointNotSetAndLog()
-        {
-            // Setup
-            string validFilePath = Path.Combine(testDataPath, validFile);
-
-            var calculator = new TestDesignWaterLevelCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultSubMechanismWithIncorrectTopLevelStochasts(),
-                Converged = true
-            };
-
-            var mockRepository = new MockRepository();
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(testDataPath)).Return(calculator);
-
-            var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
-            var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
-            mockRepository.ReplayAll();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new DesignWaterLevelCalculationService().Calculate(calculation,
-                                                                                       validFilePath,
-                                                                                       1.0 / 30,
-                                                                                       calculationMessageProvider);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening punt_flw_ 1: " +
-                                    "De stochasten van een illustratiepunt bevatten niet dezelfde stochasten als in de onderliggende illustratiepunten. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual($"Toetspeil berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
-                                    "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidDesignWaterLevelCalculationButIllustrationPointResultsWithDuplicateIllustrationPoints_IllustrationPointNotSetAndLog()
-        {
-            // Setup
-            string validFilePath = Path.Combine(testDataPath, validFile);
-
-            var calculator = new TestDesignWaterLevelCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultSubMechanismWithDuplicateIllustrationPoints(),
-                Converged = true
-            };
-
-            var mockRepository = new MockRepository();
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(testDataPath)).Return(calculator);
-
-            var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
-            var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
-            mockRepository.ReplayAll();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new DesignWaterLevelCalculationService().Calculate(calculation,
-                                                                                       validFilePath,
-                                                                                       1.0 / 30,
-                                                                                       calculationMessageProvider);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening punt_flw_ 1: " +
-                                    "Een of meerdere illustratiepunten hebben dezelfde combinatie van sluitscenario en windrichting. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual($"Toetspeil berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
-                                    "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidDesignWaterLevelCalculationButIllustrationPointResultsWithDuplicateIllustrationPointResults_IllustrationPointNotSetAndLog()
-        {
-            // Setup
-            string validFilePath = Path.Combine(testDataPath, validFile);
-
-            var calculator = new TestDesignWaterLevelCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultSubMechanismWithDuplicateIllustrationPointResults(),
-                Converged = true
-            };
-
-            var mockRepository = new MockRepository();
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(testDataPath)).Return(calculator);
-
-            var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
-            var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
-            mockRepository.ReplayAll();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new DesignWaterLevelCalculationService().Calculate(calculation,
-                                                                                       validFilePath,
-                                                                                       1.0 / 30,
-                                                                                       calculationMessageProvider);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening punt_flw_ 1: " +
-                                    "Een of meerdere uitvoer variabelen hebben dezelfde naam. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual($"Toetspeil berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
-                                    "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
         public void Calculate_ValidDesignWaterLevelCalculationThrowsException_ThrowsHydraRingFileParserException()
         {
             // Setup
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/Structures/StructuresCalculationServiceBaseTest.cs
===================================================================
diff -u -r2e944cbf52d124fd501ed4ed8e991aa50299cc69 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/Structures/StructuresCalculationServiceBaseTest.cs	(.../StructuresCalculationServiceBaseTest.cs)	(revision 2e944cbf52d124fd501ed4ed8e991aa50299cc69)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/Structures/StructuresCalculationServiceBaseTest.cs	(.../StructuresCalculationServiceBaseTest.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -597,7 +597,7 @@
         }
 
         [Test]
-        public void Calculate_ValidInputButIllustrationPointResultsWithDuplicateStochasts_IllustrationPointsNotSetAndLogsWarning()
+        public void Calculate_CalculationRanErrorInSettingIllustrationPoints_GeneralResultNotSetAndLogsWarning()
         {
             // Setup
             var mocks = new MockRepository();
@@ -653,291 +653,6 @@
         }
 
         [Test]
-        public void Calculate_ValidInputButIllustrationPointResultsWithIncorrectTopLevelStochasts_IllustrationPointsNotSetAndLogsWarning()
-        {
-            // Setup
-            var mocks = new MockRepository();
-            var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
-            {
-                OutputDirectory = validFilePath,
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithIncorrectTopLevelStochasts()
-            };
-            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(testDataPath))
-                             .Return(calculator);
-
-            const string performedCalculationMessage = "Calculation successful";
-            var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
-            mocks.ReplayAll();
-
-            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
-            var calculation = new TestStructuresCalculation
-            {
-                InputParameters =
-                {
-                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ShouldIllustrationPointsBeCalculated = true
-                }
-            };
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                var service = new TestStructuresCalculationService(messageProvider);
-
-                // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), 1, 1, 1, validFilePath);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening Nieuwe berekening: " +
-                                    "De stochasten van een illustratiepunt bevatten niet dezelfde stochasten als in de onderliggende illustratiepunten. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual(performedCalculationMessage, msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mocks.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButIllustrationPointResultsWithIncorrectStochastsInChildren_IllustrationPointsNotSetAndLogsWarning()
-        {
-            // Setup
-            var mocks = new MockRepository();
-            var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
-            {
-                OutputDirectory = validFilePath,
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren()
-            };
-            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(testDataPath))
-                             .Return(calculator);
-
-            const string performedCalculationMessage = "Calculation successful";
-            var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
-            mocks.ReplayAll();
-
-            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
-            var calculation = new TestStructuresCalculation
-            {
-                InputParameters =
-                {
-                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ShouldIllustrationPointsBeCalculated = true
-                }
-            };
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                var service = new TestStructuresCalculationService(messageProvider);
-
-                // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), 1, 1, 1, validFilePath);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening Nieuwe berekening: " +
-                                    "De stochasten van een illustratiepunt bevatten niet dezelfde stochasten als in de onderliggende illustratiepunten. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual(performedCalculationMessage, msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mocks.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButIllustrationPointResultsWithDuplicateIllustrationPoints_IllustrationPointsNotSetAndLogsWarning()
-        {
-            // Setup
-            var mocks = new MockRepository();
-            var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
-            {
-                OutputDirectory = validFilePath,
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPoints()
-            };
-            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(testDataPath))
-                             .Return(calculator);
-
-            const string performedCalculationMessage = "Calculation successful";
-            var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
-            mocks.ReplayAll();
-
-            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
-            var calculation = new TestStructuresCalculation
-            {
-                InputParameters =
-                {
-                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ShouldIllustrationPointsBeCalculated = true
-                }
-            };
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                var service = new TestStructuresCalculationService(messageProvider);
-
-                // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), 1, 1, 1, validFilePath);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening Nieuwe berekening: " +
-                                    "Een of meerdere illustratiepunten hebben dezelfde combinatie van sluitscenario en windrichting. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual(performedCalculationMessage, msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mocks.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButIllustrationPointResultsWithDuplicateIllustrationPointResults_IllustrationPointsNotSetAndLogsWarning()
-        {
-            // Setup
-            var mocks = new MockRepository();
-            var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
-            {
-                OutputDirectory = validFilePath,
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPointResults()
-            };
-            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(testDataPath))
-                             .Return(calculator);
-
-            const string performedCalculationMessage = "Calculation successful";
-            var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
-            mocks.ReplayAll();
-
-            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
-            var calculation = new TestStructuresCalculation
-            {
-                InputParameters =
-                {
-                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ShouldIllustrationPointsBeCalculated = true
-                }
-            };
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                var service = new TestStructuresCalculationService(messageProvider);
-
-                // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), 1, 1, 1, validFilePath);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening Nieuwe berekening: " +
-                                    "Een of meerdere uitvoer variabelen hebben dezelfde naam. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual(performedCalculationMessage, msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mocks.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButIllustrationPointResultsWithDuplicateNamesInChildren_IllustrationPointsNotSetAndLogsWarning()
-        {
-            // Setup
-            var mocks = new MockRepository();
-            var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
-            {
-                OutputDirectory = validFilePath,
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithDuplicateNamesInChildren()
-            };
-            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(testDataPath))
-                             .Return(calculator);
-
-            const string performedCalculationMessage = "Calculation successful";
-            var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
-            mocks.ReplayAll();
-
-            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
-            var calculation = new TestStructuresCalculation
-            {
-                InputParameters =
-                {
-                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ShouldIllustrationPointsBeCalculated = true
-                }
-            };
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                var service = new TestStructuresCalculationService(messageProvider);
-
-                // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), 1, 1, 1, validFilePath);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening Nieuwe berekening: " +
-                                    "Een of meerdere illustratiepunten bevatten illustratiepunten met dezelfde naam. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual(performedCalculationMessage, msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mocks.VerifyAll();
-        }
-
-        [Test]
         public void Calculate_CancelCalculationWithValidInput_CancelsCalculatorAndHasNullOutput()
         {
             // Setup
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationServiceTest.cs
===================================================================
diff -u -r2e944cbf52d124fd501ed4ed8e991aa50299cc69 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationServiceTest.cs	(.../WaveHeightCalculationServiceTest.cs)	(revision 2e944cbf52d124fd501ed4ed8e991aa50299cc69)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationServiceTest.cs	(.../WaveHeightCalculationServiceTest.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -307,8 +307,8 @@
 
             var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
             calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
+            calculation.Stub(c => c.Id).Return(100);
+            calculation.Stub(c => c.CalculateIllustrationPoints).Return(true);
 
             var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
@@ -344,168 +344,6 @@
         }
 
         [Test]
-        public void Calculate_ValidWaveHeightCalculationButIllustrationPointResultsWithIncorrectTopLevelStochasts_IllustrationPointNotSetAndLog()
-        {
-            // Setup
-            string validFilePath = Path.Combine(testDataPath, validFile);
-
-            var calculator = new TestWaveHeightCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultSubMechanismWithIncorrectTopLevelStochasts(),
-                Converged = true
-            };
-
-            var mockRepository = new MockRepository();
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath)).Return(calculator);
-
-            var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
-            var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
-            mockRepository.ReplayAll();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new WaveHeightCalculationService().Calculate(calculation,
-                                                                                 validFilePath,
-                                                                                 1.0 / 30,
-                                                                                 calculationMessageProvider);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening punt_flw_ 1: " +
-                                    "De stochasten van een illustratiepunt bevatten niet dezelfde stochasten als in de onderliggende illustratiepunten. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual($"Golfhoogte berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
-                                    "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidWaveHeightCalculationButIllustrationPointResultsWithDuplicateIllustrationPoints_IllustrationPointNotSetAndLog()
-        {
-            // Setup
-            string validFilePath = Path.Combine(testDataPath, validFile);
-
-            var calculator = new TestWaveHeightCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultSubMechanismWithDuplicateIllustrationPoints(),
-                Converged = true
-            };
-
-            var mockRepository = new MockRepository();
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath)).Return(calculator);
-
-            var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
-            var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
-            mockRepository.ReplayAll();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new WaveHeightCalculationService().Calculate(calculation,
-                                                                                 validFilePath,
-                                                                                 1.0 / 30,
-                                                                                 calculationMessageProvider);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening punt_flw_ 1: " +
-                                    "Een of meerdere illustratiepunten hebben dezelfde combinatie van sluitscenario en windrichting. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual($"Golfhoogte berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
-                                    "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidWaveHeightCalculationButIllustrationPointResultsWithDuplicateIllustrationPointResults_IllustrationPointNotSetAndLog()
-        {
-            // Setup
-            string validFilePath = Path.Combine(testDataPath, validFile);
-
-            var calculator = new TestWaveHeightCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultSubMechanismWithDuplicateIllustrationPointResults(),
-                Converged = true
-            };
-
-            var mockRepository = new MockRepository();
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath)).Return(calculator);
-
-            var calculation = mockRepository.Stub<IHydraulicBoundaryWrapperCalculation>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
-            var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
-            mockRepository.ReplayAll();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new WaveHeightCalculationService().Calculate(calculation,
-                                                                                 validFilePath,
-                                                                                 1.0 / 30,
-                                                                                 calculationMessageProvider);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-                    Assert.AreEqual(4, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    Assert.AreEqual("Fout bij het uitlezen van de illustratiepunten voor berekening punt_flw_ 1: " +
-                                    "Een of meerdere uitvoer variabelen hebben dezelfde naam. " +
-                                    "Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
-                    Assert.AreEqual($"Golfhoogte berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
-                                    "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
-                });
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.HasGeneralResult);
-            }
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
         public void Calculate_ValidWaveHeightCalculationThrowsException_ThrowsHydraRingFileParserException()
         {
             // Setup
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs
===================================================================
diff -u -r2e944cbf52d124fd501ed4ed8e991aa50299cc69 -r9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs	(.../GrassCoverErosionInwardsCalculationServiceTest.cs)	(revision 2e944cbf52d124fd501ed4ed8e991aa50299cc69)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs	(.../GrassCoverErosionInwardsCalculationServiceTest.cs)	(revision 9a6b8bd8e680c7b847ad548bad1c5a8c2d33b143)
@@ -2164,7 +2164,7 @@
         }
 
         [Test]
-        public void Calculate_ValidInputButOvertoppingIllustrationPointResultsWithDuplicateStochasts_GeneralResultNotSetAndLogsWarning()
+        public void Calculate_OvertoppingCalculationRanErrorInSettingIllustrationPoints_GeneralResultNotSetAndLogsWarning()
         {
             // Setup
             GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
@@ -2248,426 +2248,6 @@
         }
 
         [Test]
-        public void Calculate_ValidInputButOvertoppingIllustrationPointResultsWithIncorrectTopLevelStochasts_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithIncorrectTopLevelStochasts()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        calculation.Name,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingIllustrationPointResultsWithIncorrectStochastsInChildren_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        calculation.Name,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingIllustrationPointResultsWithDuplicateIllustrationPoints_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPoints()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateIllustrationPoints(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        calculation.Name,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingIllustrationPointResultsWithDuplicateIllustrationPointResults_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPointResults()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateIllustrationPointResults(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        calculation.Name,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingIllustrationPointResultsWithDuplicateNamesInChildren_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithDuplicateNamesInChildren()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateChildNames(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        calculation.Name,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
         public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsOfIncorrectType_GeneralResultNotSetAndLogsWarning()
         {
             // Setup
@@ -2752,7 +2332,7 @@
         }
 
         [Test]
-        public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithDuplicateStochasts_GeneralResultNotSetAndLogsWarning()
+        public void Calculate_OvertoppingRateCalculationRanErrorInSettingIllustrationPoints_GeneralResultNotSetAndLogsWarning()
         {
             // Setup
             GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
@@ -2836,426 +2416,6 @@
         }
 
         [Test]
-        public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithIncorrectTopLevelStochasts_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithIncorrectTopLevelStochasts()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithIncorrectStochastsInChildren_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithDuplicateIllustrationPoints_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPoints()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateIllustrationPoints(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithDuplicateIllustrationPointResults_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPointResults()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateIllustrationPointResults(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithDuplicateNamesInChildren_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithDuplicateNamesInChildren()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateChildNames(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
         public void Calculate_ValidInputButDikeHeightIllustrationPointResultsOfIncorrectType_GeneralResultNotSetAndLogsWarning()
         {
             // Setup
@@ -3340,7 +2500,7 @@
         }
 
         [Test]
-        public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithDuplicateStochasts_GeneralResultNotSetAndLogsWarning()
+        public void Calculate_DikeHeightCalculationRanErrorInSettingIllustrationPoints_GeneralResultNotSetAndLogsWarning()
         {
             // Setup
             GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
@@ -3423,426 +2583,6 @@
             mockRepository.VerifyAll();
         }
 
-        [Test]
-        public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithIncorrectTopLevelStochasts_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithIncorrectTopLevelStochasts()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithIncorrectStochastsInChildren_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithDuplicateIllustrationPoints_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPoints()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateIllustrationPoints(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithDuplicateIllustrationPointResults_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultFaultTreeWithDuplicateIllustrationPointResults()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateIllustrationPointResults(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
-        [Test]
-        public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithDuplicateNamesInChildren_GeneralResultNotSetAndLogsWarning()
-        {
-            // Setup
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism();
-            var mockRepository = new MockRepository();
-            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism,
-                                                                                                       mockRepository,
-                                                                                                       validFile);
-            var overtoppingCalculator = new TestOvertoppingCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var dikeHeightCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithDuplicateNamesInChildren()
-            };
-            var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
-            {
-                IllustrationPointsResult = new TestGeneralResult()
-            };
-            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
-            calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
-            mockRepository.ReplayAll();
-
-            GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings();
-
-            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
-            {
-                // Call
-                Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation,
-                                                                                               assessmentSection,
-                                                                                               failureMechanism.GeneralInput,
-                                                                                               failureMechanism.Contribution,
-                                                                                               validFile);
-
-                // Assert
-                TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
-                {
-                    Tuple<string, Level, Exception>[] tupleArray = messages.ToArray();
-
-                    string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
-
-                    Assert.AreEqual(8, msgs.Length);
-
-                    CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
-                        overtoppingCalculator.OutputDirectory,
-                        msgs[1]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        dikeHeightCalculator.OutputDirectory,
-                        msgs[2]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[3]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultWithDuplicateChildNames(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
-                        calculation.Name,
-                        msgs[4]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        overtoppingRateCalculator.OutputDirectory,
-                        msgs[5]);
-                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage(
-                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
-                        calculation.Name,
-                        msgs[6]);
-                    CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]);
-                });
-
-                Assert.IsNotNull(calculation.Output);
-                Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult);
-                Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult);
-                Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult);
-            }
-
-            mockRepository.VerifyAll();
-        }
-
         private static GrassCoverErosionInwardsFailureMechanism CreateGrassCoverErosionInwardsFailureMechanism()
         {
             return new GrassCoverErosionInwardsFailureMechanism