Index: Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Forms/WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.cs
===================================================================
diff -u -r9e6869de553715aefe4752478334c3a6a3f83340 -r8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108
--- Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Forms/WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.cs	(.../WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.cs)	(revision 9e6869de553715aefe4752478334c3a6a3f83340)
+++ Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Forms/WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.cs	(.../WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.cs)	(revision 8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108)
@@ -21,10 +21,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.Contribution;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Forms.Helpers;
+using Ringtoets.Revetment.Data;
 using Ringtoets.WaveImpactAsphaltCover.Data;
 
 namespace Ringtoets.WaveImpactAsphaltCover.Forms
@@ -36,43 +39,55 @@
     {
         /// <summary>
         /// Adds <see cref="WaveImpactAsphaltCoverWaveConditionsCalculation"/> based on the <paramref name="locations"/> 
-        /// in the <paramref name="calculations"/>.
+        /// in the <paramref name="calculations"/> and sets their initial category type input based on the <paramref name="normType"/>.
         /// </summary>
         /// <param name="locations">Locations to base the calculation upon.</param>
         /// <param name="calculations">The list to update.</param>
+        /// <param name="normType">The <see cref="NormType"/> to set the category type input for.</param>
         /// <exception cref="ArgumentNullException">Throw when any input parameter is <c>null</c>.</exception>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="normType"/> is an invalid value.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <paramref name="normType"/> is a valid value,
+        /// but unsupported.</exception>
         public static void AddCalculationsFromLocations(IEnumerable<HydraulicBoundaryLocation> locations,
-                                                        List<ICalculationBase> calculations)
+                                                        List<ICalculationBase> calculations,
+                                                        NormType normType)
         {
             if (locations == null)
             {
                 throw new ArgumentNullException(nameof(locations));
             }
+
             if (calculations == null)
             {
                 throw new ArgumentNullException(nameof(calculations));
             }
-            foreach (ICalculationBase calculation in locations.Select(location => CreateWaveImpactAsphaltCoverWaveConditionsCalculation(location, calculations)))
+
+            foreach (ICalculationBase calculation in locations.Select(location => CreateWaveImpactAsphaltCoverWaveConditionsCalculation(location,
+                                                                                                                                        calculations,
+                                                                                                                                        normType)))
             {
                 calculations.Add(calculation);
             }
         }
 
         private static ICalculationBase CreateWaveImpactAsphaltCoverWaveConditionsCalculation(
             HydraulicBoundaryLocation hydraulicBoundaryLocation,
-            IEnumerable<ICalculationBase> calculations)
+            IEnumerable<ICalculationBase> calculations,
+            NormType normType)
         {
             string nameBase = hydraulicBoundaryLocation.Name;
             string name = NamingHelper.GetUniqueName(calculations, nameBase, c => c.Name);
 
-            return new WaveImpactAsphaltCoverWaveConditionsCalculation
+            var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
             {
                 Name = name,
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            WaveConditionsInputHelper.SetCategoryType(calculation.InputParameters, normType);
+            return calculation;
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Plugin/WaveImpactAsphaltCoverPlugin.cs
===================================================================
diff -u -r7979fad76dccece25f59baeb772540e4416adefc -r8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108
--- Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Plugin/WaveImpactAsphaltCoverPlugin.cs	(.../WaveImpactAsphaltCoverPlugin.cs)	(revision 7979fad76dccece25f59baeb772540e4416adefc)
+++ Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Plugin/WaveImpactAsphaltCoverPlugin.cs	(.../WaveImpactAsphaltCoverPlugin.cs)	(revision 8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108)
@@ -32,6 +32,7 @@
 using Core.Common.Util;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.Contribution;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Forms;
 using Ringtoets.Common.Forms.ChangeHandlers;
@@ -500,18 +501,22 @@
 
                 if (dialog.SelectedItems.Any())
                 {
-                    GenerateWaveImpactAsphaltCoverWaveConditionsCalculations(dialog.SelectedItems, nodeData.WrappedData.Children);
+                    GenerateWaveImpactAsphaltCoverWaveConditionsCalculations(dialog.SelectedItems,
+                                                                             nodeData.WrappedData.Children,
+                                                                             nodeData.AssessmentSection.FailureMechanismContribution.NormativeNorm);
                     nodeData.NotifyObservers();
                 }
             }
         }
 
         private static void GenerateWaveImpactAsphaltCoverWaveConditionsCalculations(IEnumerable<HydraulicBoundaryLocation> hydraulicBoundaryLocations,
-                                                                                     List<ICalculationBase> calculationCollection)
+                                                                                     List<ICalculationBase> calculationCollection,
+                                                                                     NormType normType)
         {
             WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(
                 hydraulicBoundaryLocations,
-                calculationCollection);
+                calculationCollection,
+                normType);
         }
 
         private static void AddWaveConditionsCalculation(WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext nodeData)
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelperTest.cs
===================================================================
diff -u -r5ca67bdbaab0f6a9fb7682c06140b93bb0f5b5bb -r8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelperTest.cs	(.../WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelperTest.cs)	(revision 5ca67bdbaab0f6a9fb7682c06140b93bb0f5b5bb)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelperTest.cs	(.../WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelperTest.cs)	(revision 8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108)
@@ -22,9 +22,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Core.Common.TestUtil;
 using NUnit.Framework;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.Contribution;
 using Ringtoets.Common.Data.Hydraulics;
