Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs	(.../FailureMechanismSectionAssemblyCalculator.cs)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs	(.../FailureMechanismSectionAssemblyCalculator.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using AssemblyTool.Kernel;
 using AssemblyTool.Kernel.Data.AssemblyCategories;
 using Ringtoets.AssemblyTool.Data;
@@ -74,7 +75,7 @@
             {
                 IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
                 CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> output = kernel.SimpleAssessmentDirectFailureMechanisms(
-                    FailureMechanismSectionAssemblyCalculatorInputCreator.CreateSimplecalclCalculationResultValidityOnly(input));
+                    FailureMechanismSectionAssemblyCalculatorInputCreator.CreateSimpleCalculationResultValidityOnly(input));
 
                 return FailureMechanismSectionAssemblyCreator.Create(output.Result);
             }
@@ -83,5 +84,42 @@
                 throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e);
             }
         }
+
+        public FailureMechanismSectionAssembly AssembleDetailedAssessment(double probability, IEnumerable<FailureMechanismSectionAssemblyCategory> categories)
+        {
+            try
+            {
+                IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
+                CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> output = kernel.DetailedAssessmentDirectFailureMechanisms(
+                    FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(probability,
+                                                                                                                        categories));
+
+                return FailureMechanismSectionAssemblyCreator.Create(output.Result);
+            }
+            catch (Exception e)
+            {
+                throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e);
+            }
+        }
+
+        public FailureMechanismSectionAssembly AssembleDetailedAssessment(double probability,
+                                                                          IEnumerable<FailureMechanismSectionAssemblyCategory> categories,
+                                                                          double n)
+        {
+            try
+            {
+                IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
+                CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> output = kernel.DetailedAssessmentDirectFailureMechanisms(
+                    FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(probability,
+                                                                                                                                        categories,
+                                                                                                                                        n));
+
+                return FailureMechanismSectionAssemblyCreator.Create(output.Result);
+            }
+            catch (Exception e)
+            {
+                throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e);
+            }
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs	(.../IFailureMechanismSectionAssemblyCalculator.cs)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs	(.../IFailureMechanismSectionAssemblyCalculator.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -19,6 +19,7 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.Common.Primitives;
 
@@ -53,5 +54,28 @@
         /// <exception cref="FailureMechanismSectionAssemblyCalculatorException">Thrown when
         /// an error occurs when performing the assembly.</exception>
         FailureMechanismSectionAssembly AssembleSimpleAssessment(SimpleAssessmentResultValidityOnlyType input);
+
+        /// <summary>
+        /// Assembles the detailed assessment based on the input parameters.
+        /// </summary>
+        /// <param name="probability">The calculated probability.</param>
+        /// <param name="categories">The list of categories for this failure mechanism section.</param>
+        /// <returns>A <see cref="FailureMechanismSectionAssembly"/>.</returns>
+        /// <exception cref="FailureMechanismSectionAssemblyCalculatorException">Thrown when
+        /// an error occurs when performing the assembly.</exception>
+        FailureMechanismSectionAssembly AssembleDetailedAssessment(double probability, IEnumerable<FailureMechanismSectionAssemblyCategory> categories);
+
+        /// <summary>
+        /// Assembles the detailed assessment based on the input parameters.
+        /// </summary>
+        /// <param name="probability">The calculated probability.</param>
+        /// <param name="categories">The list of categories for this failure mechanism section.</param>
+        /// <param name="n">The 'N' parameter used to factor in the 'length effect'.</param>
+        /// <returns>A <see cref="FailureMechanismSectionAssembly"/>.</returns>
+        /// <exception cref="FailureMechanismSectionAssemblyCalculatorException">Thrown when
+        /// an error occurs when performing the assembly.</exception>
+        FailureMechanismSectionAssembly AssembleDetailedAssessment(double probability,
+                                                                   IEnumerable<FailureMechanismSectionAssemblyCategory> categories,
+                                                                   double n);
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs
===================================================================
diff -u -rb46cba3269d292e5ca3374ec0f75810686cf3ec6 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs	(.../AssemblyCategoryCreator.cs)	(revision b46cba3269d292e5ca3374ec0f75810686cf3ec6)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs	(.../AssemblyCategoryCreator.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -128,7 +128,7 @@
         }
 
         /// <summary>
-        /// Converts a <see cref="category"/> into a <see cref="FailureMechanismSectionCategoryGroup"/>.
+        /// Converts a <see cref="category"/> into a <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.
         /// </summary>
         /// <param name="category">The <see cref="FailureMechanismSectionCategoryGroup"/> to convert.</param>
         /// <returns>A <see cref="FailureMechanismSectionAssemblyCategoryGroup"/> based on <paramref name="category"/>.</returns>
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -20,9 +20,15 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
 using AssemblyTool.Kernel.Assembly;
+using AssemblyTool.Kernel.Assembly.CalculatorInput;
+using AssemblyTool.Kernel.Data;
+using AssemblyTool.Kernel.Data.AssemblyCategories;
 using AssemblyTool.Kernel.Data.CalculationResults;
+using Ringtoets.AssemblyTool.Data;
 using Ringtoets.Common.Primitives;
 
 namespace Ringtoets.AssemblyTool.KernelWrapper.Creators
@@ -74,7 +80,7 @@
         /// is an invalid value.</exception>
         /// <exception cref="NotSupportedException">Thrown when <see cref="SimpleAssessmentResultValidityOnlyType"/>
         /// is a valid value, but unsupported.</exception>
-        public static SimpleCalculationResultValidityOnly CreateSimplecalclCalculationResultValidityOnly(SimpleAssessmentResultValidityOnlyType input)
+        public static SimpleCalculationResultValidityOnly CreateSimpleCalculationResultValidityOnly(SimpleAssessmentResultValidityOnlyType input)
         {
             if (!Enum.IsDefined(typeof(SimpleAssessmentResultValidityOnlyType), input))
             {
@@ -95,5 +101,97 @@
                     throw new NotSupportedException();
             }
         }
+
+        /// <summary>
+        /// Creates <see cref="DetailedCalculationInputFromProbability"/> based on the given parameters.
+        /// </summary>
+        /// <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>
+        /// <returns>The created <see cref="DetailedCalculationInputFromProbability"/>.</returns>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="categories"/> contains
+        /// an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <see cref="categories"/> contains
+        /// a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
+        public static DetailedCalculationInputFromProbability CreateDetailedCalculationInputFromProbability(
+            double probability,
+            IEnumerable<FailureMechanismSectionAssemblyCategory> categories)
+        {
+            return new DetailedCalculationInputFromProbability(new Probability(probability),
+                                                               categories.Select(category => new FailureMechanismSectionCategory(
+                                                                                     ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group),
+                                                                                     new Probability(category.LowerBoundary),
+                                                                                     new Probability(category.UpperBoundary))).ToArray());
+        }
+
+        /// <summary>
+        /// Creates <see cref="DetailedCalculationInputFromProbabilityWithLengthEffect"/> based on the given parameters.
+        /// </summary>
+        /// <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="DetailedCalculationInputFromProbabilityWithLengthEffect"/>.</returns>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="categories"/> contains
+        /// an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <see cref="categories"/> contains
+        /// a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
+        public static DetailedCalculationInputFromProbabilityWithLengthEffect CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
+            double probability,
+            IEnumerable<FailureMechanismSectionAssemblyCategory> categories,
+            double n)
+        {
+            return new DetailedCalculationInputFromProbabilityWithLengthEffect(
+                new Probability(probability),
+                categories.Select(category => new FailureMechanismSectionCategory(
+                                      ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group),
+                                      new Probability(category.LowerBoundary),
+                                      new Probability(category.UpperBoundary))).ToArray(),
+                n);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="category"/> into a <see cref="FailureMechanismSectionCategoryGroup"/>.
+        /// </summary>
+        /// <param name="category">The <see cref="FailureMechanismSectionAssemblyCategoryGroup"/> to convert.</param>
+        /// <returns>A <see cref="FailureMechanismSectionCategoryGroup"/> 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 FailureMechanismSectionCategoryGroup ConvertFailureMechanismSectionAssemblyCategoryGroup(
+            FailureMechanismSectionAssemblyCategoryGroup category)
+        {
+            if (!Enum.IsDefined(typeof(FailureMechanismSectionAssemblyCategoryGroup), category))
+            {
+                throw new InvalidEnumArgumentException(nameof(category),
+                                                       (int) category,
+                                                       typeof(FailureMechanismSectionAssemblyCategoryGroup));
+            }
+
+            switch (category)
+            {
+                case FailureMechanismSectionAssemblyCategoryGroup.Iv:
+                    return FailureMechanismSectionCategoryGroup.Iv;
+                case FailureMechanismSectionAssemblyCategoryGroup.IIv:
+                    return FailureMechanismSectionCategoryGroup.IIv;
+                case FailureMechanismSectionAssemblyCategoryGroup.IIIv:
+                    return FailureMechanismSectionCategoryGroup.IIIv;
+                case FailureMechanismSectionAssemblyCategoryGroup.IVv:
+                    return FailureMechanismSectionCategoryGroup.IVv;
+                case FailureMechanismSectionAssemblyCategoryGroup.Vv:
+                    return FailureMechanismSectionCategoryGroup.Vv;
+                case FailureMechanismSectionAssemblyCategoryGroup.VIv:
+                    return FailureMechanismSectionCategoryGroup.VIv;
+                case FailureMechanismSectionAssemblyCategoryGroup.VIIv:
+                    return FailureMechanismSectionCategoryGroup.VIIv;
+                case FailureMechanismSectionAssemblyCategoryGroup.NotApplicable:
+                    return FailureMechanismSectionCategoryGroup.NotApplicable;
+                case FailureMechanismSectionAssemblyCategoryGroup.None:
+                    return FailureMechanismSectionCategoryGroup.None;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorTest.cs)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorTest.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -21,10 +21,12 @@
 
 using System;
 using System.ComponentModel;
+using System.Linq;
 using AssemblyTool.Kernel;
 using AssemblyTool.Kernel.Data;
 using AssemblyTool.Kernel.Data.AssemblyCategories;
 using AssemblyTool.Kernel.Data.CalculationResults;
+using Core.Common.TestUtil;
 using NUnit.Framework;
 using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
@@ -66,6 +68,39 @@
             Assert.AreEqual("factory", exception.ParamName);
         }
 
