Index: Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Data/DuneErosionFailureMechanismExtensions.cs
===================================================================
diff -u -r330f2e86f2fb575c436cdbb46b6d31bc246ef6fc -r430632f92b4e3ca3f4634108e2e30a36d26befe9
--- Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Data/DuneErosionFailureMechanismExtensions.cs	(.../DuneErosionFailureMechanismExtensions.cs)	(revision 330f2e86f2fb575c436cdbb46b6d31bc246ef6fc)
+++ Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Data/DuneErosionFailureMechanismExtensions.cs	(.../DuneErosionFailureMechanismExtensions.cs)	(revision 430632f92b4e3ca3f4634108e2e30a36d26befe9)
@@ -20,6 +20,10 @@
 // All rights reserved.
 
 using System;
+using System.ComponentModel;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Util;
 
 namespace Ringtoets.DuneErosion.Data
 {
@@ -28,22 +32,34 @@
     /// </summary>
     public static class DuneErosionFailureMechanismExtensions
     {
+        private const double failureMechanismSpecificNormFactor = 2.15;
+
         /// <summary>
-        /// Gets the norm which is needed in the calculations within <see cref="DuneErosionFailureMechanism"/>.
+        /// Gets the norm based on <see cref="FailureMechanismCategoryType"/>.
         /// </summary>
-        /// <param name="failureMechanism">The <see cref="DuneErosionFailureMechanism"/> to get the failure mechanism norm for.</param>
-        /// <param name="norm">The assessment section norm.</param>
-        /// <returns>The value of the failure mechanism norm.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        public static double GetMechanismSpecificNorm(this DuneErosionFailureMechanism failureMechanism, double norm)
+        /// <param name="failureMechanism">The failure mechanism to get the norm from.</param>
+        /// <param name="assessmentSection">The assessment section to get the norm from.</param>
+        /// <param name="categoryType">The category type to use while obtaining the norm.</param>
+        /// <returns>The norm corresponding to the provided category type.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
+        /// or <paramref name="assessmentSection"/> is <c>null</c>.</exception>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="categoryType"/>
+        /// is an invalid <see cref="FailureMechanismCategoryType"/>.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <paramref name="categoryType"/>
+        /// is a valid but unsupported <see cref="FailureMechanismCategoryType"/>.</exception>
+        public static double GetNorm(this DuneErosionFailureMechanism failureMechanism,
+                                     IAssessmentSection assessmentSection,
+                                     FailureMechanismCategoryType categoryType)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
-            return 2.15 * (failureMechanism.Contribution / 100)
-                   * norm / failureMechanism.GeneralInput.N;
+            return failureMechanismSpecificNormFactor * FailureMechanismNormHelper.GetNorm(assessmentSection,
+                                                                                           categoryType,
+                                                                                           failureMechanism.Contribution,
+                                                                                           failureMechanism.GeneralInput.N);
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Data/Ringtoets.DuneErosion.Data.csproj
===================================================================
diff -u -rbbbfacd9e38cf43c98dba73e39694850fb932a66 -r430632f92b4e3ca3f4634108e2e30a36d26befe9
--- Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Data/Ringtoets.DuneErosion.Data.csproj	(.../Ringtoets.DuneErosion.Data.csproj)	(revision bbbfacd9e38cf43c98dba73e39694850fb932a66)
+++ Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Data/Ringtoets.DuneErosion.Data.csproj	(.../Ringtoets.DuneErosion.Data.csproj)	(revision 430632f92b4e3ca3f4634108e2e30a36d26befe9)
@@ -57,6 +57,11 @@
       <Name>Ringtoets.Common.Primitives</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Common\src\Ringtoets.Common.Util\Ringtoets.Common.Util.csproj">
+      <Project>{6a074d65-a81c-4c1c-8e24-f36c916e4ed7}</Project>
+      <Name>Ringtoets.Common.Util</Name>
+      <Private>False</Private>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Data.Test/DuneErosionFailureMechanismExtensionsTest.cs
===================================================================
diff -u -rdcc94dbcc481ef9f6f83308b82096f85f9cb6f01 -r430632f92b4e3ca3f4634108e2e30a36d26befe9
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Data.Test/DuneErosionFailureMechanismExtensionsTest.cs	(.../DuneErosionFailureMechanismExtensionsTest.cs)	(revision dcc94dbcc481ef9f6f83308b82096f85f9cb6f01)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Data.Test/DuneErosionFailureMechanismExtensionsTest.cs	(.../DuneErosionFailureMechanismExtensionsTest.cs)	(revision 430632f92b4e3ca3f4634108e2e30a36d26befe9)
@@ -20,41 +20,150 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using Core.Common.TestUtil;
 using NUnit.Framework;
+using Rhino.Mocks;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.TestUtil;
 
 namespace Ringtoets.DuneErosion.Data.Test
 {
     [TestFixture]
     public class DuneErosionFailureMechanismExtensionsTest
     {
         [Test]
-        public void GetMechanismSpecificNorm_FailureMechanismNull_ThrowArgumentNullException()
+        public void GetNorm_FailureMechanismNull_ThrowArgumentNullException()
         {
+            // Setup
+            var random = new Random(21);
+
+            var mocks = new MockRepository();
+            var assessementSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
-            TestDelegate test = () => DuneErosionFailureMechanismExtensions.GetMechanismSpecificNorm(null, 0.5);
+            TestDelegate test = () => DuneErosionFailureMechanismExtensions.GetNorm(null,
+                                                                                    assessementSection,
+                                                                                    random.NextEnumValue<FailureMechanismCategoryType>());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
             Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
         }
 
         [Test]
-        [TestCase(0, 0.005, 0)]
-        [TestCase(10, 0.005, 0.0005375)]
-        [TestCase(10, 0.01, 0.001075)]
-        public void GetMechanismSpecificNorm_WithValidData_ReturnMechanismSpecificNorm(double contribution, double norm, double expectedNorm)
+        public void GetNorm_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Setup
-            var failureMechanism = new DuneErosionFailureMechanism
-            {
-                Contribution = contribution
-            };
+            var random = new Random(21);
+            var failureMechanism = new DuneErosionFailureMechanism();
 
             // Call
-            double mechanismSpecificNorm = failureMechanism.GetMechanismSpecificNorm(norm);
+            TestDelegate call = () => failureMechanism.GetNorm(null, random.NextEnumValue<FailureMechanismCategoryType>());
 
             // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void GetNorm_InvalidFailureMechanismCategoryType_ThrowsInvalidEnumArgumentException()
+        {
+            // Setup
+            const int invalidValue = 9999;
+
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new DuneErosionFailureMechanism();
+
+            // Call
+            TestDelegate test = () => failureMechanism.GetNorm(assessmentSection,
+                                                               (FailureMechanismCategoryType) invalidValue);
+
+            // Assert
+            string expectedMessage = $"The value of argument 'categoryType' ({invalidValue}) is invalid for Enum type '{nameof(FailureMechanismCategoryType)}'.";
+            string parameterName = TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage).ParamName;
+            Assert.AreEqual("categoryType", parameterName);
+        }
+
+        [Test]
+        [TestCaseSource(nameof(GetNormConfigurationPerFailureMechanismCategoryType))]
+        public void GetNorm_WithValidData_ReturnMechanismSpecificNorm(DuneErosionFailureMechanism failureMechanism,
+                                                                      IAssessmentSection assessmentSection,
+                                                                      FailureMechanismCategoryType categoryType,
+                                                                      double expectedNorm)
+        {
+            // Call
+            double mechanismSpecificNorm = failureMechanism.GetNorm(assessmentSection, categoryType);
+
+            // Assert
             Assert.AreEqual(expectedNorm, mechanismSpecificNorm);
         }
+
+        private static IEnumerable<TestCaseData> GetNormConfigurationPerFailureMechanismCategoryType()
+        {
+            const double failureMechanismSpecificNormFactor = 2.15;
+            const double signalingNorm = 0.002;
+            const double lowerLimitNorm = 0.005;
+
+            var assessmentSection = new AssessmentSectionStub
+            {
+                FailureMechanismContribution =
+                {
+                    LowerLimitNorm = lowerLimitNorm,
+                    SignalingNorm = signalingNorm
+                }
+            };
+
+            var failureMechanism = new DuneErosionFailureMechanism
+            {
+                Contribution = 25
+            };
+
+            yield return new TestCaseData(
+                failureMechanism,
+                assessmentSection,
+                FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm,
+                failureMechanismSpecificNormFactor * GetMechanismSpecificNorm(failureMechanism, signalingNorm / 30)
+            ).SetName("MechanismSpecificFactorizedSignalingNorm");
+
+            yield return new TestCaseData(
+                failureMechanism,
+                assessmentSection,
+                FailureMechanismCategoryType.MechanismSpecificSignalingNorm,
+                failureMechanismSpecificNormFactor * GetMechanismSpecificNorm(failureMechanism, signalingNorm)
+            ).SetName("MechanismSpecificSignalingNorm");
+
+            yield return new TestCaseData(
+                failureMechanism,
+                assessmentSection,
+                FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm,
+                failureMechanismSpecificNormFactor * GetMechanismSpecificNorm(failureMechanism, lowerLimitNorm)
+            ).SetName("MechanismSpecificLowerLimitNorm");
+
+            yield return new TestCaseData(
+                failureMechanism,
+                assessmentSection,
+                FailureMechanismCategoryType.LowerLimitNorm,
+                failureMechanismSpecificNormFactor * lowerLimitNorm
+            ).SetName("LowerLimitNorm");
+
+            yield return new TestCaseData(
+                failureMechanism,
+                assessmentSection,
+                FailureMechanismCategoryType.FactorizedLowerLimitNorm,
+                failureMechanismSpecificNormFactor * lowerLimitNorm * 30
+            ).SetName("FactorizedLowerLimitNorm");
+        }
+
+        private static double GetMechanismSpecificNorm(DuneErosionFailureMechanism failureMechanism,
+                                                       double norm)
+        {
+            return norm * (failureMechanism.Contribution / 100) / failureMechanism.GeneralInput.N;
+        }
     }
 }
\ No newline at end of file