Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs
===================================================================
diff -u -r0d2ad61816de23c77e9b741b5301265d3752cea3 -r6f8dc0c6b0b1018692002207d107695be438c2b1
--- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs	(.../FailureMechanismSectionAssemblyCalculator.cs)	(revision 0d2ad61816de23c77e9b741b5301265d3752cea3)
+++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs	(.../FailureMechanismSectionAssemblyCalculator.cs)	(revision 6f8dc0c6b0b1018692002207d107695be438c2b1)
@@ -1,4 +1,4 @@
-// Copyright (C) Stichting Deltares 2021. All rights reserved.
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
 //
 // This file is part of Riskeer.
 //
@@ -63,16 +63,31 @@
                 throw new ArgumentNullException(nameof(input));
             }
 
-            KernelFailureMechanismSectionAssemblyResult GetAssemblyResultFunc(
-                IAssessmentResultsTranslator kernel, CategoriesList<InterpretationCategory> interpretationCategories) =>
-                kernel.TranslateAssessmentResultAggregatedMethod(
+            try
+            {
+                ICategoryLimitsCalculator assemblyGroupsKernel = factory.CreateAssemblyGroupsKernel();
+                CategoriesList<InterpretationCategory> interpretationCategories = assemblyGroupsKernel.CalculateInterpretationCategoryLimitsBoi01(
+                    new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(input.SignalFloodingProbability),
+                                          AssemblyCalculatorInputCreator.CreateProbability(input.MaximumAllowableFloodingProbability)));
+
+                IAssessmentResultsTranslator kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
+                KernelFailureMechanismSectionAssemblyResult output = kernel.TranslateAssessmentResultAggregatedMethod(
                     GetInitialMechanismProbabilitySpecification(input),
                     AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability),
                     FailureMechanismSectionAssemblyCalculatorInputCreator.ConvertFailureMechanismSectionResultFurtherAnalysisType(input.FurtherAnalysisType),
                     AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability),
                     interpretationCategories);
 
-            return AssembleFailureMechanismSection(GetAssemblyResultFunc, input.SignalFloodingProbability, input.MaximumAllowableFloodingProbability);
+                return FailureMechanismSectionAssemblyResultCreator.Create(output);
+            }
+            catch (AssemblyException e)
+            {
+                throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e);
+            }
+            catch (Exception e)
+            {
+                throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e);
+            }
         }
 
         public RiskeerFailureMechanismSectionAssemblyResult AssembleFailureMechanismSection(FailureMechanismSectionWithProfileProbabilityAssemblyInput input)
@@ -82,9 +97,15 @@
                 throw new ArgumentNullException(nameof(input));
             }
 
-            FailureMechanismSectionAssemblyResultWithLengthEffect GetAssemblyResultFunc(
-                IAssessmentResultsTranslator kernel, CategoriesList<InterpretationCategory> interpretationCategories) =>
-                kernel.TranslateAssessmentResultWithLengthEffectAggregatedMethod(
+            try
+            {
+                ICategoryLimitsCalculator assemblyGroupsKernel = factory.CreateAssemblyGroupsKernel();
+                CategoriesList<InterpretationCategory> interpretationCategories = assemblyGroupsKernel.CalculateInterpretationCategoryLimitsBoi01(
+                    new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(input.SignalFloodingProbability),
+                                          AssemblyCalculatorInputCreator.CreateProbability(input.MaximumAllowableFloodingProbability)));
+
+                IAssessmentResultsTranslator kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
+                FailureMechanismSectionAssemblyResultWithLengthEffect output = kernel.TranslateAssessmentResultWithLengthEffectAggregatedMethod(
                     GetInitialMechanismProbabilitySpecification(input),
                     AssemblyCalculatorInputCreator.CreateProbability(input.InitialProfileProbability),
                     AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability),
@@ -93,23 +114,7 @@
                     AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability),
                     interpretationCategories);
 
