Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r3cc451ebd61f1deb89b028a5cac31a29ef50e614 -r31caffb05afa347ddcfa184d56f2e5eb97237ad6
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 3cc451ebd61f1deb89b028a5cac31a29ef50e614)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 31caffb05afa347ddcfa184d56f2e5eb97237ad6)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Riskeer.AssemblyTool.Data;
+using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
 using Riskeer.Integration.Data;
 using Riskeer.Integration.Data.Assembly;
@@ -56,53 +57,44 @@
             return new ExportableAssessmentSection(assessmentSection.Name,
                                                    assessmentSection.Id,
                                                    assessmentSection.ReferenceLine.Points,
-                                                   CreateExportableAssessmentSectionAssemblyResult(assessmentSection),
-                                                   CreateExportableFailureMechanismAssemblyResultWithProbability(assessmentSection),
-                                                   CreateExportableFailureMechanismAssemblyResultWithoutProbability(assessmentSection),
+                                                   CreateExportableAssessmentSectionAssemblyResult(),
+                                                   CreateExportableFailureMechanismAssemblyResultWithProbability(),
+                                                   CreateExportableFailureMechanismAssemblyResultWithoutProbability(),
                                                    CreateExportableFailureMechanismsWithProbability(assessmentSection),
                                                    CreateExportableFailureMechanismsWithoutProbability(assessmentSection),
                                                    CreateExportableCombinedSectionAssemblyCollection(assessmentSection));
         }
 
         /// <summary>
-        /// Creates an <see cref="ExportableAssessmentSectionAssemblyResult"/> with the assembly result
-        /// based on <paramref name="assessmentSection"/>.
+        /// Creates an <see cref="ExportableAssessmentSectionAssemblyResult"/> with the assembly result.
         /// </summary>
-        /// <param name="assessmentSection">The assessment section to create an <see cref="ExportableAssessmentSectionAssemblyResult"/> for.</param>
         /// <returns>An <see cref="ExportableAssessmentSectionAssemblyResult"/> with assembly result.</returns>
-        /// <exception cref="AssemblyException">Thrown when assembly result cannot be created for <paramref name="assessmentSection"/>.</exception>
-        private static ExportableAssessmentSectionAssemblyResult CreateExportableAssessmentSectionAssemblyResult(AssessmentSection assessmentSection)
+        private static ExportableAssessmentSectionAssemblyResult CreateExportableAssessmentSectionAssemblyResult()
         {
             return new ExportableAssessmentSectionAssemblyResult(ExportableAssemblyMethod.WBI2C1,
-                                                                 AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection, false));
+                                                                 AssessmentSectionAssemblyCategoryGroup.None);
         }
 
         /// <summary>
-        /// Creates an <see cref="ExportableFailureMechanismAssemblyResultWithProbability"/> with the assembly result
-        /// based on <paramref name="assessmentSection"/>.
+        /// Creates an <see cref="ExportableFailureMechanismAssemblyResultWithProbability"/> with the assembly result.
         /// </summary>
-        /// <param name="assessmentSection">The assessment section to create an <see cref="ExportableFailureMechanismAssemblyResultWithProbability"/> for.</param>
         /// <returns>An <see cref="ExportableFailureMechanismAssemblyResultWithProbability"/> with assembly result.</returns>
-        /// <exception cref="AssemblyException">Thrown when assembly result cannot be created for <paramref name="assessmentSection"/>.</exception>
-        private static ExportableFailureMechanismAssemblyResultWithProbability CreateExportableFailureMechanismAssemblyResultWithProbability(AssessmentSection assessmentSection)
+        private static ExportableFailureMechanismAssemblyResultWithProbability CreateExportableFailureMechanismAssemblyResultWithProbability()
         {
-            FailureMechanismAssembly assemblyResult = AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, false);
+            var assemblyResult = new FailureMechanismAssembly(0, FailureMechanismAssemblyCategoryGroup.None);
             return new ExportableFailureMechanismAssemblyResultWithProbability(ExportableAssemblyMethod.WBI2B1,
                                                                                assemblyResult.Group,
                                                                                assemblyResult.Probability);
         }
 
         /// <summary>
-        /// Creates an <see cref="ExportableFailureMechanismAssemblyResult"/> with the assembly result
-        /// based on <paramref name="assessmentSection"/>.
+        /// Creates an <see cref="ExportableFailureMechanismAssemblyResult"/> with the assembly result.
         /// </summary>
-        /// <param name="assessmentSection">The assessment section to create an <see cref="ExportableFailureMechanismAssemblyResult"/> for.</param>
         /// <returns>An <see cref="ExportableFailureMechanismAssemblyResult"/> with assembly result.</returns>
