Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs
===================================================================
diff -u -rb367efdde65a653439701bfd39029804ac363353 -r4b060445285130255df24b3b1e3cfae6d85caf19
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision b367efdde65a653439701bfd39029804ac363353)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision 4b060445285130255df24b3b1e3cfae6d85caf19)
@@ -170,60 +170,25 @@
         }
 
         /// <summary>
-        /// Creates an <see cref="IEnumerable{T}"/> of <see cref="FailureMechanismSectionAssemblyCategoryResult"/> based on the given parameters.
-        /// </summary>
-        /// <param name="simpleAssembly">The simple assembly to convert.</param>
-        /// <param name="detailedAssembly">The detailed assembly to convert.</param>
-        /// <param name="tailorMadeAssembly">The tailor made assembly to convert.</param>
-        /// <returns>The created <see cref="IEnumerable{T}"/> of <see cref="FailureMechanismSectionAssemblyCategoryResult"/>.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
-        /// <exception cref="InvalidEnumArgumentException">Thrown when a <see cref="FailureMechanismSectionAssembly"/> contains
-        /// an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
-        /// <exception cref="NotSupportedException">Thrown when <see cref="FailureMechanismSectionAssembly"/> contains
-        /// a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
-        /// <exception cref="AssemblyToolKernelException">Thrown when any input parameter has an
-        /// invalid value.</exception>
-        public static IEnumerable<FailureMechanismSectionAssemblyCategoryResult> CreateCombinedAssemblyCalculationInput(
-            FailureMechanismSectionAssembly simpleAssembly,
-            FailureMechanismSectionAssembly detailedAssembly,
-            FailureMechanismSectionAssembly tailorMadeAssembly)
-        {
-            if (simpleAssembly == null)
-            {
-                throw new ArgumentNullException(nameof(simpleAssembly));
-            }
-
-            if (detailedAssembly == null)
-            {
-                throw new ArgumentNullException(nameof(detailedAssembly));
-            }
-
-            if (tailorMadeAssembly == null)
-            {
-                throw new ArgumentNullException(nameof(tailorMadeAssembly));
-            }
-
-            return new[]
-            {
-                CreateFailureMechanismSectionAssemblyCategoryResult(simpleAssembly),
-                CreateFailureMechanismSectionAssemblyCategoryResult(detailedAssembly),
-                CreateFailureMechanismSectionAssemblyCategoryResult(tailorMadeAssembly)
-            };
-        }
-
-        /// <summary>
         /// Creates <see cref="FailureMechanismSectionAssemblyCategoryResult"/> based on the given parameters.
         /// </summary>
         /// <param name="assembly">The assembly to convert.</param>
         /// <returns>The created <see cref="FailureMechanismSectionAssemblyCategoryResult"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="assembly"/>
+        /// is <c>null</c>.</exception>
         /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="assembly"/> contains
         /// an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
         /// <exception cref="NotSupportedException">Thrown when <see cref="assembly"/> contains
         /// a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
         /// <exception cref="AssemblyToolKernelException">Thrown when any input parameter has an
         /// invalid value.</exception>
-        private static FailureMechanismSectionAssemblyCategoryResult CreateFailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionAssembly assembly)
+        public static FailureMechanismSectionAssemblyCategoryResult CreateFailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionAssembly assembly)
         {
+            if (assembly == null)
+            {
+                throw new ArgumentNullException(nameof(assembly));
+            }
+
             return new FailureMechanismSectionAssemblyCategoryResult(
                 ConvertFailureMechanismSectionAssemblyCategoryGroup(assembly.Group),
                 new Probability(assembly.Probability));
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs
===================================================================
diff -u -rb367efdde65a653439701bfd39029804ac363353 -r4b060445285130255df24b3b1e3cfae6d85caf19
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision b367efdde65a653439701bfd39029804ac363353)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision 4b060445285130255df24b3b1e3cfae6d85caf19)
@@ -20,7 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using AssemblyTool.Kernel.Assembly.CalculatorInput;
@@ -246,48 +245,17 @@
         }
 
         [Test]
-        public void CreateCombinedAssemblyCalculationInput_SimpleAssemblyNull_ThrowsArgumentNullException()
+        public void CreateFailureMechanismSectionAssemblyCategoryResult_AssemblyNull_ThrowsArgumentNullException()
         {
             // Call
-            TestDelegate call = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateCombinedAssemblyCalculationInput(
-                null,
-                new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.None),
-                new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.None));
+            TestDelegate call = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyCategoryResult(null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
-            Assert.AreEqual("simpleAssembly", exception.ParamName);
+            Assert.AreEqual("assembly", exception.ParamName);
         }
 
         [Test]