+        private static void AssertCalculatorOutput(CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> original, FailureMechanismSectionAssembly actual)
+        {
+            Assert.AreEqual(GetGroup(original.Result.CategoryGroup), actual.Group);
+            Assert.AreEqual(original.Result.EstimatedProbabilityOfFailure, actual.Probability);
+        }
+
+        private static FailureMechanismSectionAssemblyCategoryGroup GetGroup(FailureMechanismSectionCategoryGroup originalGroup)
+        {
+            switch (originalGroup)
+            {
+                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.None:
+                    return FailureMechanismSectionAssemblyCategoryGroup.None;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        #region Simple Assessment
+
         [Test]
         public void AssembleSimpleAssessment_WithInvalidEnumInput_ThrowFailureMechanismSectionAssemblyCalculatorException()
         {
@@ -182,7 +217,7 @@
             // Setup
             using (new AssemblyToolKernelFactoryConfig())
             {
-                var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
 
                 var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
 
@@ -198,13 +233,13 @@
         }
 
         [Test]
-        public void AssembleSimpleAssessmentvalidityOnly_WithValidInput_InputCorrectlySetToKernel()
+        public void AssembleSimpleAssessmentValidityOnly_WithValidInput_InputCorrectlySetToKernel()
         {
             // Setup
             const SimpleAssessmentResultValidityOnlyType assessmentResult = SimpleAssessmentResultValidityOnlyType.Applicable;
             using (new AssemblyToolKernelFactoryConfig())
             {
-                var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
                 FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
                 kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
                     new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
@@ -225,7 +260,7 @@
             // Setup
             using (new AssemblyToolKernelFactoryConfig())
             {
-                var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
                 FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
                 kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
                     new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
@@ -246,10 +281,10 @@
             // Setup
             using (new AssemblyToolKernelFactoryConfig())
             {
-                var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
                 FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
                 kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
-                    new FailureMechanismSectionAssemblyCategoryResult((FailureMechanismSectionCategoryGroup)99, Probability.NaN));
+                    new FailureMechanismSectionAssemblyCategoryResult((FailureMechanismSectionCategoryGroup) 99, Probability.NaN));
 
                 var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
 
@@ -265,12 +300,12 @@
         }
 
         [Test]
-        public void ValidityOnlyAssembleSimpleAssessment_KernelThrowsException_ThrowFailureMechanismSectionAssemblyCalculatorException()
+        public void AssembleSimpleAssessmentValidityOnly_KernelThrowsException_ThrowFailureMechanismSectionAssemblyCalculatorException()
         {
             // Setup
             using (new AssemblyToolKernelFactoryConfig())
             {
-                var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
                 FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
                 kernel.ThrowExceptionOnCalculate = true;
 
@@ -286,35 +321,342 @@
             }
         }
 
-        private static void AssertCalculatorOutput(CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> original, FailureMechanismSectionAssembly actual)
+        #endregion
+
+        #region Detailed Assessment
+
+        [Test]
+        public void AssembleDetailedAssessment_WithInvalidEnumInput_ThrowFailureMechanismSectionAssemblyCalculatorException()
         {
-            Assert.AreEqual(GetGroup(original.Result.CategoryGroup), actual.Group);
-            Assert.AreEqual(original.Result.EstimatedProbabilityOfFailure, actual.Probability);
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
+                                                            random.NextDouble(),
+                                                            (FailureMechanismSectionAssemblyCategoryGroup) 99)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                TestDelegate test = () => calculator.AssembleDetailedAssessment(probability, categories);
+
+                // Assert
+                const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
+                var exception = Assert.Throws<FailureMechanismSectionAssemblyCalculatorException>(test);
+                StringAssert.StartsWith(expectedMessage, exception.Message);
+                Assert.IsInstanceOf<InvalidEnumArgumentException>(exception.InnerException);
+            }
         }
 
-        private static FailureMechanismSectionAssemblyCategoryGroup GetGroup(FailureMechanismSectionCategoryGroup originalGroup)
+        [Test]
+        public void AssembleDetailedAssessment_WithValidInput_InputCorrectlySetToKernel()
         {
-            switch (originalGroup)
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            var categories = new[]
             {
-                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.None:
-                    return FailureMechanismSectionAssemblyCategoryGroup.None;
-                default:
-                    throw new NotSupportedException();
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                calculator.AssembleDetailedAssessment(probability, categories);
+
+                // Assert
+                Assert.AreEqual(probability, kernel.DetailedAssessmentFailureMechanismFromProbabilityInput.Probability);
+
+                FailureMechanismSectionCategory actualCategory = kernel.DetailedAssessmentFailureMechanismFromProbabilityInput.Categories.Single();
+                FailureMechanismSectionAssemblyCategory expectedCategory = categories.Single();
+                Assert.AreEqual(expectedCategory.LowerBoundary, actualCategory.LowerBoundary);
+                Assert.AreEqual(expectedCategory.UpperBoundary, actualCategory.UpperBoundary);
+                Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
             }
         }
+
+        [Test]
+        public void AssembleDetailedAssessment_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                FailureMechanismSectionAssembly assembly = calculator.AssembleDetailedAssessment(probability, categories);
+
+                // Assert
+                AssertCalculatorOutput(kernel.FailureMechanismSectionAssemblyCategoryResult, assembly);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssessment_KernelWithInvalidOutput_ThrowFailureMechanismSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult((FailureMechanismSectionCategoryGroup) 99, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                TestDelegate test = () => calculator.AssembleDetailedAssessment(probability, categories);
+
+                // Assert
+                const string expectedMessage = "The value of argument 'originalGroup' (99) is invalid for Enum type 'FailureMechanismSectionCategoryGroup'.";
+                var exception = Assert.Throws<FailureMechanismSectionAssemblyCalculatorException>(test);
+                StringAssert.StartsWith(expectedMessage, exception.Message);
+                Assert.IsInstanceOf<InvalidEnumArgumentException>(exception.InnerException);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssessment_KernelThrowsException_ThrowFailureMechanismSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.ThrowExceptionOnCalculate = true;
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                TestDelegate test = () => calculator.AssembleDetailedAssessment(probability, categories);
+
+                // Assert
+                var exception = Assert.Throws<FailureMechanismSectionAssemblyCalculatorException>(test);
+                Assert.IsInstanceOf<Exception>(exception.InnerException);
+                Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssessmentWithLengthEffect_WithInvalidEnumInput_ThrowFailureMechanismSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double n = random.NextRoundedDouble(1.0, 10.0);
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
+                                                            random.NextDouble(),
+                                                            (FailureMechanismSectionAssemblyCategoryGroup) 99)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                TestDelegate test = () => calculator.AssembleDetailedAssessment(probability, categories, n);
+
+                // Assert
+                const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
+                var exception = Assert.Throws<FailureMechanismSectionAssemblyCalculatorException>(test);
+                StringAssert.StartsWith(expectedMessage, exception.Message);
+                Assert.IsInstanceOf<InvalidEnumArgumentException>(exception.InnerException);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssessmentWithLengthEffect_WithValidInput_InputCorrectlySetToKernel()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double n = random.NextRoundedDouble(1.0, 10.0);
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                calculator.AssembleDetailedAssessment(probability, categories, n);
+
+                // Assert
+                Assert.AreEqual(probability, kernel.DetailedAssessmentFailureMechanismFromProbabilityWithLengthEffectInput.Probability);
+                Assert.AreEqual(n, kernel.DetailedAssessmentFailureMechanismFromProbabilityWithLengthEffectInput.NValue);
+
+                FailureMechanismSectionCategory actualCategory = kernel.DetailedAssessmentFailureMechanismFromProbabilityWithLengthEffectInput.Categories.Single();
+                FailureMechanismSectionAssemblyCategory expectedCategory = categories.Single();
+                Assert.AreEqual(expectedCategory.LowerBoundary, actualCategory.LowerBoundary);
+                Assert.AreEqual(expectedCategory.UpperBoundary, actualCategory.UpperBoundary);
+                Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssessmentWithLengthEffect_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double n = random.NextRoundedDouble(1.0, 10.0);
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                FailureMechanismSectionAssembly assembly = calculator.AssembleDetailedAssessment(probability, categories, n);
+
+                // Assert
+                AssertCalculatorOutput(kernel.FailureMechanismSectionAssemblyCategoryResult, assembly);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssessmentWithLengthEffect_KernelWithInvalidOutput_ThrowFailureMechanismSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double n = random.NextRoundedDouble(1.0, 10.0);
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult((FailureMechanismSectionCategoryGroup) 99, Probability.NaN));
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                TestDelegate test = () => calculator.AssembleDetailedAssessment(probability, categories, n);
+
+                // Assert
+                const string expectedMessage = "The value of argument 'originalGroup' (99) is invalid for Enum type 'FailureMechanismSectionCategoryGroup'.";
+                var exception = Assert.Throws<FailureMechanismSectionAssemblyCalculatorException>(test);
+                StringAssert.StartsWith(expectedMessage, exception.Message);
+                Assert.IsInstanceOf<InvalidEnumArgumentException>(exception.InnerException);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssessmentWithLengthEffect_KernelThrowsException_ThrowFailureMechanismSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double n = random.NextRoundedDouble(1.0, 10.0);
+            var categories = new[]
+            {
+                new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5),
+                                                            random.NextRoundedDouble(0.6, 1.0),
+                                                            FailureMechanismSectionAssemblyCategoryGroup.IIv)
+            };
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+                kernel.ThrowExceptionOnCalculate = true;
+
+                var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+                // Call
+                TestDelegate test = () => calculator.AssembleDetailedAssessment(probability, categories, n);
+
+                // Assert
+                var exception = Assert.Throws<FailureMechanismSectionAssemblyCalculatorException>(test);
+                Assert.IsInstanceOf<Exception>(exception.InnerException);
+                Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            }
+        }
+
+        #endregion
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -19,10 +19,15 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System;
 using System.ComponentModel;
