Index: Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyGroupFactory.cs
===================================================================
diff -u -r72c58e97845795fe3929d4ebaa7c6475b200eddb -r5aa18a89c72c1635e9d276b11c68753e7df93398
--- Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyGroupFactory.cs	(.../FailureMechanismSectionAssemblyGroupFactory.cs)	(revision 72c58e97845795fe3929d4ebaa7c6475b200eddb)
+++ Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyGroupFactory.cs	(.../FailureMechanismSectionAssemblyGroupFactory.cs)	(revision 5aa18a89c72c1635e9d276b11c68753e7df93398)
@@ -164,6 +164,47 @@
         }
 
         /// <summary>
+        /// Assembles the failure mechanism section based on the input arguments.
+        /// </summary>
+        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the section belongs to.</param>
+        /// <param name="isRelevant">The indicator whether the section is relevant.</param>
+        /// <param name="initialFailureMechanismResultType">The <see cref="NonAdoptableInitialFailureMechanismResultType"/> of the section.</param>
+        /// <param name="initialProfileProbability">The initial probability for the profile.</param>
+        /// <param name="initialSectionProbability">The initial probability for the section.</param>
+        /// <param name="furtherAnalysisNeeded">The indicator whether the section needs further analysis.</param>
+        /// <param name="refinedProfileProbability">The refined probability for the profile.</param>
+        /// <param name="refinedSectionProbability">The refined probability for the section.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> is <c>null</c>.</exception>
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="initialFailureMechanismResultType"/> is invalid.</exception>
+        /// <exception cref="AssemblyException">Thrown when the section could not be successfully assembled.</exception>
+        public static FailureMechanismSectionAssemblyResult AssembleSection(
+            IAssessmentSection assessmentSection,
+            bool isRelevant, NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
+            double initialProfileProbability, double initialSectionProbability,
+            bool furtherAnalysisNeeded,
+            double refinedProfileProbability, double refinedSectionProbability)
+        {
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            if (!Enum.IsDefined(typeof(NonAdoptableInitialFailureMechanismResultType), initialFailureMechanismResultType))
+            {
+                throw new InvalidEnumArgumentException(nameof(initialFailureMechanismResultType),
+                                                       (int) initialFailureMechanismResultType,
+                                                       typeof(NonAdoptableInitialFailureMechanismResultType));
+            }
+
+            FailureMechanismSectionAssemblyInput input = CreateInput(
+                assessmentSection, isRelevant, initialFailureMechanismResultType,
+                initialProfileProbability, initialSectionProbability, furtherAnalysisNeeded,
+                refinedProfileProbability, refinedSectionProbability);
+
+            return PerformAssembly(input);
+        }
+
+        /// <summary>
         /// Performs the assembly based on the <see cref="FailureMechanismSectionAssemblyInput"/>.
         /// </summary>
         /// <param name="input">The input to use in the assembly.</param>
Index: Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupFactoryTest.cs
===================================================================
diff -u -rb4f2bb1d7e6a8e2028af63b32a6f2ea3d9b6e24e -r5aa18a89c72c1635e9d276b11c68753e7df93398
--- Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupFactoryTest.cs	(.../FailureMechanismSectionAssemblyGroupFactoryTest.cs)	(revision b4f2bb1d7e6a8e2028af63b32a6f2ea3d9b6e24e)
+++ Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupFactoryTest.cs	(.../FailureMechanismSectionAssemblyGroupFactoryTest.cs)	(revision 5aa18a89c72c1635e9d276b11c68753e7df93398)
@@ -39,17 +39,17 @@
     [TestFixture]
     public class FailureMechanismSectionAssemblyGroupFactoryTest
     {
-        #region Assemble section with non-adoptable initial failure mechanism result type and without profile probability
+        #region Assemble section with adoptable initial failure mechanism result type and without profile probability
 
         [Test]
-        public void AssembleSectionNonAdoptableWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
+        public void AssembleSectionAdoptableWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Setup
             var random = new Random(21);
 
             // Call
             void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
-                null, random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
+                null, random.NextBoolean(), random.NextEnumValue<AdoptableInitialFailureMechanismResultType>(),
                 random.NextDouble(), random.NextBoolean(), random.NextDouble());
 
             // Assert
