Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs
===================================================================
diff -u -r82a3504384d5138339e41c6f7b5e586451f54661 -r7cccb012b51218b8989007633d8338eaf435d6f4
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs	(.../FailureMechanismSectionAssemblyCalculatorStubTest.cs)	(revision 82a3504384d5138339e41c6f7b5e586451f54661)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs	(.../FailureMechanismSectionAssemblyCalculatorStubTest.cs)	(revision 7cccb012b51218b8989007633d8338eaf435d6f4)
@@ -21,7 +21,6 @@
 
 using System;
 using System.Linq;
-using AssemblyTool.Kernel.Data.AssemblyCategories;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Ringtoets.AssemblyTool.Data;
@@ -47,9 +46,9 @@
             Assert.AreEqual((SimpleAssessmentResultValidityOnlyType) 0,
                             calculator.SimpleAssessmentValidityOnlyInput);
             Assert.IsNull(calculator.SimpleAssessmentAssemblyOutput);
-            Assert.IsNull(calculator.DetailedAssessmentWithLengthEffectInput);
-            Assert.IsNull(calculator.DetailedAssessmentInput);
-            Assert.IsNull(calculator.DetailedAssessmentAssemblyOutput);
+            Assert.IsNull(calculator.DetailedAssessmentCategoriesInput);
+            Assert.AreEqual(0.0, calculator.DetailedAssessmentNInput);
+            Assert.AreEqual(0.0, calculator.DetailedAssessmentProbabilityInput);
         }
 
         #region Simple Assessment
@@ -178,8 +177,8 @@
             // 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 lowerBoundary = random.NextDouble();
+            double upperBoundary = random.NextDouble();
 
             var calculator = new FailureMechanismSectionAssemblyCalculatorStub();
 
@@ -194,12 +193,12 @@
                 });
 
             // Assert
-            Assert.AreEqual(probability, calculator.DetailedAssessmentInput.Probability);
+            Assert.AreEqual(probability, calculator.DetailedAssessmentProbabilityInput);
 
-            FailureMechanismSectionCategory actualSectionCategory = calculator.DetailedAssessmentInput.Categories.Single();
+            FailureMechanismSectionAssemblyCategory actualSectionCategory = calculator.DetailedAssessmentCategoriesInput.Single();
             Assert.AreEqual(lowerBoundary, actualSectionCategory.LowerBoundary);
             Assert.AreEqual(upperBoundary, actualSectionCategory.UpperBoundary);
-            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualSectionCategory.CategoryGroup);
+            Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, actualSectionCategory.Group);
         }
 
         [Test]
@@ -275,13 +274,13 @@
                 n);
 
             // Assert
-            Assert.AreEqual(probability, calculator.DetailedAssessmentWithLengthEffectInput.Probability);
-            Assert.AreEqual(n, calculator.DetailedAssessmentWithLengthEffectInput.NValue);
+            Assert.AreEqual(probability, calculator.DetailedAssessmentProbabilityInput);
+            Assert.AreEqual(n, calculator.DetailedAssessmentNInput);
 
-            FailureMechanismSectionCategory actualSectionCategory = calculator.DetailedAssessmentWithLengthEffectInput.Categories.Single();
+            FailureMechanismSectionAssemblyCategory actualSectionCategory = calculator.DetailedAssessmentCategoriesInput.Single();
             Assert.AreEqual(lowerBoundary, actualSectionCategory.LowerBoundary);
             Assert.AreEqual(upperBoundary, actualSectionCategory.UpperBoundary);
-            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualSectionCategory.CategoryGroup);
+            Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, actualSectionCategory.Group);
         }
 
         [Test]
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs
===================================================================
diff -u -r82a3504384d5138339e41c6f7b5e586451f54661 -r7cccb012b51218b8989007633d8338eaf435d6f4
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs	(.../FailureMechanismSectionAssemblyCalculatorStub.cs)	(revision 82a3504384d5138339e41c6f7b5e586451f54661)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs	(.../FailureMechanismSectionAssemblyCalculatorStub.cs)	(revision 7cccb012b51218b8989007633d8338eaf435d6f4)
@@ -21,10 +21,8 @@
 
 using System;
 using System.Collections.Generic;
