Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs
===================================================================
diff -u -r0e2aa74c71042e7c98f9faf0bac0da6242704c16 -r91c186eb3677f573d1fb1f36da1a84ac928de186
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision 0e2aa74c71042e7c98f9faf0bac0da6242704c16)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs)	(revision 91c186eb3677f573d1fb1f36da1a84ac928de186)
@@ -20,9 +20,7 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
 using Assembly.Kernel.Interfaces;
 using Assembly.Kernel.Model;
 using Assembly.Kernel.Model.AssessmentResultTypes;
@@ -102,72 +100,6 @@
         }
 
         /// <summary>
-        /// Creates <see cref="DetailedCalculationInputFromProbability"/> based on the given parameters.
-        /// </summary>
-        /// <param name="probability">The calculated probability to create the input for.</param>
-        /// <param name="categories">A collection of <see cref="FailureMechanismSectionAssemblyCategory"/> to
-        /// create the input for.</param>
-        /// <returns>The created <see cref="DetailedCalculationInputFromProbability"/>.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="categories"/>
-        /// is <c>null</c>.</exception>
-        /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="categories"/> contains
-        /// an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
-        /// <exception cref="NotSupportedException">Thrown when <see cref="categories"/> contains
-        /// a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
-        /// <exception cref="AssemblyToolKernelException">Thrown when any input parameter has an
-        /// invalid value.</exception>
-        public static DetailedCalculationInputFromProbability CreateDetailedCalculationInputFromProbability(
-            double probability,
-            IEnumerable<FailureMechanismSectionAssemblyCategory> categories)
-        {
-            if (categories == null)
-            {
-                throw new ArgumentNullException(nameof(categories));
-            }
-
-            return new DetailedCalculationInputFromProbability(new Probability(probability),
-                                                               categories.Select(category => new FailureMechanismSectionCategory(
-                                                                                     ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group),
-                                                                                     new Probability(category.LowerBoundary),
-                                                                                     new Probability(category.UpperBoundary))).ToArray());
-        }
-
-        /// <summary>
-        /// Creates <see cref="DetailedCalculationInputFromProbabilityWithLengthEffect"/> based on the given parameters.
-        /// </summary>
-        /// <param name="probability">The calculated probability to create the input for.</param>
-        /// <param name="categories">A collection of <see cref="FailureMechanismSectionAssemblyCategory"/> to
-        /// create the input for.</param>
-        /// <param name="n">The 'N' parameter used to factor in the 'length effect'.</param>
-        /// <returns>The created <see cref="DetailedCalculationInputFromProbabilityWithLengthEffect"/>.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="categories"/>
-        /// is <c>null</c>.</exception>
-        /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="categories"/> contains
-        /// an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
-        /// <exception cref="NotSupportedException">Thrown when <see cref="categories"/> contains
-        /// a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</exception>
-        /// <exception cref="AssemblyToolKernelException">Thrown when any input parameter has an
-        /// invalid value.</exception>
-        public static DetailedCalculationInputFromProbabilityWithLengthEffect CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
-            double probability,
-            IEnumerable<FailureMechanismSectionAssemblyCategory> categories,
-            double n)
-        {
-            if (categories == null)
-            {
-                throw new ArgumentNullException(nameof(categories));
-            }
-
-            return new DetailedCalculationInputFromProbabilityWithLengthEffect(
-                new Probability(probability),
-                categories.Select(category => new FailureMechanismSectionCategory(
-                                      ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group),
-                                      new Probability(category.LowerBoundary),
-                                      new Probability(category.UpperBoundary))).ToArray(),
-                n);
-        }
-
-        /// <summary>
         /// Creates <see cref="FailureMechanismSectionAssemblyCategoryResult"/> based on the given parameters.
         /// </summary>
         /// <param name="assembly">The assembly to convert.</param>
@@ -227,39 +159,6 @@
         }
 
         /// <summary>
