Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs
===================================================================
diff -u -rea237aa9ec7893e681cfc3e2aa0cb94c2e866ee1 -r8ed5bc1cd94d92f35b5fa9318bcf4f4cff35a610
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssemblyKernelStubTest.cs)	(revision ea237aa9ec7893e681cfc3e2aa0cb94c2e866ee1)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssemblyKernelStubTest.cs)	(revision 8ed5bc1cd94d92f35b5fa9318bcf4f4cff35a610)
@@ -25,6 +25,7 @@
 using Assembly.Kernel.Interfaces;
 using Assembly.Kernel.Model;
 using Assembly.Kernel.Model.AssessmentResultTypes;
+using Assembly.Kernel.Model.CategoryLimits;
 using Assembly.Kernel.Model.FmSectionTypes;
 using Core.Common.TestUtil;
 using NUnit.Framework;
@@ -60,6 +61,8 @@
             Assert.IsNaN(kernel.LengthEffectFactorInput);
             Assert.IsNull(kernel.CategoryCompliancyResultsInput);
             Assert.IsNull(kernel.FailureMechanismSectionDirectResult);
+            Assert.IsNull(kernel.FailureMechanismAssemblyDirectResultWithProbability);
+            Assert.IsNull(kernel.FailureMechanismSectionCategories);
         }
 
         private static FailureMechanism CreateRandomFailureMechanism(Random random)
@@ -497,26 +500,24 @@
         {
             // Setup
             var random = new Random(39);
-            AssessmentSection assessmentSection = CreateRandomAssessmentSection(random);
-            FailureMechanism failureMechanism = CreateRandomFailureMechanism(random);
             var assessmentResult = random.NextEnumValue<EAssessmentResultTypeG2>();
             double failureProbability = random.NextDouble();
             double lengthEffect = random.NextDouble();
+            CategoriesList<FmSectionCategory> categories = CategoriesListTestFactory.CreateFailureMechanismSectionCategories();
 
             var kernel = new FailureMechanismSectionAssemblyKernelStub();
 
             // Precondition
             Assert.IsFalse(kernel.Calculated);
 
             // Call
-            kernel.TranslateAssessmentResultWbi0G5(assessmentSection, failureMechanism, lengthEffect, assessmentResult, failureProbability);
+            kernel.TranslateAssessmentResultWbi0G5(lengthEffect, assessmentResult, failureProbability, categories);
 
             // Assert
-            Assert.AreSame(assessmentSection, kernel.AssessmentSectionInput);
-            Assert.AreSame(failureMechanism, kernel.FailureMechanismInput);
             Assert.AreEqual(lengthEffect, kernel.LengthEffectFactorInput);
             Assert.AreEqual(assessmentResult, kernel.AssessmentResultTypeG2Input);
             Assert.AreEqual(failureProbability, kernel.FailureProbabilityInput);
+            Assert.AreSame(categories, kernel.FailureMechanismSectionCategories);
             Assert.IsTrue(kernel.Calculated);
         }
 
@@ -525,60 +526,56 @@
         {
             // Setup
             var random = new Random(39);
-            AssessmentSection assessmentSection = CreateRandomAssessmentSection(random);
-            FailureMechanism failureMechanism = CreateRandomFailureMechanism(random);
             var assessmentResult = random.NextEnumValue<EAssessmentResultTypeG2>();
             double failureProbability = random.NextDouble();
             double lengthEffect = random.NextDouble();
+            CategoriesList<FmSectionCategory> categories = CategoriesListTestFactory.CreateFailureMechanismSectionCategories();
 
             var kernel = new FailureMechanismSectionAssemblyKernelStub
             {
-                FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue<EFmSectionCategory>())
+                FailureMechanismAssemblyDirectResultWithProbability = new FmSectionAssemblyDirectResultWithProbability(random.NextEnumValue<EFmSectionCategory>(),
+                                                                                                                       random.NextDouble())
             };
 
             // Call
-            FmSectionAssemblyDirectResult result = kernel.TranslateAssessmentResultWbi0G5(assessmentSection,
-                                                                                          failureMechanism,
-                                                                                          lengthEffect,
+            FmSectionAssemblyDirectResult result = kernel.TranslateAssessmentResultWbi0G5(lengthEffect,
                                                                                           assessmentResult,
-                                                                                          failureProbability);
+                                                                                          failureProbability,
+                                                                                          categories);
 
             // Assert