-            return AssembleFailureMechanismSection(GetAssemblyResultFunc, input.SignalFloodingProbability, input.MaximumAllowableFloodingProbability);
-        }
-
-        private RiskeerFailureMechanismSectionAssemblyResult AssembleFailureMechanismSection<TAssemblyResult>(
-            Func<IAssessmentResultsTranslator, CategoriesList<InterpretationCategory>, TAssemblyResult> getAssemblyResultFunc,
-            double signalFloodingProbability, double maximumAllowableFloodingProbability)
-        {
-            try
-            {
-                ICategoryLimitsCalculator assemblyGroupsKernel = factory.CreateAssemblyGroupsKernel();
-                CategoriesList<InterpretationCategory> interpretationCategories = assemblyGroupsKernel.CalculateInterpretationCategoryLimitsBoi01(
-                    new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(signalFloodingProbability),
-                                          AssemblyCalculatorInputCreator.CreateProbability(maximumAllowableFloodingProbability)));
-
-                TAssemblyResult output = getAssemblyResultFunc(factory.CreateFailureMechanismSectionAssemblyKernel(), interpretationCategories);
-
-                return FailureMechanismSectionAssemblyResultCreator.CreateFailureMechanismSectionAssemblyResult(output);
+                return FailureMechanismSectionAssemblyResultCreator.Create(output);
             }
             catch (AssemblyException e)
             {
Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyResultCreator.cs
===================================================================
diff -u -r0d2ad61816de23c77e9b741b5301265d3752cea3 -r6f8dc0c6b0b1018692002207d107695be438c2b1
--- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyResultCreator.cs	(.../FailureMechanismSectionAssemblyResultCreator.cs)	(revision 0d2ad61816de23c77e9b741b5301265d3752cea3)
+++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyResultCreator.cs	(.../FailureMechanismSectionAssemblyResultCreator.cs)	(revision 6f8dc0c6b0b1018692002207d107695be438c2b1)
@@ -22,7 +22,7 @@
 using System;
 using System.ComponentModel;
 using Assembly.Kernel.Model.Categories;
-using KernelFailureMechanismSectionAssemblyResult = Assembly.Kernel.Model.FailureMechanismSections.FailureMechanismSectionAssemblyResult;
+using Assembly.Kernel.Model.FailureMechanismSections;
 using RiskeerFailureMechanismSectionAssemblyResult = Riskeer.AssemblyTool.Data.FailureMechanismSectionAssemblyResult;
 
 namespace Riskeer.AssemblyTool.KernelWrapper.Creators
@@ -33,26 +33,47 @@
     internal static class FailureMechanismSectionAssemblyResultCreator
     {
         /// <summary>
-        /// Converts a <see cref="KernelFailureMechanismSectionAssemblyResult"/> into a <see cref="RiskeerFailureMechanismSectionAssemblyResult"/>.
+        /// Converts a <see cref="FailureMechanismSectionAssemblyResult"/> into a <see cref="RiskeerFailureMechanismSectionAssemblyResult"/>.
         /// </summary>
-        /// <param name="result">The <see cref="KernelFailureMechanismSectionAssemblyResult"/> to convert.</param>
+        /// <param name="result">The <see cref="FailureMechanismSectionAssemblyResult"/> to convert.</param>
         /// <returns>A <see cref="RiskeerFailureMechanismSectionAssemblyResult"/> based on <paramref name="result"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
         /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="EInterpretationCategory"/>
         /// is an invalid value.</exception>
         /// <exception cref="NotSupportedException">Thrown when <see cref="EInterpretationCategory"/>
         /// is a valid value, but unsupported.</exception>
-        public static RiskeerFailureMechanismSectionAssemblyResult CreateFailureMechanismSectionAssemblyResult(
-            KernelFailureMechanismSectionAssemblyResult result)
+        public static RiskeerFailureMechanismSectionAssemblyResult Create(FailureMechanismSectionAssemblyResult result)
         {
             if (result == null)
             {
                 throw new ArgumentNullException(nameof(result));
             }
 
             return new RiskeerFailureMechanismSectionAssemblyResult(
-                result.ProbabilityProfile.Value, result.ProbabilitySection.Value, result.NSection,
+                result.ProbabilitySection, result.ProbabilitySection, 1.0,
                 FailureMechanismSectionAssemblyGroupConverter.ConvertTo(result.InterpretationCategory));
         }
+        
+        /// <summary>
+        /// Converts a <see cref="FailureMechanismSectionAssemblyResultWithLengthEffect"/> into a <see cref="RiskeerFailureMechanismSectionAssemblyResult"/>.
+        /// </summary>
+        /// <param name="result">The <see cref="FailureMechanismSectionAssemblyResultWithLengthEffect"/> to convert.</param>
+        /// <returns>A <see cref="RiskeerFailureMechanismSectionAssemblyResult"/> based on <paramref name="result"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="EInterpretationCategory"/>
+        /// is an invalid value.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <see cref="EInterpretationCategory"/>
+        /// is a valid value, but unsupported.</exception>
+        public static RiskeerFailureMechanismSectionAssemblyResult Create(FailureMechanismSectionAssemblyResultWithLengthEffect result)
+        {
+            if (result == null)
+            {
+                throw new ArgumentNullException(nameof(result));
+            }
+
+            return new RiskeerFailureMechanismSectionAssemblyResult(
+                result.ProbabilityProfile, result.ProbabilitySection, result.LengthEffectFactor,
+                FailureMechanismSectionAssemblyGroupConverter.ConvertTo(result.InterpretationCategory));
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyResultCreatorTest.cs
===================================================================
diff -u -rcf0ed9a34391a508b283b3a72f20b9646a3ce948 -r6f8dc0c6b0b1018692002207d107695be438c2b1
--- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyResultCreatorTest.cs	(.../FailureMechanismSectionAssemblyResultCreatorTest.cs)	(revision cf0ed9a34391a508b283b3a72f20b9646a3ce948)
+++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyResultCreatorTest.cs	(.../FailureMechanismSectionAssemblyResultCreatorTest.cs)	(revision 6f8dc0c6b0b1018692002207d107695be438c2b1)
@@ -22,6 +22,7 @@
 using System;
 using Assembly.Kernel.Model;
 using Assembly.Kernel.Model.Categories;
+using Assembly.Kernel.Model.FailureMechanismSections;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Riskeer.AssemblyTool.KernelWrapper.Creators;
@@ -34,36 +35,68 @@
     public class FailureMechanismSectionAssemblyResultCreatorTest
     {
         [Test]
-        public void CreateFailureMechanismSectionAssemblyResult_ResultNull_ThrowsArgumentNullException()
+        public void CreateForFailureMechanismSectionAssemblyResult_ResultNull_ThrowsArgumentNullException()
         {
             // Call
-            void Call() => FailureMechanismSectionAssemblyResultCreator.CreateFailureMechanismSectionAssemblyResult(null);
+            void Call() => FailureMechanismSectionAssemblyResultCreator.Create((KernelFailureMechanismSectionAssemblyResult) null);
 
             // Assert
-            Assert.That(Call, Throws.TypeOf<ArgumentNullException>()
-                                    .With.Property(nameof(ArgumentNullException.ParamName))
-                                    .EqualTo("result"));
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("result", exception.ParamName);
         }
 
         [Test]
-        public void CreateFailureMechanismSectionAssemblyResult_WithValidResult_ReturnsExpectedFailureMechanismSectionAssembly()
+        public void CreateForFailureMechanismSectionAssemblyResult_WithValidResult_ReturnsExpectedFailureMechanismSectionAssembly()
         {
             // Setup
             var random = new Random(21);
-            double profileProbability = random.NextDouble();
             double sectionProbability = random.NextDouble();
             var interpretationCategory = random.NextEnumValue<EInterpretationCategory>();
 
             var result = new KernelFailureMechanismSectionAssemblyResult(
+                new Probability(sectionProbability), interpretationCategory);
+
+            // Call
+            RiskeerFailureMechanismSectionAssemblyResult createdAssemblyResult = FailureMechanismSectionAssemblyResultCreator.Create(result);
+
+            // Assert
+            Assert.AreEqual(sectionProbability, createdAssemblyResult.ProfileProbability);
+            Assert.AreEqual(sectionProbability, createdAssemblyResult.SectionProbability);
+            Assert.AreEqual(1.0, createdAssemblyResult.N);
+            Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(interpretationCategory),
+                            createdAssemblyResult.FailureMechanismSectionAssemblyGroup);
+        }
+
+        [Test]
+        public void CreateForFailureMechanismSectionAssemblyResultWithLengthEffect_ResultNull_ThrowsArgumentNullException()
+        {
+            // Call
+            void Call() => FailureMechanismSectionAssemblyResultCreator.Create((FailureMechanismSectionAssemblyResultWithLengthEffect) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("result", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateForFailureMechanismSectionAssemblyResultWithLengthEffect_WithValidResult_ReturnsExpectedFailureMechanismSectionAssembly()
+        {
+            // Setup
+            var random = new Random(21);
+            double profileProbability = random.NextDouble();
+            double sectionProbability = random.NextDouble();
+            var interpretationCategory = random.NextEnumValue<EInterpretationCategory>();
+
+            var result = new FailureMechanismSectionAssemblyResultWithLengthEffect(
                 new Probability(profileProbability), new Probability(sectionProbability), interpretationCategory);
 
             // Call
-            RiskeerFailureMechanismSectionAssemblyResult createdAssemblyResult = FailureMechanismSectionAssemblyResultCreator.CreateFailureMechanismSectionAssemblyResult(result);
+            RiskeerFailureMechanismSectionAssemblyResult createdAssemblyResult = FailureMechanismSectionAssemblyResultCreator.Create(result);
 
             // Assert
             Assert.AreEqual(profileProbability, createdAssemblyResult.ProfileProbability);
             Assert.AreEqual(sectionProbability, createdAssemblyResult.SectionProbability);
-            Assert.AreEqual(result.NSection, createdAssemblyResult.N);
+            Assert.AreEqual(result.LengthEffectFactor, createdAssemblyResult.N);
             Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(interpretationCategory),
                             createdAssemblyResult.FailureMechanismSectionAssemblyGroup);
         }