-        /// Creates a <see cref="ECategoryCompliancy"/> based on the given <see cref="DetailedAssessmentResultType"/>.
-        /// </summary>
-        /// <param name="detailedAssessmentResult">The detailed assessment result to create the category compliancy for.</param>
-        /// <returns>The created detailed calculation result.</returns>
-        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="detailedAssessmentResult"/>
-        /// is an invalid <see cref="DetailedAssessmentResultType"/>.</exception>
-        /// <exception cref="NotSupportedException">Thrown when <paramref name="detailedAssessmentResult"/>
-        /// is a valid but unsupported <see cref="DetailedAssessmentResultType"/>.</exception>
-        private static ECategoryCompliancy CreateCategoryCompliancy(DetailedAssessmentResultType detailedAssessmentResult)
-        {
-            if (!Enum.IsDefined(typeof(DetailedAssessmentResultType), detailedAssessmentResult))
-            {
-                throw new InvalidEnumArgumentException(nameof(detailedAssessmentResult),
-                                                       (int) detailedAssessmentResult,
-                                                       typeof(DetailedAssessmentResultType));
-            }
-
-            switch (detailedAssessmentResult)
-            {
-                case DetailedAssessmentResultType.None:
-                    return ECategoryCompliancy.NoResult;
-                case DetailedAssessmentResultType.Sufficient:
-                    return ECategoryCompliancy.Complies;
-                case DetailedAssessmentResultType.Insufficient:
-                    return ECategoryCompliancy.DoesNotComply;
-                case DetailedAssessmentResultType.NotAssessed:
-                    return ECategoryCompliancy.Ngo;
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        /// <summary>
         /// Creates a <see cref="EAssessmentResultTypeG1"/> based on the given <see cref="DetailedAssessmentResultType"/>.
         /// </summary>
         /// <param name="detailedAssessmentResult">The detailed assessment result to create the result for.</param>
@@ -427,94 +326,6 @@
         }
 
         /// <summary>
-        /// Creates <see cref="TailorMadeCalculationInputFromProbability"/> based on the given parameters.
-        /// </summary>
-        /// <param name="tailorMadeAssessmentResult">The tailor made assessment result to create
-        /// the input for.</param>
-        /// <param name="probability">The calculated probability to create the input for.</param>
-        /// <param name="categories">A collection of <see cref="FailureMechanismSectionAssemblyCategory"/> to
-        /// create the input for.</param>
-        /// <returns>The created <see cref="TailorMadeCalculationInputFromProbability"/>.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="categories"/>
-        /// is <c>null</c>.</exception>
-        /// <exception cref="InvalidEnumArgumentException">Thrown when:
-        /// <list type="bullet">
-        /// <item><see cref="categories"/> contains an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>;</item>
-        /// <item><see cref="tailorMadeAssessmentResult"/> is an invalid <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</item>
-        /// </list>
-        /// </exception>
-        /// <exception cref="NotSupportedException">Thrown when:
-        /// <list type="bullet">
-        /// <item><see cref="categories"/> contains a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>;</item>
-        /// <item><see cref="tailorMadeAssessmentResult"/> a valid but unsupported <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</item>
-        /// </list>
-        /// </exception>
-        /// <exception cref="AssemblyToolKernelException">Thrown when any input parameter has an
-        /// invalid value.</exception>
-        public static TailorMadeCalculationInputFromProbability CreateTailorMadeCalculationInputFromProbability(
-            TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult,
-            double probability,
-            IEnumerable<FailureMechanismSectionAssemblyCategory> categories)
-        {
-            if (categories == null)
-            {
-                throw new ArgumentNullException(nameof(categories));
-            }
-
-            return new TailorMadeCalculationInputFromProbability(ConvertTailorMadeProbabilityCalculationResult(tailorMadeAssessmentResult, probability),
-                                                                 categories.Select(category => new FailureMechanismSectionCategory(
-                                                                                       ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group),
-                                                                                       new Probability(category.LowerBoundary),
-                                                                                       new Probability(category.UpperBoundary))).ToArray());
-        }
-
-        /// <summary>
-        /// Creates <see cref="TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor"/> based on the given parameters.
-        /// </summary>
-        /// <param name="tailorMadeAssessmentResult">The tailor made assessment result to create
-        /// the input for.</param>
-        /// <param name="probability">The calculated probability to create the input for.</param>
-        /// <param name="categories">A collection of <see cref="FailureMechanismSectionAssemblyCategory"/> to
-        /// create the input for.</param>
-        /// <param name="n">The 'N' parameter used to factor in the 'length effect'.</param>
-        /// <returns>The created <see cref="TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor"/>.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="categories"/>
-        /// is <c>null</c>.</exception>
-        /// <exception cref="InvalidEnumArgumentException">Thrown when:
-        /// <list type="bullet">
-        /// <item><see cref="categories"/> contains an invalid <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>;</item>
-        /// <item><see cref="tailorMadeAssessmentResult"/> is an invalid <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</item>
-        /// </list>
-        /// </exception>
-        /// <exception cref="NotSupportedException">Thrown when:
-        /// <list type="bullet">
-        /// <item><see cref="categories"/> contains a valid but unsupported <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>;</item>
-        /// <item><see cref="tailorMadeAssessmentResult"/> a valid but unsupported <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</item>
-        /// </list>
-        /// </exception>
-        /// <exception cref="AssemblyToolKernelException">Thrown when any input parameter has an
-        /// invalid value.</exception>
-        public static TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-            TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult,
-            double probability,
-            IEnumerable<FailureMechanismSectionAssemblyCategory> categories,
-            double n)
-        {
-            if (categories == null)
-            {
-                throw new ArgumentNullException(nameof(categories));
-            }
-
-            return new TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                ConvertTailorMadeProbabilityCalculationResult(tailorMadeAssessmentResult, probability),
-                categories.Select(category => new FailureMechanismSectionCategory(
-                                      ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group),
-                                      new Probability(category.LowerBoundary),
-                                      new Probability(category.UpperBoundary))).ToArray(),
-                n);
-        }
-
-        /// <summary>
         /// Converts a <see cref="FailureMechanismSectionAssemblyCategoryGroup"/> into a <see cref="FailureMechanismSectionCategoryGroup"/>.
         /// </summary>
         /// <param name="category">The <see cref="FailureMechanismSectionAssemblyCategoryGroup"/> to convert.</param>
