Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Forms/GrassCoverErosionOutwardsWaveConditionsCalculationHelper.cs
===================================================================
diff -u -r9e6869de553715aefe4752478334c3a6a3f83340 -r218e7a0206204401ad7fe9d94ea3532dc456f33e
--- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Forms/GrassCoverErosionOutwardsWaveConditionsCalculationHelper.cs	(.../GrassCoverErosionOutwardsWaveConditionsCalculationHelper.cs)	(revision 9e6869de553715aefe4752478334c3a6a3f83340)
+++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Forms/GrassCoverErosionOutwardsWaveConditionsCalculationHelper.cs	(.../GrassCoverErosionOutwardsWaveConditionsCalculationHelper.cs)	(revision 218e7a0206204401ad7fe9d94ea3532dc456f33e)
@@ -21,11 +21,14 @@
 
 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.GrassCoverErosionOutwards.Data;
+using Ringtoets.Revetment.Data;
 
 namespace Ringtoets.GrassCoverErosionOutwards.Forms
 {
@@ -36,43 +39,67 @@
     {
         /// <summary>
         /// Adds a <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> 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>
-        /// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
+        /// <param name="normType">The <see cref="NormType"/> to set the category type input for.</param>
+        /// <exception cref="ArgumentNullException">Throw when any <paramref name="locations"/>
+        /// or <paramref name="calculations"/> 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 => CreateGrassCoverErosionOutwardsWaveConditionsCalculation(location, calculations)))
+
+            foreach (ICalculationBase calculation in locations.Select(location => CreateGrassCoverErosionOutwardsWaveConditionsCalculation(location,
+                                                                                                                                           calculations,
+                                                                                                                                           normType)))
             {
                 calculations.Add(calculation);
             }
         }
 
+        /// <summary>
+        /// Creates a calculation and sets the <paramref name="hydraulicBoundaryLocation"/>
+        /// and the category type on its input.
+        /// </summary>
+        /// <param name="hydraulicBoundaryLocation">The <see cref="HydraulicBoundaryLocation"/> to set.</param>
+        /// <param name="calculations">The list of calculations to base the calculation name from.</param>
+        /// <param name="normType">The <see cref="NormType"/> to base the category type input on.</param>
+        /// <returns>An <see cref="ICalculationBase"/> representing a grass cover erosion outwards calculation.</returns>
+        /// <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>
         private static ICalculationBase CreateGrassCoverErosionOutwardsWaveConditionsCalculation(
             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 GrassCoverErosionOutwardsWaveConditionsCalculation
+            var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
             {
                 Name = name,
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            WaveConditionsInputHelper.SetCategoryType(calculation.InputParameters, normType);
+            return calculation;
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Plugin/GrassCoverErosionOutwardsPlugin.cs
===================================================================
diff -u -r5b29dd531b618b6d3969e7cba9c95d31517290e4 -r218e7a0206204401ad7fe9d94ea3532dc456f33e
--- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Plugin/GrassCoverErosionOutwardsPlugin.cs	(.../GrassCoverErosionOutwardsPlugin.cs)	(revision 5b29dd531b618b6d3969e7cba9c95d31517290e4)
+++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Plugin/GrassCoverErosionOutwardsPlugin.cs	(.../GrassCoverErosionOutwardsPlugin.cs)	(revision 218e7a0206204401ad7fe9d94ea3532dc456f33e)
@@ -33,6 +33,7 @@
 using Core.Common.Util;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.Contribution;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Forms;
@@ -765,18 +766,22 @@
 
                 if (dialog.SelectedItems.Any())
                 {
-                    GenerateGrassCoverErosionOutwardsWaveConditionsCalculations(dialog.SelectedItems, nodeData.WrappedData.Children);
+                    GenerateGrassCoverErosionOutwardsWaveConditionsCalculations(dialog.SelectedItems,
+                                                                                nodeData.WrappedData.Children,
+                                                                                nodeData.AssessmentSection.FailureMechanismContribution.NormativeNorm);
                     nodeData.NotifyObservers();
                 }
             }
         }
 
         private static void GenerateGrassCoverErosionOutwardsWaveConditionsCalculations(IEnumerable<HydraulicBoundaryLocation> hydraulicBoundaryLocations,
-                                                                                        List<ICalculationBase> calculationCollection)
+                                                                                        List<ICalculationBase> calculationCollection,
+                                                                                        NormType normType)
         {
             GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(
                 hydraulicBoundaryLocations,
-                calculationCollection);
+                calculationCollection,
+                normType);
         }
 
         private static void AddWaveConditionsCalculation(GrassCoverErosionOutwardsWaveConditionsCalculationGroupContext nodeData)