+using Ringtoets.Revetment.Data;
 using Ringtoets.WaveImpactAsphaltCover.Data;
 
 namespace Ringtoets.WaveImpactAsphaltCover.Forms.Test
@@ -36,10 +40,13 @@
         public void AddCalculationsFromLocations_LocationsIsNull_ThrowsArgumentNullException()
         {
             // Setup
+            var random = new Random(21);
             var calculations = new List<ICalculationBase>();
 
             // Call
-            TestDelegate test = () => WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(null, calculations);
+            TestDelegate test = () => WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(null,
+                                                                                                                                      calculations,
+                                                                                                                                      random.NextEnumValue<NormType>());
 
             // Assert
             string paramName = Assert.Throws<ArgumentNullException>(test).ParamName;
@@ -50,10 +57,13 @@
         public void AddCalculationsFromLocations_CalculationsIsNull_ThrowsArgumentNullException()
         {
             // Setup
+            var random = new Random(21);
             IEnumerable<HydraulicBoundaryLocation> locations = Enumerable.Empty<HydraulicBoundaryLocation>();
 
             // Call
-            TestDelegate test = () => WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations, null);
+            TestDelegate test = () => WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations,
+                                                                                                                                      null,
+                                                                                                                                      random.NextEnumValue<NormType>());
 
             // Assert
             string paramName = Assert.Throws<ArgumentNullException>(test).ParamName;
@@ -64,18 +74,25 @@
         public void AddCalculationsFromLocations_EmptyCollections_ReturnsEmptyList()
         {
             // Setup
+            var random = new Random(21);
             IEnumerable<HydraulicBoundaryLocation> locations = Enumerable.Empty<HydraulicBoundaryLocation>();
             var calculationBases = new List<ICalculationBase>();
 
             // Call
-            WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations, calculationBases);
+            WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations,
+                                                                                                            calculationBases,
+                                                                                                            random.NextEnumValue<NormType>());
 
             // Assert
             CollectionAssert.IsEmpty(calculationBases);
         }
 
         [Test]
-        public void AddCalculationsFromLocations_MultipleCalculationsEmptyCalculationBase_ReturnsUniquelyNamedCalculations()
+        [TestCase(NormType.LowerLimit, AssessmentSectionCategoryType.LowerLimitNorm)]
+        [TestCase(NormType.Signaling, AssessmentSectionCategoryType.SignalingNorm)]
+        public void AddCalculationsFromLocations_MultipleCalculationsEmptyCalculationBase_ReturnsUniquelyNamedCalculations(
+            NormType normType,
+            AssessmentSectionCategoryType expectedAssessmentSectionCategoryType)
         {
             // Setup
             const string name = "name";
@@ -87,21 +104,31 @@
             var calculationBases = new List<ICalculationBase>();
 
             // Call
-            WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations, calculationBases);
+            WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations,
+                                                                                                            calculationBases,
+                                                                                                            normType);
 
             // Assert
             Assert.AreEqual(2, calculationBases.Count);
             var firstCalculation = (WaveImpactAsphaltCoverWaveConditionsCalculation) calculationBases.First();
             Assert.AreEqual(name, firstCalculation.Name);
-            Assert.AreEqual(locations[0], firstCalculation.InputParameters.HydraulicBoundaryLocation);
+            AssessmentSectionCategoryWaveConditionsInput firstCalculationInput = firstCalculation.InputParameters;
+            Assert.AreEqual(locations[0], firstCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedAssessmentSectionCategoryType, firstCalculationInput.CategoryType);
 
             var secondCalculation = (WaveImpactAsphaltCoverWaveConditionsCalculation) calculationBases.ElementAt(1);
             Assert.AreEqual($"{name} (1)", secondCalculation.Name);
-            Assert.AreSame(locations[1], secondCalculation.InputParameters.HydraulicBoundaryLocation);
+            AssessmentSectionCategoryWaveConditionsInput secondCalculationInput = secondCalculation.InputParameters;
+            Assert.AreSame(locations[1], secondCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedAssessmentSectionCategoryType, secondCalculationInput.CategoryType);
         }
 
         [Test]
-        public void AddCalculationsFromLocations_MultipleCalculationsAndDuplicateNameInCalculationBase_ReturnsUniquelyNamedCalculations()
+        [TestCase(NormType.LowerLimit, AssessmentSectionCategoryType.LowerLimitNorm)]
+        [TestCase(NormType.Signaling, AssessmentSectionCategoryType.SignalingNorm)]
+        public void AddCalculationsFromLocations_MultipleCalculationsAndDuplicateNameInCalculationBase_ReturnsUniquelyNamedCalculations(
+            NormType normType,
+            AssessmentSectionCategoryType expectedAssessmentSectionCategoryType)
         {
             // Setup
             const string name = "name";
@@ -119,17 +146,21 @@
             };
 
             // Call