@@ -523,7 +334,7 @@
         /// is an invalid value.</exception>
         /// <exception cref="NotSupportedException">Thrown when <paramref name="category"/>
         /// is a valid value, but unsupported.</exception>
-        public static FailureMechanismSectionCategoryGroup ConvertFailureMechanismSectionAssemblyCategoryGroup(
+        public static EFmSectionCategory ConvertFailureMechanismSectionAssemblyCategoryGroup(
             FailureMechanismSectionAssemblyCategoryGroup category)
         {
             if (!Enum.IsDefined(typeof(FailureMechanismSectionAssemblyCategoryGroup), category))
@@ -536,23 +347,23 @@
             switch (category)
             {
                 case FailureMechanismSectionAssemblyCategoryGroup.Iv:
-                    return FailureMechanismSectionCategoryGroup.Iv;
+                    return EFmSectionCategory.Iv;
                 case FailureMechanismSectionAssemblyCategoryGroup.IIv:
-                    return FailureMechanismSectionCategoryGroup.IIv;
+                    return EFmSectionCategory.IIv;
                 case FailureMechanismSectionAssemblyCategoryGroup.IIIv:
-                    return FailureMechanismSectionCategoryGroup.IIIv;
+                    return EFmSectionCategory.IIIv;
                 case FailureMechanismSectionAssemblyCategoryGroup.IVv:
-                    return FailureMechanismSectionCategoryGroup.IVv;
+                    return EFmSectionCategory.IVv;
                 case FailureMechanismSectionAssemblyCategoryGroup.Vv:
-                    return FailureMechanismSectionCategoryGroup.Vv;
+                    return EFmSectionCategory.Vv;
                 case FailureMechanismSectionAssemblyCategoryGroup.VIv:
-                    return FailureMechanismSectionCategoryGroup.VIv;
+                    return EFmSectionCategory.VIv;
                 case FailureMechanismSectionAssemblyCategoryGroup.VIIv:
-                    return FailureMechanismSectionCategoryGroup.VIIv;
+                    return EFmSectionCategory.VIIv;
                 case FailureMechanismSectionAssemblyCategoryGroup.NotApplicable:
-                    return FailureMechanismSectionCategoryGroup.NotApplicable;
+                    return EFmSectionCategory.NotApplicable;
                 case FailureMechanismSectionAssemblyCategoryGroup.None:
-                    return FailureMechanismSectionCategoryGroup.None;
+                    return EFmSectionCategory.Gr;
                 default:
                     throw new NotSupportedException();
             }
@@ -602,38 +413,33 @@
         }
 
         /// <summary>
-        /// Converts a <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/> and the given
-        /// <paramref name="probability"/> to a <see cref="TailorMadeProbabilityCalculationResult"/>.
+        /// Creates a <see cref="ECategoryCompliancy"/> based on the given <see cref="DetailedAssessmentResultType"/>.
         /// </summary>
-        /// <param name="tailorMadeAssessmentResult">The tailor made assessment result to create
-        /// the input for.</param>
-        /// <param name="probability">The calculated probability to create the input for.</param>
-        /// <returns>The converted <see cref="TailorMadeProbabilityCalculationResult"/>.</returns>
-        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="tailorMadeAssessmentResult"/>
-        /// is an invalid <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</exception>
-        /// <exception cref="NotSupportedException">Thrown when <paramref name="tailorMadeAssessmentResult"/>
-        /// is a valid but unsupported <see cref="TailorMadeAssessmentProbabilityCalculationResultType"/>.</exception>
-        private static TailorMadeProbabilityCalculationResult ConvertTailorMadeProbabilityCalculationResult(
-            TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult,
-            double probability)
+        /// <param name="detailedAssessmentResult">The detailed assessment result to create the category compliancy for.</param>
+        /// <returns>The created detailed calculation result.</returns>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="detailedAssessmentResult"/>
+        /// is an invalid <see cref="DetailedAssessmentResultType"/>.</exception>
+        /// <exception cref="NotSupportedException">Thrown when <paramref name="detailedAssessmentResult"/>
+        /// is a valid but unsupported <see cref="DetailedAssessmentResultType"/>.</exception>
+        private static ECategoryCompliancy CreateCategoryCompliancy(DetailedAssessmentResultType detailedAssessmentResult)
         {
-            if (!Enum.IsDefined(typeof(TailorMadeAssessmentProbabilityCalculationResultType), tailorMadeAssessmentResult))
+            if (!Enum.IsDefined(typeof(DetailedAssessmentResultType), detailedAssessmentResult))
             {
-                throw new InvalidEnumArgumentException(nameof(tailorMadeAssessmentResult),
-                                                       (int) tailorMadeAssessmentResult,
-                                                       typeof(TailorMadeAssessmentProbabilityCalculationResultType));
+                throw new InvalidEnumArgumentException(nameof(detailedAssessmentResult),
+                                                       (int) detailedAssessmentResult,
+                                                       typeof(DetailedAssessmentResultType));
             }
 
-            switch (tailorMadeAssessmentResult)
+            switch (detailedAssessmentResult)
             {
-                case TailorMadeAssessmentProbabilityCalculationResultType.None:
-                    return new TailorMadeProbabilityCalculationResult(TailorMadeProbabilityCalculationResultGroup.None);
-                case TailorMadeAssessmentProbabilityCalculationResultType.ProbabilityNegligible:
-                    return new TailorMadeProbabilityCalculationResult(TailorMadeProbabilityCalculationResultGroup.FV);
-                case TailorMadeAssessmentProbabilityCalculationResultType.NotAssessed:
-                    return new TailorMadeProbabilityCalculationResult(TailorMadeProbabilityCalculationResultGroup.NGO);
-                case TailorMadeAssessmentProbabilityCalculationResultType.Probability:
-                    return new TailorMadeProbabilityCalculationResult(new Probability(probability));
+                case DetailedAssessmentResultType.None:
+                    return ECategoryCompliancy.NoResult;
+                case DetailedAssessmentResultType.Sufficient:
+                    return ECategoryCompliancy.Complies;
+                case DetailedAssessmentResultType.Insufficient:
+                    return ECategoryCompliancy.DoesNotComply;
+                case DetailedAssessmentResultType.NotAssessed:
+                    return ECategoryCompliancy.Ngo;
                 default:
                     throw new NotSupportedException();
             }
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs
===================================================================
diff -u -r0e2aa74c71042e7c98f9faf0bac0da6242704c16 -r91c186eb3677f573d1fb1f36da1a84ac928de186
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision 0e2aa74c71042e7c98f9faf0bac0da6242704c16)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs)	(revision 91c186eb3677f573d1fb1f36da1a84ac928de186)
@@ -96,162 +96,6 @@
         #region Detailed Assessment
 
         [Test]
