Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs
===================================================================
diff -u -r26259e86f36858575c3307e3a97602a899026bbf -rf6d8a38a39fa980545938710e144e835ecc22015
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs)	(revision 26259e86f36858575c3307e3a97602a899026bbf)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs)	(revision f6d8a38a39fa980545938710e144e835ecc22015)
@@ -21,7 +21,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
@@ -73,13 +72,13 @@
                                                                                                                 failureMechanismAssemblyMethod);
             }
 
-            FailureMechanismAssembly failureMechanismAssembly = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection, false);
+            var failureMechanismAssembly = new FailureMechanismAssembly(0, FailureMechanismAssemblyCategoryGroup.None);
 
             return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
                 new ExportableFailureMechanismAssemblyResultWithProbability(failureMechanismAssemblyMethod,
                                                                             failureMechanismAssembly.Group,
                                                                             failureMechanismAssembly.Probability),
-                CreateExportableFailureMechanismSectionResults(failureMechanism, assessmentSection),
+                CreateExportableFailureMechanismSectionResults(failureMechanism),
                 failureMechanismCode,
                 failureMechanismGroup);
         }
@@ -90,40 +89,22 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="GrassCoverErosionInwardsFailureMechanism"/> to create a a collection
         /// of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/> for.</param>
-        /// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
         /// <returns>A collection of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/>.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         private static IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> CreateExportableFailureMechanismSectionResults(
-            GrassCoverErosionInwardsFailureMechanism failureMechanism,
-            IAssessmentSection assessmentSection)
+            GrassCoverErosionInwardsFailureMechanism failureMechanism)
         {
             IDictionary<GrassCoverErosionInwardsFailureMechanismSectionResultOld, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
                 ExportableFailureMechanismSectionHelper.CreateFailureMechanismSectionResultLookup(failureMechanism.SectionResultsOld);
 
-            IEnumerable<GrassCoverErosionInwardsCalculationScenario> calculationScenarios = failureMechanism.Calculations.Cast<GrassCoverErosionInwardsCalculationScenario>();
-
             var exportableResults = new List<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>();
             foreach (KeyValuePair<GrassCoverErosionInwardsFailureMechanismSectionResultOld, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSectionsLookup)
             {
-                GrassCoverErosionInwardsFailureMechanismSectionResultOld failureMechanismSectionResult = failureMechanismSectionPair.Key;
+                var simpleAssembly = new FailureMechanismSectionAssemblyOld(0, FailureMechanismSectionAssemblyCategoryGroup.None);
+                var detailedAssembly = new FailureMechanismSectionAssemblyOld(0, FailureMechanismSectionAssemblyCategoryGroup.None);
+                var tailorMadeAssembly = new FailureMechanismSectionAssemblyOld(0, FailureMechanismSectionAssemblyCategoryGroup.None);
+                var combinedAssembly = new FailureMechanismSectionAssemblyOld(0, FailureMechanismSectionAssemblyCategoryGroup.None);
 
-                FailureMechanismSectionAssemblyOld simpleAssembly =
-                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(failureMechanismSectionResult);
-                FailureMechanismSectionAssemblyOld detailedAssembly =
-                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(failureMechanismSectionResult,
-                                                                                                       calculationScenarios,
-                                                                                                       failureMechanism,
-                                                                                                       assessmentSection);
-                FailureMechanismSectionAssemblyOld tailorMadeAssembly =
-                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(failureMechanismSectionResult,
-                                                                                                         failureMechanism,
-                                                                                                         assessmentSection);
-                FailureMechanismSectionAssemblyOld combinedAssembly =
-                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanismSectionResult,
-                                                                                                       calculationScenarios,
-                                                                                                       failureMechanism,
-                                                                                                       assessmentSection);
-
                 exportableResults.Add(
                     new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability(
                         failureMechanismSectionPair.Value,
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs
===================================================================
diff -u -rbecb20be0283702deba5ab628e9150e9c749e130 -rf6d8a38a39fa980545938710e144e835ecc22015
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs)	(revision becb20be0283702deba5ab628e9150e9c749e130)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs)	(revision f6d8a38a39fa980545938710e144e835ecc22015)
@@ -25,9 +25,6 @@
 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.AssessmentSection;
 using Riskeer.Common.Data.TestUtil;
 using Riskeer.GrassCoverErosionInwards.Data;
@@ -40,6 +37,8 @@
     [TestFixture]
     public class ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest
     {
+        private static readonly FailureMechanismSectionAssemblyOld expectedAssemblyResult = new FailureMechanismSectionAssemblyOld(0, FailureMechanismSectionAssemblyCategoryGroup.None);
+        
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
@@ -109,66 +108,28 @@
 
             var assessmentSection = new AssessmentSectionStub();
 
-            using (new AssemblyToolCalculatorFactoryConfigOld())
-            {
-                var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance;
-                FailureMechanismAssemblyCalculatorOldStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
-                FailureMechanismSectionAssemblyCalculatorOldStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+            // Call
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
-                // Call
-                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
-                    ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
+            // Assert
+            Assert.AreEqual(ExportableFailureMechanismType.GEKB, exportableFailureMechanism.Code);
+            Assert.AreEqual(ExportableFailureMechanismGroup.Group1, exportableFailureMechanism.Group);
 
-                // Assert
-                Assert.AreEqual(ExportableFailureMechanismType.GEKB, exportableFailureMechanism.Code);
-                Assert.AreEqual(ExportableFailureMechanismGroup.Group1, exportableFailureMechanism.Group);
+            ExportableFailureMechanismAssemblyResultWithProbability exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly;
+            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.None, exportableFailureMechanismAssembly.AssemblyCategory);
+            Assert.AreEqual(0, exportableFailureMechanismAssembly.Probability);
+            Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, exportableFailureMechanismAssembly.AssemblyMethod);
 
-                FailureMechanismAssembly calculatorOutput = failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput;
-                ExportableFailureMechanismAssemblyResultWithProbability exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly;
-                Assert.AreEqual(calculatorOutput.Group, exportableFailureMechanismAssembly.AssemblyCategory);
-                Assert.AreEqual(calculatorOutput.Probability, exportableFailureMechanismAssembly.Probability);
-                Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, exportableFailureMechanismAssembly.AssemblyMethod);
-
-                IEnumerable<ExportableFailureMechanismSection> exportableFailureMechanismSections = exportableFailureMechanism.SectionAssemblyResults
-                                                                                                                              .Select(sar => sar.FailureMechanismSection);
-                ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, exportableFailureMechanismSections);
-                AssertExportableFailureMechanismSectionResults(failureMechanismSectionAssemblyCalculator.SimpleAssessmentAssemblyOutput,
-                                                               failureMechanismSectionAssemblyCalculator.DetailedAssessmentAssemblyOutput,
-                                                               failureMechanismSectionAssemblyCalculator.TailorMadeAssessmentAssemblyOutput,
-                                                               failureMechanismSectionAssemblyCalculator.CombinedAssemblyOutput,
-                                                               exportableFailureMechanismSections,
-                                                               exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
-            }
+            IEnumerable<ExportableFailureMechanismSection> exportableFailureMechanismSections = exportableFailureMechanism.SectionAssemblyResults
+                                                                                                                          .Select(sar => sar.FailureMechanismSection);
+            ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, exportableFailureMechanismSections);
+            AssertExportableFailureMechanismSectionResults(exportableFailureMechanismSections,
+                                                           exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
         }
 