@@ -787,7 +792,7 @@
                                                   RingtoetsCommonDataResources.Calculation_DefaultName,
                                                   c => c.Name)
             };
-            WaveConditionsInputHelper.SetCategoryType(calculation.InputParameters, 
+            WaveConditionsInputHelper.SetCategoryType(calculation.InputParameters,
                                                       nodeData.AssessmentSection.FailureMechanismContribution.NormativeNorm);
             nodeData.WrappedData.Children.Add(calculation);
             nodeData.WrappedData.NotifyObservers();
Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Forms.Test/GrassCoverErosionOutwardsWaveConditionsCalculationHelperTest.cs
===================================================================
diff -u -r04cf5f873b69cb330aeda88b622e286b2aefa852 -r218e7a0206204401ad7fe9d94ea3532dc456f33e
--- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Forms.Test/GrassCoverErosionOutwardsWaveConditionsCalculationHelperTest.cs	(.../GrassCoverErosionOutwardsWaveConditionsCalculationHelperTest.cs)	(revision 04cf5f873b69cb330aeda88b622e286b2aefa852)
+++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Forms.Test/GrassCoverErosionOutwardsWaveConditionsCalculationHelperTest.cs	(.../GrassCoverErosionOutwardsWaveConditionsCalculationHelperTest.cs)	(revision 218e7a0206204401ad7fe9d94ea3532dc456f33e)
@@ -22,10 +22,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Core.Common.TestUtil;
 using NUnit.Framework;
 using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.Contribution;
+using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.GrassCoverErosionOutwards.Data;
+using Ringtoets.Revetment.Data;
 
 namespace Ringtoets.GrassCoverErosionOutwards.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 = () => GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(null, calculations);
+            TestDelegate test = () => GrassCoverErosionOutwardsWaveConditionsCalculationHelper.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 = () => GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, null);
+            TestDelegate test = () => GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations,
+                                                                                                                            null,
+                                                                                                                            random.NextEnumValue<NormType>());
 
             // Assert
             string paramName = Assert.Throws<ArgumentNullException>(test).ParamName;
@@ -64,18 +74,23 @@
         public void AddCalculationsFromLocations_EmptyCollections_ReturnsEmptyList()
         {
             // Setup
+            var random = new Random(21);
             IEnumerable<HydraulicBoundaryLocation> locations = Enumerable.Empty<HydraulicBoundaryLocation>();
             var calculationBases = new List<ICalculationBase>();
 
             // Call
-            GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, calculationBases);
+            GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, calculationBases, random.NextEnumValue<NormType>());
 
             // Assert
             CollectionAssert.IsEmpty(calculationBases);
         }
 
         [Test]
-        public void AddCalculationsFromLocations_MultipleLocationsEmptyCalculationBase_ReturnsUniquelyNamedCalculations()
+        [TestCase(NormType.LowerLimit, FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm)]
+        [TestCase(NormType.Signaling, FailureMechanismCategoryType.MechanismSpecificSignalingNorm)]
+        public void AddCalculationsFromLocations_MultipleLocationsEmptyCalculationBase_ReturnsUniquelyNamedCalculations(
+            NormType normType,
+            FailureMechanismCategoryType expectedFailureMechanismCategoryType)
         {
             // Setup
             const string name = "name";
@@ -87,21 +102,29 @@
             var calculationBases = new List<ICalculationBase>();
 
             // Call
-            GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, calculationBases);
+            GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, calculationBases, normType);
 
             // Assert
             Assert.AreEqual(2, calculationBases.Count);
             var firstCalculation = (GrassCoverErosionOutwardsWaveConditionsCalculation) calculationBases.First();
             Assert.AreEqual(name, firstCalculation.Name);
-            Assert.AreEqual(locations[0], firstCalculation.InputParameters.HydraulicBoundaryLocation);
+            FailureMechanismCategoryWaveConditionsInput firstCalculationInput = firstCalculation.InputParameters;
+            Assert.AreEqual(locations[0], firstCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedFailureMechanismCategoryType, firstCalculationInput.CategoryType);
 
             var secondCalculation = (GrassCoverErosionOutwardsWaveConditionsCalculation) calculationBases.ElementAt(1);
             Assert.AreEqual($"{name} (1)", secondCalculation.Name);
-            Assert.AreSame(locations[1], secondCalculation.InputParameters.HydraulicBoundaryLocation);
+            FailureMechanismCategoryWaveConditionsInput secondCalculationInput = secondCalculation.InputParameters;
+            Assert.AreSame(locations[1], secondCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedFailureMechanismCategoryType, secondCalculationInput.CategoryType);
         }
 
         [Test]