-        public void CreateDetailedCalculationInputFromProbability_WithInvalidEnumInput_ThrowInvalidEnumArgumentException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(
-                random.NextDouble(),
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
-                                                                random.NextDouble(),
-                                                                (FailureMechanismSectionAssemblyCategoryGroup) 99)
-                });
-
-            // Assert
-            const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
-        public void CreateDetailedCalculationInputFromProbability_CategoriesNull_ThrowArgumentNullException()
-        {
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(
-                new Random(39).NextDouble(),
-                null);
-
-            // Assert
-            var exception = Assert.Throws<ArgumentNullException>(test);
-            Assert.AreEqual("categories", exception.ParamName);
-        }
-
-        [Test]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
-        public void CreateDetailedCalculationInputFromProbability_ValidData_ReturnDetailedCalculationInputFromProbabilityWithLengthEffect(
-            FailureMechanismSectionAssemblyCategoryGroup originalResult,
-            FailureMechanismSectionCategoryGroup expectedResult)
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-
-            // Call
-            DetailedCalculationInputFromProbability result =
-                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbability(
-                    probability,
-                    new[]
-                    {
-                        new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                    upperBoundary,
-                                                                    originalResult)
-                    });
-
-            // Assert
-            Assert.AreEqual(probability, result.Probability);
-
-            FailureMechanismSectionCategory actualCategory = result.Categories.Single();
-            Assert.AreEqual(expectedResult, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
-        public void CreateDetailedCalculationInputFromProbabilityWithLengthEffect_WithInvalidEnumInput_ThrowInvalidEnumArgumentException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
-                random.NextDouble(),
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
-                                                                random.NextDouble(),
-                                                                (FailureMechanismSectionAssemblyCategoryGroup) 99)
-                },
-                random.NextDouble());
-
-            // Assert
-            const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
-        public void CreateDetailedCalculationInputFromProbabilityWithLengthEffect_CategoriesNull_ThrowArgumentNullException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
-                random.NextDouble(),
-                null,
-                random.NextDouble());
-
-            // Assert
-            var exception = Assert.Throws<ArgumentNullException>(test);
-            Assert.AreEqual("categories", exception.ParamName);
-        }
-
-        [Test]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
-        public void CreateDetailedCalculationInputFromProbabilityWithLengthEffect_ValidData_ReturnDetailedCalculationInputFromProbabilityWithLengthEffect(
-            FailureMechanismSectionAssemblyCategoryGroup originalResult,
-            FailureMechanismSectionCategoryGroup expectedResult)
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-            double n = random.NextDouble(1.0, 10.0);
-
-            // Call
-            DetailedCalculationInputFromProbabilityWithLengthEffect result =
-                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateDetailedCalculationInputFromProbabilityWithLengthEffect(
-                    probability,
-                    new[]
-                    {
-                        new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                    upperBoundary,
-                                                                    originalResult)
-                    },
-                    n);
-
-            // Assert
-            Assert.AreEqual(probability, result.Probability);
-            Assert.AreEqual(n, result.NValue);
-
-            FailureMechanismSectionCategory actualCategory = result.Categories.Single();
-            Assert.AreEqual(expectedResult, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
         [TestCaseSource(nameof(InvalidDetailedAssessmentCategoryResults))]
         public void CreateCategoryCompliancyResults_InvalidEnumInput_ThrowInvalidEnumArgumentException(
             DetailedAssessmentResultType detailedAssessmentResultForFactorizedSignalingNorm,
@@ -431,17 +275,17 @@
 
         [Test]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, EFmSectionCategory.None)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, EFmSectionCategory.Iv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, EFmSectionCategory.IIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, EFmSectionCategory.IIIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, EFmSectionCategory.IVv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, EFmSectionCategory.Vv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, EFmSectionCategory.VIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, EFmSectionCategory.VIIv)]
         public void CreateFailureMechanismSectionAssemblyCategoryResult_WithAssembly_ReturnFailureMechanismSectionAssemblyCategoryResult(
             FailureMechanismSectionAssemblyCategoryGroup originalGroup,
-            FailureMechanismSectionCategoryGroup expectedGroup)
+            EFmSectionCategory expectedGroup)
         {
             // Setup
             var random = new Random(11);
@@ -469,21 +313,21 @@
         }
 
         [Test]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