-        [Test]
-        public void CreateExportableFailureMechanism_WithFailureMechanismWithManualAssessment_ManualAssemblyIgnored()
-        {
-            // Setup
-            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
-            FailureMechanismTestHelper.AddSections(failureMechanism, 1);
-            failureMechanism.SectionResultsOld.Single().UseManualAssembly = true;
 
-            using (new AssemblyToolCalculatorFactoryConfigOld())
-            {
-                var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance;
-                FailureMechanismSectionAssemblyCalculatorOldStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
-                FailureMechanismAssemblyCalculatorOldStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
-
-                // Call
-                ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, new AssessmentSectionStub());
-
-                // Assert
-                Assert.AreSame(failureMechanismSectionAssemblyCalculator.CombinedAssemblyOutput,
-                               failureMechanismAssemblyCalculator.FailureMechanismSectionAssemblies.Single());
-            }
-        }
-
-        private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyOld expectedSimpleAssembly,
-                                                                           FailureMechanismSectionAssemblyOld expectedDetailedAssembly,
-                                                                           FailureMechanismSectionAssemblyOld expectedTailorMadeAssembly,
-                                                                           FailureMechanismSectionAssemblyOld expectedCombinedAssembly,
-                                                                           IEnumerable<ExportableFailureMechanismSection> sections,
+        private static void AssertExportableFailureMechanismSectionResults(IEnumerable<ExportableFailureMechanismSection> sections,
                                                                            IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> results)
         {
             int expectedNrOfResults = sections.Count();
@@ -179,37 +140,29 @@
                 ExportableFailureMechanismSection section = sections.ElementAt(i);
                 ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability result = results.ElementAt(i);
 
-                AssertExportableFailureMechanismSectionResult(expectedSimpleAssembly,
-                                                              expectedDetailedAssembly,
-                                                              expectedTailorMadeAssembly,
-                                                              expectedCombinedAssembly,
-                                                              section,
+                AssertExportableFailureMechanismSectionResult(section,
                                                               result);
             }
         }
 
-        private static void AssertExportableFailureMechanismSectionResult(FailureMechanismSectionAssemblyOld expectedSimpleAssembly,
-                                                                          FailureMechanismSectionAssemblyOld expectedDetailedAssembly,
-                                                                          FailureMechanismSectionAssemblyOld expectedTailorMadeAssembly,
-                                                                          FailureMechanismSectionAssemblyOld expectedCombinedAssembly,
-                                                                          ExportableFailureMechanismSection expectedSection,
+        private static void AssertExportableFailureMechanismSectionResult(ExportableFailureMechanismSection expectedSection,
                                                                           ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability actualResult)
         {
             Assert.AreSame(expectedSection, actualResult.FailureMechanismSection);
 
-            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedSimpleAssembly,
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedAssemblyResult,
                                                                                             ExportableAssemblyMethod.WBI0E3,
                                                                                             actualResult.SimpleAssembly);
 
-            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedDetailedAssembly,
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedAssemblyResult,
                                                                                             ExportableAssemblyMethod.WBI0G3,
                                                                                             actualResult.DetailedAssembly);
 
-            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedTailorMadeAssembly,
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedAssemblyResult,
                                                                                             ExportableAssemblyMethod.WBI0T3,
                                                                                             actualResult.TailorMadeAssembly);
 
-            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedCombinedAssembly,
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedAssemblyResult,
                                                                                             ExportableAssemblyMethod.WBI0A1,
                                                                                             actualResult.CombinedAssembly);
         }