-using AssemblyTool.Kernel.Assembly.CalculatorInput;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly;
-using Ringtoets.AssemblyTool.KernelWrapper.Creators;
 using Ringtoets.Common.Primitives;
 
 namespace Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly
@@ -55,16 +53,21 @@
         public FailureMechanismSectionAssembly DetailedAssessmentAssemblyOutput { get; private set; }
 
         /// <summary>
-        /// Gets the input of the detailed assessment calculation.
+        /// Gets the probability input of the detailed assessment calculation.
         /// </summary>
-        public DetailedCalculationInputFromProbability DetailedAssessmentInput { get; private set; }
+        public double DetailedAssessmentProbabilityInput { get; private set; }
 
         /// <summary>
-        /// Gets the input of the detailed assessment with length effect calculation.
+        /// Gets the categories input of the detailed assessment calculation.
         /// </summary>
-        public DetailedCalculationInputFromProbabilityWithLengthEffect DetailedAssessmentWithLengthEffectInput { get; private set; }
+        public IEnumerable<FailureMechanismSectionAssemblyCategory> DetailedAssessmentCategoriesInput { get; private set; }
 
         /// <summary>
+        /// Gets the 'N' parameter input of the detailed assessment calculation.
+        /// </summary>
+        public double DetailedAssessmentNInput { get; private set; }
+
+        /// <summary>
         /// Gets or sets an indicator whether an exception must be thrown when performing a calculation.
         /// </summary>
         public bool ThrowExceptionOnCalculate { private get; set; }
@@ -100,8 +103,8 @@
                 throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception());
             }
 
-            DetailedAssessmentInput = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(probability,
-                                                                                                                                          categories);
+            DetailedAssessmentProbabilityInput = probability;
+            DetailedAssessmentCategoriesInput = categories;
 
             return DetailedAssessmentAssemblyOutput = new FailureMechanismSectionAssembly(1, FailureMechanismSectionAssemblyCategoryGroup.VIIv);
         }
@@ -115,11 +118,9 @@
                 throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception());
             }
 
-            DetailedAssessmentWithLengthEffectInput =
-                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
-                    probability,
-                    categories,
-                    n);
+            DetailedAssessmentProbabilityInput = probability;
+            DetailedAssessmentCategoriesInput = categories;
+            DetailedAssessmentNInput = n;
 
             return DetailedAssessmentAssemblyOutput = new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.VIIv);
         }
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.csproj
===================================================================
diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r7cccb012b51218b8989007633d8338eaf435d6f4
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.csproj	(.../Ringtoets.AssemblyTool.KernelWrapper.TestUtil.csproj)	(revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.csproj	(.../Ringtoets.AssemblyTool.KernelWrapper.TestUtil.csproj)	(revision 7cccb012b51218b8989007633d8338eaf435d6f4)
@@ -36,10 +36,6 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\..\Common\src\Ringtoets.Common.Data\Ringtoets.Common.Data.csproj">
-      <Project>{D4200F43-3F72-4F42-AF0A-8CED416A38EC}</Project>
-      <Name>Ringtoets.Common.Data</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\Common\src\Ringtoets.Common.Primitives\Ringtoets.Common.Primitives.csproj">
       <Project>{78AA56F5-431D-465C-AC50-3173D7E90AC1}</Project>
       <Name>Ringtoets.Common.Primitives</Name>
Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs
===================================================================
diff -u -r40cbb4e66eedb0468bc0256f49b1d1c02a1b6086 -r7cccb012b51218b8989007633d8338eaf435d6f4
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs	(.../PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs)	(revision 40cbb4e66eedb0468bc0256f49b1d1c02a1b6086)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs	(.../PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs)	(revision 7cccb012b51218b8989007633d8338eaf435d6f4)
@@ -83,24 +83,15 @@
                 return double.NaN;
             }
 