-        /// <exception cref="AssemblyException">Thrown when assembly result cannot be created for <paramref name="assessmentSection"/>.</exception>
-        private static ExportableFailureMechanismAssemblyResult CreateExportableFailureMechanismAssemblyResultWithoutProbability(AssessmentSection assessmentSection)
+        private static ExportableFailureMechanismAssemblyResult CreateExportableFailureMechanismAssemblyResultWithoutProbability()
         {
             return new ExportableFailureMechanismAssemblyResult(ExportableAssemblyMethod.WBI2A1,
-                                                                AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false));
+                                                                FailureMechanismAssemblyCategoryGroup.None);
         }
 
         /// <summary>
@@ -158,9 +150,9 @@
         /// <param name="assessmentSection">The assessment section to create a collection of <see cref="ExportableCombinedSectionAssembly"/> for.</param>
         /// <returns>A <see cref="CreateExportableCombinedSectionAssemblyCollection"/>.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created for <paramref name="assessmentSection"/>.</exception>
-        private static IEnumerable<ExportableCombinedSectionAssembly> CreateExportableCombinedSectionAssemblyCollection(AssessmentSection assessmentSection)
+        private static IEnumerable<ExportableCombinedSectionAssembly> CreateExportableCombinedSectionAssemblyCollection(IAssessmentSection assessmentSection)
         {
-            IEnumerable<CombinedFailureMechanismSectionAssemblyResult> assemblyResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, false);
+            IEnumerable<CombinedFailureMechanismSectionAssemblyResult> assemblyResults = new List<CombinedFailureMechanismSectionAssemblyResult>();
             return ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, assessmentSection.ReferenceLine);
         }
     }
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs
===================================================================
diff -u -r98843de5182156088942567717084407b0c0c1ab -r31caffb05afa347ddcfa184d56f2e5eb97237ad6
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 98843de5182156088942567717084407b0c0c1ab)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 31caffb05afa347ddcfa184d56f2e5eb97237ad6)
@@ -32,7 +32,6 @@
 using Riskeer.Common.Data.FailureMechanism;
 using Riskeer.Common.Data.TestUtil;
 using Riskeer.Integration.Data;
-using Riskeer.Integration.Data.Assembly;
 using Riskeer.Integration.IO.Assembly;
 using Riskeer.Integration.IO.Factories;
 using Riskeer.Piping.Data;
@@ -42,6 +41,8 @@
     [TestFixture]
     public class ExportableAssessmentSectionFactoryTest
     {
+        private const FailureMechanismAssemblyCategoryGroup assemblyCategoryGroup = FailureMechanismAssemblyCategoryGroup.None;
+        
         [Test]
         public void CreateExportableAssessmentSection_AssessmentSectionNull_ThrowsArgumentNullException()
         {
@@ -88,10 +89,6 @@
 
             using (new AssemblyToolCalculatorFactoryConfigOld())
             {
-                var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance;
-                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
-                FailureMechanismAssemblyCalculatorOldStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
-
                 // Call
                 ExportableAssessmentSection exportableAssessmentSection = ExportableAssessmentSectionFactory.CreateExportableAssessmentSection(assessmentSection);
 
@@ -102,26 +99,24 @@
 
                 ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyWithProbability = exportableAssessmentSection.FailureMechanismAssemblyWithProbability;
                 Assert.AreEqual(ExportableAssemblyMethod.WBI2B1, failureMechanismAssemblyWithProbability.AssemblyMethod);
-                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyOutput.Group, failureMechanismAssemblyWithProbability.AssemblyCategory);
-                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyOutput.Probability, failureMechanismAssemblyWithProbability.Probability);
+                Assert.AreEqual(assemblyCategoryGroup, failureMechanismAssemblyWithProbability.AssemblyCategory);
+                Assert.AreEqual(0, failureMechanismAssemblyWithProbability.Probability);
 
                 ExportableFailureMechanismAssemblyResult failureMechanismAssemblyWithoutProbability = exportableAssessmentSection.FailureMechanismAssemblyWithoutProbability;
                 Assert.AreEqual(ExportableAssemblyMethod.WBI2A1, failureMechanismAssemblyWithoutProbability.AssemblyMethod);
-                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyCategoryGroupOutput, failureMechanismAssemblyWithoutProbability.AssemblyCategory);
+                Assert.AreEqual(assemblyCategoryGroup, failureMechanismAssemblyWithoutProbability.AssemblyCategory);
 
                 ExportableAssessmentSectionAssemblyResult exportableAssessmentSectionAssemblyResult = exportableAssessmentSection.AssessmentSectionAssembly;
-                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleAssessmentSectionCategoryGroupOutput, exportableAssessmentSectionAssemblyResult.AssemblyCategory);
+                Assert.AreEqual(AssessmentSectionAssemblyCategoryGroup.None, exportableAssessmentSectionAssemblyResult.AssemblyCategory);
                 Assert.AreEqual(ExportableAssemblyMethod.WBI2C1, exportableAssessmentSectionAssemblyResult.AssemblyMethod);
 
                 AssertExportableFailureMechanismsWithProbability(exportableAssessmentSection.FailureMechanismsWithProbability,
                                                                  assessmentSection);
 
                 AssertExportableFailureMechanismsWithoutProbability(exportableAssessmentSection.FailureMechanismsWithoutProbability,
-                                                                    failureMechanismAssemblyCalculator,
                                                                     assessmentSection);
 