+using System.Linq;
+using AssemblyTool.Kernel.Assembly.CalculatorInput;
+using AssemblyTool.Kernel.Data.AssemblyCategories;
 using AssemblyTool.Kernel.Data.CalculationResults;
 using Core.Common.TestUtil;
 using NUnit.Framework;
+using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Creators;
 using Ringtoets.Common.Primitives;
 
@@ -58,10 +63,10 @@
         }
 
         [Test]
-        public void CreateSimplecalclCalculationResultValidityOnly_WithInvalidEnumInput_ThrowInvalidEnumArgumentException()
+        public void CreateSimpleCalculationResultValidityOnly_WithInvalidEnumInput_ThrowInvalidEnumArgumentException()
         {
             // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateSimplecalclCalculationResultValidityOnly((SimpleAssessmentResultValidityOnlyType) 99);
+            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateSimpleCalculationResultValidityOnly((SimpleAssessmentResultValidityOnlyType) 99);
 
             // Assert
             const string expectedMessage = "The value of argument 'input' (99) is invalid for Enum type 'SimpleAssessmentResultValidityOnlyType'.";
@@ -72,14 +77,141 @@
         [TestCase(SimpleAssessmentResultValidityOnlyType.None, SimpleCalculationResultValidityOnly.None)]
         [TestCase(SimpleAssessmentResultValidityOnlyType.NotApplicable, SimpleCalculationResultValidityOnly.NVT)]
         [TestCase(SimpleAssessmentResultValidityOnlyType.Applicable, SimpleCalculationResultValidityOnly.WVT)]
-        public void CreateSimplecalclCalculationResultValidityOnly_ValidData_ReturnSimpleCalculationResultValidityOnly(SimpleAssessmentResultValidityOnlyType originalResult,
-                                                                                                                       SimpleCalculationResultValidityOnly expectedResult)
+        public void CreateSimpleCalculationResultValidityOnly_ValidData_ReturnSimpleCalculationResultValidityOnly(
+            SimpleAssessmentResultValidityOnlyType originalResult,
+            SimpleCalculationResultValidityOnly expectedResult)
         {
             // Call
-            SimpleCalculationResultValidityOnly result = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateSimplecalclCalculationResultValidityOnly(originalResult);
+            SimpleCalculationResultValidityOnly result = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateSimpleCalculationResultValidityOnly(originalResult);
 
             // Assert
             Assert.AreEqual(expectedResult, result);
         }
+
+        [Test]
+        public void CreateDetailedCalculationInputFromProbability_WithInvalidEnumInput_ThrowInvalidEnumArgumentException()
+        {
+            // Setup
+            var random = new Random(39);
+
+            // Call
+            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(
+                random.NextDouble(),
+                new[]
+                {
+                    new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
+                                                                random.NextDouble(),
+                                                                (FailureMechanismSectionAssemblyCategoryGroup) 99)
+                });
+
+            // 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 CreateDetailedCalculationInputFromProbability_ValidData_ReturnSimpleCalculationResult(
+            FailureMechanismSectionAssemblyCategoryGroup originalResult,
+            FailureMechanismSectionCategoryGroup expectedResult)
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double lowerBoundary = random.NextRoundedDouble(0.0, 0.5);
+            double upperBoundary = random.NextRoundedDouble(0.6, 1.0);
+
+            // Call
+            DetailedCalculationInputFromProbability result =
+                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(
+                    probability,
+                    new[]
+                    {
+                        new FailureMechanismSectionAssemblyCategory(lowerBoundary,
+                                                                    upperBoundary,
+                                                                    originalResult)
+                    });
+
+            // Assert
+            Assert.AreEqual(probability, result.Probability);
+
+            FailureMechanismSectionCategory actualCategory = result.Categories.Single();
+            Assert.AreEqual(expectedResult, actualCategory.CategoryGroup);
+            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
+            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
+        }
+
+        [Test]
+        public void CreateDetailedCalculationInputFromProbabilityWithLengthEffect_WithInvalidEnumInput_ThrowInvalidEnumArgumentException()
+        {
+            // Setup
+            var random = new Random(39);
+
+            // Call
+            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
+                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 CreateDetailedCalculationInputFromProbabilityWithLengthEffect_ValidData_ReturnSimpleCalculationResult(
+            FailureMechanismSectionAssemblyCategoryGroup originalResult,
+            FailureMechanismSectionCategoryGroup expectedResult)
+        {
+            // Setup
+            var random = new Random(39);
+            double probability = random.NextDouble();
+            double lowerBoundary = random.NextRoundedDouble(0.0, 0.5);
+            double upperBoundary = random.NextRoundedDouble(0.6, 1.0);
+            double n = random.NextRoundedDouble(1.0, 10.0);
+
+            // Call
+            DetailedCalculationInputFromProbabilityWithLengthEffect result =
+                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
+                    probability,
+                    new[]
+                    {
+                        new FailureMechanismSectionAssemblyCategory(lowerBoundary,
+                                                                    upperBoundary,
+                                                                    originalResult)
+                    },
+                    n);
+
+            // Assert
+            Assert.AreEqual(probability, result.Probability);
+            Assert.AreEqual(n, result.NValue);
+
+            FailureMechanismSectionCategory actualCategory = result.Categories.Single();
+            Assert.AreEqual(expectedResult, actualCategory.CategoryGroup);
+            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
+            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Ringtoets.AssemblyTool.KernelWrapper.Test.csproj
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Ringtoets.AssemblyTool.KernelWrapper.Test.csproj	(.../Ringtoets.AssemblyTool.KernelWrapper.Test.csproj)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Ringtoets.AssemblyTool.KernelWrapper.Test.csproj	(.../Ringtoets.AssemblyTool.KernelWrapper.Test.csproj)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -38,6 +38,10 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\..\..\Core\Common\src\Core.Common.Base\Core.Common.Base.csproj">
+      <Project>{3BBFD65B-B277-4E50-AE6D-BD24C3434609}</Project>
+      <Name>Core.Common.Base</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\..\Core\Common\test\Core.Common.TestUtil\Core.Common.TestUtil.csproj">
       <Project>{D749EE4C-CE50-4C17-BF01-9A953028C126}</Project>
       <Name>Core.Common.TestUtil</Name>
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs
===================================================================
diff -u -r55dfc8f739672258343f1c85bac8629498b5b21e -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssemblyKernelStubTest.cs)	(revision 55dfc8f739672258343f1c85bac8629498b5b21e)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssemblyKernelStubTest.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -46,6 +46,8 @@
             Assert.IsFalse(kernel.Calculated);
             Assert.IsNull(kernel.SimpleAssessmentFailureMechanismsInput);
             Assert.IsNull(kernel.SimpleAssessmentFailureMechanismsValidityOnlyInput);
