Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -rbbbfacd9e38cf43c98dba73e39694850fb932a66 -r76d5e546e8087c3cd169dd2e6bb04556d88eec87
--- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision bbbfacd9e38cf43c98dba73e39694850fb932a66)
+++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision 76d5e546e8087c3cd169dd2e6bb04556d88eec87)
@@ -26,10 +26,10 @@
 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;
-using Ringtoets.Common.Primitives;
 
 namespace Ringtoets.MacroStabilityInwards.Data
 {
@@ -238,15 +238,13 @@
         /// </summary>
         /// <param name="failureMechanism">The failure mechanism to assemble for.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the failure mechanism belongs to.</param>
-        /// <param name="considerManualAssembly">Indicator whether the manual assembly should be used in the assembly.</param>
         /// <returns>A <see cref="FailureMechanismAssembly"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when the <see cref="FailureMechanismAssembly"/>
         /// could not be created.</exception>
         public static FailureMechanismAssembly AssembleFailureMechanism(
             MacroStabilityInwardsFailureMechanism failureMechanism,
-            IAssessmentSection assessmentSection,
-            bool considerManualAssembly = true)
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
@@ -259,52 +257,81 @@
             }
 
             IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance;
+            AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput(failureMechanism, assessmentSection);
+            IEnumerable<FailureMechanismSectionAssembly> sectionAssemblies = AssembleSections(failureMechanism,
+                                                                                              assessmentSection,
+                                                                                              assemblyCategoriesInput);
+
+            try
+            {
+                IFailureMechanismAssemblyCalculator calculator =
+                    calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance);
+
+                return calculator.Assemble(sectionAssemblies, assemblyCategoriesInput);
+            }
+            catch (FailureMechanismAssemblyCalculatorException e)
+            {
+                throw new AssemblyException(e.Message, e);
+            }
+        }
+
+        /// <summary>
+        /// Assembles the combined assembly for all sections in the <paramref name="failureMechanism"/>.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism to assemble for.</param>
+        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the failure mechanism belongs to.</param>
+        /// <param name="assemblyCategoriesInput">The object containing the input parameters for determining the assembly categories.</param>
+        /// <exception cref="AssemblyException">Thrown when a <see cref="FailureMechanismSectionAssembly"/>
+        /// could not be created.</exception>
+        /// <returns>A collection of all section assembly results.</returns>
+        private static IEnumerable<FailureMechanismSectionAssembly> AssembleSections(MacroStabilityInwardsFailureMechanism failureMechanism,
+                                                                                     IAssessmentSection assessmentSection,
+                                                                                     AssemblyCategoriesInput assemblyCategoriesInput)
+        {
+            IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance;
             IFailureMechanismSectionAssemblyCalculator sectionCalculator =
                 calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance);
 
-            AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput(failureMechanism, assessmentSection);
             var sectionAssemblies = new List<FailureMechanismSectionAssembly>();
 
-            try
+            foreach (MacroStabilityInwardsFailureMechanismSectionResult sectionResult in failureMechanism.SectionResults)
             {
-                foreach (MacroStabilityInwardsFailureMechanismSectionResult sectionResult in failureMechanism.SectionResults)
+                FailureMechanismSectionAssembly sectionAssembly;
+                if (sectionResult.UseManualAssemblyProbability)
                 {
-                    if (sectionResult.UseManualAssemblyProbability && considerManualAssembly)
+                    try
                     {
-                        sectionAssemblies.Add(sectionCalculator.AssembleDetailedAssessment(
-                                                  DetailedAssessmentProbabilityOnlyResultType.Probability,
-                                                  sectionResult.ManualAssemblyProbability,
-                                                  failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(sectionResult.Section.Length),
-                                                  assemblyCategoriesInput));
+                        sectionAssembly = sectionCalculator.AssembleManual(sectionResult.ManualAssemblyProbability,
+                                                                           failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(
+                                                                               sectionResult.Section.Length),
+                                                                           assemblyCategoriesInput);
                     }
-                    else
+                    catch (FailureMechanismSectionAssemblyCalculatorException e)
                     {
-                        sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult,
-                                                                         failureMechanism.Calculations.Cast<MacroStabilityInwardsCalculationScenario>(),
-                                                                         failureMechanism,
-                                                                         assessmentSection));
+                        throw new AssemblyException(e.Message, e);
                     }
                 }
+                else
+                {
+                    sectionAssembly = AssembleCombinedAssessment(sectionResult,
+                                                                 failureMechanism.Calculations.Cast<MacroStabilityInwardsCalculationScenario>(),
+                                                                 failureMechanism,
+                                                                 assessmentSection);
+                }
 
-                IFailureMechanismAssemblyCalculator calculator =
-                    calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance);
-
-                return calculator.Assemble(sectionAssemblies, assemblyCategoriesInput);
+                sectionAssemblies.Add(sectionAssembly);
             }
-            catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException)
-            {
-                throw new AssemblyException(e.Message, e);
-            }
+
+            return sectionAssemblies;
         }
 
-        private static AssemblyCategoriesInput CreateAssemblyCategoriesInput(MacroStabilityInwardsFailureMechanism failureMechanism, 
+        private static AssemblyCategoriesInput CreateAssemblyCategoriesInput(MacroStabilityInwardsFailureMechanism failureMechanism,
                                                                              IAssessmentSection assessmentSection)
         {
-            return new AssemblyCategoriesInput(failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(
-                                                   failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.SectionLength),
-                                               failureMechanism.Contribution,
-                                               assessmentSection.FailureMechanismContribution.SignalingNorm,
-                                               assessmentSection.FailureMechanismContribution.LowerLimitNorm);
+            return AssemblyCategoriesInputFactory.CreateAssemblyCategoriesInput(failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(
+                                                                                    failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.SectionLength),
+                                                                                failureMechanism,
+                                                                                assessmentSection);
         }
     }
 }
\ No newline at end of file