-        public void CreateCombinedAssemblyCalculationInput_DetailedAssemblyNull_ThrowsArgumentNullException()
-        {
-            // Call
-            TestDelegate call = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateCombinedAssemblyCalculationInput(
-                new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.None),
-                null,
-                new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.None));
-
-            // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
-            Assert.AreEqual("detailedAssembly", exception.ParamName);
-        }
-
-        [Test]
-        public void CreateCombinedAssemblyCalculationInput_TailorMadeAssemblyNull_ThrowsArgumentNullException()
-        {
-            // Call
-            TestDelegate call = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateCombinedAssemblyCalculationInput(
-                new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.None),
-                new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.None),
-                null);
-
-            // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
-            Assert.AreEqual("tailorMadeAssembly", exception.ParamName);
-        }
-
-        [Test]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
@@ -297,65 +265,33 @@
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
-        public void CreateCombinedAssemblyCalculationInput_WithInput_ReturnFailureMechanismSectionAssemblyCategoryResults(
+        public void CreateFailureMechanismSectionAssemblyCategoryResult_WithAssembly_ReturnFailureMechanismSectionAssemblyCategoryResult(
             FailureMechanismSectionAssemblyCategoryGroup originalGroup,
             FailureMechanismSectionCategoryGroup expectedGroup)
         {
             // Setup
             var random = new Random(11);
-            var simpleAssembly = new FailureMechanismSectionAssembly(random.NextDouble(), originalGroup);
-            var detailedAssembly = new FailureMechanismSectionAssembly(random.NextDouble(), originalGroup);
-            var tailorMadeAssembly = new FailureMechanismSectionAssembly(random.NextDouble(), originalGroup);
+            var asesmbly = new FailureMechanismSectionAssembly(random.NextDouble(), originalGroup);
 
             // Call
-            FailureMechanismSectionAssemblyCategoryResult[] input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateCombinedAssemblyCalculationInput(
-                simpleAssembly, detailedAssembly, tailorMadeAssembly).ToArray();
+            FailureMechanismSectionAssemblyCategoryResult input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyCategoryResult(
+                asesmbly);
 
             // Assert
-            Assert.AreEqual(3, input.Length);
-            FailureMechanismSectionAssemblyCategoryResult simpleAssemblyInput = input[0];
-            Assert.AreEqual(simpleAssembly.Probability, simpleAssemblyInput.EstimatedProbabilityOfFailure);
-            Assert.AreEqual(expectedGroup, simpleAssemblyInput.CategoryGroup);
-            FailureMechanismSectionAssemblyCategoryResult detailedAssemblyInput = input[1];
-            Assert.AreEqual(detailedAssembly.Probability, detailedAssemblyInput.EstimatedProbabilityOfFailure);
-            Assert.AreEqual(expectedGroup, detailedAssemblyInput.CategoryGroup);
-            FailureMechanismSectionAssemblyCategoryResult tailorMadeAssemblyInput = input[2];
-            Assert.AreEqual(tailorMadeAssembly.Probability, tailorMadeAssemblyInput.EstimatedProbabilityOfFailure);
-            Assert.AreEqual(expectedGroup, tailorMadeAssemblyInput.CategoryGroup);
+            Assert.AreEqual(asesmbly.Probability, input.EstimatedProbabilityOfFailure);
+            Assert.AreEqual(expectedGroup, input.CategoryGroup);
         }
 
         [Test]
-        [TestCaseSource(nameof(GetFailureMechanismSectionAssembliesWithInvalidEnum))]
-        public void CreateCombinedAssemblyCalculationInput_WithInvalidEnumInput_ThrowInvalidEnumArgumentException(
-            FailureMechanismSectionAssembly simpleAssembly,
-            FailureMechanismSectionAssembly detailedAssembly,
-            FailureMechanismSectionAssembly tailorMadeAssembly)
+        public void CreateFailureMechanismSectionAssemblyCategoryResult_WithInvalidEnumInput_ThrowInvalidEnumArgumentException()
         {
             // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateCombinedAssemblyCalculationInput(
-                simpleAssembly, detailedAssembly, tailorMadeAssembly);
+            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyCategoryResult(
+                new FailureMechanismSectionAssembly(0, (FailureMechanismSectionAssemblyCategoryGroup)99));
 
             // Assert
             const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
         }
-
-        private static IEnumerable<TestCaseData> GetFailureMechanismSectionAssembliesWithInvalidEnum()
-        {
-            var random = new Random(11);
-
-            yield return new TestCaseData(
-                new FailureMechanismSectionAssembly(random.NextDouble(), (FailureMechanismSectionAssemblyCategoryGroup) 99),
-                new FailureMechanismSectionAssembly(random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>()), 
-                new FailureMechanismSectionAssembly(random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>()));
-            yield return new TestCaseData(
-                new FailureMechanismSectionAssembly(random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>()),
-                new FailureMechanismSectionAssembly(random.NextDouble(), (FailureMechanismSectionAssemblyCategoryGroup)99),
-                new FailureMechanismSectionAssembly(random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>()));
-            yield return new TestCaseData(
-                new FailureMechanismSectionAssembly(random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>()),
-                new FailureMechanismSectionAssembly(random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>()),
-                new FailureMechanismSectionAssembly(random.NextDouble(), (FailureMechanismSectionAssemblyCategoryGroup)99));
-        }
     }
 }
\ No newline at end of file