Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs
===================================================================
diff -u -r7ed02cd32907187a42007f6f4fa7b35468b088ba -r6ddca0d359e34472c80be5e095765577d24fac07
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs	(.../FailureMechanismSectionAssemblyCalculator.cs)	(revision 7ed02cd32907187a42007f6f4fa7b35468b088ba)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs	(.../FailureMechanismSectionAssemblyCalculator.cs)	(revision 6ddca0d359e34472c80be5e095765577d24fac07)
@@ -76,10 +76,10 @@
             try
             {
                 IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
-                CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> output = kernel.SimpleAssessmentDirectFailureMechanisms(
+                FmSectionAssemblyDirectResult output = kernel.TranslateAssessmentResultWbi0E3(
                     FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeE2(input));
 
-                return FailureMechanismSectionAssemblyCreator.Create(output.Result);
+                return FailureMechanismSectionAssemblyCreator.Create(output);
             }
             catch (Exception e)
             {
@@ -96,8 +96,8 @@
             try
             {
                 IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
-                CalculationOutput<FailureMechanismSectionCategoryGroup> output = kernel.DetailedAssessmentDirectFailureMechanisms(
-                    FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationResult(detailedAssessmentResult));
+                FmSectionAssemblyDirectResult output = kernel.TranslateAssessmentResultWbi0G1(
+                    FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG1(detailedAssessmentResult));
 
                 return FailureMechanismSectionAssemblyCreator.ConvertFailureMechanismSectionCategory(output.Result);
             }
@@ -124,11 +124,11 @@
                     try
                     {
                         IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
-                        CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> output = kernel.DetailedAssessmentDirectFailureMechanisms(
+                        FmSectionAssemblyDirectResult output = kernel.DetailedAssessmentDirectFailureMechanisms(
                             FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(probability,
                                                                                                                                 categories));
 
-                        return FailureMechanismSectionAssemblyCreator.Create(output.Result);
+                        return FailureMechanismSectionAssemblyCreator.Create(output);
                     }
                     catch (Exception e)
                     {
@@ -161,7 +161,7 @@
                     try
                     {
                         IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
-                        CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> output = kernel.DetailedAssessmentDirectFailureMechanisms(
+                        FmSectionAssemblyDirectResult output = kernel.DetailedAssessmentDirectFailureMechanisms(
                             FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(probability,
                                                                                                                                                 categories,
                                                                                                                                                 n));
@@ -216,7 +216,7 @@
             try
             {
                 IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
-                CalculationOutput<FailureMechanismSectionCategoryGroup> output = kernel.TailorMadeAssessmentDirectFailureMechanisms(
+                FmSectionAssemblyDirectResult output = kernel.TailorMadeAssessmentDirectFailureMechanisms(
                     FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationResult(tailorMadeAssessmentResult));
 
                 return FailureMechanismSectionAssemblyCreator.ConvertFailureMechanismSectionCategory(output.Result);
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs
===================================================================
diff -u -ra19b349a904f33edd89b2f1fb8a746b30857594d -r6ddca0d359e34472c80be5e095765577d24fac07
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorTest.cs)	(revision a19b349a904f33edd89b2f1fb8a746b30857594d)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorTest.cs)	(revision 6ddca0d359e34472c80be5e095765577d24fac07)
@@ -22,6 +22,8 @@
 using System;
 using System.ComponentModel;
 using System.Linq;
+using Assembly.Kernel.Model.AssessmentResultTypes;
+using Assembly.Kernel.Model.FmSectionTypes;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Rhino.Mocks;
@@ -64,31 +66,31 @@
             Assert.AreEqual("factory", exception.ParamName);
         }
 
-        private static void AssertCalculatorOutput(CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> original, FailureMechanismSectionAssembly actual)
+        private static void AssertCalculatorOutput(FmSectionAssemblyDirectResult original, FailureMechanismSectionAssembly actual)
         {
-            Assert.AreEqual(GetGroup(original.Result.CategoryGroup), actual.Group);
-            Assert.AreEqual(original.Result.EstimatedProbabilityOfFailure, actual.Probability);
+            Assert.AreEqual(GetGroup(original.Result), actual.Group);
+            Assert.AreEqual(original.FailureProbability, actual.Probability);
         }
 
-        private static FailureMechanismSectionAssemblyCategoryGroup GetGroup(FailureMechanismSectionCategoryGroup originalGroup)
+        private static FailureMechanismSectionAssemblyCategoryGroup GetGroup(EFmSectionCategory originalGroup)
         {
             switch (originalGroup)
             {
-                case FailureMechanismSectionCategoryGroup.Iv:
+                case EFmSectionCategory.Iv:
                     return FailureMechanismSectionAssemblyCategoryGroup.Iv;
-                case FailureMechanismSectionCategoryGroup.IIv:
+                case EFmSectionCategory.IIv:
                     return FailureMechanismSectionAssemblyCategoryGroup.IIv;
-                case FailureMechanismSectionCategoryGroup.IIIv:
+                case EFmSectionCategory.IIIv:
                     return FailureMechanismSectionAssemblyCategoryGroup.IIIv;
-                case FailureMechanismSectionCategoryGroup.IVv:
+                case EFmSectionCategory.IVv:
                     return FailureMechanismSectionAssemblyCategoryGroup.IVv;
-                case FailureMechanismSectionCategoryGroup.Vv:
+                case EFmSectionCategory.Vv:
                     return FailureMechanismSectionAssemblyCategoryGroup.Vv;
-                case FailureMechanismSectionCategoryGroup.VIv:
+                case EFmSectionCategory.VIv:
                     return FailureMechanismSectionAssemblyCategoryGroup.VIv;
-                case FailureMechanismSectionCategoryGroup.VIIv:
+                case EFmSectionCategory.VIIv:
                     return FailureMechanismSectionAssemblyCategoryGroup.VIIv;
-                case FailureMechanismSectionCategoryGroup.None:
+                case EFmSectionCategory.Gr:
                     return FailureMechanismSectionAssemblyCategoryGroup.None;
                 default:
                     throw new NotSupportedException();
@@ -353,16 +355,15 @@
             {
                 var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
                 FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
-                kernel.FailureMechanismSectionAssemblyCategoryGroup = new CalculationOutput<FailureMechanismSectionCategoryGroup>(
-                    random.NextEnumValue<FailureMechanismSectionCategoryGroup>());
+                kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue<EFmSectionCategory>());
 
                 var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
 
                 // Call
                 calculator.AssembleDetailedAssessment(detailedAssessmentResult);
 
                 // Assert
-                Assert.AreEqual(kernel.DetailedCalculationResultInput, GetDetailedCalculationResult(detailedAssessmentResult));
+                Assert.AreEqual(kernel.AssessmentResultTypeG1Input, GetAssessmentResultTypeG1(detailedAssessmentResult));
             }
         }
 
@@ -377,8 +378,7 @@
             {
                 var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
                 FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
-                kernel.FailureMechanismSectionAssemblyCategoryGroup = new CalculationOutput<FailureMechanismSectionCategoryGroup>(
-                    (FailureMechanismSectionCategoryGroup) 99);
+                kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult((EFmSectionCategory) 99);
 
                 var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
 
@@ -403,8 +403,7 @@
             {
                 var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
                 FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
-                kernel.FailureMechanismSectionAssemblyCategoryGroup = new CalculationOutput<FailureMechanismSectionCategoryGroup>(
-                    random.NextEnumValue<FailureMechanismSectionCategoryGroup>());
+                kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue<EFmSectionCategory>());
 
                 var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
 
@@ -413,7 +412,7 @@
                     random.NextEnumValue<DetailedAssessmentResultType>());
 
                 // Assert
-                Assert.AreEqual(GetGroup(kernel.FailureMechanismSectionAssemblyCategoryGroup.Result), assembly);
+                Assert.AreEqual(GetGroup(kernel.FailureMechanismSectionDirectResult.Result), assembly);
             }
         }
 
@@ -940,15 +939,15 @@
 
                 // Assert
                 Assert.AreEqual(kernel.DetailedAssessmentFailureMechanismFromCategoriesInput.ResultItoII,
-                                GetDetailedCalculationResult(detailedAssessmentResultForFactorizedSignalingNorm));
+                                GetAssessmentResultTypeG1(detailedAssessmentResultForFactorizedSignalingNorm));
                 Assert.AreEqual(kernel.DetailedAssessmentFailureMechanismFromCategoriesInput.ResultIItoIII,
-                                GetDetailedCalculationResult(detailedAssessmentResultForSignalingNorm));
+                                GetAssessmentResultTypeG1(detailedAssessmentResultForSignalingNorm));
                 Assert.AreEqual(kernel.DetailedAssessmentFailureMechanismFromCategoriesInput.ResultIIItoIV,
-                                GetDetailedCalculationResult(detailedAssessmentResultForMechanismSpecificLowerLimitNorm));
+                                GetAssessmentResultTypeG1(detailedAssessmentResultForMechanismSpecificLowerLimitNorm));
                 Assert.AreEqual(kernel.DetailedAssessmentFailureMechanismFromCategoriesInput.ResultIVtoV,
-                                GetDetailedCalculationResult(detailedAssessmentResultForLowerLimitNorm));
+                                GetAssessmentResultTypeG1(detailedAssessmentResultForLowerLimitNorm));
                 Assert.AreEqual(kernel.DetailedAssessmentFailureMechanismFromCategoriesInput.ResultVtoVI,
-                                GetDetailedCalculationResult(detailedAssessmentResultForFactorizedLowerLimitNorm));
+                                GetAssessmentResultTypeG1(detailedAssessmentResultForFactorizedLowerLimitNorm));
             }
         }
 
@@ -1046,18 +1045,18 @@
             }
         }
 
-        private static DetailedCalculationResult GetDetailedCalculationResult(DetailedAssessmentResultType detailedAssessmentResult)
+        private static EAssessmentResultTypeG1 GetAssessmentResultTypeG1(DetailedAssessmentResultType detailedAssessmentResult)
         {
             switch (detailedAssessmentResult)
             {
                 case DetailedAssessmentResultType.None:
-                    return DetailedCalculationResult.None;
+                    return EAssessmentResultTypeG1.Gr;
                 case DetailedAssessmentResultType.Sufficient:
-                    return DetailedCalculationResult.V;
+                    return EAssessmentResultTypeG1.V;
                 case DetailedAssessmentResultType.Insufficient:
-                    return DetailedCalculationResult.VN;
+                    return EAssessmentResultTypeG1.Vn;
                 case DetailedAssessmentResultType.NotAssessed:
-                    return DetailedCalculationResult.NGO;
+                    return EAssessmentResultTypeG1.Ngo;
                 default:
                     throw new NotSupportedException();
             }