Index: Riskeer/Common/src/Riskeer.Common.Data/FailurePath/FailurePathAssemblyHelper.cs
===================================================================
diff -u -r1c6e42882810c407d90bbe92002a82f77d7d660d -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/Common/src/Riskeer.Common.Data/FailurePath/FailurePathAssemblyHelper.cs	(.../FailurePathAssemblyHelper.cs)	(revision 1c6e42882810c407d90bbe92002a82f77d7d660d)
+++ Riskeer/Common/src/Riskeer.Common.Data/FailurePath/FailurePathAssemblyHelper.cs	(.../FailurePathAssemblyHelper.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,6 +20,11 @@
 // All rights reserved.
 
 using System;
+using System.Linq;
+using Riskeer.AssemblyTool.Data;
+using Riskeer.Common.Data.AssemblyTool;
+using Riskeer.Common.Data.Exceptions;
+using Riskeer.Common.Data.FailureMechanism;
 
 namespace Riskeer.Common.Data.FailurePath
 {
@@ -29,34 +34,81 @@
     public static class FailurePathAssemblyHelper
     {
         /// <summary>
-        /// Assembles the failure path based on the input arguments.
+        /// Assembles the failure mechanism section.
         /// </summary>
-        /// <param name="failurePath">The <see cref="IFailurePath"/> to assemble.</param>
-        /// <param name="performFailurePathAssemblyFunc">The function to perform the failure path assembly with.</param>
-        /// <returns>A <see cref="double"/> representing the failure path probability.</returns>
+        /// <param name="sectionResult">The section result to assemble.</param>
+        /// <param name="performSectionAssemblyFunc">The <see cref="Func{T1,TResult}"/>to perform the assembly.</param>
+        /// <typeparam name="TSectionResult">The type of section result.</typeparam>
+        /// <returns>A <see cref="FailureMechanismSectionAssemblyResult"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        public static double AssembleFailurePath(IFailurePath failurePath,
-                                                 Func<double> performFailurePathAssemblyFunc)
+        /// <remarks>When the failure mechanism section cannot be assembled,
+        /// a <see cref="DefaultFailureMechanismSectionAssemblyResult"/> is created.</remarks>
+        public static FailureMechanismSectionAssemblyResult AssembleFailureMechanismSection<TSectionResult>(
+            TSectionResult sectionResult, Func<TSectionResult, FailureMechanismSectionAssemblyResult> performSectionAssemblyFunc)
+            where TSectionResult : FailureMechanismSectionResult
         {
+            if (sectionResult == null)
+            {
+                throw new ArgumentNullException(nameof(sectionResult));
+            }
+
+            if (performSectionAssemblyFunc == null)
+            {
+                throw new ArgumentNullException(nameof(performSectionAssemblyFunc));
+            }
+
+            try
+            {
+                return performSectionAssemblyFunc(sectionResult);
+            }
+            catch (AssemblyException)
+            {
+                return new DefaultFailureMechanismSectionAssemblyResult();
+            }
+        }
+
+        /// <summary>
+        /// Assembles the failure path.
+        /// </summary>
+        /// <param name="failurePath">The <see cref="IFailurePath"/> to assemble.</param>
+        /// <param name="performSectionAssemblyFunc">The <see cref="Func{T1,TResult}"/> to perform the failure mechanism section assembly.</param>
+        /// <param name="failurePathN">The n value of the <paramref name="failurePath"/>.</param>
+        /// <typeparam name="TSectionResult">The type of section result.</typeparam>
+        /// <returns>The failure path probability.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failurePath"/>
+        /// or <paramref name="performSectionAssemblyFunc"/> is <c>null</c>.</exception>
+        /// <exception cref="AssemblyException">Thrown when the failure mechanism could not be successfully assembled.</exception>
+        public static double AssembleFailurePath<TSectionResult>(
+            IHasSectionResults<FailureMechanismSectionResultOld, TSectionResult> failurePath,
+            Func<TSectionResult, FailureMechanismSectionAssemblyResult> performSectionAssemblyFunc,
+            double failurePathN)
+            where TSectionResult : FailureMechanismSectionResult
+        {
             if (failurePath == null)
             {
                 throw new ArgumentNullException(nameof(failurePath));
             }
 
-            if (performFailurePathAssemblyFunc == null)
+            if (performSectionAssemblyFunc == null)
             {
-                throw new ArgumentNullException(nameof(performFailurePathAssemblyFunc));
+                throw new ArgumentNullException(nameof(performSectionAssemblyFunc));
             }
 
             if (!failurePath.InAssembly)
             {
                 return double.NaN;
             }
-            
+
             FailurePathAssemblyResult assemblyResult = failurePath.AssemblyResult;
-            return assemblyResult.ProbabilityResultType == FailurePathAssemblyProbabilityResultType.Manual
-                       ? assemblyResult.ManualFailurePathAssemblyProbability
-                       : performFailurePathAssemblyFunc();
+            if (assemblyResult.ProbabilityResultType == FailurePathAssemblyProbabilityResultType.Manual)
+            {
+                return assemblyResult.ManualFailurePathAssemblyProbability;
+            }
+
+            return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(
+                failurePathN, failurePath.SectionResults.Select(sr => AssembleFailureMechanismSection(
+                                                                    sr, performSectionAssemblyFunc))
+                                         .ToArray());
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Common/test/Riskeer.Common.Data.Test/FailurePath/FailurePathAssemblyHelperTest.cs
===================================================================
diff -u -r1c6e42882810c407d90bbe92002a82f77d7d660d -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/Common/test/Riskeer.Common.Data.Test/FailurePath/FailurePathAssemblyHelperTest.cs	(.../FailurePathAssemblyHelperTest.cs)	(revision 1c6e42882810c407d90bbe92002a82f77d7d660d)
+++ Riskeer/Common/test/Riskeer.Common.Data.Test/FailurePath/FailurePathAssemblyHelperTest.cs	(.../FailurePathAssemblyHelperTest.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,115 +20,287 @@
 // All rights reserved.
 
 using System;
+using System.Linq;
+using Core.Common.Base;
+using Core.Common.TestUtil;
 using NUnit.Framework;
 using Rhino.Mocks;
+using Riskeer.AssemblyTool.Data;
+using Riskeer.AssemblyTool.KernelWrapper.Calculators;
+using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators;
+using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Riskeer.Common.Data.AssemblyTool;
+using Riskeer.Common.Data.Exceptions;
+using Riskeer.Common.Data.FailureMechanism;
 using Riskeer.Common.Data.FailurePath;
+using Riskeer.Common.Data.TestUtil;
 
 namespace Riskeer.Common.Data.Test.FailurePath
 {
     [TestFixture]
     public class FailurePathAssemblyHelperTest
     {
         [Test]
+        public void AssembleFailureMechanismSection_SectionResultNull_ThrowsArgumentNullException()
+        {
+            // Call
+            void Call() => FailurePathAssemblyHelper.AssembleFailureMechanismSection<FailureMechanismSectionResult>(null, sr => null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("sectionResult", exception.ParamName);
+        }
+
+        [Test]
+        public void AssembleFailureMechanismSection_PerformSectionAssemblyFuncNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var sectionResult = new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
+
+            // Call
+            void Call() => FailurePathAssemblyHelper.AssembleFailureMechanismSection(sectionResult, null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("performSectionAssemblyFunc", exception.ParamName);
+        }
+
+        [Test]
+        public void AssembleFailureMechanismSection_WithValidData_ReturnsFailureMechanismSectionAssemblyResult()
+        {
+            // Setup
+            var sectionResult = new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
+
+            var random = new Random(21);
+            var expectedAssemblyResult = new FailureMechanismSectionAssemblyResult(
+                random.NextDouble(), random.NextDouble(), random.NextDouble(),
+                random.NextEnumValue<FailureMechanismSectionAssemblyGroup>());
+
+            // Call
+            FailureMechanismSectionAssemblyResult assemblyResult = FailurePathAssemblyHelper.AssembleFailureMechanismSection(
+                sectionResult, sr => expectedAssemblyResult);
+
+            // Assert
+            Assert.AreSame(expectedAssemblyResult, assemblyResult);
+        }
+
+        [Test]
+        public void AssembleFailureMechanismSection_PerformSectionAssemblyFuncThrowsAssemblyException_ReturnsDefaultFailureMechanismSectionAssemblyResult()
+        {
+            // Setup
+            var sectionResult = new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
+
+            // Call
+            FailureMechanismSectionAssemblyResult assemblyResult = FailurePathAssemblyHelper.AssembleFailureMechanismSection(
+                sectionResult, sr => throw new AssemblyException());
+
+            // Assert
+            Assert.IsInstanceOf<DefaultFailureMechanismSectionAssemblyResult>(assemblyResult);
+        }
+
+        [Test]
         public void AssembleFailurePath_FailurePathNull_ThrowsArgumentNullException()
         {
             // Call
-            void Call() => FailurePathAssemblyHelper.AssembleFailurePath(null, () => double.NaN);
+            void Call() => FailurePathAssemblyHelper.AssembleFailurePath<FailureMechanismSectionResult>(
+                null, sr => null, double.NaN);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failurePath", exception.ParamName);
         }
 
         [Test]
-        public void AssembleFailurePath_PerformFailurePathAssemblyFuncNull_ThrowsArgumentNullException()
+        public void AssembleFailurePath_PerformSectionAssemblyFuncNull_ThrowsArgumentNullException()
         {
             // Setup
             var mocks = new MockRepository();
-            var failurePath = mocks.Stub<IFailurePath>();
+            var failurePath = mocks.Stub<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>>();
             mocks.ReplayAll();
 
             // Call
-            void Call() => FailurePathAssemblyHelper.AssembleFailurePath(failurePath, null);
+            void Call() => FailurePathAssemblyHelper.AssembleFailurePath(
+                failurePath, null, double.NaN);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
-            Assert.AreEqual("performFailurePathAssemblyFunc", exception.ParamName);
+            Assert.AreEqual("performSectionAssemblyFunc", exception.ParamName);
         }
 
         [Test]
         public void AssembleFailurePath_WithFailureInAssemblyFalse_ReturnsNaN()
         {
             // Setup
             var random = new Random(21);
-            double probability = random.NextDouble();
 
             var mocks = new MockRepository();
-            var failurePath = mocks.Stub<IFailurePath>();
+            var failurePath = mocks.Stub<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>>();
             mocks.ReplayAll();
 
             failurePath.InAssembly = false;
-            
+
             // Call
-            double assemblyResult = FailurePathAssemblyHelper.AssembleFailurePath(failurePath, () => probability);
+            double assemblyResult = FailurePathAssemblyHelper.AssembleFailurePath(
+                failurePath, sr => null, random.NextDouble());
 
             // Assert
             Assert.IsNaN(assemblyResult);
             mocks.VerifyAll();
         }
-        
+
         [Test]
-        public void AssembleFailurePath_WithFailurePathAssemblyProbabilityResultTypeManual_ReturnsExpectedProbability()
+        public void AssembleFailurePath_WithFailurePathAssemblyProbabilityResultTypeManual_ReturnsExpectedAssemblyResult()
         {
             // Setup
             var random = new Random(21);
-            double assemblyProbability = random.NextDouble();
+            double expectedAssemblyResult = random.NextDouble();
 
             var mocks = new MockRepository();
-            var failurePath = mocks.Stub<IFailurePath>();
+            var failurePath = mocks.Stub<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>>();
             failurePath.Stub(fp => fp.AssemblyResult)
                        .Return(new FailurePathAssemblyResult
                        {
                            ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Manual,
-                           ManualFailurePathAssemblyProbability = assemblyProbability
+                           ManualFailurePathAssemblyProbability = expectedAssemblyResult
                        });
             mocks.ReplayAll();
 
             failurePath.InAssembly = true;
 
             // Call
-            double assemblyResult = FailurePathAssemblyHelper.AssembleFailurePath(failurePath, () => double.NaN);
+            double assemblyResult = FailurePathAssemblyHelper.AssembleFailurePath(failurePath, sr => null, double.NaN);
 
             // Assert
-            Assert.AreEqual(assemblyProbability, assemblyResult);
+            Assert.AreEqual(expectedAssemblyResult, assemblyResult);
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AssembleFailurePath_WithFailurePathAssemblyProbabilityResultTypeAutomatic_ReturnsExpectedProbability()
+        public void AssembleFailurePath_WithFailurePathAssemblyProbabilityResultTypeAutomatic_InputCorrectlySetOnCalculator()
         {
             // Setup
             var random = new Random(21);
-            double assemblyProbability = random.NextDouble();
+            double failureMechanismN = random.NextDouble();
 
             var mocks = new MockRepository();
-            var failurePath = mocks.Stub<IFailurePath>();
+            var failurePath = mocks.Stub<IHasSectionResults<FailureMechanismSectionResultOld, TestFailureMechanismSectionResult>>();
             failurePath.Stub(fp => fp.AssemblyResult)
                        .Return(new FailurePathAssemblyResult
                        {
                            ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic,
                            ManualFailurePathAssemblyProbability = double.NaN
                        });
+            failurePath.Stub(fp => fp.SectionResults)
+                       .Return(new ObservableList<TestFailureMechanismSectionResult>
+                       {
+                           new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+                       });
             mocks.ReplayAll();
 
             failurePath.InAssembly = true;
 
-            // Call
-            double assemblyResult = FailurePathAssemblyHelper.AssembleFailurePath(failurePath, () => assemblyProbability);
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var failureMechanismSectionAssemblyResult = new FailureMechanismSectionAssemblyResult(
+                    random.NextDouble(), random.NextDouble(), random.NextDouble(),
+                    random.NextEnumValue<FailureMechanismSectionAssemblyGroup>());
 
-            // Assert
-            Assert.AreEqual(assemblyProbability, assemblyResult);
+                // Call
+                FailurePathAssemblyHelper.AssembleFailurePath(failurePath, sr => failureMechanismSectionAssemblyResult, failureMechanismN);
+
+                // Assert
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+
+                CollectionAssert.AreEqual(new[]
+                {
+                    failureMechanismSectionAssemblyResult
+                }, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput);
+                Assert.AreEqual(failureMechanismN, failureMechanismAssemblyCalculator.FailureMechanismN);
+            }
+
             mocks.VerifyAll();
         }
+
+        [Test]
+        public void AssembleFailurePath_WithFailurePathAssemblyProbabilityResultTypeAutomaticAndFailureMechanismSectionAssemblyThrowsException_InputCorrectlySetOnCalculator()
+        {
+            // Setup
+            var random = new Random(21);
+            double failureMechanismN = random.NextDouble();
+
+            var mocks = new MockRepository();
+            var failurePath = mocks.Stub<IHasSectionResults<FailureMechanismSectionResultOld, TestFailureMechanismSectionResult>>();
+            failurePath.Stub(fp => fp.AssemblyResult)
+                       .Return(new FailurePathAssemblyResult
+                       {
+                           ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic,
+                           ManualFailurePathAssemblyProbability = double.NaN
+                       });
+            failurePath.Stub(fp => fp.SectionResults)
+                       .Return(new ObservableList<TestFailureMechanismSectionResult>
+                       {
+                           new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+                       });
+            mocks.ReplayAll();
+
+            failurePath.InAssembly = true;
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                // Call
+                FailurePathAssemblyHelper.AssembleFailurePath(failurePath, sr => throw new AssemblyException(), failureMechanismN);
+
+                // Assert
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+
+                Assert.AreEqual(1, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Count());
+                Assert.IsInstanceOf<DefaultFailureMechanismSectionAssemblyResult>(failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.First());
+                Assert.AreEqual(failureMechanismN, failureMechanismAssemblyCalculator.FailureMechanismN);
+            }
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AssembleFailurePath_WithFailurePathAssemblyProbabilityResultTypeAutomatic_ReturnsExpectedAssemblyResult()
+        {
+            // Setup
+            var random = new Random(21);
+            double expectedAssemblyResult = random.NextDouble();
+
+            var mocks = new MockRepository();
+            var failurePath = mocks.Stub<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>>();
+            failurePath.Stub(fp => fp.AssemblyResult)
+                       .Return(new FailurePathAssemblyResult
+                       {
+                           ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic,
+                           ManualFailurePathAssemblyProbability = double.NaN
+                       });
+            failurePath.Stub(fp => fp.SectionResults)
+                       .Return(new ObservableList<TestFailureMechanismSectionResult>
+                       {
+                           new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+                       });
+            mocks.ReplayAll();
+
+            failurePath.InAssembly = true;
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+                failureMechanismAssemblyCalculator.AssemblyResult = expectedAssemblyResult;
+
+                // Call
+                double assemblyResult = FailurePathAssemblyHelper.AssembleFailurePath(failurePath, sr => null, double.NaN);
+
+                // Assert
+                Assert.AreEqual(expectedAssemblyResult, assemblyResult);
+            }
+
+            mocks.VerifyAll();
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/DuneErosion/src/Riskeer.DuneErosion.Data/DuneErosionFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -r84db4e20f1cf46d8ac33f7fcfe8f30222354f83f -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/DuneErosion/src/Riskeer.DuneErosion.Data/DuneErosionFailureMechanismAssemblyFactory.cs	(.../DuneErosionFailureMechanismAssemblyFactory.cs)	(revision 84db4e20f1cf46d8ac33f7fcfe8f30222354f83f)
+++ Riskeer/DuneErosion/src/Riskeer.DuneErosion.Data/DuneErosionFailureMechanismAssemblyFactory.cs	(.../DuneErosionFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,9 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
@@ -57,16 +54,9 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, assessmentSection))
-                                    .ToArray();
-
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralInput.N,
-                                                                                      sectionAssemblyResults);
-            };
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(
+                failureMechanism, sr => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, assessmentSection),
+                failureMechanism.GeneralInput.N);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -r47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53 -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs)	(revision 47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53)
+++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,7 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
@@ -96,16 +95,8 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
-                                    .ToArray();
-
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralInput.N,
-                                                                                      sectionAssemblyResults);
-            };
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, sr => AssembleSection(sr, failureMechanism, assessmentSection),
+                                                                 failureMechanism.GeneralInput.N);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/GrassCoverErosionOutwards/src/Riskeer.GrassCoverErosionOutwards.Data/GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -reca9022fde719d5d998065e7801e17194a51f93b -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/GrassCoverErosionOutwards/src/Riskeer.GrassCoverErosionOutwards.Data/GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs)	(revision eca9022fde719d5d998065e7801e17194a51f93b)
+++ Riskeer/GrassCoverErosionOutwards/src/Riskeer.GrassCoverErosionOutwards.Data/GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,8 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
@@ -89,16 +87,8 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
-                                    .ToArray();
-
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralInput.N,
-                                                                                      sectionAssemblyResults);
-            };
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, sr => AssembleSection(sr, failureMechanism, assessmentSection),
+                                                                 failureMechanism.GeneralInput.N);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/PipingStructureFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -rc24134e3e4b9b06ec693eebf36b09b3e3a5a5177 -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/PipingStructureFailureMechanismAssemblyFactory.cs	(.../PipingStructureFailureMechanismAssemblyFactory.cs)	(revision c24134e3e4b9b06ec693eebf36b09b3e3a5a5177)
+++ Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/PipingStructureFailureMechanismAssemblyFactory.cs	(.../PipingStructureFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,9 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
@@ -56,15 +53,9 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, assessmentSection))
-                                    .ToArray();
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralInput.N, sectionAssemblyResults);
-            };
-
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(
+                failureMechanism, sr => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, assessmentSection),
+                failureMechanism.GeneralInput.N);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/StandAloneFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -rc24134e3e4b9b06ec693eebf36b09b3e3a5a5177 -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/StandAloneFailureMechanismAssemblyFactory.cs	(.../StandAloneFailureMechanismAssemblyFactory.cs)	(revision c24134e3e4b9b06ec693eebf36b09b3e3a5a5177)
+++ Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/StandAloneFailureMechanismAssemblyFactory.cs	(.../StandAloneFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,8 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
@@ -91,15 +89,9 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
-                                    .ToArray();
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralInput.N, sectionAssemblyResults);
-            };
-
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(
+                failureMechanism, sr => AssembleSection(sr, failureMechanism, assessmentSection),
+                failureMechanism.GeneralInput.N);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -r47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53 -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision 47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53)
+++ Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,7 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
@@ -98,16 +97,9 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
-                                    .ToArray();
-
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length),
-                                                                                      sectionAssemblyResults);
-            };
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(
+                failureMechanism, sr => AssembleSection(sr, failureMechanism, assessmentSection),
+                failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length));
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -ra620173dad71eeab4c184dcd224b706591ecc8ea -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismAssemblyFactory.cs	(.../PipingFailureMechanismAssemblyFactory.cs)	(revision a620173dad71eeab4c184dcd224b706591ecc8ea)
+++ Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismAssemblyFactory.cs	(.../PipingFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,8 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
@@ -97,16 +95,9 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
-                                    .ToArray();
-
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.PipingProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length),
-                                                                                      sectionAssemblyResults);
-            };
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(
+                failureMechanism, sr => AssembleSection(sr, failureMechanism, assessmentSection),
+                failureMechanism.PipingProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length));
         }
     }
 }
