Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs
===================================================================
diff -u -rbc3f585dcc4ef814652ff76d2713ffc14fe247cb -rbef7de785c1b8116e6dc9fb4b5a897772ff68e6a
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision bc3f585dcc4ef814652ff76d2713ffc14fe247cb)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision bef7de785c1b8116e6dc9fb4b5a897772ff68e6a)
@@ -212,7 +212,7 @@
         /// </list>
         /// </exception>
         /// <exception cref="NotSupportedException">Thrown when:
-        ///  <list type="bullet">
+        /// <list type="bullet">
         /// <item><see cref="categories"/> contains a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>;</item>
         /// <item><see cref="tailorMadeAssessmentResult"/> a valid but unsupported <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</item>
         /// </list>
@@ -237,6 +237,52 @@
         }
 
         /// <summary>
+        /// Creates <see cref="TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor"/> based on the given parameters.
+        /// </summary>
+        /// <param name="tailorMadeAssessmentResult">The tailor made assessment result to create
+        /// the input for.</param>
+        /// <param name="probability">The calculated probability to create the input for.</param>
+        /// <param name="categories">A collection of <see cref="FailureMechanismSectionAssemblyCategory"/> to
+        /// create the input for.</param>
+        /// <param name="n">The 'N' parameter used to factor in the 'length effect'.</param>
+        /// <returns>The created <see cref="TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="categories"/>
+        /// is <c>null</c>.</exception>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when:
+        /// <list type="bullet">
+        /// <item><see cref="categories"/> contains an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>;</item>
+        /// <item><see cref="tailorMadeAssessmentResult"/> is an invalid <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</item>
+        /// </list>
+        /// </exception>
+        /// <exception cref="NotSupportedException">Thrown when:
+        /// <list type="bullet">
+        /// <item><see cref="categories"/> contains a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>;</item>
+        /// <item><see cref="tailorMadeAssessmentResult"/> a valid but unsupported <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</item>
+        /// </list>
+        /// </exception>
+        /// <exception cref="AssemblyToolKernelException">Thrown when any input parameter has an
+        /// invalid value.</exception>
+        public static TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+            TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult,
+            double probability,
+            IEnumerable<FailureMechanismSectionAssemblyCategory> categories,
+            double n)
+        {
+            if (categories == null)
+            {
+                throw new ArgumentNullException(nameof(categories));
+            }
+
+            return new TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+                ConvertTailorMadeProbabilityCalculationResult(tailorMadeAssessmentResult, probability),
+                categories.Select(category => new FailureMechanismSectionCategory(
+                                      ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group),
+                                      new Probability(category.LowerBoundary),
+                                      new Probability(category.UpperBoundary))).ToArray(),
+                n);
+        }
+
+        /// <summary>
         /// Converts a <see cref="FailureMechanismSectionAssemblyCategoryGroup"/> into a <see cref="FailureMechanismSectionCategoryGroup"/>.
         /// </summary>
         /// <param name="category">The <see cref="FailureMechanismSectionAssemblyCategoryGroup"/> to convert.</param>
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs
===================================================================
diff -u -r6badc3eccf485d334217250d2e261e18dfc86727 -rbef7de785c1b8116e6dc9fb4b5a897772ff68e6a
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision 6badc3eccf485d334217250d2e261e18dfc86727)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision bef7de785c1b8116e6dc9fb4b5a897772ff68e6a)
@@ -501,6 +501,178 @@
             Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
         }
 
