Index: Riskeer/Common/src/Riskeer.Common.Service/WaveHeightCalculationActivity.cs
===================================================================
diff -u -ra9dc04dde69e1d7b8ebc2207dc45644d3c06a4bc -rf77a46717fb97e9edff3f4392b02168e6e96475c
--- Riskeer/Common/src/Riskeer.Common.Service/WaveHeightCalculationActivity.cs	(.../WaveHeightCalculationActivity.cs)	(revision a9dc04dde69e1d7b8ebc2207dc45644d3c06a4bc)
+++ Riskeer/Common/src/Riskeer.Common.Service/WaveHeightCalculationActivity.cs	(.../WaveHeightCalculationActivity.cs)	(revision f77a46717fb97e9edff3f4392b02168e6e96475c)
@@ -30,7 +30,7 @@
     /// </summary>
     internal class WaveHeightCalculationActivity : CalculatableActivity
     {
-        private readonly double norm;
+        private readonly double targetProbability;
         private readonly HydraulicBoundaryCalculationSettings calculationSettings;
         private readonly ICalculationMessageProvider messageProvider;
         private readonly WaveHeightCalculationService calculationService;
@@ -42,14 +42,14 @@
         /// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation to perform.</param>
         /// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
         /// hydraulic boundary calculation settings.</param>
-        /// <param name="norm">The norm to use during the calculation.</param>
+        /// <param name="targetProbability">The target probability to use during the calculation.</param>
         /// <param name="calculationIdentifier">The calculation identifier to use in all messages.</param>
         /// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculation"/> is <c>null</c>.</exception>
         /// <exception cref="ArgumentException">Thrown when <paramref name="calculationIdentifier"/> is <c>null</c> or empty.</exception>
         public WaveHeightCalculationActivity(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
                                              HydraulicBoundaryCalculationSettings calculationSettings,
-                                             double norm,
+                                             double targetProbability,
                                              string calculationIdentifier)
             : base(hydraulicBoundaryLocationCalculation)
         {
@@ -62,7 +62,7 @@
 
             this.hydraulicBoundaryLocationCalculation = hydraulicBoundaryLocationCalculation;
             this.calculationSettings = calculationSettings;
-            this.norm = norm;
+            this.targetProbability = targetProbability;
 
             calculationService = new WaveHeightCalculationService();
 
@@ -71,14 +71,14 @@
 
         protected override bool Validate()
         {
-            return calculationService.Validate(calculationSettings, norm);
+            return calculationService.Validate(calculationSettings, targetProbability);
         }
 
         protected override void PerformCalculation()
         {
             calculationService.Calculate(hydraulicBoundaryLocationCalculation,
                                          calculationSettings,
-                                         norm,
+                                         targetProbability,
                                          messageProvider);
         }
 
Index: Riskeer/Common/test/Riskeer.Common.Service.Test/WaveHeightCalculationActivityTest.cs
===================================================================
diff -u -rbc647a8d846e81516061cc3b491e367a0c5d3ca1 -rf77a46717fb97e9edff3f4392b02168e6e96475c
--- Riskeer/Common/test/Riskeer.Common.Service.Test/WaveHeightCalculationActivityTest.cs	(.../WaveHeightCalculationActivityTest.cs)	(revision bc647a8d846e81516061cc3b491e367a0c5d3ca1)
+++ Riskeer/Common/test/Riskeer.Common.Service.Test/WaveHeightCalculationActivityTest.cs	(.../WaveHeightCalculationActivityTest.cs)	(revision f77a46717fb97e9edff3f4392b02168e6e96475c)
@@ -43,8 +43,6 @@
     [TestFixture]
     public class WaveHeightCalculationActivityTest
     {
-        private const double validNorm = 0.005;
-
         private static readonly string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.Service, "HydraRingCalculation");
         private static readonly string validHydraulicBoundaryDatabaseFilePath = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
         private static readonly string validHlcdFilePath = Path.Combine(testDataPath, "Hlcd.sqlite");
@@ -70,15 +68,11 @@
         [Test]
         public void Constructor_CalculationSettingsNull_ThrowsArgumentNullException()
         {
-            // Setup
-            const string locationName = "locationName";
-            const string calculationIdentifier = "1/200";
-
             // Call
-            void Call() => new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName)),
+            void Call() => new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation("locationName")),
                                                              null,
-                                                             validNorm,
-                                                             calculationIdentifier);
+                                                             0.01,
+                                                             "1/100");
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -90,12 +84,12 @@
         {
             // Setup
             const string locationName = "locationName";
-            const string calculationIdentifier = "1/200";
+            const string calculationIdentifier = "1/100";
 
             // Call
             var activity = new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName)),
                                                              CreateCalculationSettings(),
-                                                             validNorm,
+                                                             0.01,
                                                              calculationIdentifier);
 
             // Assert
@@ -111,15 +105,15 @@
             // Setup
             string invalidFilePath = Path.Combine(testDataPath, "notexisting.sqlite");
             const string locationName = "locationName";
-            const string calculationIdentifier = "1/200";
+            const string calculationIdentifier = "1/100";
 
             var settings = new HydraulicBoundaryCalculationSettings(invalidFilePath,
                                                                     validHlcdFilePath,
                                                                     false,
                                                                     string.Empty);
             var activity = new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName)),
                                                              settings,
-                                                             validNorm,
+                                                             0.01,
                                                              calculationIdentifier);
 
             // Call
@@ -144,22 +138,22 @@
             // Setup
             const string invalidPreprocessorDirectory = "NonExistingPreprocessorDirectory";
             const string locationName = "locationName";
