Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/IAssemblyCategoriesCalculator.cs
===================================================================
diff -u -rb46cba3269d292e5ca3374ec0f75810686cf3ec6 -r77413ce11244a9aa8a12fd50aa8cee99bfe54476
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/IAssemblyCategoriesCalculator.cs	(.../IAssemblyCategoriesCalculator.cs)	(revision b46cba3269d292e5ca3374ec0f75810686cf3ec6)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/IAssemblyCategoriesCalculator.cs	(.../IAssemblyCategoriesCalculator.cs)	(revision 77413ce11244a9aa8a12fd50aa8cee99bfe54476)
@@ -57,7 +57,7 @@
             double signalingNorm, double lowerLimitNorm, double probabilityDistributionFactor, double n);
 
         /// <summary>
-        /// Performs the calculation for getting the failure mechanism section categories.
+        /// Performs the calculation for getting the geotechnic failure mechanism section categories.
         /// </summary>
         /// <param name="signalingNorm">The signaling norm to calculate with.</param>
         /// <param name="lowerLimitNorm">The lower limit norm to calculate with.</param>
Index: Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs
===================================================================
diff -u -r18fd05a902f0f8a73d93947f0737a91ad86aa0af -r77413ce11244a9aa8a12fd50aa8cee99bfe54476
--- Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs	(.../AssemblyToolCategoriesFactory.cs)	(revision 18fd05a902f0f8a73d93947f0737a91ad86aa0af)
+++ Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs	(.../AssemblyToolCategoriesFactory.cs)	(revision 77413ce11244a9aa8a12fd50aa8cee99bfe54476)
@@ -41,7 +41,7 @@
         /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="AssessmentSectionAssemblyCategory"/>.</returns>
         /// <exception cref="AssemblyFactoryException">Thrown when an error occurred while creating the categories.</exception>
         public static IEnumerable<AssessmentSectionAssemblyCategory> CreateAssessmentSectionAssemblyCategories(double signalingNorm, double lowerLimitNorm)
-        { 
+        {
             IAssemblyCategoriesCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateAssemblyCategoriesCalculator(
                 AssemblyToolKernelFactory.Instance);
 
@@ -54,5 +54,69 @@
                 throw new AssemblyFactoryException(e.Message, e);
             }
         }
+
+        /// <summary>
+        /// Creates the failure mechanism section assembly categories.
+        /// </summary>
+        /// <param name="signalingNorm">The signaling norm to use in the calculation.</param>
+        /// <param name="lowerLimitNorm">The lower limit norm to use in the calculation.</param>
+        /// <param name="probabilityDistributionFactor">The probability distribution factor to calculate with.</param>
+        /// <param name="n">The n to calculate with.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> with categories of
+        /// <see cref="FailureMechanismSectionAssemblyCategory"/>.</returns>
+        /// <exception cref="AssemblyFactoryException">Thrown when an error occurred while creating the categories.</exception>
+        public static IEnumerable<FailureMechanismSectionAssemblyCategory> CreateFailureMechanismSectionAssemblyCategories(
+            double signalingNorm,
+            double lowerLimitNorm,
+            double probabilityDistributionFactor,
+            double n)
+        {
+            IAssemblyCategoriesCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateAssemblyCategoriesCalculator(
+                AssemblyToolKernelFactory.Instance);
+
+            try
+            {
+                return calculator.CalculateFailureMechanismSectionCategories(signalingNorm,
+                                                                             lowerLimitNorm,
+                                                                             probabilityDistributionFactor,
+                                                                             n);
+            }
+            catch (AssemblyCategoriesCalculatorException e)
+            {
+                throw new AssemblyFactoryException(e.Message, e);
+            }
+        }
+
+        /// <summary>
+        /// Creates the geotechnic failure mechanism section assembly categories.
+        /// </summary>
+        /// <param name="signalingNorm">The signaling norm to use in the calculation.</param>
+        /// <param name="lowerLimitNorm">The lower limit norm to use in the calculation.</param>
+        /// <param name="probabilityDistributionFactor">The probability distribution factor to calculate with.</param>
+        /// <param name="n">The n to calculate with.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> with categories of
+        /// <see cref="FailureMechanismSectionAssemblyCategory"/>.</returns>
+        /// <exception cref="AssemblyFactoryException">Thrown when an error occurred while creating the categories.</exception>
+        public static IEnumerable<FailureMechanismSectionAssemblyCategory> CreateGeotechnicFailureMechanismSectionAssemblyCategories(
+            double signalingNorm,
+            double lowerLimitNorm,
+            double probabilityDistributionFactor,
+            double n)
+        {
+            IAssemblyCategoriesCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateAssemblyCategoriesCalculator(
+                AssemblyToolKernelFactory.Instance);
+
+            try
+            {
+                return calculator.CalculateGeotechnicFailureMechanismSectionCategories(signalingNorm,
+                                                                                       lowerLimitNorm,
+                                                                                       probabilityDistributionFactor,
+                                                                                       n);
+            }
+            catch (AssemblyCategoriesCalculatorException e)
+            {
+                throw new AssemblyFactoryException(e.Message, e);
+            }
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs
===================================================================
diff -u -r18fd05a902f0f8a73d93947f0737a91ad86aa0af -r77413ce11244a9aa8a12fd50aa8cee99bfe54476
--- Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs	(.../AssemblyToolCategoriesFactoryTest.cs)	(revision 18fd05a902f0f8a73d93947f0737a91ad86aa0af)
+++ Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs	(.../AssemblyToolCategoriesFactoryTest.cs)	(revision 77413ce11244a9aa8a12fd50aa8cee99bfe54476)
@@ -102,5 +102,167 @@
                 Assert.AreEqual(exception.InnerException.Message, exception.Message);
             }
         }