-        public void ConvertFailureMechanismSectionAssemblyCategoryGroup_ValidGroup_ReturnFailureMechanismSectionCategoryGroup(
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, EFmSectionCategory.NotApplicable)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, EFmSectionCategory.Gr)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, EFmSectionCategory.Iv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, EFmSectionCategory.IIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, EFmSectionCategory.IIIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, EFmSectionCategory.IVv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, EFmSectionCategory.Vv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, EFmSectionCategory.VIv)]
+        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, EFmSectionCategory.VIIv)]
+        public void ConvertFailureMechanismSectionAssemblyCategoryGroup_ValidGroup_ReturnEFmSectionCategory(
             FailureMechanismSectionAssemblyCategoryGroup originalGroup,
-            FailureMechanismSectionCategoryGroup expectedGroup)
+            EFmSectionCategory expectedGroup)
         {
             // Call
-            FailureMechanismSectionCategoryGroup actualGroup = FailureMechanismSectionAssemblyCalculatorInputCreator.ConvertFailureMechanismSectionAssemblyCategoryGroup(
+            EFmSectionCategory actualGroup = FailureMechanismSectionAssemblyCalculatorInputCreator.ConvertFailureMechanismSectionAssemblyCategoryGroup(
                 originalGroup);
 
             // Assert
@@ -507,337 +351,6 @@
         #region Tailor Made Assessment
 
         [Test]
-        public void CreateTailorMadeCalculationInputFromProbability_CategoriesNull_ThrowArgumentNullException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability(
-                random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
-                random.NextDouble(),
-                null);
-
-            // Assert
-            var exception = Assert.Throws<ArgumentNullException>(test);
-            Assert.AreEqual("categories", exception.ParamName);
-        }
-
-        [Test]
-        public void CreateTailorMadeCalculationInputFromProbability_WithInvalidResultEnumInput_ThrowInvalidEnumArgumentException()
-        {
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability(
-                (TailorMadeAssessmentProbabilityCalculationResultType) 99,
-                new Random(39).NextDouble(),
-                Enumerable.Empty<FailureMechanismSectionAssemblyCategory>());
-
-            // Assert
-            const string expectedMessage = "The value of argument 'tailorMadeAssessmentResult' (99) is invalid for Enum type 'TailorMadeAssessmentProbabilityCalculationResultType'.";
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
-        public void CreateTailorMadeCalculationInputFromProbability_WithInvalidCategoryEnumInput_ThrowInvalidEnumArgumentException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability(
-                random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
-                random.NextDouble(),
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
-                                                                random.NextDouble(),
-                                                                (FailureMechanismSectionAssemblyCategoryGroup) 99)
-                });
-
-            // Assert
-            const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
-        public void CreateTailorMadeCalculationInputFromProbability_ValidData_ReturnTailorMadeCalculationInputFromProbabilityWithCorrectCategories(
-            FailureMechanismSectionAssemblyCategoryGroup originalResult,
-            FailureMechanismSectionCategoryGroup expectedResult)
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-
-            // Call
-            TailorMadeCalculationInputFromProbability result =
-                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability(
-                    random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
-                    probability,
-                    new[]
-                    {
-                        new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                    upperBoundary,
-                                                                    originalResult)
-                    });
-
-            // Assert
-            FailureMechanismSectionCategory actualCategory = result.Categories.Single();
-            Assert.AreEqual(expectedResult, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
-        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.None, TailorMadeProbabilityCalculationResultGroup.None)]
-        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.ProbabilityNegligible, TailorMadeProbabilityCalculationResultGroup.FV)]
-        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.NotAssessed, TailorMadeProbabilityCalculationResultGroup.NGO)]
-        public void CreateTailorMadeCalculationInputFromProbability_ValidDataNotProbability_ReturnTailorMadeCalculationInputFromProbability(
-            TailorMadeAssessmentProbabilityCalculationResultType originalResult,
-            TailorMadeProbabilityCalculationResultGroup expectedResult)
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-            const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv;
-
-            // Call
-            TailorMadeCalculationInputFromProbability input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability(
-                originalResult,
-                probability,
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                upperBoundary,
-                                                                categoryGroup)
-                });
-
-            // Assert
-            Assert.AreEqual(expectedResult, input.Result.CalculationResultGroup);
-            Assert.AreEqual(0.0, input.Result.Probability);
-
-            FailureMechanismSectionCategory actualCategory = input.Categories.Single();
-            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
-        public void CreateTailorMadeCalculationInputFromProbability_ValidDataProbability_ReturnTailorMadeCalculationInputFromProbability()
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-            const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv;
-
-            // Call
-            TailorMadeCalculationInputFromProbability input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability(
-                TailorMadeAssessmentProbabilityCalculationResultType.Probability,
-                probability,
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                upperBoundary,
-                                                                categoryGroup)
-                });
-
-            // Assert
-            Assert.AreEqual(TailorMadeProbabilityCalculationResultGroup.Probability, input.Result.CalculationResultGroup);
-            Assert.AreEqual(probability, input.Result.Probability);
-
-            FailureMechanismSectionCategory actualCategory = input.Categories.Single();
-            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
-        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_CategoriesNull_ThrowArgumentNullException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
-                random.NextDouble(),
-                null,
-                random.NextDouble());
-
-            // Assert
-            var exception = Assert.Throws<ArgumentNullException>(test);
-            Assert.AreEqual("categories", exception.ParamName);
-        }
-
-        [Test]
-        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_WithInvalidResultEnumInput_ThrowInvalidEnumArgumentException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                (TailorMadeAssessmentProbabilityCalculationResultType) 99,
-                random.NextDouble(),
-                Enumerable.Empty<FailureMechanismSectionAssemblyCategory>(),
-                random.NextDouble());
-
-            // Assert
-            const string expectedMessage = "The value of argument 'tailorMadeAssessmentResult' (99) is invalid for Enum type 'TailorMadeAssessmentProbabilityCalculationResultType'.";
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
-        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_WithInvalidCategoryEnumInput_ThrowInvalidEnumArgumentException()
-        {
-            // Setup
-            var random = new Random(39);
-
-            // Call
-            TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
-                random.NextDouble(),
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(random.NextDouble(),
-                                                                random.NextDouble(),
-                                                                (FailureMechanismSectionAssemblyCategoryGroup) 99)
-                },
-                random.NextDouble());
-
-            // Assert
-            const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'.";
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)]
-        [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)]
-        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_ValidData_ReturnTailorMadeCalculationInputFromProbabilityWithLengthEffectFactorWithCorrectCategories(
-            FailureMechanismSectionAssemblyCategoryGroup originalResult,
-            FailureMechanismSectionCategoryGroup expectedResult)
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-
-            // Call
-            TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor result =
-                FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                    random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
-                    probability,
-                    new[]
-                    {
-                        new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                    upperBoundary,
-                                                                    originalResult)
-                    },
-                    random.NextDouble(1.0, 10.0));
-
-            // Assert
-            FailureMechanismSectionCategory actualCategory = result.Categories.Single();
-            Assert.AreEqual(expectedResult, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
-        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.None, TailorMadeProbabilityCalculationResultGroup.None)]
-        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.ProbabilityNegligible, TailorMadeProbabilityCalculationResultGroup.FV)]
-        [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.NotAssessed, TailorMadeProbabilityCalculationResultGroup.NGO)]
-        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_ValidDataNotProbability_ReturnTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-            TailorMadeAssessmentProbabilityCalculationResultType originalResult,
-            TailorMadeProbabilityCalculationResultGroup expectedResult)
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-            double n = random.NextDouble(1.0, 10.0);
-            const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv;
-
-            // Call
-            TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                originalResult,
-                probability,
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                upperBoundary,
-                                                                categoryGroup)
-                },
-                n);
-
-            // Assert
-            Assert.AreEqual(expectedResult, input.Result.CalculationResultGroup);
-            Assert.AreEqual(0.0, input.Result.Probability);
-            Assert.AreEqual(n, input.NValue);
-
-            FailureMechanismSectionCategory actualCategory = input.Categories.Single();
-            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
-        public void CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor_ValidDataProbability_ReturnTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor()
-        {
-            // Setup
-            var random = new Random(39);
-            double probability = random.NextDouble();
-            double lowerBoundary = random.NextDouble(0.0, 0.5);
-            double upperBoundary = random.NextDouble(0.6, 1.0);
-            double n = random.NextDouble(1.0, 10.0);
-            const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv;
-
-            // Call
-            TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                TailorMadeAssessmentProbabilityCalculationResultType.Probability,
-                probability,
-                new[]
-                {
-                    new FailureMechanismSectionAssemblyCategory(lowerBoundary,
-                                                                upperBoundary,
-                                                                categoryGroup)
-                },
-                n);
-
-            // Assert
-            Assert.AreEqual(TailorMadeProbabilityCalculationResultGroup.Probability, input.Result.CalculationResultGroup);
-            Assert.AreEqual(probability, input.Result.Probability);
-            Assert.AreEqual(n, input.NValue);
-
-            FailureMechanismSectionCategory actualCategory = input.Categories.Single();
-            Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup);
-            Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary);
-            Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary);
-        }
-
-        [Test]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, TailorMadeCategoryCalculationResult.None)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, TailorMadeCategoryCalculationResult.None)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, TailorMadeCategoryCalculationResult.FV)]
@@ -847,7 +360,7 @@
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, TailorMadeCategoryCalculationResult.Vv)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, TailorMadeCategoryCalculationResult.VIv)]
         [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, TailorMadeCategoryCalculationResult.NGO)]
-        public void ConvertTailorMadeFailureMechanismSectionAssemblyCategoryGroup_ValidGroup_ReturnFailureMechanismSectionCategoryGroup(
+        public void ConvertTailorMadeFailureMechanismSectionAssemblyCategoryGroup_ValidGroup_ReturnEFmSectionCategory(
             FailureMechanismSectionAssemblyCategoryGroup originalGroup,
             TailorMadeCategoryCalculationResult expectedGroup)
         {