-            IEnumerable<PipingCalculationScenario> calculationScenarios = sectionResult
-                                                                          .GetCalculationScenarios(relevantScenarios)
-                                                                          .Where(cs => cs.Status == CalculationScenarioStatus.Done);
-
-            if (calculationScenarios.Any())
+            double totalDetailedAssessment = 0;
+            foreach (PipingCalculationScenario scenario in relevantScenarios)
             {
-                double totalDetailedAssessment = 0;
-                foreach (PipingCalculationScenario scenario in calculationScenarios)
-                {
-                    DerivedPipingOutput derivedOutput = DerivedPipingOutputFactory.Create(scenario.Output, failureMechanism, assessmentSection);
+                DerivedPipingOutput derivedOutput = DerivedPipingOutputFactory.Create(scenario.Output, failureMechanism, assessmentSection);
 
-                    totalDetailedAssessment += derivedOutput.PipingProbability * (double) scenario.Contribution;
-                }
-
-                return totalDetailedAssessment;
+                totalDetailedAssessment += derivedOutput.PipingProbability * (double) scenario.Contribution;
             }
 
-            return double.NaN;
+            return totalDetailedAssessment;
         }
 
         /// <summary>
Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionResultAssemblyFactory.cs
===================================================================
diff -u -r2c8012ba40f0290a41ed277712a4eb8fc5ce8431 -r7cccb012b51218b8989007633d8338eaf435d6f4
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionResultAssemblyFactory.cs	(.../PipingFailureMechanismSectionResultAssemblyFactory.cs)	(revision 2c8012ba40f0290a41ed277712a4eb8fc5ce8431)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionResultAssemblyFactory.cs	(.../PipingFailureMechanismSectionResultAssemblyFactory.cs)	(revision 7cccb012b51218b8989007633d8338eaf435d6f4)
@@ -20,11 +20,15 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly;
 using Ringtoets.AssemblyTool.KernelWrapper.Kernels;
+using Ringtoets.Common.Data.AssemblyTool;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
+using Ringtoets.Common.Data.Probability;
 
 namespace Ringtoets.Piping.Data
 {
@@ -64,5 +68,64 @@
                 throw new AssemblyFactoryException(e.Message, e);
             }
         }
+
+        /// <summary>
+        /// Assembles the detailed assessment result.
+        /// </summary>
+        /// <param name="failureMechanismSectionResult">The failure mechanism section result to
+        /// assemble the detailed assembly for.</param>
+        /// <param name="calculationScenarios">The calculations belonging to this section.</param>
+        /// <param name="failureMechanism">The failure mechanism.</param>
+        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/>.</param>
+        /// <returns>A <see cref="FailureMechanismSectionAssembly"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        /// <exception cref="AssemblyFactoryException">Thrown when <see cref="FailureMechanismSectionAssembly"/>
+        /// cannot be assembled.</exception>
+        public static FailureMechanismSectionAssembly AssembleDetailedAssembly(
+            PipingFailureMechanismSectionResult failureMechanismSectionResult,
+            IEnumerable<PipingCalculationScenario> calculationScenarios,
+            PipingFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
+        {
+            if (failureMechanismSectionResult == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismSectionResult));
+            }
+
+            if (calculationScenarios == null)
+            {
+                throw new ArgumentNullException(nameof(calculationScenarios));
+            }
+
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance;
+            IFailureMechanismSectionAssemblyCalculator calculator = calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance);
+
+            try
+            {
+                IEnumerable<FailureMechanismSectionAssemblyCategory> categories = AssemblyToolCategoriesFactory.CreateFailureMechanismSectionAssemblyCategories(
+                    assessmentSection.FailureMechanismContribution.SignalingNorm,
+                    assessmentSection.FailureMechanismContribution.LowerLimitNorm,
+                    failureMechanism.Contribution,
+                    failureMechanism.PipingProbabilityAssessmentInput.GetN(failureMechanism.PipingProbabilityAssessmentInput.SectionLength));
+
+                return calculator.AssembleDetailedAssessment(failureMechanismSectionResult.GetDetailedAssessmentProbability(calculationScenarios, failureMechanism, assessmentSection),
+                                                             categories,
+                                                             failureMechanism.PipingProbabilityAssessmentInput.GetN(failureMechanismSectionResult.Section.Length));
+            }
+            catch (FailureMechanismSectionAssemblyCalculatorException e)
+            {
+                throw new AssemblyFactoryException(e.Message, e);
+            }
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingFailureMechanismSectionResultAssemblyFactoryTest.cs
===================================================================
diff -u -r2c8012ba40f0290a41ed277712a4eb8fc5ce8431 -r7cccb012b51218b8989007633d8338eaf435d6f4
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingFailureMechanismSectionResultAssemblyFactoryTest.cs	(.../PipingFailureMechanismSectionResultAssemblyFactoryTest.cs)	(revision 2c8012ba40f0290a41ed277712a4eb8fc5ce8431)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingFailureMechanismSectionResultAssemblyFactoryTest.cs	(.../PipingFailureMechanismSectionResultAssemblyFactoryTest.cs)	(revision 7cccb012b51218b8989007633d8338eaf435d6f4)
@@ -20,23 +20,30 @@
 // All rights reserved.
 
 using System;
