Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs
===================================================================
diff -u -rf1d92a5cb2eebdf9f6c093b9ae66bb7ff95b6e41 -r3e2a8feb80fe42eb72d66a456a21e030f2d25674
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs	(.../FailureMechanismContributionNormChangeHandlerTest.cs)	(revision f1d92a5cb2eebdf9f6c093b9ae66bb7ff95b6e41)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs	(.../FailureMechanismContributionNormChangeHandlerTest.cs)	(revision 3e2a8feb80fe42eb72d66a456a21e030f2d25674)
@@ -309,7 +309,7 @@
 
             AssertHydraulicBoundaryLocationCalculationOutput(assessmentSection, true);
 
-            Assert.IsNotNull(assessmentSection.DuneErosion.DuneLocations[1].Calculation.Output);
+            Assert.IsNotNull(assessmentSection.DuneErosion.DuneLocations[0].Calculation.Output);
             CollectionAssert.IsEmpty(affectedObjects);
         }
 
Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/TestDataGeneratorTest.cs
===================================================================
diff -u -r159e58fb2b4574e9e7485cbcd706d3e1c5b7423f -r3e2a8feb80fe42eb72d66a456a21e030f2d25674
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/TestDataGeneratorTest.cs	(.../TestDataGeneratorTest.cs)	(revision 159e58fb2b4574e9e7485cbcd706d3e1c5b7423f)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/TestDataGeneratorTest.cs	(.../TestDataGeneratorTest.cs)	(revision 3e2a8feb80fe42eb72d66a456a21e030f2d25674)
@@ -60,8 +60,8 @@
             DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
                                                                                        .OfType<DuneErosionFailureMechanism>()
                                                                                        .Single();
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
         }
 
         [Test]
@@ -82,8 +82,8 @@
             DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
                                                                                        .OfType<DuneErosionFailureMechanism>()
                                                                                        .Single();
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
         }
 
         [Test]
@@ -96,7 +96,11 @@
             Assert.AreEqual(AssessmentSectionComposition.Dike, assessmentSection.Composition);
             AssertFailureMechanismsHaveAllPossibleCalculationConfigurations(assessmentSection);
             AssertHydraulicBoundaryOutput(assessmentSection, false);
-            Assert.True(assessmentSection.DuneErosion.DuneLocations.All(dl => dl.Calculation.Output == null));
+
+            DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
+                                                                                       .OfType<DuneErosionFailureMechanism>()
+                                                                                       .Single();
+            AssertDuneErosionFailureAssertDuneErosionFailureMechanismCalculationConfigurations(duneErosionFailureMechanism, false);
         }
 
         [Test]
@@ -113,7 +117,11 @@
             Assert.AreEqual(composition, assessmentSection.Composition);
             AssertFailureMechanismsHaveAllPossibleCalculationConfigurations(assessmentSection);
             AssertHydraulicBoundaryOutput(assessmentSection, false);
-            Assert.True(assessmentSection.DuneErosion.DuneLocations.All(dl => dl.Calculation.Output == null));
+
+            DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
+                                                                                       .OfType<DuneErosionFailureMechanism>()
+                                                                                       .Single();
+            AssertDuneErosionFailureAssertDuneErosionFailureMechanismCalculationConfigurations(duneErosionFailureMechanism, false);
         }
 
         [Test]
@@ -131,8 +139,8 @@
             DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
                                                                                        .OfType<DuneErosionFailureMechanism>()
                                                                                        .Single();
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
         }
 
         [Test]
@@ -154,8 +162,9 @@
             DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
                                                                                        .OfType<DuneErosionFailureMechanism>()
                                                                                        .Single();
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
-            AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+            AssertNumberOfDuneErosionFailureMechanismCalculations(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
         }
 
         private static void AssertHydraulicBoundaryOutput(AssessmentSection assessmentSection, bool hasOutput)
@@ -326,6 +335,11 @@
                     AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithoutOutputs(waveImpactAsphaltCoverFailureMechanism);
                 }
 