-                int expectedNrOfSections = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, false).Count();
-                Assert.AreEqual(expectedNrOfSections, exportableAssessmentSection.CombinedSectionAssemblies.Count());
+                Assert.AreEqual(0, exportableAssessmentSection.CombinedSectionAssemblies.Count());
             }
         }
 
@@ -205,7 +200,7 @@
             Assert.AreEqual(expectedFailureMechanismGroup, actualExportableFailureMechanism.Group);
 
             ExportableFailureMechanismAssemblyResultWithProbability exportableFailureMechanismAssemblyResult = actualExportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.None, exportableFailureMechanismAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(assemblyCategoryGroup, exportableFailureMechanismAssemblyResult.AssemblyCategory);
             Assert.AreEqual(0, exportableFailureMechanismAssemblyResult.Probability);
             Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, exportableFailureMechanismAssemblyResult.AssemblyMethod);
 
@@ -218,69 +213,57 @@
 
         private static void AssertExportableFailureMechanismsWithoutProbability(
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> exportableFailureMechanisms,
-            FailureMechanismAssemblyCalculatorOldStub failureMechanismAssemblyCalculator,
             AssessmentSection assessmentSection)
         {
             Assert.AreEqual(9, exportableFailureMechanisms.Count());
 
-            FailureMechanismAssemblyCategoryGroup expectedFailureMechanismAssemblyOutput = failureMechanismAssemblyCalculator.FailureMechanismAssemblyCategoryGroupOutput.Value;
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.ZST,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.ZST,
                                                                ExportableFailureMechanismGroup.Group3,
                                                                assessmentSection.StabilityStoneCover,
                                                                exportableFailureMechanisms.First());
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.AGK,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.AGK,
                                                                ExportableFailureMechanismGroup.Group3,
                                                                assessmentSection.WaveImpactAsphaltCover,
                                                                exportableFailureMechanisms.ElementAt(1));
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.GEBU,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.GEBU,
                                                                ExportableFailureMechanismGroup.Group3,
                                                                assessmentSection.GrassCoverErosionOutwards,
                                                                exportableFailureMechanisms.ElementAt(2));
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.DA,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.DA,
                                                                ExportableFailureMechanismGroup.Group3,
                                                                assessmentSection.DuneErosion,
                                                                exportableFailureMechanisms.ElementAt(3));
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.STMI,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.STMI,
                                                                ExportableFailureMechanismGroup.Group4,
                                                                assessmentSection.Microstability,
                                                                exportableFailureMechanisms.ElementAt(4));
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.GABU,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.GABU,
                                                                ExportableFailureMechanismGroup.Group4,
                                                                assessmentSection.GrassCoverSlipOffOutwards,
                                                                exportableFailureMechanisms.ElementAt(5));
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.GABI,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.GABI,
                                                                ExportableFailureMechanismGroup.Group4,
                                                                assessmentSection.GrassCoverSlipOffInwards,
                                                                exportableFailureMechanisms.ElementAt(6));
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.PKW,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.PKW,
                                                                ExportableFailureMechanismGroup.Group4,
                                                                assessmentSection.PipingStructure,
                                                                exportableFailureMechanisms.ElementAt(7));
 
-            AssertExportableFailureMechanismWithoutProbability(expectedFailureMechanismAssemblyOutput,
-                                                               ExportableFailureMechanismType.AWO,
+            AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType.AWO,
                                                                ExportableFailureMechanismGroup.Group4,
                                                                assessmentSection.WaterPressureAsphaltCover,
                                                                exportableFailureMechanisms.ElementAt(8));
         }
 
-        private static void AssertExportableFailureMechanismWithoutProbability(FailureMechanismAssemblyCategoryGroup expectedAssemblyOutput,
-                                                                               ExportableFailureMechanismType expectedFailureMechanismCode,
+        private static void AssertExportableFailureMechanismWithoutProbability(ExportableFailureMechanismType expectedFailureMechanismCode,
                                                                                ExportableFailureMechanismGroup expectedFailureMechanismGroup,
                                                                                IHasSectionResults<FailureMechanismSectionResultOld> failureMechanism,
                                                                                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> actualExportableFailureMechanism)
@@ -289,7 +272,7 @@
             Assert.AreEqual(expectedFailureMechanismGroup, actualExportableFailureMechanism.Group);
 
             ExportableFailureMechanismAssemblyResult exportableFailureMechanismAssemblyResult = actualExportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.None, exportableFailureMechanismAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(assemblyCategoryGroup, exportableFailureMechanismAssemblyResult.AssemblyCategory);
             Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, exportableFailureMechanismAssemblyResult.AssemblyMethod);
 
             Assert.AreEqual(failureMechanism.SectionResultsOld.Count(), actualExportableFailureMechanism.SectionAssemblyResults.Count());