Index: Riskeer/Common/src/Riskeer.Common.Data/Contribution/FailureMechanismContribution.cs
===================================================================
diff -u -r391d022746e1bd895983935af75594fd3b1912d4 -r948224ba18427dc94d0d4bbaf77f57f9f601a5b2
--- Riskeer/Common/src/Riskeer.Common.Data/Contribution/FailureMechanismContribution.cs	(.../FailureMechanismContribution.cs)	(revision 391d022746e1bd895983935af75594fd3b1912d4)
+++ Riskeer/Common/src/Riskeer.Common.Data/Contribution/FailureMechanismContribution.cs	(.../FailureMechanismContribution.cs)	(revision 948224ba18427dc94d0d4bbaf77f57f9f601a5b2)
@@ -32,7 +32,7 @@
     /// </summary>
     public class FailureMechanismContribution : Observable
     {
-        private static readonly Range<double> normValidityRange = new Range<double>(1.0 / 1000000, 1.0 / 10);
+        private static readonly Range<double> floodingProbabilityValidityRange = new Range<double>(1.0 / 1000000, 1.0 / 10);
 
         private double maximumAllowableFloodingProbability;
         private double signalFloodingProbability;
@@ -51,7 +51,7 @@
         /// </exception>
         public FailureMechanismContribution(double maximumAllowableFloodingProbability, double signalFloodingProbability)
         {
-            ValidateNorms(signalFloodingProbability, maximumAllowableFloodingProbability);
+            ValidateProbabilities(signalFloodingProbability, maximumAllowableFloodingProbability);
 
             this.maximumAllowableFloodingProbability = maximumAllowableFloodingProbability;
             this.signalFloodingProbability = signalFloodingProbability;
@@ -71,7 +71,7 @@
             get => signalFloodingProbability;
             set
             {
-                ValidateNorms(value, maximumAllowableFloodingProbability);
+                ValidateProbabilities(value, maximumAllowableFloodingProbability);
 
                 signalFloodingProbability = value;
             }
@@ -90,7 +90,7 @@
             get => maximumAllowableFloodingProbability;
             set
             {
-                ValidateNorm(value);
+                ValidateProbability(value);
 
                 if (value < signalFloodingProbability)
                 {
@@ -124,43 +124,43 @@
         public NormativeProbabilityType NormativeProbabilityType { get; set; }
 
         /// <summary>
-        /// Validates the norm value;
+        /// Validates the probability;
         /// </summary>
         /// <param name="value">The value to validate.</param>
         /// <exception cref="ArgumentOutOfRangeException">Thrown when the new value is not in 
         /// the interval [0.000001, 0.1] or is <see cref="double.NaN"/>.</exception>
-        private static void ValidateNorm(double value)
+        private static void ValidateProbability(double value)
         {
-            if (!normValidityRange.InRange(value))
+            if (!floodingProbabilityValidityRange.InRange(value))
             {
                 string message = string.Format(Resources.Norm_should_be_in_Range_0_,
-                                               normValidityRange.ToString(FormattableConstants.ShowAtLeastOneDecimal, CultureInfo.CurrentCulture));
+                                               floodingProbabilityValidityRange.ToString(FormattableConstants.ShowAtLeastOneDecimal, CultureInfo.CurrentCulture));
                 throw new ArgumentOutOfRangeException(nameof(value), value, message);
             }
         }
 
         /// <summary>
-        /// Validates the norm values.
+        /// Validates the probabilities.
         /// </summary>
-        /// <param name="signalingNormValue">The signaling norm to validate.</param>
-        /// <param name="lowerLimitNormValue">The lower limit norm to validate against.</param>
+        /// <param name="signalFloodingProbability">The signal flooding probability  to validate.</param>
+        /// <param name="maximumAllowableFloodingProbability">The maximum allowable flooding probability to validate against.</param>
         /// <exception cref="ArgumentOutOfRangeException">Thrown when:
         /// <list type="bullet">
-        /// <item><paramref name="lowerLimitNormValue"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
-        /// <item><paramref name="signalingNormValue"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
-        /// <item>The <paramref name="signalingNormValue"/> is larger than <paramref name="lowerLimitNormValue"/>.</item>
+        /// <item><paramref name="maximumAllowableFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
+        /// <item><paramref name="signalFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
+        /// <item>The <paramref name="signalFloodingProbability"/> is larger than <paramref name="maximumAllowableFloodingProbability"/>.</item>
         /// </list>
         /// </exception>
-        private static void ValidateNorms(double signalingNormValue,
-                                          double lowerLimitNormValue)
+        private static void ValidateProbabilities(double signalFloodingProbability,
+                                                  double maximumAllowableFloodingProbability)
         {
-            ValidateNorm(signalingNormValue);
-            ValidateNorm(lowerLimitNormValue);
+            ValidateProbability(signalFloodingProbability);
+            ValidateProbability(maximumAllowableFloodingProbability);
 
-            if (signalingNormValue > lowerLimitNormValue)
+            if (signalFloodingProbability > maximumAllowableFloodingProbability)
             {
-                throw new ArgumentOutOfRangeException(nameof(signalingNormValue),
-                                                      signalingNormValue,
+                throw new ArgumentOutOfRangeException(nameof(signalFloodingProbability),
+                                                      signalFloodingProbability,
                                                       Resources.FailureMechanismContribution_SignalFloodingProbability_should_be_same_or_smaller_than_MaximumAllowableFloodingProbability);
             }
         }
Index: Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/AssessmentSectionAssemblyGroupBoundariesFactoryTest.cs
===================================================================
diff -u -rec1498df715811275418ab822d8c9334adae3a69 -r948224ba18427dc94d0d4bbaf77f57f9f601a5b2
--- Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/AssessmentSectionAssemblyGroupBoundariesFactoryTest.cs	(.../AssessmentSectionAssemblyGroupBoundariesFactoryTest.cs)	(revision ec1498df715811275418ab822d8c9334adae3a69)
+++ Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/AssessmentSectionAssemblyGroupBoundariesFactoryTest.cs	(.../AssessmentSectionAssemblyGroupBoundariesFactoryTest.cs)	(revision 948224ba18427dc94d0d4bbaf77f57f9f601a5b2)
@@ -40,20 +40,20 @@
         {
             // Setup
             var random = new Random(11);
-            double signalingNorm = random.NextDouble();
-            double lowerLimitNorm = random.NextDouble();
+            double signalFloodingProbability = random.NextDouble();
+            double maximumAllowableFloodingProbability = random.NextDouble();
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
                 var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
                 AssessmentSectionAssemblyGroupBoundariesCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyGroupBoundariesCalculator;
 
                 // Call
-                AssessmentSectionAssemblyGroupBoundariesFactory.CreateAssessmentSectionAssemblyGroupBoundaries(signalingNorm, lowerLimitNorm);
+                AssessmentSectionAssemblyGroupBoundariesFactory.CreateAssessmentSectionAssemblyGroupBoundaries(signalFloodingProbability, maximumAllowableFloodingProbability);
 
                 // Assert
-                Assert.AreEqual(signalingNorm, calculator.SignalFloodingProbability);
-                Assert.AreEqual(lowerLimitNorm, calculator.MaximumAllowableFloodingProbability);
+                Assert.AreEqual(signalFloodingProbability, calculator.SignalFloodingProbability);
+                Assert.AreEqual(maximumAllowableFloodingProbability, calculator.MaximumAllowableFloodingProbability);
             }
         }
 
@@ -62,16 +62,16 @@
         {
             // Setup
             var random = new Random(11);
-            double signalingNorm = random.NextDouble();
-            double lowerLimitNorm = random.NextDouble();
+            double signalFloodingProbability = random.NextDouble();
+            double maximumAllowableFloodingProbability = random.NextDouble();
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
                 var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
                 AssessmentSectionAssemblyGroupBoundariesCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyGroupBoundariesCalculator;
 
                 // Call
-                AssessmentSectionAssemblyGroupBoundaries[] output = AssessmentSectionAssemblyGroupBoundariesFactory.CreateAssessmentSectionAssemblyGroupBoundaries(signalingNorm, lowerLimitNorm).ToArray();
+                AssessmentSectionAssemblyGroupBoundaries[] output = AssessmentSectionAssemblyGroupBoundariesFactory.CreateAssessmentSectionAssemblyGroupBoundaries(signalFloodingProbability, maximumAllowableFloodingProbability).ToArray();
 
                 // Assert
                 AssessmentSectionAssemblyGroupBoundaries[] calculatorOutput = calculator.AssessmentSectionAssemblyGroupBoundariesOutput.ToArray();
Index: Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupBoundariesFactoryTest.cs
===================================================================
diff -u -rfc7ea4e6dd24e0417f8a81b834933f0c88af113d -r948224ba18427dc94d0d4bbaf77f57f9f601a5b2
--- Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupBoundariesFactoryTest.cs	(.../FailureMechanismSectionAssemblyGroupBoundariesFactoryTest.cs)	(revision fc7ea4e6dd24e0417f8a81b834933f0c88af113d)
+++ Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupBoundariesFactoryTest.cs	(.../FailureMechanismSectionAssemblyGroupBoundariesFactoryTest.cs)	(revision 948224ba18427dc94d0d4bbaf77f57f9f601a5b2)
@@ -40,20 +40,20 @@
         {
             // Setup
             var random = new Random(11);
-            double signalingNorm = random.NextDouble();
-            double lowerLimitNorm = random.NextDouble();
+            double signalFloodingProbability = random.NextDouble();
+            double maximumAllowableFloodingProbability = random.NextDouble();
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
                 var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
                 FailureMechanismSectionAssemblyGroupBoundariesCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyGroupBoundariesCalculator;
 
                 // Call
-                FailureMechanismSectionAssemblyGroupBoundariesFactory.CreateFailureMechanismSectionAssemblyGroupBoundaries(signalingNorm, lowerLimitNorm);
+                FailureMechanismSectionAssemblyGroupBoundariesFactory.CreateFailureMechanismSectionAssemblyGroupBoundaries(signalFloodingProbability, maximumAllowableFloodingProbability);
 
                 // Assert
-                Assert.AreEqual(signalingNorm, calculator.SignalFloodingProbability);
-                Assert.AreEqual(lowerLimitNorm, calculator.MaximumAllowableFloodingProbability);
+                Assert.AreEqual(signalFloodingProbability, calculator.SignalFloodingProbability);
+                Assert.AreEqual(maximumAllowableFloodingProbability, calculator.MaximumAllowableFloodingProbability);
             }
         }
 
@@ -62,8 +62,8 @@
         {
             // Setup
             var random = new Random(11);
-            double signalingNorm = random.NextDouble();
-            double lowerLimitNorm = random.NextDouble();
+            double signalFloodingProbability = random.NextDouble();
+            double maximumAllowableFloodingProbability = random.NextDouble();
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
@@ -72,7 +72,7 @@
 
                 // Call
                 FailureMechanismSectionAssemblyGroupBoundaries[] output =
-                    FailureMechanismSectionAssemblyGroupBoundariesFactory.CreateFailureMechanismSectionAssemblyGroupBoundaries(signalingNorm, lowerLimitNorm)
+                    FailureMechanismSectionAssemblyGroupBoundariesFactory.CreateFailureMechanismSectionAssemblyGroupBoundaries(signalFloodingProbability, maximumAllowableFloodingProbability)
                                                       .ToArray();
 
                 // Assert
Index: Riskeer/Common/test/Riskeer.Common.Forms.Test/Helpers/TargetProbabilityCalculationsDisplayNameHelperTest.cs
===================================================================
diff -u -rd4749082335af6df65a972298b2698475b4d4959 -r948224ba18427dc94d0d4bbaf77f57f9f601a5b2
--- Riskeer/Common/test/Riskeer.Common.Forms.Test/Helpers/TargetProbabilityCalculationsDisplayNameHelperTest.cs	(.../TargetProbabilityCalculationsDisplayNameHelperTest.cs)	(revision d4749082335af6df65a972298b2698475b4d4959)
+++ Riskeer/Common/test/Riskeer.Common.Forms.Test/Helpers/TargetProbabilityCalculationsDisplayNameHelperTest.cs	(.../TargetProbabilityCalculationsDisplayNameHelperTest.cs)	(revision 948224ba18427dc94d0d4bbaf77f57f9f601a5b2)
@@ -75,15 +75,15 @@
         [TestCase(0.0025, 0.00025, 0.0025, 0.0025, "1/400")]
         [TestCase(0.0025, 0.0025, 0.0025, 0.0025, "1/400")]
         public void GetUniqueDisplayNameForWaterLevelCalculations_ValidParameters_ReturnsExpectedDisplayNameForLowerLimitNorm(
-            double lowerLimitNorm, double signalingNorm, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
+            double maximumAllowableFloodingProbability, double signalFloodingProbability, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
         {
             // Setup
             var hydraulicBoundaryLocationCalculations = new ObservableList<HydraulicBoundaryLocationCalculation>();
 
             var mockRepository = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
 
-            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(lowerLimitNorm, signalingNorm));
+            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(maximumAllowableFloodingProbability, signalFloodingProbability));
             assessmentSection.Stub(a => a.WaterLevelCalculationsForLowerLimitNorm).Return(hydraulicBoundaryLocationCalculations);
             assessmentSection.Stub(a => a.WaterLevelCalculationsForSignalingNorm).Return(new ObservableList<HydraulicBoundaryLocationCalculation>());
             assessmentSection.Stub(a => a.WaterLevelCalculationsForUserDefinedTargetProbabilities).Return(
@@ -109,15 +109,15 @@
         [TestCase(0.025, 0.0025, 0.0025, 0.0025, "1/400")]
         [TestCase(0.0025, 0.0025, 0.0025, 0.0025, "1/400 (1)")]
         public void GetUniqueDisplayNameForWaterLevelCalculations_ValidParameters_ReturnsExpectedDisplayNameForSignalingNorm(
-            double lowerLimitNorm, double signalingNorm, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
+            double maximumAllowableFloodingProbability, double signalFloodingProbability, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
         {
             // Setup
             var hydraulicBoundaryLocationCalculations = new ObservableList<HydraulicBoundaryLocationCalculation>();
 
             var mockRepository = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
 
-            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(lowerLimitNorm, signalingNorm));
+            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(maximumAllowableFloodingProbability, signalFloodingProbability));
             assessmentSection.Stub(a => a.WaterLevelCalculationsForLowerLimitNorm).Return(new ObservableList<HydraulicBoundaryLocationCalculation>());
             assessmentSection.Stub(a => a.WaterLevelCalculationsForSignalingNorm).Return(hydraulicBoundaryLocationCalculations);
             assessmentSection.Stub(a => a.WaterLevelCalculationsForUserDefinedTargetProbabilities).Return(
@@ -147,15 +147,15 @@
         [TestCase(0.0025, 0.0025, 0.025, 0.0025, "1/400 (2)")]
         [TestCase(0.0025, 0.0025, 0.0025, 0.0025, "1/400 (3)")]
         public void GetUniqueDisplayNameForWaterLevelCalculations_ValidParameters_ReturnsExpectedDisplayNameForUserDefinedTargetProbability(
-            double lowerLimitNorm, double signalingNorm, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
+            double maximumAllowableFloodingProbability, double signalFloodingProbability, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
         {
             // Setup
             var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability2);
 
             var mockRepository = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
 
-            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(lowerLimitNorm, signalingNorm));
+            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(maximumAllowableFloodingProbability, signalFloodingProbability));
             assessmentSection.Stub(a => a.WaterLevelCalculationsForLowerLimitNorm).Return(new ObservableList<HydraulicBoundaryLocationCalculation>());
             assessmentSection.Stub(a => a.WaterLevelCalculationsForSignalingNorm).Return(new ObservableList<HydraulicBoundaryLocationCalculation>());
             assessmentSection.Stub(a => a.WaterLevelCalculationsForUserDefinedTargetProbabilities).Return(