Index: Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyGroupFactory.cs
===================================================================
diff -u -r9f244919473b0a2faf72a567c632d0f39a2cff2e -r1630d6c8d176e19206db5bdd3622809d498aa127
--- Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyGroupFactory.cs	(.../FailureMechanismSectionAssemblyGroupFactory.cs)	(revision 9f244919473b0a2faf72a567c632d0f39a2cff2e)
+++ Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyGroupFactory.cs	(.../FailureMechanismSectionAssemblyGroupFactory.cs)	(revision 1630d6c8d176e19206db5bdd3622809d498aa127)
@@ -20,13 +20,15 @@
 // All rights reserved.
 
 using System;
+using System.ComponentModel;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.AssemblyTool.KernelWrapper.Calculators;
 using Riskeer.AssemblyTool.KernelWrapper.Calculators.Assembly;
 using Riskeer.AssemblyTool.KernelWrapper.Kernels;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Contribution;
 using Riskeer.Common.Data.Exceptions;
+using Riskeer.Common.Data.FailureMechanism;
 
 namespace Riskeer.Common.Data.AssemblyTool
 {
@@ -40,15 +42,17 @@
         /// </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="InitialFailureMechanismResultType"/> 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,
+                                                                            bool isRelevant, InitialFailureMechanismResultType initialFailureMechanismResultType,
                                                                             double initialProfileProbability, double initialSectionProbability,
                                                                             bool furtherAnalysisNeeded,
                                                                             double refinedProfileProbability, double refinedSectionProbability)
@@ -58,16 +62,21 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
+            if (!Enum.IsDefined(typeof(InitialFailureMechanismResultType), initialFailureMechanismResultType))
+            {
+                throw new InvalidEnumArgumentException(nameof(initialFailureMechanismResultType),
+                                                       (int) initialFailureMechanismResultType,
+                                                       typeof(InitialFailureMechanismResultType));
+            }
+
             IFailureMechanismSectionAssemblyCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateFailureMechanismSectionAssemblyCalculator(
                 AssemblyToolKernelFactory.Instance);
 
             try
             {
-                FailureMechanismSectionAssemblyInput input = CreateInput(assessmentSection,
-                                                                         isRelevant,
-                                                                         initialProfileProbability, initialSectionProbability,
-                                                                         furtherAnalysisNeeded,
-                                                                         refinedProfileProbability, refinedSectionProbability);
+                FailureMechanismSectionAssemblyInput input = CreateInput(
+                    assessmentSection, isRelevant, initialFailureMechanismResultType != InitialFailureMechanismResultType.NoFailureProbability,
+                    initialProfileProbability, initialSectionProbability, furtherAnalysisNeeded, refinedProfileProbability, refinedSectionProbability);
 
                 return calculator.AssembleFailureMechanismSection(input);
             }