@@ -58,7 +58,7 @@
         }
 
         [Test]
-        public void AssembleSectionNonAdoptableWithoutProfileProbability_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
+        public void AssembleSectionAdoptableWithoutProfileProbability_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
         {
             // Setup
             var random = new Random(21);
@@ -76,10 +76,11 @@
         }
 
         [Test]
-        [TestCase(NonAdoptableInitialFailureMechanismResultType.Manual, true)]
-        [TestCase(NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, false)]
-        public void AssembleSectionNonAdoptableWithoutProfileProbability_WithInput_SetsInputOnCalculator(NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
-                                                                                                         bool expectedHasProbabilitySpecified)
+        [TestCase(AdoptableInitialFailureMechanismResultType.Adopt, true)]
+        [TestCase(AdoptableInitialFailureMechanismResultType.Manual, true)]
+        [TestCase(AdoptableInitialFailureMechanismResultType.NoFailureProbability, false)]
+        public void AssembleSectionAdoptableWithoutProfileProbability_WithInput_SetsInputOnCalculator(AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
+                                                                                                      bool expectedHasProbabilitySpecified)
         {
             // Setup
             var random = new Random(21);
@@ -117,7 +118,7 @@
         }
 
         [Test]
-        public void AssembleSectionNonAdoptableWithoutProfileProbability_CalculatorRan_ReturnsOutput()
+        public void AssembleSectionAdoptableWithoutProfileProbability_CalculatorRan_ReturnsOutput()
         {
             // Setup
             var random = new Random(21);
@@ -129,7 +130,7 @@
                 // Call
                 FailureMechanismSectionAssemblyResult output =
                     FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
-                        new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
+                        new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<AdoptableInitialFailureMechanismResultType>(),
                         random.NextDouble(), random.NextBoolean(), random.NextDouble());
 
                 // Assert
@@ -142,7 +143,7 @@
         }
 
         [Test]
-        public void AssembleSectionNonAdoptableWithoutProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
+        public void AssembleSectionAdoptableWithoutProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
         {
             // Setup
             var random = new Random(21);
@@ -154,7 +155,7 @@
 
                 // Call
                 void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
-                    new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
+                    new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<AdoptableInitialFailureMechanismResultType>(),
                     random.NextDouble(), random.NextBoolean(), random.NextDouble());
 
                 // Assert
@@ -167,17 +168,17 @@
 
         #endregion
 
-        #region Assemble section with adoptable initial failure mechanism result type and without profile probability
+        #region Assemble section with non-adoptable initial failure mechanism result type and without profile probability
 
         [Test]
-        public void AssembleSectionAdoptableWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
+        public void AssembleSectionNonAdoptableWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Setup
             var random = new Random(21);
 
             // Call
             void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
-                null, random.NextBoolean(), random.NextEnumValue<AdoptableInitialFailureMechanismResultType>(),
+                null, random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
                 random.NextDouble(), random.NextBoolean(), random.NextDouble());
 
             // Assert
@@ -186,7 +187,7 @@
         }
 
         [Test]
-        public void AssembleSectionAdoptableWithoutProfileProbability_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
+        public void AssembleSectionNonAdoptableWithoutProfileProbability_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
         {
             // Setup
             var random = new Random(21);
@@ -204,11 +205,10 @@
         }
 
         [Test]
-        [TestCase(AdoptableInitialFailureMechanismResultType.Adopt, true)]
-        [TestCase(AdoptableInitialFailureMechanismResultType.Manual, true)]
-        [TestCase(AdoptableInitialFailureMechanismResultType.NoFailureProbability, false)]
-        public void AssembleSectionAdoptableWithoutProfileProbability_WithInput_SetsInputOnCalculator(AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
-                                                                                                      bool expectedHasProbabilitySpecified)
+        [TestCase(NonAdoptableInitialFailureMechanismResultType.Manual, true)]
+        [TestCase(NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, false)]
+        public void AssembleSectionNonAdoptableWithoutProfileProbability_WithInput_SetsInputOnCalculator(NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
+                                                                                                         bool expectedHasProbabilitySpecified)
         {
             // Setup
             var random = new Random(21);
@@ -246,7 +246,7 @@
         }
 
         [Test]
