Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs
===================================================================
diff -u -r19fd80cc583267703afacd8eb812d170d3282fa0 -r7b5c9aa3a65821c1b219ba3ef2c99830c1e25d8a
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs	(.../AssemblyCategoryCreator.cs)	(revision 19fd80cc583267703afacd8eb812d170d3282fa0)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs	(.../AssemblyCategoryCreator.cs)	(revision 7b5c9aa3a65821c1b219ba3ef2c99830c1e25d8a)
@@ -61,6 +61,32 @@
         }
 
         /// <summary>
+        /// Creates an <see cref="IEnumerable{FailureMechanismSectionAssemblyCategory}"/>
+        /// based on the information given in the <paramref name="output"/>.
+        /// </summary>
+        /// <param name="output">The output to create the result for.</param>
+        /// <returns>An <see cref="IEnumerable{FailureMechanismSectionAssemblyCategory}"/>
+        /// with information taken from the <paramref name="output"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/> is <c>null</c>.</exception>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="FailureMechanismSectionCategoryGroup"/>
+        /// is an invalid value.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <see cref="FailureMechanismSectionCategoryGroup"/>
+        /// is a valid value, but unsupported.</exception>
+        public static IEnumerable<FailureMechanismSectionAssemblyCategory> CreateFailureMechanismSectionAssemblyCategories(
+            CalculationOutput<FailureMechanismSectionCategory[]> output)
+        {
+            if (output == null)
+            {
+                throw new ArgumentNullException(nameof(output));
+            }
+
+            return output.Result.Select(
+                categoriesOutput => new FailureMechanismSectionAssemblyCategory(categoriesOutput.LowerBoundary,
+                                                                                categoriesOutput.UpperBoundary,
+                                                                                ConvertFailureMechanismSectionCategoryGroup(categoriesOutput.CategoryGroup))).ToArray();
+        }
+
+        /// <summary>
         /// Converts a <see cref="category"/> into a <see cref="AssessmentSectionAssemblyCategoryGroup"/>.
         /// </summary>
         /// <param name="category">The <see cref="AssessmentSectionCategoryGroup"/> to convert.</param>
@@ -94,5 +120,48 @@
                     throw new NotSupportedException();
             }
         }