@@ -78,17 +87,17 @@
         }
 
         private static FailureMechanismSectionAssemblyInput CreateInput(IAssessmentSection assessmentSection,
-                                                                        bool isRelevant,
+                                                                        bool isRelevant, bool hasProbabilitySpecified,
                                                                         double initialProfileProbability, double initialSectionProbability,
                                                                         bool furtherAnalysisNeeded,
                                                                         double refinedProfileProbability, double refinedSectionProbability)
         {
             FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
-            return new FailureMechanismSectionAssemblyInput(failureMechanismContribution.LowerLimitNorm,
-                                                            failureMechanismContribution.SignalingNorm,
-                                                            isRelevant, initialProfileProbability,
-                                                            initialSectionProbability,
-                                                            furtherAnalysisNeeded, refinedProfileProbability, refinedSectionProbability);
+            return new FailureMechanismSectionAssemblyInput(failureMechanismContribution.LowerLimitNorm, failureMechanismContribution.SignalingNorm,
+                                                            isRelevant, hasProbabilitySpecified,
+                                                            initialProfileProbability, initialSectionProbability,
+                                                            furtherAnalysisNeeded,
+                                                            refinedProfileProbability, refinedSectionProbability);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupFactoryTest.cs
===================================================================
diff -u -r877f80f8669e3bae22e1a5151480634ebf4c3d0d -r1630d6c8d176e19206db5bdd3622809d498aa127
--- Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupFactoryTest.cs	(.../FailureMechanismSectionAssemblyGroupFactoryTest.cs)	(revision 877f80f8669e3bae22e1a5151480634ebf4c3d0d)
+++ Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyGroupFactoryTest.cs	(.../FailureMechanismSectionAssemblyGroupFactoryTest.cs)	(revision 1630d6c8d176e19206db5bdd3622809d498aa127)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.ComponentModel;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Riskeer.AssemblyTool.Data;
@@ -30,6 +31,7 @@
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.Contribution;
 using Riskeer.Common.Data.Exceptions;
+using Riskeer.Common.Data.FailureMechanism;
 using Riskeer.Common.Data.TestUtil;
 
 namespace Riskeer.Common.Data.Test.AssemblyTool
@@ -44,19 +46,17 @@
             var random = new Random(21);
 
             // Call
-            void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(null,
-                                                                                       random.NextBoolean(),
-                                                                                       random.NextDouble(), random.NextDouble(),
-                                                                                       random.NextBoolean(),
-                                                                                       random.NextDouble(), random.NextDouble());
+            void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                null, random.NextBoolean(), random.NextEnumValue<InitialFailureMechanismResultType>(), 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 AssembleSection_WithInput_SetsInputOnCalculator()
+        public void AssembleSection_InvalidInitialFailureMechanismResultType_ThrowsInvalidEnumArgumentException()
         {
             // Setup
             var random = new Random(21);
@@ -69,17 +69,45 @@
 
             var assessmentSection = new AssessmentSectionStub();
 
+            const InitialFailureMechanismResultType initialFailureMechanismResultType = (InitialFailureMechanismResultType) 99;
+
+            // Call
+            void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                assessmentSection, isRelevant, initialFailureMechanismResultType, profileProbability, sectionProbability,
+                furtherAnalysisNeeded, refinedProfileProbability, refinedSectionProbability);
+
+            // Assert
+            var expectedMessage = $"The value of argument 'initialFailureMechanismResultType' ({initialFailureMechanismResultType}) is invalid for Enum type '{nameof(InitialFailureMechanismResultType)}'.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(Call, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(InitialFailureMechanismResultType.Adopt, true)]
+        [TestCase(InitialFailureMechanismResultType.Manual, true)]
+        [TestCase(InitialFailureMechanismResultType.NoFailureProbability, false)]
+        public void AssembleSection_WithInput_SetsInputOnCalculator(InitialFailureMechanismResultType 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,
-                                                                            profileProbability, sectionProbability,
-                                                                            furtherAnalysisNeeded,
-                                                                            refinedProfileProbability, refinedSectionProbability);
+                FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                    assessmentSection, isRelevant, initialFailureMechanismResultType, profileProbability, sectionProbability,
+                    furtherAnalysisNeeded, refinedProfileProbability, refinedSectionProbability);
 
                 // Assert
                 FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
@@ -88,6 +116,7 @@
                 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);
@@ -108,11 +137,9 @@
 
                 // Call
                 FailureMechanismSectionAssemblyResult output =
-                    FailureMechanismSectionAssemblyGroupFactory.AssembleSection(new AssessmentSectionStub(),
-                                                                                random.NextBoolean(),
-                                                                                random.NextDouble(), random.NextDouble(),
-                                                                                random.NextBoolean(),
-                                                                                random.NextDouble(), random.NextDouble());
+                    FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                        new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<InitialFailureMechanismResultType>(),
+                        random.NextDouble(), random.NextDouble(), random.NextBoolean(), random.NextDouble(), random.NextDouble());
 
                 // Assert
                 FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput;
@@ -135,11 +162,9 @@
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
-                void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(new AssessmentSectionStub(),
-                                                                                           random.NextBoolean(),
-                                                                                           random.NextDouble(), random.NextDouble(),
-                                                                                           random.NextBoolean(),
-                                                                                           random.NextDouble(), random.NextDouble());
+                void Call() => FailureMechanismSectionAssemblyGroupFactory.AssembleSection(
+                    new AssessmentSectionStub(), random.NextBoolean(), random.NextEnumValue<InitialFailureMechanismResultType>(),
+                    random.NextDouble(), random.NextDouble(), random.NextBoolean(), random.NextDouble(), random.NextDouble());
 
                 // Assert
                 var exception = Assert.Throws<AssemblyException>(Call);