-        public void AssembleSectionAdoptableWithoutProfileProbability_CalculatorRan_ReturnsOutput()
+        public void AssembleSectionNonAdoptableWithoutProfileProbability_CalculatorRan_ReturnsOutput()
         {
             // Setup
             var random = new Random(21);
@@ -258,7 +258,7 @@
                 // Call
                 FailureMechanismSectionAssemblyResult output =
                     FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
-                        new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<AdoptableInitialFailureMechanismResultType>(),
+                        new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
                         random.NextDouble(), random.NextBoolean(), random.NextDouble());
 
                 // Assert
@@ -271,7 +271,7 @@
         }
 
         [Test]
-        public void AssembleSectionAdoptableWithoutProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
+        public void AssembleSectionNonAdoptableWithoutProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
         {
             // Setup
             var random = new Random(21);
@@ -283,7 +283,7 @@
 
                 // Call
                 void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
-                    new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<AdoptableInitialFailureMechanismResultType>(),
+                    new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
                     random.NextDouble(), random.NextBoolean(), random.NextDouble());
 
                 // Assert
@@ -299,7 +299,7 @@
         #region Assemble section with adoptable initial failure mechanism result type and with profile probability
 
         [Test]
-        public void AssembleSectionWithProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
+        public void AssembleSectionAdoptableWithProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Setup
             var random = new Random(21);
@@ -316,7 +316,7 @@
         }
 
         [Test]
-        public void AssembleSectionWithProfileProbability_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
+        public void AssembleSectionAdoptableWithProfileProbability_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
         {
             // Setup
             var random = new Random(21);
@@ -335,7 +335,7 @@
         }
 
         [Test]
