Index: Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs
===================================================================
diff -u -r442f20a0b0fad631a079f542068483de27670a31 -r838bb1c311bac154e5a2c61ebe25e36d44f3fe17
--- Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs	(.../AssemblyToolCategoriesFactory.cs)	(revision 442f20a0b0fad631a079f542068483de27670a31)
+++ Ringtoets/Common/src/Ringtoets.Common.Data/AssemblyTool/AssemblyToolCategoriesFactory.cs	(.../AssemblyToolCategoriesFactory.cs)	(revision 838bb1c311bac154e5a2c61ebe25e36d44f3fe17)
@@ -87,6 +87,36 @@
         }
 
         /// <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="failureProbabilityMarginFactor">The failure probability margin factor to
+        /// calculate with.</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 failureProbabilityMarginFactor)
+        {
+            IAssemblyCategoriesCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateAssemblyCategoriesCalculator(
+                AssemblyToolKernelFactory.Instance);
+
+            try
+            {
+                return calculator.CalculateFailureMechanismCategories(new AssemblyCategoriesInput(
+                                                                          1, failureProbabilityMarginFactor,
+                                                                          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 -r2a71f68f6907092e21a39aa7a16c25be80ea9523 -r838bb1c311bac154e5a2c61ebe25e36d44f3fe17
--- Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs	(.../AssemblyToolCategoriesFactoryTest.cs)	(revision 2a71f68f6907092e21a39aa7a16c25be80ea9523)
+++ Ringtoets/Common/test/Ringtoets.Common.Data.Test/AssemblyTool/AssemblyToolCategoriesFactoryTest.cs	(.../AssemblyToolCategoriesFactoryTest.cs)	(revision 838bb1c311bac154e5a2c61ebe25e36d44f3fe17)
@@ -104,7 +104,7 @@
         }
 
         [Test]
-        public void CreateFailureMechanismAssemblyCategories_WithInput_SetsInputOnCalculator()
+        public void CreateFailureMechanismAssemblyCategoriesWithN_WithInput_SetsInputOnCalculator()
         {
             // Setup
             var random = new Random(11);
@@ -134,7 +134,7 @@
         }
 
         [Test]
-        public void CreateFailureMechanismAssemblyCategories_CalculatorRan_ReturnsOutput()
+        public void CreateFailureMechanismAssemblyCategoriesWithN_CalculatorRan_ReturnsOutput()
         {
             // Setup
             var random = new Random(11);
@@ -166,7 +166,7 @@
         }
 
         [Test]
-        public void CreateFailureMechanismAssemblyCategories_CalculatorThrowsException_ThrowsAssemblyException()
+        public void CreateFailureMechanismAssemblyCategoriesWithN_CalculatorThrowsException_ThrowsAssemblyException()
         {
             // Setup
             using (new AssemblyToolCalculatorFactoryConfig())
@@ -186,6 +186,84 @@
         }
 
         [Test]
+        public void CreateFailureMechanismAssemblyCategories_WithInput_SetsInputOnCalculator()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double failureProbabilityMarginFactor = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                AssemblyToolCategoriesFactory.CreateFailureMechanismAssemblyCategories(signalingNorm,
+                                                                                       lowerLimitNorm,
+                                                                                       failureProbabilityMarginFactor);
+
+                // Assert
+                AssemblyCategoriesInput assemblyCategoriesInput = calculator.AssemblyCategoriesInput;
+                Assert.AreEqual(signalingNorm, assemblyCategoriesInput.SignalingNorm);
+                Assert.AreEqual(lowerLimitNorm, assemblyCategoriesInput.LowerLimitNorm);
+                Assert.AreEqual(failureProbabilityMarginFactor , assemblyCategoriesInput.FailureMechanismContribution);
+                Assert.AreEqual(1, assemblyCategoriesInput.N);
+            }
+        }
+
+        [Test]
+        public void CreateFailureMechanismAssemblyCategories_CalculatorRan_ReturnsOutput()
+        {
+            // Setup
+            var random = new Random(11);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = random.NextDouble();
+            double failureProbabilityMarginFactor = random.NextDouble();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssemblyCategoriesCalculatorStub calculator = calculatorFactory.LastCreatedAssemblyCategoriesCalculator;
+
+                // Call
+                FailureMechanismAssemblyCategory[] output = AssemblyToolCategoriesFactory.CreateFailureMechanismAssemblyCategories(
+                    signalingNorm,
+                    lowerLimitNorm,
+                    failureProbabilityMarginFactor).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);
+
+                // 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