-            Assert.AreSame(kernel.FailureMechanismSectionDirectResult, result);
+            Assert.AreSame(kernel.FailureMechanismAssemblyDirectResultWithProbability, result);
         }
 
         [Test]
         public void TranslateAssessmentResultWbi0G5_ThrowExceptionOnCalculateTrue_ThrowsException()
         {
             // Setup
             var random = new Random(39);
-            AssessmentSection assessmentSection = CreateRandomAssessmentSection(random);
-            FailureMechanism failureMechanism = CreateRandomFailureMechanism(random);
             var assessmentResult = random.NextEnumValue<EAssessmentResultTypeG2>();
             double failureProbability = random.NextDouble();
             double lengthEffect = random.NextDouble();
+            CategoriesList<FmSectionCategory> categories = CategoriesListTestFactory.CreateFailureMechanismSectionCategories();
 
             var kernel = new FailureMechanismSectionAssemblyKernelStub
             {
                 ThrowExceptionOnCalculate = true
             };
 
             // Call
-            TestDelegate test = () => kernel.TranslateAssessmentResultWbi0G5(assessmentSection,
-                                                                             failureMechanism,
-                                                                             lengthEffect,
+            TestDelegate test = () => kernel.TranslateAssessmentResultWbi0G5(lengthEffect,
                                                                              assessmentResult,
-                                                                             failureProbability);
+                                                                             failureProbability,
+                                                                             categories);
 
             // Assert
             var exception = Assert.Throws<Exception>(test);
             Assert.AreEqual("Message", exception.Message);
             Assert.IsNotNull(exception.InnerException);
-            Assert.IsNull(kernel.AssessmentSectionInput);
-            Assert.IsNull(kernel.FailureMechanismInput);
             Assert.IsNaN(kernel.LengthEffectFactorInput);
             Assert.IsNull(kernel.AssessmentResultTypeG2Input);
             Assert.IsNaN(kernel.FailureProbabilityInput);
+            Assert.IsNull(kernel.FailureMechanismSectionCategories);
             Assert.IsFalse(kernel.Calculated);
             Assert.IsNull(kernel.FailureMechanismSectionDirectResult);
         }
@@ -588,34 +585,31 @@
         {
             // Setup
             var random = new Random(39);
-            AssessmentSection assessmentSection = CreateRandomAssessmentSection(random);
-            FailureMechanism failureMechanism = CreateRandomFailureMechanism(random);
             var assessmentResult = random.NextEnumValue<EAssessmentResultTypeG2>();
             double failureProbability = random.NextDouble();
             double lengthEffect = random.NextDouble();
+            CategoriesList<FmSectionCategory> categories = CategoriesListTestFactory.CreateFailureMechanismSectionCategories();
 
             var kernel = new FailureMechanismSectionAssemblyKernelStub
             {
                 ThrowAssemblyExceptionOnCalculate = true
             };
 
             // Call
-            TestDelegate test = () => kernel.TranslateAssessmentResultWbi0G5(assessmentSection,
-                                                                             failureMechanism,
-                                                                             lengthEffect,
+            TestDelegate test = () => kernel.TranslateAssessmentResultWbi0G5(lengthEffect,
                                                                              assessmentResult,
-                                                                             failureProbability);
+                                                                             failureProbability,
+                                                                             categories);
 
             // Assert
             var exception = Assert.Throws<AssemblyException>(test);
             AssemblyErrorMessage errorMessage = exception.Errors.Single();
             Assert.AreEqual("entity", errorMessage.EntityId);
             Assert.AreEqual(EAssemblyErrors.CategoryLowerLimitOutOfRange, errorMessage.ErrorCode);
-            Assert.IsNull(kernel.AssessmentSectionInput);
-            Assert.IsNull(kernel.FailureMechanismInput);
             Assert.IsNaN(kernel.LengthEffectFactorInput);
             Assert.IsNull(kernel.AssessmentResultTypeG2Input);
             Assert.IsNaN(kernel.FailureProbabilityInput);
+            Assert.IsNull(kernel.FailureMechanismSectionCategories);
             Assert.IsFalse(kernel.Calculated);
             Assert.IsNull(kernel.FailureMechanismSectionDirectResult);
         }
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs
===================================================================
diff -u -rea237aa9ec7893e681cfc3e2aa0cb94c2e866ee1 -r8ed5bc1cd94d92f35b5fa9318bcf4f4cff35a610
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs	(.../FailureMechanismSectionAssemblyKernelStub.cs)	(revision ea237aa9ec7893e681cfc3e2aa0cb94c2e866ee1)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs	(.../FailureMechanismSectionAssemblyKernelStub.cs)	(revision 8ed5bc1cd94d92f35b5fa9318bcf4f4cff35a610)
@@ -24,7 +24,9 @@
 using Assembly.Kernel.Interfaces;
 using Assembly.Kernel.Model;
 using Assembly.Kernel.Model.AssessmentResultTypes;