-        public void AssembleSectionWithProfileProbability_InvalidProbabilityRefinementType_ThrowsInvalidEnumArgumentException()
+        public void AssembleSectionAdoptableWithProfileProbability_InvalidProbabilityRefinementType_ThrowsInvalidEnumArgumentException()
         {
             // Setup
             var random = new Random(21);
@@ -357,8 +357,8 @@
         [TestCase(AdoptableInitialFailureMechanismResultType.Adopt, true)]
         [TestCase(AdoptableInitialFailureMechanismResultType.Manual, true)]
         [TestCase(AdoptableInitialFailureMechanismResultType.NoFailureProbability, false)]
-        public void AssembleSectionWithProfileProbability_WithInput_SetsInputOnCalculator(AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
-                                                                                          bool expectedHasProbabilitySpecified)
+        public void AssembleSectionAdoptableWithProfileProbability_WithInput_SetsInputOnCalculator(AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
+                                                                                                   bool expectedHasProbabilitySpecified)
         {
             // Setup
             var random = new Random(21);
@@ -402,7 +402,7 @@
         [TestCase(ProbabilityRefinementType.Both, 1.5, 1.6)]
         [TestCase(ProbabilityRefinementType.Profile, 1.5, 3.0)]
         [TestCase(ProbabilityRefinementType.Section, 0.8, 1.6)]
-        public void AssembleSectionWithProfileProbability_WithRefinedProbabilities_SetsInputOnCalculator(
+        public void AssembleSectionAdoptableWithProfileProbability_WithRefinedProbabilities_SetsInputOnCalculator(
             ProbabilityRefinementType probabilityRefinementType, double expectedRefinedProfileProbability, double expectedRefinedSectionProbability)
         {
             // Setup
@@ -430,7 +430,7 @@
         }
 
         [Test]
-        public void AssembleSectionWithProfileProbability_CalculatorRan_ReturnsOutput()
+        public void AssembleSectionAdoptableWithProfileProbability_CalculatorRan_ReturnsOutput()
         {
             // Setup
             var random = new Random(21);
@@ -456,7 +456,7 @@
         }
 
         [Test]
-        public void AssembleSectionWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
+        public void AssembleSectionAdoptableWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
         {
             // Setup
             var random = new Random(21);
@@ -481,5 +481,135 @@
         }
 
         #endregion
+
+        #region Assemble section with non-adoptable initial failure mechanism result type and with profile probability
+
+        [Test]
+        public void AssembleSectionNonAdoptableWithProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var random = new Random(21);
+
+            // Call
+            void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                null, random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(), random.NextDouble(),
+                random.NextDouble(), random.NextBoolean(), random.NextDouble(), random.NextDouble());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void AssembleSectionNonAdoptableWithProfileProbability_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
+        {
+            // Setup
+            var random = new Random(21);
+
+            const NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType = (NonAdoptableInitialFailureMechanismResultType) 99;
+
+            // Call
+            void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                new AssessmentSectionStub(), random.NextBoolean(), initialFailureMechanismResultType,
+                random.NextDouble(), random.NextDouble(), random.NextBoolean(), random.NextDouble(), random.NextDouble());
+
+            // Assert
+            var expectedMessage = $"The value of argument 'initialFailureMechanismResultType' ({initialFailureMechanismResultType}) is invalid for Enum type '{nameof(NonAdoptableInitialFailureMechanismResultType)}'.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(Call, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(NonAdoptableInitialFailureMechanismResultType.Manual, true)]
+        [TestCase(NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, false)]
+        public void AssembleSectionNonAdoptableWithProfileProbability_WithInput_SetsInputOnCalculator(NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType,
+                                                                                                      bool expectedHasProbabilitySpecified)
+        {
+            // Setup
+            var random = new Random(21);
+            bool isRelevant = random.NextBoolean();
+            double profileProbability = random.NextDouble();
+            double sectionProbability = random.NextDouble();
+            bool furtherAnalysisNeeded = random.NextBoolean();
+            double refinedProfileProbability = random.NextDouble();
+            double refinedSectionProbability = random.NextDouble();
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                // Call
+                FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                    assessmentSection, isRelevant, initialFailureMechanismResultType, profileProbability, sectionProbability,
+                    furtherAnalysisNeeded, refinedProfileProbability, refinedSectionProbability);
+
+                // Assert
+                FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
+                FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
+                Assert.AreEqual(failureMechanismContribution.SignalingNorm, calculatorInput.SignalingNorm);
+                Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, calculatorInput.LowerLimitNorm);
+
+                Assert.AreEqual(isRelevant, calculatorInput.IsRelevant);
+                Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified);
+                Assert.AreEqual(profileProbability, calculatorInput.InitialProfileProbability);
+                Assert.AreEqual(sectionProbability, calculatorInput.InitialSectionProbability);
+                Assert.AreEqual(furtherAnalysisNeeded, calculatorInput.FurtherAnalysisNeeded);
+                Assert.AreEqual(refinedProfileProbability, calculatorInput.RefinedProfileProbability);
+                Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability);
+            }
+        }
+
+        [Test]
+        public void AssembleSectionNonAdoptableWithProfileProbability_CalculatorRan_ReturnsOutput()
+        {
+            // Setup
+            var random = new Random(21);
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                // Call
+                FailureMechanismSectionAssemblyResult output =
+                    FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                        new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
+                        random.NextDouble(), random.NextDouble(), random.NextBoolean(), random.NextDouble(), random.NextDouble());
+
+                // Assert
+                FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput;
+                Assert.AreEqual(calculatorOutput.N, output.N);
+                Assert.AreEqual(calculatorOutput.AssemblyGroup, output.AssemblyGroup);
+                Assert.AreEqual(calculatorOutput.ProfileProbability, output.ProfileProbability);
+                Assert.AreEqual(calculatorOutput.SectionProbability, output.SectionProbability);
+            }
+        }
+
+        [Test]
+        public void AssembleSectionNonAdoptableWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
+        {
+            // Setup
+            var random = new Random(21);
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                calculator.ThrowExceptionOnCalculate = true;
+
+                // Call
+                void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                    new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<NonAdoptableInitialFailureMechanismResultType>(),
+                    random.NextDouble(), random.NextDouble(), random.NextBoolean(), random.NextDouble(), random.NextDouble());
+
+                // Assert
+                var exception = Assert.Throws<AssemblyException>(Call);
+                Exception innerException = exception.InnerException;
+                Assert.IsInstanceOf<FailureMechanismSectionAssemblyCalculatorException>(innerException);
+                Assert.AreEqual(innerException.Message, exception.Message);
+            }
+        }
+
+        #endregion
     }
 }
\ No newline at end of file