+                if (duneErosionFailureMechanism != null)
+                {
+                    AssertNumberOfDuneErosionFailureMechanismCalculations(duneErosionFailureMechanism);
+                }
+
                 if (macroStabilityInwardsFailureMechanism != null)
                 {
                     MacroStabilityInwardsTestDataGeneratorHelper.AssertHasStochasticSoilModels(macroStabilityInwardsFailureMechanism);
@@ -609,14 +623,60 @@
 
         #region Dune Erosion
 
-        private static void AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(DuneErosionFailureMechanism failureMechanism)
+        private static void AssertNumberOfDuneErosionFailureMechanismCalculations(DuneErosionFailureMechanism failureMechanism)
         {
+            int expectedCalculationsCount = failureMechanism.DuneLocations.Count;
+            Assert.AreEqual(expectedCalculationsCount, failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.Count());
+            Assert.AreEqual(expectedCalculationsCount, failureMechanism.CalculationsForMechanismSpecificSignalingNorm.Count());
+            Assert.AreEqual(expectedCalculationsCount, failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.Count());
+            Assert.AreEqual(expectedCalculationsCount, failureMechanism.CalculationsForLowerLimitNorm.Count());
+            Assert.AreEqual(expectedCalculationsCount, failureMechanism.CalculationsForFactorizedLowerLimitNorm.Count());
+        }
+
+        private static void AssertDuneErosionFailureAssertDuneErosionFailureMechanismCalculationConfigurations(DuneErosionFailureMechanism failureMechanism, bool hasOutput)
+        {
+            if (hasOutput)
+            {
+                Assert.True(failureMechanism.DuneLocations.All(dl => dl.Calculation.Output != null));
+
+                Assert.True(failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.All(calc => calc.Output != null));
+                Assert.True(failureMechanism.CalculationsForMechanismSpecificSignalingNorm.All(calc => calc.Output != null));
+                Assert.True(failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.All(calc => calc.Output != null));
+                Assert.True(failureMechanism.CalculationsForLowerLimitNorm.All(calc => calc.Output != null));
+                Assert.True(failureMechanism.CalculationsForFactorizedLowerLimitNorm.All(calc => calc.Output != null));
+            }
+            else
+            {
+                Assert.True(failureMechanism.DuneLocations.All(dl => dl.Calculation.Output == null));
+
+                Assert.True(failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.All(calc => calc.Output == null));
+                Assert.True(failureMechanism.CalculationsForMechanismSpecificSignalingNorm.All(calc => calc.Output == null));
+                Assert.True(failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.All(calc => calc.Output == null));
+                Assert.True(failureMechanism.CalculationsForLowerLimitNorm.All(calc => calc.Output == null));
+                Assert.True(failureMechanism.CalculationsForFactorizedLowerLimitNorm.All(calc => calc.Output == null));
+            }
+        }
+
+        private static void AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithOutputs(DuneErosionFailureMechanism failureMechanism)
+        {
             Assert.True(failureMechanism.DuneLocations.Any(dl => dl.Calculation.Output != null));
+
+            Assert.True(failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.Any(calc => calc.Output != null));
+            Assert.True(failureMechanism.CalculationsForMechanismSpecificSignalingNorm.Any(calc => calc.Output != null));
+            Assert.True(failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.Any(calc => calc.Output != null));
+            Assert.True(failureMechanism.CalculationsForLowerLimitNorm.Any(calc => calc.Output != null));
+            Assert.True(failureMechanism.CalculationsForFactorizedLowerLimitNorm.Any(calc => calc.Output != null));
         }
 
-        private static void AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(DuneErosionFailureMechanism failureMechanism)
+        private static void AssertDuneErosionFailureMechanismContainsCalculationConfigurationsWithoutOutputs(DuneErosionFailureMechanism failureMechanism)
         {
             Assert.True(failureMechanism.DuneLocations.Any(dl => dl.Calculation.Output == null));
+
+            Assert.True(failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.Any(calc => calc.Output == null));
+            Assert.True(failureMechanism.CalculationsForMechanismSpecificSignalingNorm.Any(calc => calc.Output == null));
+            Assert.True(failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.Any(calc => calc.Output == null));
+            Assert.True(failureMechanism.CalculationsForLowerLimitNorm.Any(calc => calc.Output == null));
+            Assert.True(failureMechanism.CalculationsForFactorizedLowerLimitNorm.Any(calc => calc.Output == null));
         }
 
         #endregion
Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Ringtoets.Integration.TestUtil.csproj
===================================================================
diff -u -r98bb82fc9a5d16eab7a9d25b69f20806ef10a1f1 -r3e2a8feb80fe42eb72d66a456a21e030f2d25674
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Ringtoets.Integration.TestUtil.csproj	(.../Ringtoets.Integration.TestUtil.csproj)	(revision 98bb82fc9a5d16eab7a9d25b69f20806ef10a1f1)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Ringtoets.Integration.TestUtil.csproj	(.../Ringtoets.Integration.TestUtil.csproj)	(revision 3e2a8feb80fe42eb72d66a456a21e030f2d25674)
@@ -74,6 +74,10 @@
       <Project>{D1068432-C172-4AA6-847B-D9DEB4C6DE26}</Project>
       <Name>Ringtoets.DuneErosion.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\DuneErosion\src\Ringtoets.DuneErosion.Service\Ringtoets.DuneErosion.Service.csproj">
+      <Project>{FDEE3429-0BB1-4AD2-813A-06FAD425EA6F}</Project>
+      <Name>Ringtoets.DuneErosion.Service</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\DuneErosion\test\Ringtoets.DuneErosion.Data.TestUtil\Ringtoets.DuneErosion.Data.TestUtil.csproj">
       <Project>{7BE6B522-02E3-4143-8508-C021A211DE54}</Project>
       <Name>Ringtoets.DuneErosion.Data.TestUtil</Name>
Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/TestDataGenerator.cs
===================================================================
diff -u -r2d0cd8264d0b12ae69a8bd1fc781af8ce30b458b -r3e2a8feb80fe42eb72d66a456a21e030f2d25674
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/TestDataGenerator.cs	(.../TestDataGenerator.cs)	(revision 2d0cd8264d0b12ae69a8bd1fc781af8ce30b458b)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/TestDataGenerator.cs	(.../TestDataGenerator.cs)	(revision 3e2a8feb80fe42eb72d66a456a21e030f2d25674)
@@ -33,6 +33,7 @@
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.DuneErosion.Data;
 using Ringtoets.DuneErosion.Data.TestUtil;
+using Ringtoets.DuneErosion.Service;
 using Ringtoets.GrassCoverErosionInwards.Data;
 using Ringtoets.GrassCoverErosionInwards.Data.TestUtil;
 using Ringtoets.GrassCoverErosionOutwards.Data;
@@ -124,6 +125,11 @@
         {
             AssessmentSection assessmentSection = GetAssessmentSectionWithAllCalculationConfigurations(composition);
             RingtoetsDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationOutput(assessmentSection);
+            DuneErosionDataSynchronizationService.ClearDuneCalculationsOutput(assessmentSection.DuneErosion.CalculationsForMechanismSpecificFactorizedSignalingNorm);
+            DuneErosionDataSynchronizationService.ClearDuneCalculationsOutput(assessmentSection.DuneErosion.CalculationsForMechanismSpecificSignalingNorm);
+            DuneErosionDataSynchronizationService.ClearDuneCalculationsOutput(assessmentSection.DuneErosion.CalculationsForMechanismSpecificLowerLimitNorm);
+            DuneErosionDataSynchronizationService.ClearDuneCalculationsOutput(assessmentSection.DuneErosion.CalculationsForLowerLimitNorm);
+            DuneErosionDataSynchronizationService.ClearDuneCalculationsOutput(assessmentSection.DuneErosion.CalculationsForFactorizedLowerLimitNorm);
 
             return assessmentSection;
         }
@@ -999,15 +1005,27 @@
 
         private static void SetFullyConfiguredFailureMechanism(DuneErosionFailureMechanism failureMechanism)
         {
-            failureMechanism.DuneLocations.Add(new TestDuneLocation());
-            failureMechanism.DuneLocations.Add(new TestDuneLocation
+            var duneLocations = new[]
             {
-                Calculation =
+                new TestDuneLocation
                 {
-                    Output = new TestDuneLocationOutput()
-                }
-            });
+                    Calculation =
+                    {
+                        Output = new TestDuneLocationOutput()
+                    }
+                },
+                new TestDuneLocation()
+            };
 
+            failureMechanism.DuneLocations.AddRange(duneLocations);
+            failureMechanism.SetDuneLocationCalculations(duneLocations);
+
+            failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.First().Output = new TestDuneLocationOutput();
+            failureMechanism.CalculationsForMechanismSpecificSignalingNorm.First().Output = new TestDuneLocationOutput();
+            failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.First().Output = new TestDuneLocationOutput();
+            failureMechanism.CalculationsForLowerLimitNorm.First().Output = new TestDuneLocationOutput();
+            failureMechanism.CalculationsForFactorizedLowerLimitNorm.First().Output = new TestDuneLocationOutput();
+
             AddFailureMechanismSections(failureMechanism);
         }