+
+        /// <summary>
+        /// Converts a <see cref="category"/> into a <see cref="FailureMechanismSectionCategoryGroup"/>.
+        /// </summary>
+        /// <param name="category">The <see cref="FailureMechanismSectionCategoryGroup"/> to convert.</param>
+        /// <returns>A <see cref="FailureMechanismSectionAssemblyCategoryGroup"/> based on <paramref name="category"/>.</returns>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="category"/>
+        /// is an invalid value.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <paramref name="category"/>
+        /// is a valid value, but unsupported.</exception>
+        private static FailureMechanismSectionAssemblyCategoryGroup ConvertFailureMechanismSectionCategoryGroup(FailureMechanismSectionCategoryGroup category)
+        {
+            if (!Enum.IsDefined(typeof(FailureMechanismSectionCategoryGroup), category))
+            {
+                throw new InvalidEnumArgumentException(nameof(category),
+                                                       (int) category,
+                                                       typeof(FailureMechanismSectionCategoryGroup));
+            }
+
+            switch (category)
+            {
+                case FailureMechanismSectionCategoryGroup.Iv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.Iv;
+                case FailureMechanismSectionCategoryGroup.IIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.IIv;
+                case FailureMechanismSectionCategoryGroup.IIIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.IIIv;
+                case FailureMechanismSectionCategoryGroup.IVv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.IVv;
+                case FailureMechanismSectionCategoryGroup.Vv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.Vv;
+                case FailureMechanismSectionCategoryGroup.VIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.VIv;
+                case FailureMechanismSectionCategoryGroup.VIIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.VIIv;
+                case FailureMechanismSectionCategoryGroup.NotApplicable:
+                    return FailureMechanismSectionAssemblyCategoryGroup.NotApplicable;
+                case FailureMechanismSectionCategoryGroup.None:
+                    return FailureMechanismSectionAssemblyCategoryGroup.None;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/AssemblyCategoryAssert.cs
===================================================================
diff -u -r78a2d68d97b329b4c1309349a564b6a52448accd -r7b5c9aa3a65821c1b219ba3ef2c99830c1e25d8a
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/AssemblyCategoryAssert.cs	(.../AssemblyCategoryAssert.cs)	(revision 78a2d68d97b329b4c1309349a564b6a52448accd)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/AssemblyCategoryAssert.cs	(.../AssemblyCategoryAssert.cs)	(revision 7b5c9aa3a65821c1b219ba3ef2c99830c1e25d8a)
@@ -42,17 +42,34 @@
         /// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
         /// is not equal to <paramref name="original"/>.</exception>
         public static void AssertAssessmentSectionAssemblyCategories(CalculationOutput<AssessmentSectionCategory[]> original,
-                                                                           IEnumerable<AssessmentSectionAssemblyCategory> actual)
+                                                                     IEnumerable<AssessmentSectionAssemblyCategory> actual)
         {
             Assert.AreEqual(original.Result.Length, actual.Count());
 
-            CollectionAssert.AreEqual(original.Result.Select(o => GetCategoryGroup(o.CategoryGroup)), actual.Select(r => r.Group));
+            CollectionAssert.AreEqual(original.Result.Select(o => GetAssessmentSectionCategoryGroup(o.CategoryGroup)), actual.Select(r => r.Group));
             CollectionAssert.AreEqual(original.Result.Select(o => o.LowerBoundary), actual.Select(r => r.LowerBoundary));
             CollectionAssert.AreEqual(original.Result.Select(o => o.UpperBoundary), actual.Select(r => r.UpperBoundary));
         }
 
-        private static AssessmentSectionAssemblyCategoryGroup GetCategoryGroup(AssessmentSectionCategoryGroup category)
+        /// <summary>
+        /// Asserts whether <paramref name="actual"/> is equal to <paramref name="original"/>.
+        /// </summary>
+        /// <param name="original">The original <see cref="CalculationOutput{T}"/>.</param>
+        /// <param name="actual">The actual <see cref="IEnumerable{T}"/>.</param>
+        /// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
+        /// is not equal to <paramref name="original"/>.</exception>
+        public static void AssertFailureMechanismSectionAssemblyCategories(CalculationOutput<FailureMechanismSectionCategory[]> original,
+                                                                           IEnumerable<FailureMechanismSectionAssemblyCategory> actual)
         {
+            Assert.AreEqual(original.Result.Length, actual.Count());
+
+            CollectionAssert.AreEqual(original.Result.Select(o => GetFailureMechanismSectionCategoryGroup(o.CategoryGroup)), actual.Select(r => r.Group));
+            CollectionAssert.AreEqual(original.Result.Select(o => o.LowerBoundary), actual.Select(r => r.LowerBoundary));
+            CollectionAssert.AreEqual(original.Result.Select(o => o.UpperBoundary), actual.Select(r => r.UpperBoundary));
+        }
+
+        private static AssessmentSectionAssemblyCategoryGroup GetAssessmentSectionCategoryGroup(AssessmentSectionCategoryGroup category)
+        {
             switch (category)
             {
                 case AssessmentSectionCategoryGroup.APlus:
@@ -69,5 +86,32 @@
                     throw new NotSupportedException();
             }
         }
+
+        private static FailureMechanismSectionAssemblyCategoryGroup GetFailureMechanismSectionCategoryGroup(FailureMechanismSectionCategoryGroup category)
+        {
+            switch (category)
+            {
+                case FailureMechanismSectionCategoryGroup.Iv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.Iv;
+                case FailureMechanismSectionCategoryGroup.IIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.IIv;
+                case FailureMechanismSectionCategoryGroup.IIIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.IIIv;
+                case FailureMechanismSectionCategoryGroup.IVv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.IVv;
+                case FailureMechanismSectionCategoryGroup.Vv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.Vv;
+                case FailureMechanismSectionCategoryGroup.VIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.VIv;
+                case FailureMechanismSectionCategoryGroup.VIIv:
+                    return FailureMechanismSectionAssemblyCategoryGroup.VIIv;
+                case FailureMechanismSectionCategoryGroup.NotApplicable:
+                    return FailureMechanismSectionAssemblyCategoryGroup.NotApplicable;
+                case FailureMechanismSectionCategoryGroup.None:
+                    return FailureMechanismSectionAssemblyCategoryGroup.None;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/AssemblyCategoryCreatorTest.cs
===================================================================
diff -u -r78a2d68d97b329b4c1309349a564b6a52448accd -r7b5c9aa3a65821c1b219ba3ef2c99830c1e25d8a
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/AssemblyCategoryCreatorTest.cs	(.../AssemblyCategoryCreatorTest.cs)	(revision 78a2d68d97b329b4c1309349a564b6a52448accd)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/AssemblyCategoryCreatorTest.cs	(.../AssemblyCategoryCreatorTest.cs)	(revision 7b5c9aa3a65821c1b219ba3ef2c99830c1e25d8a)
@@ -110,5 +110,84 @@
 
             Assert.AreEqual(expectedCategoryGroup, categoryResult.Group);
         }
+
+        [Test]
+        public void CreateFailureMechanismSectionAssemblyCategories_OutputNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AssemblyCategoryCreator.CreateFailureMechanismSectionAssemblyCategories(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("output", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateFailureMechanismSectionAssemblyCategories_WithOutput_ReturnFailureMechanismSectionAssemblyCategoryResult()
+        {
+            // Setup
+            var random = new Random(11);
+
+            var output = new CalculationOutput<FailureMechanismSectionCategory[]>(new[]
+            {
+                new FailureMechanismSectionCategory(random.NextEnumValue<FailureMechanismSectionCategoryGroup>(), new Probability(random.Next(1)), new Probability(random.Next(1, 2))),
+                new FailureMechanismSectionCategory(random.NextEnumValue<FailureMechanismSectionCategoryGroup>(), new Probability(random.Next(1)), new Probability(random.Next(1, 2))),
+                new FailureMechanismSectionCategory(random.NextEnumValue<FailureMechanismSectionCategoryGroup>(), new Probability(random.Next(1)), new Probability(random.Next(1, 2))),
+                new FailureMechanismSectionCategory(random.NextEnumValue<FailureMechanismSectionCategoryGroup>(), new Probability(random.Next(1)), new Probability(random.Next(1, 2)))
+            });
+
+            // Call
+            IEnumerable<FailureMechanismSectionAssemblyCategory> result = AssemblyCategoryCreator.CreateFailureMechanismSectionAssemblyCategories(output);
+
+            // Assert
+            AssemblyCategoryAssert.AssertFailureMechanismSectionAssemblyCategories(output, result);
+        }
+
+        [Test]
+        public void CreateFailureMechanismSectionAssemblyCategories_CategoryWithInvalidFailureMechanismSectionAssemblyCategory_ThrowsInvalidEnumArgumentException()
+        {
+            // Setup
+            var output = new CalculationOutput<FailureMechanismSectionCategory[]>(new[]
+            {
+                new FailureMechanismSectionCategory((FailureMechanismSectionCategoryGroup) 99, new Probability(0), new Probability(0))
+            });
+
+            // Call
+            TestDelegate test = () => AssemblyCategoryCreator.CreateFailureMechanismSectionAssemblyCategories(output);
+
+            // Assert
+            const string exceptionMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionCategoryGroup'.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, exceptionMessage);
+        }
+
+        [Test]
+        [TestCase(FailureMechanismSectionCategoryGroup.Iv, FailureMechanismSectionAssemblyCategoryGroup.Iv)]
+        [TestCase(FailureMechanismSectionCategoryGroup.IIv, FailureMechanismSectionAssemblyCategoryGroup.IIv)]
+        [TestCase(FailureMechanismSectionCategoryGroup.IIIv, FailureMechanismSectionAssemblyCategoryGroup.IIIv)]
+        [TestCase(FailureMechanismSectionCategoryGroup.IVv, FailureMechanismSectionAssemblyCategoryGroup.IVv)]
+        [TestCase(FailureMechanismSectionCategoryGroup.Vv, FailureMechanismSectionAssemblyCategoryGroup.Vv)]
+        [TestCase(FailureMechanismSectionCategoryGroup.VIv, FailureMechanismSectionAssemblyCategoryGroup.VIv)]
+        [TestCase(FailureMechanismSectionCategoryGroup.VIIv, FailureMechanismSectionAssemblyCategoryGroup.VIIv)]
+        [TestCase(FailureMechanismSectionCategoryGroup.NotApplicable, FailureMechanismSectionAssemblyCategoryGroup.NotApplicable)]
+        [TestCase(FailureMechanismSectionCategoryGroup.None, FailureMechanismSectionAssemblyCategoryGroup.None)]
+        public void CreateFailureMechanismSectionAssemblyCategories_CategoryWithValidFailureMechanismSectionAssemblyCategory_ExpectedFailureMechanismSectionAssemblyCategoryResultType(
+            FailureMechanismSectionCategoryGroup categoryGroup,
+            FailureMechanismSectionAssemblyCategoryGroup expectedCategoryGroup)
+        {
+            // Setup
+            var output = new CalculationOutput<FailureMechanismSectionCategory[]>(new[]
+            {
+                new FailureMechanismSectionCategory(categoryGroup, new Probability(0), new Probability(0))
+            });
+
+            // Call
+            IEnumerable<FailureMechanismSectionAssemblyCategory> result = AssemblyCategoryCreator.CreateFailureMechanismSectionAssemblyCategories(output);
+
+            // Assert
+            Assert.AreEqual(1, result.Count());
+            FailureMechanismSectionAssemblyCategory categoryResult = result.First();
+
+            Assert.AreEqual(expectedCategoryGroup, categoryResult.Group);
+        }
     }
 }
\ No newline at end of file