-            const string calculationIdentifier = "1/200";
+            const string calculationIdentifier = "1/100";
 
             var settings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
                                                                     validHlcdFilePath,
                                                                     false,
                                                                     invalidPreprocessorDirectory);
             var activity = new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName)),
                                                              settings,
-                                                             validNorm,
+                                                             0.01,
                                                              calculationIdentifier);
 
             // Call
-            Action call = () => activity.Run();
+            void Call() => activity.Run();
 
             // Assert
-            TestHelper.AssertLogMessages(call, messages =>
+            TestHelper.AssertLogMessages(Call, messages =>
             {
                 string[] msgs = messages.ToArray();
                 Assert.AreEqual(4, msgs.Length);
@@ -172,7 +166,7 @@
         }
 
         [Test]
-        public void Run_InvalidNorm_PerformValidationAndLogStartAndEndAndError()
+        public void Run_InvalidTargetProbability_PerformValidationAndLogStartAndEndAndError()
         {
             // Setup
             const string locationName = "locationName";
@@ -206,8 +200,8 @@
         {
             // Setup
             const string locationName = "locationName";
-            const string calculationIdentifier = "1/30";
-            const double norm = 1.0 / 30;
+            const string calculationIdentifier = "1/100";
+            const double targetProbability = 0.01;
 
             var calculator = new TestWaveHeightCalculator
             {
@@ -234,7 +228,7 @@
 
             var activity = new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation),
                                                              calculationSettings,
-                                                             norm,
+                                                             targetProbability,
                                                              calculationIdentifier);
 
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
@@ -246,7 +240,7 @@
                 WaveHeightCalculationInput waveHeightCalculationInput = calculator.ReceivedInputs.Single();
 
                 Assert.AreEqual(hydraulicBoundaryLocation.Id, waveHeightCalculationInput.HydraulicBoundaryLocationId);
-                Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(norm), waveHeightCalculationInput.Beta);
+                Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), waveHeightCalculationInput.Beta);
             }
 
             Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -258,8 +252,8 @@
         {
             // Setup
             const string locationName = "locationName";
-            const string calculationIdentifier = "1/30";
-            const double norm = 1.0 / 30;
+            const string calculationIdentifier = "1/100";
+            const double targetProbability = 0.01;
 
             var calculator = new TestWaveHeightCalculator
             {
@@ -277,16 +271,16 @@
 
             var activity = new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation),
                                                              CreateCalculationSettings(),
-                                                             norm,
+                                                             targetProbability,
                                                              calculationIdentifier);
 
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
-                Action call = () => activity.Run();
+                void Call() => activity.Run();
 
                 // Assert
-                TestHelper.AssertLogMessages(call, m =>
+                TestHelper.AssertLogMessages(Call, m =>
                 {
                     string[] messages = m.ToArray();
                     Assert.AreEqual(6, messages.Length);
@@ -308,7 +302,7 @@
         public void Run_ValidCalculation_SetsWaveHeightAndConvergence(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation)
         {
             // Setup
-            const double norm = 1.0 / 30;
+            const double targetProbability = 0.01;
             const double expectedWaveHeight = 3.5;
 
             var calculator = new TestWaveHeightCalculator
@@ -331,8 +325,8 @@
 
             var activity = new WaveHeightCalculationActivity(hydraulicBoundaryLocationCalculation,
                                                              CreateCalculationSettings(),
-                                                             norm,
-                                                             "1/30");
+                                                             targetProbability,
+                                                             "1/100");
 
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
@@ -357,7 +351,7 @@
         {
             // Setup
             const string locationName = "locationName";
-            const string calculationIdentifier = "1/200";
+            const string calculationIdentifier = "1/100";
 
             var calculator = new TestWaveHeightCalculator
             {
@@ -384,7 +378,7 @@
 
             var activity = new WaveHeightCalculationActivity(hydraulicBoundaryLocationCalculation,
                                                              CreateCalculationSettings(),
-                                                             validNorm,
+                                                             0.01,
                                                              calculationIdentifier);
 
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
@@ -424,7 +418,7 @@
         {
             // Setup
             const string locationName = "locationName";
-            const string calculationIdentifier = "1/300";
+            const string calculationIdentifier = "1/100";
 
             var calculator = new TestWaveHeightCalculator
             {
@@ -448,10 +442,9 @@
                 Output = new TestHydraulicBoundaryLocationCalculationOutput(double.NaN, CalculationConvergence.CalculatedConverged)
             };
 
-            const double norm = 1.0 / 300;
             var activity = new WaveHeightCalculationActivity(hydraulicBoundaryLocationCalculation,
                                                              CreateCalculationSettings(),
-                                                             norm,
+                                                             0.01,
                                                              calculationIdentifier);
 
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
@@ -480,7 +473,7 @@
         public void Finish_ActivityWithSpecificState_NotifyHydraulicBoundaryLocationCalculation(ActivityState state)
         {
             // Setup
-            const string calculationIdentifier = "1/200";
+            const string calculationIdentifier = "1/100";
 
             var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation());
 
@@ -492,7 +485,7 @@
 
             var activity = new TestWaveHeightCalculationActivity(hydraulicBoundaryLocationCalculation,
                                                                  CreateCalculationSettings(),
-                                                                 validNorm,
+                                                                 0.01,
                                                                  calculationIdentifier,
                                                                  state);
 
@@ -520,12 +513,12 @@
         {
             public TestWaveHeightCalculationActivity(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
                                                      HydraulicBoundaryCalculationSettings calculationSettings,
-                                                     double norm,
+                                                     double targetProbability,
                                                      string calculationIdentifier,
                                                      ActivityState state)
                 : base(hydraulicBoundaryLocationCalculation,
                        calculationSettings,
-                       norm,
+                       targetProbability,
                        calculationIdentifier)
             {
                 State = state;