\ No newline at end of file
Index: Riskeer/StabilityStoneCover/src/Riskeer.StabilityStoneCover.Data/StabilityStoneCoverFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -reca9022fde719d5d998065e7801e17194a51f93b -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/StabilityStoneCover/src/Riskeer.StabilityStoneCover.Data/StabilityStoneCoverFailureMechanismAssemblyFactory.cs	(.../StabilityStoneCoverFailureMechanismAssemblyFactory.cs)	(revision eca9022fde719d5d998065e7801e17194a51f93b)
+++ Riskeer/StabilityStoneCover/src/Riskeer.StabilityStoneCover.Data/StabilityStoneCoverFailureMechanismAssemblyFactory.cs	(.../StabilityStoneCoverFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,8 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
@@ -89,16 +87,8 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
-                                    .ToArray();
-
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralInput.N,
-                                                                                      sectionAssemblyResults);
-            };
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, sr => AssembleSection(sr, failureMechanism, assessmentSection),
+                                                                 failureMechanism.GeneralInput.N);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/WaveImpactAsphaltCover/src/Riskeer.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -reca9022fde719d5d998065e7801e17194a51f93b -r6d08d2a395b4412431bf333b84053b605b896935
--- Riskeer/WaveImpactAsphaltCover/src/Riskeer.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs	(.../WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs)	(revision eca9022fde719d5d998065e7801e17194a51f93b)
+++ Riskeer/WaveImpactAsphaltCover/src/Riskeer.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs	(.../WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs)	(revision 6d08d2a395b4412431bf333b84053b605b896935)
@@ -20,8 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
@@ -89,16 +87,9 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            Func<double> performAssemblyFunc = () =>
-            {
-                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
-                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
-                                    .ToArray();
-
-                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralWaveImpactAsphaltCoverInput.GetN(assessmentSection.ReferenceLine.Length),
-                                                                                      sectionAssemblyResults);
-            };
-            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+            return FailurePathAssemblyHelper.AssembleFailurePath(
+                failureMechanism, sr => AssembleSection(sr, failureMechanism, assessmentSection),
+                failureMechanism.GeneralWaveImpactAsphaltCoverInput.GetN(assessmentSection.ReferenceLine.Length));
         }
     }
 }
\ No newline at end of file