+        [Test]
+        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_CategoriesNull_ThrowArgumentNullException()
+        {
+            // Setup
+            var random = new Random(39);
+
+            // Call
+            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+                random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
+                random.NextDouble(),
+                null,
+                random.NextDouble());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("categories", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_WithInvalidResultEnumInput_ThrowInvalidEnumArgumentException()
+        {
+            // Setup
+            var random = new Random(39);
+
+            // Call
+            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+                (TailorMadeAssessmentProbabilityCalculationResultType) 99,
+                random.NextDouble(),
+                Enumerable.Empty<FailureMechanismSectionAssemblyCategory>(),
+                random.NextDouble());
+
+            // Assert
+            const string expectedMessage = "The value of argument 'tailorMadeAssessmentResult' (99) is invalid for Enum type 'TailorMadeAssessmentProbabilityCalculationResultType'.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_WithInvalidCategoryEnumInput_ThrowInvalidEnumArgumentException()
+        {
+            // Setup
+            var random = new Random(39);
+
+            // Call
+            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+                random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
+                random.NextDouble(),
+                new[]
+                {
+                    new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
+                                                                random.NextDouble(),
+                                                                (FailureMechanismSectionAssemblyCategoryGroup) 99)
+                },
+                random.NextDouble());
+
+            // Assert
+            const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
+        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_ValidData_ReturnTailorMadeCalculationInputFromProbabilityWithLengthEffectFactorWithCorrectCategories(
+            FailureMechanismSectionAssemblyCategoryGroup originalResult,
+            FailureMechanismSectionCategoryGroup expectedResult)
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double lowerBoundary = random.NextDouble(0.0, 0.5);
+            double upperBoundary = random.NextDouble(0.6, 1.0);
+
+            // Call
+            TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor result =
+                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+                    random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
+                    probability,
+                    new[]
+                    {
+                        new FailureMechanismSectionAssemblyCategory(lowerBoundary,
+                                                                    upperBoundary,
+                                                                    originalResult)
+                    },
+                    random.NextDouble(1.0, 10.0));
+
+            // Assert
+            FailureMechanismSectionCategory actualCategory = result.Categories.Single();
+            Assert.AreEqual(expectedResult, actualCategory.CategoryGroup);
+            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
+            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
+        }
+
+        [Test]
+        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.None, TailorMadeProbabilityCalculationResultGroup.None)]
+        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.ProbabilityNegligible, TailorMadeProbabilityCalculationResultGroup.FV)]
+        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.NotAssessed, TailorMadeProbabilityCalculationResultGroup.NGO)]
+        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_ValidDataNotProbability_ReturnTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+            TailorMadeAssessmentProbabilityCalculationResultType originalResult,
+            TailorMadeProbabilityCalculationResultGroup expectedResult)
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double lowerBoundary = random.NextDouble(0.0, 0.5);
+            double upperBoundary = random.NextDouble(0.6, 1.0);
+            double n = random.NextDouble(1.0, 10.0);
+            const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv;
+
+            // Call
+            TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+                originalResult,
+                probability,
+                new[]
+                {
+                    new FailureMechanismSectionAssemblyCategory(lowerBoundary,
+                                                                upperBoundary,
+                                                                categoryGroup)
+                },
+                n);
+
+            // Assert
+            Assert.AreEqual(expectedResult, input.Result.CalculationResultGroup);
+            Assert.AreEqual(0.0, input.Result.Probability);
+            Assert.AreEqual(n, input.NValue);
+
+            FailureMechanismSectionCategory actualCategory = input.Categories.Single();
+            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
+            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
+            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
+        }
+
+        [Test]
+        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_ValidDataProbability_ReturnTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double lowerBoundary = random.NextDouble(0.0, 0.5);
+            double upperBoundary = random.NextDouble(0.6, 1.0);
+            double n = random.NextDouble(1.0, 10.0);
+            const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv;
+
+            // Call
+            TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
+                TailorMadeAssessmentProbabilityCalculationResultType.Probability,
+                probability,
+                new[]
+                {
+                    new FailureMechanismSectionAssemblyCategory(lowerBoundary,
+                                                                upperBoundary,
+                                                                categoryGroup)
+                },
+                n);
+
+            // Assert
+            Assert.AreEqual(TailorMadeProbabilityCalculationResultGroup.Probability, input.Result.CalculationResultGroup);
+            Assert.AreEqual(probability, input.Result.Probability);
+            Assert.AreEqual(n, input.NValue);
+
+            FailureMechanismSectionCategory actualCategory = input.Categories.Single();
+            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
+            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
+            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
+        }
+
         #endregion
     }
 }
\ No newline at end of file