Index: Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs
===================================================================
diff -u -rbaf9e7a385fd374010f076868ddccc77b4da17ce -r8b119f52dad2aeba53f63b9bde9e6176452e834e
--- Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs	(.../AssemblyToolCategoriesFactory.cs)	(revision baf9e7a385fd374010f076868ddccc77b4da17ce)
+++ Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs	(.../AssemblyToolCategoriesFactory.cs)	(revision 8b119f52dad2aeba53f63b9bde9e6176452e834e)
@@ -56,6 +56,38 @@
         }
 
         /// <summary>
+        /// Creates the failure mechanism 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="failureMechanismContribution">The failure mechanism contribution to calculate with.</param>
+        /// <param name="n">The 'N' parameter used to factor in the 'length effect'.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> with categories of
+        /// <see cref="FailureMechanismAssemblyCategory"/>.</returns>
+        /// <exception cref="AssemblyException">Thrown when an error occurred while creating the categories.</exception>
+        public static IEnumerable<FailureMechanismAssemblyCategory> CreateFailureMechanismAssemblyCategories(
+            double signalingNorm,
+            double lowerLimitNorm,
+            double failureMechanismContribution,
+            double n)
+        {
+            IAssemblyCategoriesCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateAssemblyCategoriesCalculator(
+                AssemblyToolKernelFactory.Instance);
+
+            try
+            {
+                return calculator.CalculateFailureMechanismCategories(new AssemblyCategoriesInput(n,
+                                                                                                  failureMechanismContribution,
+                                                                                                  signalingNorm,
+                                                                                                  lowerLimitNorm));
+            }
+            catch (AssemblyCategoriesCalculatorException e)
+            {
+                throw new AssemblyException(e.Message, e);
+            }
+        }
+
+        /// <summary>
         /// Creates the failure mechanism section assembly categories.
         /// </summary>
         /// <param name="signalingNorm">The signaling norm to use in the calculation.</param>
Index: Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs
===================================================================
diff -u -rbaf9e7a385fd374010f076868ddccc77b4da17ce -r8b119f52dad2aeba53f63b9bde9e6176452e834e
--- Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs	(.../AssemblyToolCategoriesFactoryTest.cs)	(revision baf9e7a385fd374010f076868ddccc77b4da17ce)
+++ Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs	(.../AssemblyToolCategoriesFactoryTest.cs)	(revision 8b119f52dad2aeba53f63b9bde9e6176452e834e)
@@ -104,6 +104,88 @@
         }
 
         [Test]
+        public void CreateFailureMechanismAssemblyCategories_WithInput_SetsInputOnCalculator()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double failureMechanismContribution = random.NextDouble();
+            double n = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                AssemblyToolCategoriesFactory.CreateFailureMechanismAssemblyCategories(signalingNorm,
+                                                                                       lowerLimitNorm,
+                                                                                       failureMechanismContribution,
+                                                                                       n);
+
+                // Assert
+                AssemblyCategoriesInput assemblyCategoriesInput = calculator.AssemblyCategoriesInput;
+                Assert.AreEqual(signalingNorm, assemblyCategoriesInput.SignalingNorm);
+                Assert.AreEqual(lowerLimitNorm, assemblyCategoriesInput.LowerLimitNorm);
+                Assert.AreEqual(failureMechanismContribution / 100, assemblyCategoriesInput.FailureMechanismContribution);
+                Assert.AreEqual(n, assemblyCategoriesInput.N);
+            }
+        }
+
+        [Test]
+        public void CreateFailureMechanismAssemblyCategories_CalculatorRan_ReturnsOutput()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double failureMechanismContribution = random.NextDouble();
+            double n = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                FailureMechanismAssemblyCategory[] output = AssemblyToolCategoriesFactory.CreateFailureMechanismAssemblyCategories(
+                    signalingNorm,
+                    lowerLimitNorm,
+                    failureMechanismContribution,
+                    n).ToArray();
+
+                // Assert
+                FailureMechanismAssemblyCategory[] calculatorOutput = calculator.FailureMechanismCategoriesOutput.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 CreateFailureMechanismAssemblyCategories_CalculatorThrowsException_ThrowsAssemblyException()
+        {
+            // Setup
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+                calculator.ThrowExceptionOnCalculate = true;
+
+                // Call
+                TestDelegate test = () => AssemblyToolCategoriesFactory.CreateFailureMechanismAssemblyCategories(0, 0, 0, 0);
+
+                // Assert
+                var exception = Assert.Throws<AssemblyException>(test);
+                Assert.IsInstanceOf<AssemblyCategoriesCalculatorException>(exception.InnerException);
+                Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            }
+        }
+
+        [Test]
         public void CreateFailureMechanismSectionAssemblyCategories_WithInput_SetsInputOnCalculator()
         {
             // Setup