+using Assembly.Kernel.Model.CategoryLimits;
 using Assembly.Kernel.Model.FmSectionTypes;
+using Ringtoets.AssemblyTool.Data;
 
 namespace Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Kernels.Assembly
 {
@@ -124,11 +126,22 @@
         public FmSectionCategoryCompliancyResults CategoryCompliancyResultsInput { get; private set; }
 
         /// <summary>
+        /// Gets the <see cref="CategoriesList{TCategory}"/> with <see cref="FmSectionCategory"/> used
+        /// as input for assembly methods.
+        /// </summary>
+        public CategoriesList<FmSectionCategory> FailureMechanismSectionCategories { get; private set; }
+
+        /// <summary>
         /// Gets or sets the failure mechanism section assembly result.
         /// </summary>
         public FmSectionAssemblyDirectResult FailureMechanismSectionDirectResult { get; set; }
 
         /// <summary>
+        /// Gets or sets the failure mechanism section assembly result with probability.
+        /// </summary>
+        public FmSectionAssemblyDirectResultWithProbability FailureMechanismAssemblyDirectResultWithProbability { get; set; }
+
+        /// <summary>
         /// Gets a value indicating whether a calculation was called or not.
         /// </summary>
         public bool Calculated { get; private set; }
@@ -143,29 +156,29 @@
         /// </summary>
         public bool ThrowAssemblyExceptionOnCalculate { private get; set; }
 
-        public FmSectionAssemblyDirectResult TranslateAssessmentResultWbi0E1(EAssessmentResultTypeE1 assessment)
+        public FmSectionAssemblyDirectResultWithProbability TranslateAssessmentResultWbi0E1(EAssessmentResultTypeE1 assessment)
         {
             ThrowException();
 
             AssessmentResultTypeE1Input = assessment;
 
             Calculated = true;
-            return FailureMechanismSectionDirectResult;
+            return FailureMechanismAssemblyDirectResultWithProbability;
         }
 
         public FmSectionAssemblyIndirectResult TranslateAssessmentResultWbi0E2(EAssessmentResultTypeE1 assessment)
         {
             throw new NotImplementedException();
         }
 
-        public FmSectionAssemblyDirectResult TranslateAssessmentResultWbi0E3(EAssessmentResultTypeE2 assessment)
+        public FmSectionAssemblyDirectResultWithProbability TranslateAssessmentResultWbi0E3(EAssessmentResultTypeE2 assessment)
         {
             ThrowException();
 
             AssessmentResultTypeE2Input = assessment;
 
             Calculated = true;
-            return FailureMechanismSectionDirectResult;
+            return FailureMechanismAssemblyDirectResultWithProbability;
         }
 
         public FmSectionAssemblyIndirectResult TranslateAssessmentResultWbi0E4(EAssessmentResultTypeE2 assessment)
@@ -209,22 +222,20 @@
             throw new NotImplementedException();
         }
 
-        public FmSectionAssemblyDirectResult TranslateAssessmentResultWbi0G5(AssessmentSection section,
-                                                                             FailureMechanism failureMechanism,
-                                                                             double fmSectionLengthEffectFactor,
-                                                                             EAssessmentResultTypeG2 assessment,
-                                                                             double failureProbability)
+        public FmSectionAssemblyDirectResultWithProbability TranslateAssessmentResultWbi0G5(double fmSectionLengthEffectFactor,
+                                                                                            EAssessmentResultTypeG2 assessment,
+                                                                                            double failureProbability,
+                                                                                            CategoriesList<FmSectionCategory> categories)
         {
             ThrowException();
 
-            AssessmentSectionInput = section;
-            FailureMechanismInput = failureMechanism;
             AssessmentResultTypeG2Input = assessment;
             FailureProbabilityInput = failureProbability;
             LengthEffectFactorInput = fmSectionLengthEffectFactor;
+            FailureMechanismSectionCategories = categories;
 
             Calculated = true;
-            return FailureMechanismSectionDirectResult;
+            return FailureMechanismAssemblyDirectResultWithProbability;
         }
 
         public FmSectionAssemblyDirectResult TranslateAssessmentResultWbi0G6(FmSectionCategoryCompliancyResults compliancyResults)