+using System.Linq;
 using Core.Common.TestUtil;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.Contribution;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
+using Ringtoets.Piping.Data.TestUtil;
 
 namespace Ringtoets.Piping.Data.Test
 {
     [TestFixture]
     public class PipingFailureMechanismSectionResultAssemblyFactoryTest
     {
+        #region Simple Assessment
+
         [Test]
         public void AssembleSimpleAssessment_FailureMechanismSectionResultNull_ThrowsArgumentNullException()
         {
@@ -117,5 +124,220 @@
                 Assert.AreEqual(innerException.Message, exception.Message);
             }
         }
+
+        #endregion
+
+        #region Detailed Assessment
+
+        [Test]
+        public void AssembleDetailedAssembly_FailureMechanismSectionResultNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () => PipingFailureMechanismSectionResultAssemblyFactory.AssembleDetailedAssembly(
+                null,
+                Enumerable.Empty<PipingCalculationScenario>(),
+                new PipingFailureMechanism(),
+                assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanismSectionResult", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AssembleDetailedAssembly_CalculationScenariosNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () => PipingFailureMechanismSectionResultAssemblyFactory.AssembleDetailedAssembly(
+                new PipingFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
+                null,
+                new PipingFailureMechanism(),
+                assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("calculationScenarios", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AssembleDetailedAssembly_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () => PipingFailureMechanismSectionResultAssemblyFactory.AssembleDetailedAssembly(
+                new PipingFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
+                Enumerable.Empty<PipingCalculationScenario>(),
+                null,
+                assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AssembleDetailedAssembly_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => PipingFailureMechanismSectionResultAssemblyFactory.AssembleDetailedAssembly(
+                new PipingFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
+                Enumerable.Empty<PipingCalculationScenario>(),
+                new PipingFailureMechanism(),
+                null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void AssembleDetailedAssembly_WithInput_SetsInputOnCalculator()
+        {
+            // Setup
+            var random = new Random(21);
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(
+                                                                                   Enumerable.Empty<IFailureMechanism>(),
+                                                                                   random.Next(0, 100),
+                                                                                   random.NextRoundedDouble(0.06, 0.1),
+                                                                                   random.NextRoundedDouble(0.00001, 0.05)));
+            mocks.ReplayAll();
+
+            var sectionResult = new PipingFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+            {
+                SimpleAssessmentResult = random.NextEnumValue<SimpleAssessmentResultType>()
+            };
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                // Call
+                PipingFailureMechanismSectionResultAssemblyFactory.AssembleDetailedAssembly(
+                    sectionResult,
+                    new[]
+                    {
+                        PipingCalculationScenarioTestFactory.CreatePipingCalculationScenarioWithValidInput()
+                    },
+                    new PipingFailureMechanism(),
+                    assessmentSection);
+
+                // Assert
+                Assert.AreEqual(sectionResult.GetDetailedAssessmentProbability(
+                                    new[]
+                                    {
+                                        PipingCalculationScenarioTestFactory.CreatePipingCalculationScenarioWithValidInput()
+                                    },
+                                    new PipingFailureMechanism(),
+                                    assessmentSection),
+                                calculator.DetailedAssessmentProbabilityInput);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssembly_AssemblyRan_ReturnsOutput()
+        {
+            // Setup
+            var random = new Random(21);
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(
+                                                                                   Enumerable.Empty<IFailureMechanism>(),
+                                                                                   random.Next(0, 100),
+                                                                                   random.NextRoundedDouble(0.06, 0.1),
+                                                                                   random.NextRoundedDouble(0.00001, 0.05)));
+            mocks.ReplayAll();
+
+            var sectionResult = new PipingFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+            {
+                SimpleAssessmentResult = random.NextEnumValue<SimpleAssessmentResultType>()
+            };
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                // Call
+                FailureMechanismSectionAssembly actualOutput =
+                    PipingFailureMechanismSectionResultAssemblyFactory.AssembleDetailedAssembly(
+                        sectionResult,
+                        new[]
+                        {
+                            PipingCalculationScenarioTestFactory.CreatePipingCalculationScenarioWithValidInput()
+                        },
+                        new PipingFailureMechanism(),
+                        assessmentSection);
+
+                // Assert
+                FailureMechanismSectionAssembly calculatorOutput = calculator.DetailedAssessmentAssemblyOutput;
+                Assert.AreSame(calculatorOutput, actualOutput);
+            }
+        }
+
+        [Test]
+        public void AssembleDetailedAssembly_CalculatorThrowsExceptions_ThrowsAssemblyFactoryException()
+        {
+            // Setup
+            var random = new Random(21);
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(
+                                                                                   Enumerable.Empty<IFailureMechanism>(),
+                                                                                   random.Next(0, 100),
+                                                                                   random.NextRoundedDouble(0.06, 0.1),
+                                                                                   random.NextRoundedDouble(0.00001, 0.05)));
+            mocks.ReplayAll();
+
+            var sectionResult = new PipingFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+            {
+                SimpleAssessmentResult = random.NextEnumValue<SimpleAssessmentResultType>()
+            };
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                calculator.ThrowExceptionOnCalculate = true;
+
+                // Call
+                TestDelegate call = () => PipingFailureMechanismSectionResultAssemblyFactory.AssembleDetailedAssembly(
+                    sectionResult,
+                    new[]
+                    {
+                        PipingCalculationScenarioTestFactory.CreatePipingCalculationScenarioWithValidInput()
+                    },
+                    new PipingFailureMechanism(),
+                    assessmentSection);
+
+                // Assert
+                var exception = Assert.Throws<AssemblyFactoryException>(call);
+                Exception innerException = exception.InnerException;
+                Assert.IsInstanceOf<FailureMechanismSectionAssemblyCalculatorException>(innerException);
+                Assert.AreEqual(innerException.Message, exception.Message);
+            }
+        }
+
+        #endregion
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationScenarioTestFactory.cs
===================================================================
diff -u -r8b37c0f11e7d78b71c298763124973e94845c87b -r7cccb012b51218b8989007633d8338eaf435d6f4
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationScenarioTestFactory.cs	(.../PipingCalculationScenarioTestFactory.cs)	(revision 8b37c0f11e7d78b71c298763124973e94845c87b)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationScenarioTestFactory.cs	(.../PipingCalculationScenarioTestFactory.cs)	(revision 7cccb012b51218b8989007633d8338eaf435d6f4)
@@ -79,6 +79,7 @@
             {
                 throw new ArgumentNullException(nameof(section));
             }
+
             var pipingSurfaceLine = new PipingSurfaceLine(string.Empty);
             Point2D p = section.Points.First();
             pipingSurfaceLine.SetGeometry(new[]
@@ -165,7 +166,7 @@
             surfaceLine.SetBottomDitchDikeSideAt(thirdCharacteristicPointLocation);
             surfaceLine.SetBottomDitchPolderSideAt(fourthCharacteristicPointLocation);
             surfaceLine.SetDitchPolderSideAt(fifthCharacteristicPointLocation);
-
+            surfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(0.0, 0.0);
             HydraulicBoundaryLocation hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation
             {
                 DesignWaterLevelCalculation2 =