-            WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations, calculationBases);
+            WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationHelper.AddCalculationsFromLocations(locations, calculationBases, normType);
 
             // Assert
             Assert.AreEqual(3, calculationBases.Count);
             var firstCalculation = (WaveImpactAsphaltCoverWaveConditionsCalculation) calculationBases.ElementAt(1);
             Assert.AreEqual($"{name} (1)", firstCalculation.Name);
-            Assert.AreEqual(locations[0], firstCalculation.InputParameters.HydraulicBoundaryLocation);
+            AssessmentSectionCategoryWaveConditionsInput firstCalculationInput = firstCalculation.InputParameters;
+            Assert.AreEqual(locations[0], firstCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedAssessmentSectionCategoryType, firstCalculationInput.CategoryType);
 
             var secondCalculation = (WaveImpactAsphaltCoverWaveConditionsCalculation) calculationBases.ElementAt(2);
             Assert.AreEqual($"{name} (2)", secondCalculation.Name);
-            Assert.AreSame(locations[1], secondCalculation.InputParameters.HydraulicBoundaryLocation);
+            AssessmentSectionCategoryWaveConditionsInput secondCalculationInput = secondCalculation.InputParameters;
+            Assert.AreSame(locations[1], secondCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedAssessmentSectionCategoryType, secondCalculationInput.CategoryType);
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Plugin.Test/TreeNodeInfos/WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs
===================================================================
diff -u -r7979fad76dccece25f59baeb772540e4416adefc -r8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Plugin.Test/TreeNodeInfos/WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs	(.../WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs)	(revision 7979fad76dccece25f59baeb772540e4416adefc)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Plugin.Test/TreeNodeInfos/WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs	(.../WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs)	(revision 8588a6a0d9c1d11a496590ef3eaaccd5cf3a1108)
@@ -1488,6 +1488,9 @@
         public void GivenDialogGenerateCalculationButtonClicked_WhenCalculationSelectedAndDialogClosed_ThenUpdateCalculationGroup()
         {
             // Given
+            var random = new Random(21);
+            var normType = random.NextEnumValue<NormType>();
+
             using (var treeViewControl = new TreeViewControl())
             {
                 var existingGroup = new CalculationGroup();
@@ -1501,17 +1504,20 @@
                     }
                 };
                 var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
-                var assessmentSection = mocks.Stub<IAssessmentSection>();
                 var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation();
                 var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation();
 
-                assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(new HydraulicBoundaryDatabase
+                var assessmentSection = new AssessmentSectionStub
                 {
-                    Locations =
+                    FailureMechanismContribution =
                     {
-                        hydraulicBoundaryLocation1,
-                        hydraulicBoundaryLocation2
+                        NormativeNorm = normType
                     }
+                };
+                assessmentSection.HydraulicBoundaryDatabase.Locations.AddRange(new[]
+                {
+                    hydraulicBoundaryLocation1,
+                    hydraulicBoundaryLocation2
                 });
 
                 var observer = mocks.StrictMock<IObserver>();
@@ -1553,12 +1559,19 @@
                 Assert.AreSame(existingcalculation, group.Children[1]);
                 Assert.NotNull(dialog);
                 Assert.NotNull(grid);
+
+                AssessmentSectionCategoryType expectedAssessmentSectionCategoryType = GetCategoryTypeFromNormType(normType);
                 var firstCalculation = group.Children[2] as WaveImpactAsphaltCoverWaveConditionsCalculation;
                 Assert.IsNotNull(firstCalculation);
-                Assert.AreSame(hydraulicBoundaryLocation1, firstCalculation.InputParameters.HydraulicBoundaryLocation);
+                AssessmentSectionCategoryWaveConditionsInput firstCalculationInput = firstCalculation.InputParameters;
+                Assert.AreSame(hydraulicBoundaryLocation1, firstCalculationInput.HydraulicBoundaryLocation);
+                Assert.AreEqual(expectedAssessmentSectionCategoryType, firstCalculationInput.CategoryType);
+
                 var secondCalculation = group.Children[3] as WaveImpactAsphaltCoverWaveConditionsCalculation;
                 Assert.IsNotNull(secondCalculation);
-                Assert.AreSame(hydraulicBoundaryLocation2, secondCalculation.InputParameters.HydraulicBoundaryLocation);
+                AssessmentSectionCategoryWaveConditionsInput secondCalculationInput = secondCalculation.InputParameters;
+                Assert.AreSame(hydraulicBoundaryLocation2, secondCalculationInput.HydraulicBoundaryLocation);
+                Assert.AreEqual(expectedAssessmentSectionCategoryType, secondCalculationInput.CategoryType);
             }
         }