-        public void AddCalculationsFromLocations_MultipleLocationsAndDuplicateNameInCalculationBase_ReturnsUniquelyNamedCalculations()
+        [TestCase(NormType.LowerLimit, FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm)]
+        [TestCase(NormType.Signaling, FailureMechanismCategoryType.MechanismSpecificSignalingNorm)]
+        public void AddCalculationsFromLocations_MultipleLocationsAndDuplicateNameInCalculationBase_ReturnsUniquelyNamedCalculations(
+            NormType normType,
+            FailureMechanismCategoryType expectedFailureMechanismCategoryType)
         {
             // Setup
             const string name = "name";
@@ -119,17 +142,21 @@
             };
 
             // Call
-            GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, calculationBases);
+            GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, calculationBases, normType);
 
             // Assert
             Assert.AreEqual(3, calculationBases.Count);
             var firstCalculation = (GrassCoverErosionOutwardsWaveConditionsCalculation) calculationBases.ElementAt(1);
             Assert.AreEqual($"{name} (1)", firstCalculation.Name);
-            Assert.AreEqual(locations[0], firstCalculation.InputParameters.HydraulicBoundaryLocation);
+            FailureMechanismCategoryWaveConditionsInput firstCalculationInput = firstCalculation.InputParameters;
+            Assert.AreEqual(locations[0], firstCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedFailureMechanismCategoryType, firstCalculationInput.CategoryType);
 
             var secondCalculation = (GrassCoverErosionOutwardsWaveConditionsCalculation) calculationBases.ElementAt(2);
             Assert.AreEqual($"{name} (2)", secondCalculation.Name);
-            Assert.AreSame(locations[1], secondCalculation.InputParameters.HydraulicBoundaryLocation);
+            FailureMechanismCategoryWaveConditionsInput secondCalculationInput = secondCalculation.InputParameters;
+            Assert.AreSame(locations[1], secondCalculationInput.HydraulicBoundaryLocation);
+            Assert.AreEqual(expectedFailureMechanismCategoryType, secondCalculationInput.CategoryType);
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionOutwardsWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs
===================================================================
diff -u -r5b29dd531b618b6d3969e7cba9c95d31517290e4 -r218e7a0206204401ad7fe9d94ea3532dc456f33e
--- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionOutwardsWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs	(.../GrassCoverErosionOutwardsWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs)	(revision 5b29dd531b618b6d3969e7cba9c95d31517290e4)
+++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionOutwardsWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs	(.../GrassCoverErosionOutwardsWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs)	(revision 218e7a0206204401ad7fe9d94ea3532dc456f33e)
@@ -1813,6 +1813,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();
@@ -1828,7 +1831,13 @@
                 var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation();
                 var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation();
                 var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
-                var assessmentSection = new AssessmentSectionStub();
+                var assessmentSection = new AssessmentSectionStub
+                {
+                    FailureMechanismContribution =
+                    {
+                        NormativeNorm = normType
+                    }
+                };
 
                 GrassCoverErosionOutwardsHydraulicBoundaryLocationsTestHelper.SetHydraulicBoundaryLocations(
                     failureMechanism, assessmentSection, new[]
@@ -1877,12 +1886,19 @@
                 Assert.AreSame(existingcalculation, group.Children[1]);
                 Assert.NotNull(dialog);
                 Assert.NotNull(grid);
+
+                FailureMechanismCategoryType expectedFailureMechanismCategoryType = GetCategoryTypeFromNormType(normType);
                 var firstCalculation = group.Children[2] as GrassCoverErosionOutwardsWaveConditionsCalculation;
                 Assert.IsNotNull(firstCalculation);
-                Assert.AreSame(hydraulicBoundaryLocation1, firstCalculation.InputParameters.HydraulicBoundaryLocation);
+                FailureMechanismCategoryWaveConditionsInput firstCalculationInput = firstCalculation.InputParameters;
+                Assert.AreSame(hydraulicBoundaryLocation1, firstCalculationInput.HydraulicBoundaryLocation);
+                Assert.AreEqual(expectedFailureMechanismCategoryType, firstCalculationInput.CategoryType);
+
                 var secondCalculation = group.Children[3] as GrassCoverErosionOutwardsWaveConditionsCalculation;
                 Assert.IsNotNull(secondCalculation);
-                Assert.AreSame(hydraulicBoundaryLocation2, secondCalculation.InputParameters.HydraulicBoundaryLocation);
+                FailureMechanismCategoryWaveConditionsInput secondCalculationInput = secondCalculation.InputParameters;
+                Assert.AreSame(hydraulicBoundaryLocation2, secondCalculationInput.HydraulicBoundaryLocation);
+                Assert.AreEqual(expectedFailureMechanismCategoryType, secondCalculationInput.CategoryType);
             }
         }