Index: Ringtoets/Common/src/Ringtoets.Common.Service/DesignWaterLevelCalculationService.cs
===================================================================
diff -u -r8905298103eb01ce13dd5c1a2f267f879d4fda3e -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Common/src/Ringtoets.Common.Service/DesignWaterLevelCalculationService.cs	(.../DesignWaterLevelCalculationService.cs)	(revision 8905298103eb01ce13dd5c1a2f267f879d4fda3e)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/DesignWaterLevelCalculationService.cs	(.../DesignWaterLevelCalculationService.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -101,7 +101,7 @@
                 if (string.IsNullOrEmpty(calculator.LastErrorFileContent))
                 {
                     hydraulicBoundaryLocation.DesignWaterLevelOutput = CreateHydraulicBoundaryLocationOutput(
-                        messageProvider, hydraulicBoundaryLocation.Name, calculationInput.Beta, norm);
+                        messageProvider, hydraulicBoundaryLocation.Name, calculationInput.Beta, norm, calculator.Converged);
                 }
             }
             catch (HydraRingFileParserException)
@@ -148,17 +148,18 @@
             }
         }
 
-        private HydraulicBoundaryLocationOutput CreateHydraulicBoundaryLocationOutput(ICalculationMessageProvider messageProvider,
-                                                                                      string hydraulicBoundaryLocationName,
-                                                                                      double targetReliability,
-                                                                                      double targetProbability)
+        private HydraulicBoundaryLocationOutput CreateHydraulicBoundaryLocationOutput(
+            ICalculationMessageProvider messageProvider,
+            string hydraulicBoundaryLocationName,
+            double targetReliability,
+            double targetProbability,
+            bool? calculatorConverged)
         {
             var designWaterLevel = calculator.DesignWaterLevel;
             var reliability = calculator.ReliabilityIndex;
             var probability = StatisticsConverter.ReliabilityToProbability(reliability);
 
-            CalculationConvergence converged = RingtoetsCommonDataCalculationService.CalculationConverged(
-                calculator.ReliabilityIndex, targetProbability);
+            CalculationConvergence converged = RingtoetsCommonDataCalculationService.CalculationConverged(calculatorConverged);
 
             if (converged != CalculationConvergence.CalculatedConverged)
             {
Index: Ringtoets/Common/src/Ringtoets.Common.Service/RingtoetsCommonDataCalculationService.cs
===================================================================
diff -u -r1233bb8bd98ffff10b7bd790b1488d978e5fb027 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Common/src/Ringtoets.Common.Service/RingtoetsCommonDataCalculationService.cs	(.../RingtoetsCommonDataCalculationService.cs)	(revision 1233bb8bd98ffff10b7bd790b1488d978e5fb027)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/RingtoetsCommonDataCalculationService.cs	(.../RingtoetsCommonDataCalculationService.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -20,7 +20,6 @@
 // All rights reserved.
 
 using System;
-using Core.Common.Utils;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Service.Properties;
 
@@ -32,20 +31,6 @@
     public static class RingtoetsCommonDataCalculationService
     {
         /// <summary>
-        /// Determines whether the calculated output is converged,
-        /// based on the <paramref name="reliabilityIndex"/> and the <paramref name="norm"/>.
-        /// </summary>
-        /// <param name="reliabilityIndex">The resultant reliability index after a calculation.</param>
-        /// <param name="norm">The norm used during the calculation.</param>
-        /// <returns><c>True</c> if the solution converged, <c>false</c> if otherwise.</returns>
-        public static CalculationConvergence CalculationConverged(double reliabilityIndex, double norm)
-        {
-            return Math.Abs(reliabilityIndex - StatisticsConverter.ProbabilityToReliability(norm)) <= 1.0e-3 ?
-                       CalculationConvergence.CalculatedConverged :
-                       CalculationConvergence.CalculatedNotConverged;
-        }
-
-        /// <summary>
         /// Determines whether the calculated output is converged.
         /// </summary>
         /// <param name="converged">The value indicating whether convergence has been reached.</param>
@@ -74,7 +59,7 @@
         {
             if (!(failureMechanismContribution > 0))
             {
-                throw new ArgumentOutOfRangeException("failureMechanismContribution", failureMechanismContribution,
+                throw new ArgumentOutOfRangeException(nameof(failureMechanismContribution), failureMechanismContribution,
                                                       Resources.RingtoetsCommonDataCalculationService_ProfileSpecificRequiredProbability_Contribution_is_zero_or_negative);
             }
             if (n == 0)
Index: Ringtoets/Common/src/Ringtoets.Common.Service/WaveHeightCalculationService.cs
===================================================================
diff -u -r3d6119b921ede5e5eea3de083a17a26f12ffa447 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Common/src/Ringtoets.Common.Service/WaveHeightCalculationService.cs	(.../WaveHeightCalculationService.cs)	(revision 3d6119b921ede5e5eea3de083a17a26f12ffa447)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/WaveHeightCalculationService.cs	(.../WaveHeightCalculationService.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -102,7 +102,7 @@
                 if (string.IsNullOrEmpty(calculator.LastErrorFileContent))
                 {
                     hydraulicBoundaryLocation.WaveHeightOutput = CreateHydraulicBoundaryLocationOutput(
-                        messageProvider, hydraulicBoundaryLocation.Name, calculationInput.Beta, norm);
+                        messageProvider, hydraulicBoundaryLocation.Name, calculationInput.Beta, norm, calculator.Converged);
                 }
             }
             catch (HydraRingFileParserException)
@@ -149,17 +149,18 @@
             }
         }
 
-        private HydraulicBoundaryLocationOutput CreateHydraulicBoundaryLocationOutput(ICalculationMessageProvider messageProvider,
-                                                                                      string hydraulicBoundaryLocationName,
-                                                                                      double targetReliability,
-                                                                                      double targetProbability)
+        private HydraulicBoundaryLocationOutput CreateHydraulicBoundaryLocationOutput(
+            ICalculationMessageProvider messageProvider, 
+            string hydraulicBoundaryLocationName, 
+            double targetReliability, 
+            double targetProbability, 
+            bool? calculatorConverged)
         {
             double waveHeight = calculator.WaveHeight;
             double reliability = calculator.ReliabilityIndex;
             double probability = StatisticsConverter.ReliabilityToProbability(reliability);
 
-            CalculationConvergence converged = RingtoetsCommonDataCalculationService.CalculationConverged(
-                reliability, targetProbability);
+            CalculationConvergence converged = RingtoetsCommonDataCalculationService.CalculationConverged(calculatorConverged);
 
             if (converged != CalculationConvergence.CalculatedConverged)
             {
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/DesignWaterLevelCalculationActivityTest.cs
===================================================================
diff -u -re1d4d3fe987bfa6504703952ea0dbd8a18f5a698 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/DesignWaterLevelCalculationActivityTest.cs	(.../DesignWaterLevelCalculationActivityTest.cs)	(revision e1d4d3fe987bfa6504703952ea0dbd8a18f5a698)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/DesignWaterLevelCalculationActivityTest.cs	(.../DesignWaterLevelCalculationActivityTest.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -150,9 +150,9 @@
             {
                 var msgs = messages.ToArray();
                 Assert.AreEqual(3, msgs.Length);
-                StringAssert.StartsWith(string.Format("Validatie van '{0}' gestart om: ", calculationName), msgs[0]);
+                StringAssert.StartsWith($"Validatie van '{calculationName}' gestart om: ", msgs[0]);
                 StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische randvoorwaardendatabase is mislukt. Fout bij het lezen van bestand", msgs[1]);
-                StringAssert.StartsWith(string.Format("Validatie van '{0}' beëindigd om: ", calculationName), msgs[2]);
+                StringAssert.StartsWith($"Validatie van '{calculationName}' beëindigd om: ", msgs[2]);
             });
             Assert.AreEqual(ActivityState.Failed, activity.State);
             mockRepository.VerifyAll();
@@ -185,7 +185,7 @@
             using (new HydraRingCalculatorFactoryConfig())
             {
                 var testDesignWaterLevelCalculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DesignWaterLevelCalculator;
-                testDesignWaterLevelCalculator.ReliabilityIndex = StatisticsConverter.ProbabilityToReliability(norm);
+                testDesignWaterLevelCalculator.Converged = true;
 
                 // Call
                 Action call = () => activity.Run();
@@ -195,11 +195,11 @@
                 {
                     var messages = m.ToArray();
                     Assert.AreEqual(5, messages.Length);
-                    StringAssert.StartsWith(string.Format("Validatie van '{0}' gestart om: ", calculationName), messages[0]);
-                    StringAssert.StartsWith(string.Format("Validatie van '{0}' beëindigd om: ", calculationName), messages[1]);
-                    StringAssert.StartsWith(string.Format("Berekening van '{0}' gestart om: ", calculationName), messages[2]);
+                    StringAssert.StartsWith($"Validatie van '{calculationName}' gestart om: ", messages[0]);
+                    StringAssert.StartsWith($"Validatie van '{calculationName}' beëindigd om: ", messages[1]);
+                    StringAssert.StartsWith($"Berekening van '{calculationName}' gestart om: ", messages[2]);
                     StringAssert.StartsWith("Toetspeil berekening is uitgevoerd op de tijdelijke locatie", messages[3]);
-                    StringAssert.StartsWith(string.Format("Berekening van '{0}' beëindigd om: ", calculationName), messages[4]);
+                    StringAssert.StartsWith($"Berekening van '{calculationName}' beëindigd om: ", messages[4]);
                 });
 
                 var designWaterLevelCalculationInput = testDesignWaterLevelCalculator.ReceivedInputs.First();
@@ -276,7 +276,7 @@
             {
                 var testDesignWaterLevelCalculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DesignWaterLevelCalculator;
                 testDesignWaterLevelCalculator.DesignWaterLevel = expectedDesignWaterLevel;
-                testDesignWaterLevelCalculator.ReliabilityIndex = StatisticsConverter.ProbabilityToReliability(norm);
+                testDesignWaterLevelCalculator.Converged = true;
 
                 // Call
                 activity.Run();
@@ -364,7 +364,7 @@
             using (new HydraRingCalculatorFactoryConfig())
             {
                 var calculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DesignWaterLevelCalculator;
-                calculator.ReliabilityIndex = 3;
+                calculator.Converged = false;
 
                 Action call = () => activity.Run();
 
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/RingtoetsCommonDataCalculationServiceTest.cs
===================================================================
diff -u -rdd5aa48365b805d37f8ecce133832e5b920f5064 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/RingtoetsCommonDataCalculationServiceTest.cs	(.../RingtoetsCommonDataCalculationServiceTest.cs)	(revision dd5aa48365b805d37f8ecce133832e5b920f5064)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/RingtoetsCommonDataCalculationServiceTest.cs	(.../RingtoetsCommonDataCalculationServiceTest.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -31,34 +31,19 @@
     public class RingtoetsCommonDataCalculationServiceTest
     {
         [Test]
-        public void CalculationConverged_WithConvergedResults_CalculationConvergedTrue()
+        [TestCase(true, CalculationConvergence.CalculatedConverged)]
+        [TestCase(false, CalculationConvergence.CalculatedNotConverged)]
+        [TestCase(null, CalculationConvergence.NotCalculated)]
+        public void CalculationConverged_WithDifferentValues_ReturnsExpectedConvergence(bool? value, CalculationConvergence expectedConvergence)
         {
-            // Setup
-            const double norm = 0.05;
-            double reliabilityIndex = StatisticsConverter.ProbabilityToReliability(norm);
-
             // Call
-            CalculationConvergence calculationConverged = RingtoetsCommonDataCalculationService.CalculationConverged(reliabilityIndex, norm);
+            CalculationConvergence calculationConverged = RingtoetsCommonDataCalculationService.CalculationConverged(value);
 
             // Assert
-            Assert.AreEqual(CalculationConvergence.CalculatedConverged, calculationConverged);
+            Assert.AreEqual(expectedConvergence, calculationConverged);
         }
 
         [Test]
-        public void CalculationConverged_WithoutConvergedResults_CalculationConvergedFalse()
-        {
-            // Setup
-            var output = new ReliabilityIndexCalculationOutput(5.0e-3, 5.0e-3);
-            const double norm = 1;
-
-            // Call
-            CalculationConvergence calculationConverged = RingtoetsCommonDataCalculationService.CalculationConverged(output.CalculatedReliabilityIndex, norm);
-
-            // Assert
-            Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, calculationConverged);
-        }
-
-        [Test]
         public void ProfileSpecificRequiredProbability_WithValidParameters_ReturnSpecificProbability()
         {
             // Setup
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationActivityTest.cs
===================================================================
diff -u -re1d4d3fe987bfa6504703952ea0dbd8a18f5a698 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationActivityTest.cs	(.../WaveHeightCalculationActivityTest.cs)	(revision e1d4d3fe987bfa6504703952ea0dbd8a18f5a698)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationActivityTest.cs	(.../WaveHeightCalculationActivityTest.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -134,9 +134,9 @@
             {
                 var msgs = messages.ToArray();
                 Assert.AreEqual(3, msgs.Length);
-                StringAssert.StartsWith(string.Format("Validatie van '{0}' gestart om: ", calculationName), msgs[0]);
+                StringAssert.StartsWith($"Validatie van '{calculationName}' gestart om: ", msgs[0]);
                 StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische randvoorwaardendatabase is mislukt. Fout bij het lezen van bestand", msgs[1]);
-                StringAssert.StartsWith(string.Format("Validatie van '{0}' beëindigd om: ", calculationName), msgs[2]);
+                StringAssert.StartsWith($"Validatie van '{calculationName}' beëindigd om: ", msgs[2]);
             });
             Assert.AreEqual(ActivityState.Failed, activity.State);
         }
@@ -167,7 +167,7 @@
             using (new HydraRingCalculatorFactoryConfig())
             {
                 var testWaveHeightCalculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).WaveHeightCalculator;
-                testWaveHeightCalculator.ReliabilityIndex = StatisticsConverter.ProbabilityToReliability(norm);
+                testWaveHeightCalculator.Converged = true;
 
                 // Call
                 Action call = () => activity.Run();
@@ -177,11 +177,11 @@
                 {
                     var messages = m.ToArray();
                     Assert.AreEqual(5, messages.Length);
-                    StringAssert.StartsWith(string.Format("Validatie van '{0}' gestart om: ", calculationName), messages[0]);
-                    StringAssert.StartsWith(string.Format("Validatie van '{0}' beëindigd om: ", calculationName), messages[1]);
-                    StringAssert.StartsWith(string.Format("Berekening van '{0}' gestart om: ", calculationName), messages[2]);
+                    StringAssert.StartsWith($"Validatie van '{calculationName}' gestart om: ", messages[0]);
+                    StringAssert.StartsWith($"Validatie van '{calculationName}' beëindigd om: ", messages[1]);
+                    StringAssert.StartsWith($"Berekening van '{calculationName}' gestart om: ", messages[2]);
                     StringAssert.StartsWith("Golfhoogte berekening is uitgevoerd op de tijdelijke locatie", messages[3]);
-                    StringAssert.StartsWith(string.Format("Berekening van '{0}' beëindigd om: ", calculationName), messages[4]);
+                    StringAssert.StartsWith($"Berekening van '{calculationName}' beëindigd om: ", messages[4]);
                 });
                 var waveHeightCalculationInput = testWaveHeightCalculator.ReceivedInputs.First();
 
@@ -258,7 +258,7 @@
             {
                 var testWaveHeightCalculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).WaveHeightCalculator;
                 testWaveHeightCalculator.WaveHeight = expectedWaveHeight;
-                testWaveHeightCalculator.ReliabilityIndex = StatisticsConverter.ProbabilityToReliability(norm);
+                testWaveHeightCalculator.Converged = true;
 
                 // Call
                 activity.Run();
@@ -346,7 +346,7 @@
             using (new HydraRingCalculatorFactoryConfig())
             {
                 var calculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).WaveHeightCalculator;
-                calculator.ReliabilityIndex = 3;
+                calculator.Converged = false;
 
                 // Call
                 Action call = () => activity.Run();
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs
===================================================================
diff -u -r4f62ac1a7379ebe7de146b9cd3e4bbe485a1949f -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs	(.../GrassCoverErosionInwardsCalculationService.cs)	(revision 4f62ac1a7379ebe7de146b9cd3e4bbe485a1949f)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs	(.../GrassCoverErosionInwardsCalculationService.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -178,8 +178,7 @@
             var reliability = dikeHeightCalculator.ReliabilityIndex;
             var probability = StatisticsConverter.ReliabilityToProbability(reliability);
 
-            CalculationConvergence converged = RingtoetsCommonDataCalculationService.CalculationConverged(
-                reliability, targetProbability);
+            CalculationConvergence converged = RingtoetsCommonDataCalculationService.CalculationConverged(dikeHeightCalculator.Converged);
 
             if (converged != CalculationConvergence.CalculatedConverged)
             {
Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Forms.Test/TreeNodeInfos/GrassCoverErosionOutwardsDesignWaterLevelLocationsContextTreeNodeInfoTest.cs
===================================================================
diff -u -r0981b22c56801334d3f71343f1a861070a404e3e -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Forms.Test/TreeNodeInfos/GrassCoverErosionOutwardsDesignWaterLevelLocationsContextTreeNodeInfoTest.cs	(.../GrassCoverErosionOutwardsDesignWaterLevelLocationsContextTreeNodeInfoTest.cs)	(revision 0981b22c56801334d3f71343f1a861070a404e3e)
+++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Forms.Test/TreeNodeInfos/GrassCoverErosionOutwardsDesignWaterLevelLocationsContextTreeNodeInfoTest.cs	(.../GrassCoverErosionOutwardsDesignWaterLevelLocationsContextTreeNodeInfoTest.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -433,8 +433,7 @@
                         Action action = () => contextMenuAdapter.Items[contextMenuRunDesignWaterLevelCalculationsIndex].PerformClick();
 
                         // Then
-                        string message = string.Format("Berekeningen konden niet worden gestart. Fout bij het lezen van bestand '{0}': het bestand bestaat niet.",
-                                                       filePath);
+                        string message = $"Berekeningen konden niet worden gestart. Fout bij het lezen van bestand '{filePath}': het bestand bestaat niet.";
                         TestHelper.AssertLogMessageWithLevelIsGenerated(action, new Tuple<string, LogLevelConstant>(message, LogLevelConstant.Error));
 
                         Assert.IsNaN(grassCoverErosionOutwardsHydraulicBoundaryLocation1.DesignWaterLevel); // No result set
@@ -482,6 +481,9 @@
                     using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
                     using (new HydraRingCalculatorFactoryConfig())
                     {
+                        var testDesignWaterLevelCalculator = ((TestHydraRingCalculatorFactory)HydraRingCalculatorFactory.Instance).DesignWaterLevelCalculator;
+                        testDesignWaterLevelCalculator.Converged = false;
+
                         // When
                         Action call = () => contextMenuAdapter.Items[contextMenuRunDesignWaterLevelCalculationsIndex].PerformClick();
 
@@ -490,20 +492,14 @@
                         {
                             var msgs = messages.ToArray();
                             Assert.AreEqual(7, msgs.Length);
-                            StringAssert.StartsWith(string.Format("Validatie van 'Waterstand bij doorsnede-eis voor locatie '{0}'' gestart om: ",
-                                                                  hydraulicBoundaryLocation.Name), msgs[0]);
-                            StringAssert.StartsWith(string.Format("Validatie van 'Waterstand bij doorsnede-eis voor locatie '{0}'' beëindigd om: ",
-                                                                  hydraulicBoundaryLocation.Name), msgs[1]);
-                            StringAssert.StartsWith(string.Format("Berekening van 'Waterstand bij doorsnede-eis voor locatie '{0}'' gestart om: ",
-                                                                  hydraulicBoundaryLocation.Name), msgs[2]);
-                            Assert.AreEqual(string.Format("Waterstand bij doorsnede-eis berekening voor locatie '{0}' is niet geconvergeerd.",
-                                                          hydraulicBoundaryLocation.Name), msgs[3]);
+                            StringAssert.StartsWith($"Validatie van 'Waterstand bij doorsnede-eis voor locatie '{hydraulicBoundaryLocation.Name}'' gestart om: ", msgs[0]);
+                            StringAssert.StartsWith($"Validatie van 'Waterstand bij doorsnede-eis voor locatie '{hydraulicBoundaryLocation.Name}'' beëindigd om: ", msgs[1]);
+                            StringAssert.StartsWith($"Berekening van 'Waterstand bij doorsnede-eis voor locatie '{hydraulicBoundaryLocation.Name}'' gestart om: ", msgs[2]);
+                            Assert.AreEqual($"Waterstand bij doorsnede-eis berekening voor locatie '{hydraulicBoundaryLocation.Name}' is niet geconvergeerd.", msgs[3]);
                             StringAssert.StartsWith("Toetspeil berekening is uitgevoerd op de tijdelijke locatie",
                                                     msgs[4]);
-                            StringAssert.StartsWith(string.Format("Berekening van 'Waterstand bij doorsnede-eis voor locatie '{0}'' beëindigd om: ",
-                                                                  hydraulicBoundaryLocation.Name), msgs[5]);
-                            StringAssert.AreNotEqualIgnoringCase(string.Format("Uitvoeren van '{0}' is gelukt.",
-                                                                               hydraulicBoundaryLocation.Name), msgs[6]);
+                            StringAssert.StartsWith($"Berekening van 'Waterstand bij doorsnede-eis voor locatie '{hydraulicBoundaryLocation.Name}'' beëindigd om: ", msgs[5]);
+                            StringAssert.AreNotEqualIgnoringCase($"Uitvoeren van '{hydraulicBoundaryLocation.Name}' is gelukt.", msgs[6]);
                         });
                         Assert.AreEqual(0, hydraulicBoundaryLocation.DesignWaterLevel,
                                         hydraulicBoundaryLocation.DesignWaterLevel.GetAccuracy());
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/HydraRing/RingComputation.exe
===================================================================
diff -u -r335f22bf291368f3339c22ca40d295d3aea726de -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
Binary files differ
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/HydraRing/hydraring_computation.dll
===================================================================
diff -u -r335f22bf291368f3339c22ca40d295d3aea726de -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
Binary files differ
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj
===================================================================
diff -u -r6fa1bd13de71a612bbb0abcee6df366e7a318943 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj	(.../Ringtoets.Integration.Forms.Test.csproj)	(revision 6fa1bd13de71a612bbb0abcee6df366e7a318943)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj	(.../Ringtoets.Integration.Forms.Test.csproj)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -203,6 +203,10 @@
       <Project>{BF753DB5-973B-4ADF-B0F6-9437325C3466}</Project>
       <Name>Ringtoets.GrassCoverErosionInwards.Data.TestUtil</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\HydraRing\src\Ringtoets.HydraRing.Calculation\Ringtoets.HydraRing.Calculation.csproj">
+      <Project>{888D4097-8BC2-4703-9FB1-8744C94D525E}</Project>
+      <Name>Ringtoets.HydraRing.Calculation</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\HydraRing\test\Ringtoets.HydraRing.Calculation.TestUtil\Ringtoets.HydraRing.Calculation.TestUtil.csproj">
       <Project>{74CBA865-9338-447F-BAD9-28312446AE84}</Project>
       <Name>Ringtoets.HydraRing.Calculation.TestUtil</Name>
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/DesignWaterLevelLocationsContextTreeNodeInfoTest.cs
===================================================================
diff -u -r19db52c6c2776ade0a18342b78f1d64f809ce9d7 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/DesignWaterLevelLocationsContextTreeNodeInfoTest.cs	(.../DesignWaterLevelLocationsContextTreeNodeInfoTest.cs)	(revision 19db52c6c2776ade0a18342b78f1d64f809ce9d7)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/DesignWaterLevelLocationsContextTreeNodeInfoTest.cs	(.../DesignWaterLevelLocationsContextTreeNodeInfoTest.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -38,6 +38,7 @@
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.TestUtil.Calculator;
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Forms.PresentationObjects;
@@ -290,8 +291,7 @@
                         Action action = () => contextMenuAdapter.Items[contextMenuRunAssessmentLevelCalculationsIndex].PerformClick();
 
                         // Then
-                        string message = string.Format("Berekeningen konden niet worden gestart. Fout bij het lezen van bestand '{0}': het bestand bestaat niet.",
-                                                       hydraulicBoundaryDatabase.FilePath);
+                        string message = $"Berekeningen konden niet worden gestart. Fout bij het lezen van bestand '{hydraulicBoundaryDatabase.FilePath}': het bestand bestaat niet.";
                         TestHelper.AssertLogMessageWithLevelIsGenerated(action, new Tuple<string, LogLevelConstant>(message, LogLevelConstant.Error));
 
                         Assert.IsNaN(hydraulicBoundaryLocation1.DesignWaterLevel); // No result set
@@ -347,6 +347,9 @@
                     using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
                     using (new HydraRingCalculatorFactoryConfig())
                     {
+                        var testDesignWaterLevelCalculator = ((TestHydraRingCalculatorFactory)HydraRingCalculatorFactory.Instance).DesignWaterLevelCalculator;
+                        testDesignWaterLevelCalculator.Converged = false;
+
                         // When
                         Action call = () => contextMenuAdapter.Items[contextMenuRunAssessmentLevelCalculationsIndex].PerformClick();
 
@@ -355,13 +358,13 @@
                         {
                             var msgs = messages.ToArray();
                             Assert.AreEqual(7, msgs.Length);
-                            StringAssert.StartsWith(string.Format("Validatie van 'Toetspeil berekenen voor locatie '{0}'' gestart om:", location.Name), msgs[0]);
-                            StringAssert.StartsWith(string.Format("Validatie van 'Toetspeil berekenen voor locatie '{0}'' beëindigd om:", location.Name), msgs[1]);
-                            StringAssert.StartsWith(string.Format("Berekening van 'Toetspeil berekenen voor locatie '{0}'' gestart om:", location.Name), msgs[2]);
-                            StringAssert.StartsWith(string.Format("Toetspeil berekening voor locatie {0} is niet geconvergeerd.", location.Name), msgs[3]);
+                            StringAssert.StartsWith($"Validatie van 'Toetspeil berekenen voor locatie '{location.Name}'' gestart om:", msgs[0]);
+                            StringAssert.StartsWith($"Validatie van 'Toetspeil berekenen voor locatie '{location.Name}'' beëindigd om:", msgs[1]);
+                            StringAssert.StartsWith($"Berekening van 'Toetspeil berekenen voor locatie '{location.Name}'' gestart om:", msgs[2]);
+                            StringAssert.StartsWith($"Toetspeil berekening voor locatie {location.Name} is niet geconvergeerd.", msgs[3]);
                             StringAssert.StartsWith("Toetspeil berekening is uitgevoerd op de tijdelijke locatie", msgs[4]);
-                            StringAssert.StartsWith(string.Format("Berekening van 'Toetspeil berekenen voor locatie '{0}'' beëindigd om:", location.Name), msgs[5]);
-                            StringAssert.StartsWith(string.Format("Uitvoeren van 'Toetspeil berekenen voor locatie '{0}'' is gelukt.", location.Name), msgs[6]);
+                            StringAssert.StartsWith($"Berekening van 'Toetspeil berekenen voor locatie '{location.Name}'' beëindigd om:", msgs[5]);
+                            StringAssert.StartsWith($"Uitvoeren van 'Toetspeil berekenen voor locatie '{location.Name}'' is gelukt.", msgs[6]);
                         });
                         Assert.AreEqual(0, location.DesignWaterLevel, location.DesignWaterLevel.GetAccuracy());
                         Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, location.DesignWaterLevelCalculationConvergence);
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/WaveHeightLocationsContextTreeNodeInfoTest.cs
===================================================================
diff -u -r533cfb6b8d9c3e198204d1c6ee022b79049e6d43 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/WaveHeightLocationsContextTreeNodeInfoTest.cs	(.../WaveHeightLocationsContextTreeNodeInfoTest.cs)	(revision 533cfb6b8d9c3e198204d1c6ee022b79049e6d43)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/WaveHeightLocationsContextTreeNodeInfoTest.cs	(.../WaveHeightLocationsContextTreeNodeInfoTest.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -38,6 +38,7 @@
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.TestUtil.Calculator;
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Forms.PresentationObjects;
@@ -336,8 +337,7 @@
                         Action action = () => contextMenuAdapter.Items[contextMenuRunWaveHeightCalculationsIndex].PerformClick();
 
                         // Then
-                        string message = string.Format("Berekeningen konden niet worden gestart. Fout bij het lezen van bestand '{0}': het bestand bestaat niet.",
-                                                       hydraulicBoundaryDatabase.FilePath);
+                        string message = $"Berekeningen konden niet worden gestart. Fout bij het lezen van bestand '{hydraulicBoundaryDatabase.FilePath}': het bestand bestaat niet.";
                         TestHelper.AssertLogMessageWithLevelIsGenerated(action, new Tuple<string, LogLevelConstant>(message, LogLevelConstant.Error));
 
                         Assert.IsNaN(hydraulicBoundaryLocation1.WaveHeight); // No result set
@@ -395,6 +395,9 @@
                     using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
                     using (new HydraRingCalculatorFactoryConfig())
                     {
+                        var testWaveHeightCalculator = ((TestHydraRingCalculatorFactory)HydraRingCalculatorFactory.Instance).WaveHeightCalculator;
+                        testWaveHeightCalculator.Converged = false;
+
                         // When
                         Action action = () => contextMenuAdapter.Items[contextMenuRunWaveHeightCalculationsIndex].PerformClick();
 
@@ -403,13 +406,13 @@
                         {
                             var msgs = messages.ToArray();
                             Assert.AreEqual(7, msgs.Length);
-                            StringAssert.StartsWith(string.Format("Validatie van 'Golfhoogte berekenen voor locatie '{0}'' gestart om:", locationName), msgs[0]);
-                            StringAssert.StartsWith(string.Format("Validatie van 'Golfhoogte berekenen voor locatie '{0}'' beëindigd om:", locationName), msgs[1]);
-                            StringAssert.StartsWith(string.Format("Berekening van 'Golfhoogte berekenen voor locatie '{0}'' gestart om:", locationName), msgs[2]);
-                            StringAssert.StartsWith(string.Format("Golfhoogte berekening voor locatie {0} is niet geconvergeerd.", locationName), msgs[3]);
+                            StringAssert.StartsWith($"Validatie van 'Golfhoogte berekenen voor locatie '{locationName}'' gestart om:", msgs[0]);
+                            StringAssert.StartsWith($"Validatie van 'Golfhoogte berekenen voor locatie '{locationName}'' beëindigd om:", msgs[1]);
+                            StringAssert.StartsWith($"Berekening van 'Golfhoogte berekenen voor locatie '{locationName}'' gestart om:", msgs[2]);
+                            StringAssert.StartsWith($"Golfhoogte berekening voor locatie {locationName} is niet geconvergeerd.", msgs[3]);
                             StringAssert.StartsWith("Golfhoogte berekening is uitgevoerd op de tijdelijke locatie", msgs[4]);
-                            StringAssert.StartsWith(string.Format("Berekening van 'Golfhoogte berekenen voor locatie '{0}'' beëindigd om:", locationName), msgs[5]);
-                            StringAssert.StartsWith(string.Format("Uitvoeren van 'Golfhoogte berekenen voor locatie '{0}'' is gelukt.", locationName), msgs[6]);
+                            StringAssert.StartsWith($"Berekening van 'Golfhoogte berekenen voor locatie '{locationName}'' beëindigd om:", msgs[5]);
+                            StringAssert.StartsWith($"Uitvoeren van 'Golfhoogte berekenen voor locatie '{locationName}'' is gelukt.", msgs[6]);
                         });
                         Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, location.WaveHeightCalculationConvergence);
                     }
Index: Ringtoets/Revetment/src/Ringtoets.Revetment.Service/WaveConditionsCalculationServiceBase.cs
===================================================================
diff -u -r9063c3c60f936760953c52185b72f0cb2dce9bf8 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Revetment/src/Ringtoets.Revetment.Service/WaveConditionsCalculationServiceBase.cs	(.../WaveConditionsCalculationServiceBase.cs)	(revision 9063c3c60f936760953c52185b72f0cb2dce9bf8)
+++ Ringtoets/Revetment/src/Ringtoets.Revetment.Service/WaveConditionsCalculationServiceBase.cs	(.../WaveConditionsCalculationServiceBase.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -234,7 +234,8 @@
                                                                               calculator.WaveAngle,
                                                                               calculator.WaveDirection,
                                                                               norm,
-                                                                              calculator.ReliabilityIndex);
+                                                                              calculator.ReliabilityIndex,
+                                                                              calculator.Converged);
                 return output;
             }
             catch (HydraRingFileParserException)
Index: Ringtoets/Revetment/src/Ringtoets.Revetment.Service/WaveConditionsService.cs
===================================================================
diff -u -re182f6f394aa75e739467a77e7bcacd9a8b25429 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Revetment/src/Ringtoets.Revetment.Service/WaveConditionsService.cs	(.../WaveConditionsService.cs)	(revision e182f6f394aa75e739467a77e7bcacd9a8b25429)
+++ Ringtoets/Revetment/src/Ringtoets.Revetment.Service/WaveConditionsService.cs	(.../WaveConditionsService.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -41,17 +41,16 @@
         /// <param name="waveDirection">The calculated wave direction w.r.t. North.</param>
         /// <param name="norm">The target norm to calculate for.</param>
         /// <param name="calculatedReliability">The calculated reliability.</param>
+        /// <param name="calculatedConvergence">The calculated convergence value.</param>
         /// <returns>The calculated <see cref="WaveConditionsOutput"/>.</returns>
-        public static WaveConditionsOutput Calculate(double waterLevel, double waveHeight, double wavePeakPeriod,
-                                                     double waveAngle, double waveDirection,
-                                                     double norm, double calculatedReliability)
+        public static WaveConditionsOutput Calculate(double waterLevel, double waveHeight, double wavePeakPeriod, double waveAngle, double waveDirection, double norm, double calculatedReliability, bool? calculatedConvergence)
         {
             double targetReliability = StatisticsConverter.ProbabilityToReliability(norm);
             double targetProbability = StatisticsConverter.ReliabilityToProbability(targetReliability);
 
             double calculatedProbability = StatisticsConverter.ReliabilityToProbability(calculatedReliability);
 
-            CalculationConvergence convergence = RingtoetsCommonDataCalculationService.CalculationConverged(calculatedReliability, norm);
+            CalculationConvergence convergence = RingtoetsCommonDataCalculationService.CalculationConverged(calculatedConvergence);
 
             return new WaveConditionsOutput(waterLevel, waveHeight, wavePeakPeriod, waveAngle, waveDirection, targetProbability,
                                             targetReliability, calculatedProbability, calculatedReliability, convergence);
Index: Ringtoets/Revetment/test/Ringtoets.Revetment.Service.Test/WaveConditionsServiceTest.cs
===================================================================
diff -u -re182f6f394aa75e739467a77e7bcacd9a8b25429 -ra19c5c366cdc06eb5872ee9a78c4db1fd72564a1
--- Ringtoets/Revetment/test/Ringtoets.Revetment.Service.Test/WaveConditionsServiceTest.cs	(.../WaveConditionsServiceTest.cs)	(revision e182f6f394aa75e739467a77e7bcacd9a8b25429)
+++ Ringtoets/Revetment/test/Ringtoets.Revetment.Service.Test/WaveConditionsServiceTest.cs	(.../WaveConditionsServiceTest.cs)	(revision a19c5c366cdc06eb5872ee9a78c4db1fd72564a1)
@@ -42,43 +42,32 @@
 
             // Call 
             WaveConditionsOutput output = WaveConditionsService.Calculate(waterLevel, waveHeight, wavePeakPeriod,
-                                                                          waveAngle, waveDirection, double.MinValue, double.NaN);
+                                                                          waveAngle, waveDirection, double.MinValue, double.NaN, null);
 
             // Assert
             Assert.AreEqual(waterLevel, output.WaterLevel, output.WaterLevel.GetAccuracy());
             Assert.AreEqual(waveHeight, output.WaveHeight, output.WaveHeight.GetAccuracy());
             Assert.AreEqual(wavePeakPeriod, output.WavePeakPeriod, output.WavePeakPeriod.GetAccuracy());
             Assert.AreEqual(waveAngle, output.WaveAngle, output.WaveAngle.GetAccuracy());
             Assert.AreEqual(waveDirection, output.WaveDirection, output.WaveDirection.GetAccuracy());
+            Assert.AreEqual(CalculationConvergence.NotCalculated, output.CalculationConvergence);
         }
 
         [Test]
-        public void CalculationConverged_WithConvergedResults_CalculationConvergedTrue()
+        [TestCase(true, CalculationConvergence.CalculatedConverged)]
+        [TestCase(false, CalculationConvergence.CalculatedNotConverged)]
+        [TestCase(null, CalculationConvergence.NotCalculated)]
+        public void CalculationConverged_WithConvergedResults_CalculationConvergedTrue(bool? convergence, CalculationConvergence expectedConvergence)
         {
-            // Setup
-            const double norm = 0.001;
-            double calculatedReliability = StatisticsConverter.ProbabilityToReliability(norm);
-
             // Call
             WaveConditionsOutput output = WaveConditionsService.Calculate(double.NaN, double.NaN, double.NaN, double.NaN,
-                                                                          double.NaN, norm, calculatedReliability);
+                                                                          double.NaN, double.NaN, double.NaN, convergence);
 
             // Assert
-            Assert.AreEqual(CalculationConvergence.CalculatedConverged, output.CalculationConvergence);
+            Assert.AreEqual(expectedConvergence, output.CalculationConvergence);
         }
 
         [Test]
-        public void CalculationConverged_WithoutConvergedResults_CalculationConvergedFalse()
-        {
-            // Call 
-            WaveConditionsOutput output = WaveConditionsService.Calculate(double.NaN, double.NaN, double.NaN, double.NaN,
-                                                                          double.NaN, 1, 5.0e-3);
-
-            // Assert
-            Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, output.CalculationConvergence);
-        }
-
-        [Test]
         [TestCase(1.1, -1.335177736118940)]
         [TestCase(3000, 3.402932835385330)]
         [TestCase(20000, 3.890591886413120)]
@@ -93,7 +82,7 @@
 
             // Call 
             WaveConditionsOutput output = WaveConditionsService.Calculate(double.NaN, double.NaN, double.NaN, double.NaN,
-                                                                          double.NaN, norm, double.NaN);
+                                                                          double.NaN, norm, double.NaN, null);
 
             // Assert
             Assert.AreEqual(expectedReliability, output.TargetReliability, output.TargetReliability.GetAccuracy());
@@ -114,7 +103,7 @@
 
             // Call 
             WaveConditionsOutput output = WaveConditionsService.Calculate(double.NaN, double.NaN, double.NaN, double.NaN,
-                                                                          double.NaN, norm, double.NaN);
+                                                                          double.NaN, norm, double.NaN, null);
 
             // Assert
             Assert.AreEqual(expectedProbability, output.TargetProbability, 1e-6);
@@ -127,7 +116,7 @@
         {
             // Call 
             WaveConditionsOutput output = WaveConditionsService.Calculate(double.NaN, double.NaN, double.NaN, double.NaN,
-                                                                          double.NaN, double.MinValue, reliability);
+                                                                          double.NaN, double.MinValue, reliability, null);
 
             // Assert
             Assert.AreEqual(expectedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy());
@@ -145,7 +134,7 @@
         {
             // Call 
             WaveConditionsOutput output = WaveConditionsService.Calculate(double.NaN, double.NaN, double.NaN, double.NaN,
-                                                                          double.NaN, double.MinValue, reliability);
+                                                                          double.NaN, double.MinValue, reliability, null);
 
             // Assert
             Assert.AreEqual(expectedProbability, output.CalculatedProbability, 1e-6);