+            Assert.IsNull(kernel.DetailedAssessmentFailureMechanismFromProbabilityInput);
+            Assert.IsNull(kernel.DetailedAssessmentFailureMechanismFromProbabilityWithLengthEffectInput);
         }
 
         #region Simple Assessment
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs	(.../FailureMechanismSectionAssemblyCalculatorStub.cs)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs	(.../FailureMechanismSectionAssemblyCalculatorStub.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly;
 using Ringtoets.Common.Primitives;
@@ -75,5 +76,17 @@
             return SimpleAssessmentAssemblyOutput ??
                    (SimpleAssessmentAssemblyOutput = new FailureMechanismSectionAssembly(1, FailureMechanismSectionAssemblyCategoryGroup.VIIv));
         }
+
+        public FailureMechanismSectionAssembly AssembleDetailedAssessment(double probability, IEnumerable<FailureMechanismSectionAssemblyCategory> categories)
+        {
+            throw new NotImplementedException();
+        }
+
+        public FailureMechanismSectionAssembly AssembleDetailedAssessment(double probability,
+                                                                          IEnumerable<FailureMechanismSectionAssemblyCategory> categories,
+                                                                          double n)
+        {
+            throw new NotImplementedException();
+        }
     }
-}
+}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs
===================================================================
diff -u -r55dfc8f739672258343f1c85bac8629498b5b21e -r65088ddf1c49c4df81c8129a7e0ca158455c4281
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs	(.../FailureMechanismSectionAssemblyKernelStub.cs)	(revision 55dfc8f739672258343f1c85bac8629498b5b21e)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs	(.../FailureMechanismSectionAssemblyKernelStub.cs)	(revision 65088ddf1c49c4df81c8129a7e0ca158455c4281)
@@ -51,7 +51,7 @@
         /// <summary>
         /// Gets the input used in <see cref="DetailedAssessmentDirectFailureMechanisms(DetailedCalculationInputFromProbabilityWithLengthEffect)"/>.
         /// </summary>
-        public DetailedCalculationInputFromProbability DetailedAssessmentFailureMechanismFromProbabilityWithLengthEffectInput { get; private set; }
+        public DetailedCalculationInputFromProbabilityWithLengthEffect DetailedAssessmentFailureMechanismFromProbabilityWithLengthEffectInput { get; private set; }
 
         /// <summary>
         /// Gets a value indicating whether a calculation was called or not.
@@ -117,7 +117,6 @@
             DetailedAssessmentFailureMechanismFromProbabilityInput = input;
             Calculated = true;
             return FailureMechanismSectionAssemblyCategoryResult;
-
         }
 
         public CalculationOutput<FailureMechanismSectionCategoryGroup> DetailedAssessmentDirectFailureMechanisms(DetailedCategoryBoundariesCalculationResult calculationResults)