+
+        [Test]
+        public void CreateFailureMechanismSectionAssemblyCategories_WithInput_SetsInputOnCalculator()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double probabilityDistributionFactor = random.NextDouble();
+            double n = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                AssemblyToolCategoriesFactory.CreateFailureMechanismSectionAssemblyCategories(signalingNorm,
+                                                                                              lowerLimitNorm,
+                                                                                              probabilityDistributionFactor,
+                                                                                              n);
+
+                // Assert
+                Assert.AreEqual(signalingNorm, calculator.SignalingNorm);
+                Assert.AreEqual(lowerLimitNorm, calculator.LowerLimitNorm);
+                Assert.AreEqual(probabilityDistributionFactor, calculator.ProbabilityDistributionFactor);
+                Assert.AreEqual(n, calculator.N);
+            }
+        }
+
+        [Test]
+        public void CreateFailureMechanismSectionAssemblyCategories_CalculatorRan_ReturnsOutput()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double probabilityDistributionFactor = random.NextDouble();
+            double n = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                FailureMechanismSectionAssemblyCategory[] output = AssemblyToolCategoriesFactory.CreateFailureMechanismSectionAssemblyCategories(
+                    signalingNorm,
+                    lowerLimitNorm,
+                    probabilityDistributionFactor,
+                    n).ToArray();
+
+                // Assert
+                FailureMechanismSectionAssemblyCategory[] calculatorOutput = calculator.FailureMechanismSectionCategoriesOutput.ToArray();
+
+                Assert.AreEqual(calculatorOutput.Length, output.Length);
+                CollectionAssert.AreEqual(calculatorOutput.Select(co => co.LowerBoundary), output.Select(o => o.LowerBoundary));
+                CollectionAssert.AreEqual(calculatorOutput.Select(co => co.UpperBoundary), output.Select(o => o.UpperBoundary));
+                CollectionAssert.AreEqual(calculatorOutput.Select(co => co.Group), output.Select(o => o.Group));
+            }
+        }
+
+        [Test]
+        public void CreateFailureMechanismSectionAssemblyCategories_CalculatorThrowsException_ThrowsAssemblyFactoryException()
+        {
+            // Setup
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+                calculator.ThrowExceptionOnCalculate = true;
+
+                // Call
+                TestDelegate test = () => AssemblyToolCategoriesFactory.CreateFailureMechanismSectionAssemblyCategories(0, 0, 0, 0);
+
+                // Assert
+                var exception = Assert.Throws<AssemblyFactoryException>(test);
+                Assert.IsInstanceOf<AssemblyCategoriesCalculatorException>(exception.InnerException);
+                Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            }
+        }
+
+        [Test]
+        public void CreateGeotechnicFailureMechanismSectionAssemblyCategories_WithInput_SetsInputOnCalculator()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double probabilityDistributionFactor = random.NextDouble();
+            double n = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                AssemblyToolCategoriesFactory.CreateGeotechnicFailureMechanismSectionAssemblyCategories(signalingNorm,
+                                                                                                        lowerLimitNorm,
+                                                                                                        probabilityDistributionFactor,
+                                                                                                        n);
+
+                // Assert
+                Assert.AreEqual(signalingNorm, calculator.SignalingNorm);
+                Assert.AreEqual(lowerLimitNorm, calculator.LowerLimitNorm);
+                Assert.AreEqual(probabilityDistributionFactor, calculator.ProbabilityDistributionFactor);
+                Assert.AreEqual(n, calculator.N);
+            }
+        }
+
+        [Test]
+        public void CreateGeotechnicFailureMechanismSectionAssemblyCategories_CalculatorRan_ReturnsOutput()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double probabilityDistributionFactor = random.NextDouble();
+            double n = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                FailureMechanismSectionAssemblyCategory[] output = AssemblyToolCategoriesFactory.CreateGeotechnicFailureMechanismSectionAssemblyCategories(
+                    signalingNorm,
+                    lowerLimitNorm,
+                    probabilityDistributionFactor,
+                    n).ToArray();
+
+                // Assert
+                FailureMechanismSectionAssemblyCategory[] calculatorOutput = calculator.FailureMechanismSectionCategoriesOutput.ToArray();
+
+                Assert.AreEqual(calculatorOutput.Length, output.Length);
+                CollectionAssert.AreEqual(calculatorOutput.Select(co => co.LowerBoundary), output.Select(o => o.LowerBoundary));
+                CollectionAssert.AreEqual(calculatorOutput.Select(co => co.UpperBoundary), output.Select(o => o.UpperBoundary));
+                CollectionAssert.AreEqual(calculatorOutput.Select(co => co.Group), output.Select(o => o.Group));
+            }
+        }
+
+        [Test]
+        public void CreateGeotechnicFailureMechanismSectionAssemblyCategories_CalculatorThrowsException_ThrowsAssemblyFactoryException()
+        {
+            // Setup
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+                calculator.ThrowExceptionOnCalculate = true;
+
+                // Call
+                TestDelegate test = () => AssemblyToolCategoriesFactory.CreateGeotechnicFailureMechanismSectionAssemblyCategories(0, 0, 0, 0);
+
+                // Assert
+                var exception = Assert.Throws<AssemblyFactoryException>(test);
+                Assert.IsInstanceOf<AssemblyCategoriesCalculatorException>(exception.InnerException);
+                Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            }
+        }
     }
 }
\ No newline at end of file