Index: Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructuresFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -r42750c3eeb3410d3cd559ac0cb1a899efbaa1659 -rb6aef8024f47ca91daacd5f5da44d73751f27545
--- Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructuresFailureMechanismAssemblyFactory.cs	(.../ClosingStructuresFailureMechanismAssemblyFactory.cs)	(revision 42750c3eeb3410d3cd559ac0cb1a899efbaa1659)
+++ Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructuresFailureMechanismAssemblyFactory.cs	(.../ClosingStructuresFailureMechanismAssemblyFactory.cs)	(revision b6aef8024f47ca91daacd5f5da44d73751f27545)
@@ -229,13 +229,16 @@
         /// <param name="failureMechanismSectionResult">The failure mechanism section result to get the assembly category group for.</param>
         /// <param name="failureMechanism">The failure mechanism this section belongs to.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> this section belongs to.</param>
+        /// <param name="useManual">Indicator that determines whether the manual assembly should be used or ignored, regardless of
+        /// the value of <see cref="ClosingStructuresFailureMechanismSectionResult.UseManualAssemblyProbability"/>.</param>
         /// <returns>A <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when the <see cref="FailureMechanismSectionAssemblyCategoryGroup"/>
         /// could not be created.</exception>
         public static FailureMechanismSectionAssemblyCategoryGroup GetSectionAssemblyCategoryGroup(ClosingStructuresFailureMechanismSectionResult failureMechanismSectionResult,
                                                                                                    ClosingStructuresFailureMechanism failureMechanism,
-                                                                                                   IAssessmentSection assessmentSection)
+                                                                                                   IAssessmentSection assessmentSection,
+                                                                                                   bool useManual)
         {
             if (failureMechanismSectionResult == null)
             {
@@ -252,21 +255,24 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            return GetSectionAssembly(failureMechanismSectionResult, failureMechanism, assessmentSection).Group;
+            return GetSectionAssembly(failureMechanismSectionResult, failureMechanism, assessmentSection, useManual).Group;
         }
 
         /// <summary>
         /// Assembles the failure mechanism assembly.
         /// </summary>
         /// <param name="failureMechanism">The failure mechanism to assemble for.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the failure mechanism belongs to.</param>
+        /// <param name="useManual">Indicator that determines whether the manual assembly should be used or ignored, regardless of
+        /// the value of <see cref="ClosingStructuresFailureMechanismSectionResult.UseManualAssemblyProbability"/>.</param>
         /// <returns>A <see cref="FailureMechanismAssembly"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when the <see cref="FailureMechanismAssembly"/>
         /// could not be created.</exception>
         public static FailureMechanismAssembly AssembleFailureMechanism(
             ClosingStructuresFailureMechanism failureMechanism,
-            IAssessmentSection assessmentSection)
+            IAssessmentSection assessmentSection,
+            bool useManual)
         {
             if (failureMechanism == null)
             {
@@ -288,7 +294,7 @@
                 IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance;
                 AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput(failureMechanism, assessmentSection);
                 IEnumerable<FailureMechanismSectionAssembly> sectionAssemblies = failureMechanism.SectionResults
-                                                                                                 .Select(sr => GetSectionAssembly(sr, failureMechanism, assessmentSection))
+                                                                                                 .Select(sr => GetSectionAssembly(sr, failureMechanism, assessmentSection, useManual))
                                                                                                  .ToArray();
 
                 IFailureMechanismAssemblyCalculator calculator =
@@ -312,15 +318,18 @@
         /// <param name="failureMechanismSectionResult">The failure mechanism section result to get the assembly for.</param>
         /// <param name="failureMechanism">The failure mechanism to assemble for.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the failure mechanism belongs to.</param>
+        /// <param name="useManual">Indicator that determines whether the manual assembly should be used or ignored, regardless of
+        /// the value of <see cref="ClosingStructuresFailureMechanismSectionResult.UseManualAssemblyProbability"/>.</param>
         /// <returns>A <see cref="FailureMechanismSectionAssembly"/>.</returns>
         /// <exception cref="AssemblyException">Thrown when a <see cref="FailureMechanismSectionAssembly"/>
         /// could not be created.</exception>
         private static FailureMechanismSectionAssembly GetSectionAssembly(ClosingStructuresFailureMechanismSectionResult failureMechanismSectionResult,
                                                                           ClosingStructuresFailureMechanism failureMechanism,
-                                                                          IAssessmentSection assessmentSection)
+                                                                          IAssessmentSection assessmentSection,
+                                                                          bool useManual)
         {
             FailureMechanismSectionAssembly sectionAssembly;
-            if (failureMechanismSectionResult.UseManualAssemblyProbability)
+            if (failureMechanismSectionResult.UseManualAssemblyProbability && useManual)
             {
                 sectionAssembly = AssembleManualAssessment(failureMechanismSectionResult,
                                                            CreateAssemblyCategoriesInput(failureMechanism, assessmentSection));
Index: Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Forms/Views/ClosingStructuresFailureMechanismResultView.cs
===================================================================
diff -u -re2d3933efb7550b981eb917efa5e7ff68786138b -rb6aef8024f47ca91daacd5f5da44d73751f27545
--- Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Forms/Views/ClosingStructuresFailureMechanismResultView.cs	(.../ClosingStructuresFailureMechanismResultView.cs)	(revision e2d3933efb7550b981eb917efa5e7ff68786138b)
+++ Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Forms/Views/ClosingStructuresFailureMechanismResultView.cs	(.../ClosingStructuresFailureMechanismResultView.cs)	(revision b6aef8024f47ca91daacd5f5da44d73751f27545)
@@ -179,7 +179,7 @@
 
         protected override void UpdateAssemblyResultControl()
         {
-            FailureMechanismAssemblyResultControl.SetAssemblyResult(ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(FailureMechanism, assessmentSection));
+            FailureMechanismAssemblyResultControl.SetAssemblyResult(ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(FailureMechanism, assessmentSection, true));
         }
 
         protected override bool HasManualAssemblyResults()
Index: Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructuresFailureMechanismAssemblyFactoryTest.cs
===================================================================
diff -u -rc1ad8e8431d65da2f22adeb93f9deddd9fae77e3 -rb6aef8024f47ca91daacd5f5da44d73751f27545
--- Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructuresFailureMechanismAssemblyFactoryTest.cs	(.../ClosingStructuresFailureMechanismAssemblyFactoryTest.cs)	(revision c1ad8e8431d65da2f22adeb93f9deddd9fae77e3)
+++ Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructuresFailureMechanismAssemblyFactoryTest.cs	(.../ClosingStructuresFailureMechanismAssemblyFactoryTest.cs)	(revision b6aef8024f47ca91daacd5f5da44d73751f27545)
@@ -78,8 +78,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
 
                 // Call
                 ClosingStructuresFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult);
@@ -98,8 +98,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
 
                 // Call
                 FailureMechanismSectionAssembly actualOutput =
@@ -120,8 +120,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
@@ -220,9 +220,9 @@
                     assessmentSection);
 
                 // Assert
-                Assert.AreEqual(sectionResult.DetailedAssessmentResult, calculator.DetailedAssessmentProbabilityOnlyResultInput);
                 Assert.AreEqual(sectionResult.GetDetailedAssessmentProbability(failureMechanism, assessmentSection),
                                 calculator.DetailedAssessmentProbabilityInput);
+                Assert.AreEqual(sectionResult.DetailedAssessmentResult, calculator.DetailedAssessmentProbabilityOnlyResultInput);
                 AssertAssemblyCategoriesInput(assessmentSection, failureMechanism, calculator.AssemblyCategoriesInput);
                 mocks.VerifyAll();
             }
@@ -242,8 +242,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
 
                 // Call
                 FailureMechanismSectionAssembly actualOutput =
@@ -273,8 +273,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
@@ -294,7 +294,7 @@
 
         #endregion
 
-        #region Tailor made Assembly
+        #region Tailor Made Assembly
 
         [Test]
         public void AssembleTailorMadeAssessment_FailureMechanismSectionResultNull_ThrowsArgumentNullException()
@@ -426,8 +426,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
@@ -635,14 +635,14 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculateCombinedAssembly = true;
 
                 // Call
                 TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
                     sectionResult,
-                    new ClosingStructuresFailureMechanism(),
+                    failureMechanism,
                     assessmentSection);
 
                 // Assert
@@ -670,7 +670,8 @@
             TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 null,
                 new ClosingStructuresFailureMechanism(),
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -690,7 +691,8 @@
             TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 new ClosingStructuresFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
                 null,
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -705,7 +707,8 @@
             TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 new ClosingStructuresFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
                 new ClosingStructuresFailureMechanism(),
-                null);
+                null,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -732,7 +735,8 @@
                 ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 FailureMechanismSectionAssembly expectedSimpleAssembly = ClosingStructuresFailureMechanismAssemblyFactory.AssembleSimpleAssessment(
@@ -754,7 +758,7 @@
         }
 
         [Test]
-        public void GetSectionAssemblyCategoryGroup_WithManualInput_SetsInputOnCalculator()
+        public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualTrue_SetsInputOnCalculator()
         {
             // Setup
             var sectionResult = new ClosingStructuresFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
@@ -778,15 +782,57 @@
                 ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    true);
 
                 // Assert
                 Assert.AreEqual(sectionResult.ManualAssemblyProbability, calculator.ManualAssemblyProbabilityInput);
+                Assert.AreEqual(0.0, calculator.TailorMadeAssessmentProbabilityInput);
+                Assert.AreEqual((TailorMadeAssessmentProbabilityCalculationResultType) 0, calculator.TailorMadeAssessmentProbabilityCalculationResultInput);
                 mocks.VerifyAll();
             }
         }
 
         [Test]
+        public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualFalse_SetsInputOnCalculator()
+        {
+            // Setup
+            var random = new Random(39);
+            var sectionResult = new ClosingStructuresFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+            {
+                UseManualAssemblyProbability = true,
+                ManualAssemblyProbability = random.NextDouble(),
+                TailorMadeAssessmentResult = random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
+                TailorMadeAssessmentProbability = random.NextDouble()
+            };
+
+            var failureMechanism = new ClosingStructuresFailureMechanism();
+
+            var mocks = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
+            mocks.ReplayAll();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                // Call
+                ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+                    sectionResult,
+                    failureMechanism,
+                    assessmentSection,
+                    false);
+
+                // Assert
+                Assert.AreEqual(0.0, calculator.ManualAssemblyProbabilityInput);
+                Assert.AreEqual(sectionResult.TailorMadeAssessmentProbability, calculator.TailorMadeAssessmentProbabilityInput);
+                Assert.AreEqual(sectionResult.TailorMadeAssessmentResult, calculator.TailorMadeAssessmentProbabilityCalculationResultInput);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
         public void GetSectionAssemblyCategoryGroup_WithoutManualInput_ReturnsOutput()
         {
             // Setup
@@ -803,7 +849,8 @@
                 FailureMechanismSectionAssemblyCategoryGroup categoryGroup = ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 FailureMechanismSectionAssembly expectedAssembly = ClosingStructuresFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
@@ -816,7 +863,7 @@
         }
 
         [Test]
-        public void GetSectionAssemblyCategoryGroup_WithManualInput_ReturnsOutput()
+        public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualTrue_ReturnsOutput()
         {
             // Setup
             var sectionResult = new ClosingStructuresFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
@@ -840,7 +887,8 @@
                 FailureMechanismSectionAssemblyCategoryGroup categoryGroup = ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    true);
 
                 // Assert
                 FailureMechanismSectionAssembly expectedAssembly = calculator.AssembleManual(
@@ -852,6 +900,41 @@
         }
 
         [Test]
+        public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualFalse_ReturnsOutput()
+        {
+            // Setup
+            var sectionResult = new ClosingStructuresFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+            {
+                UseManualAssemblyProbability = true,
+                ManualAssemblyProbability = new Random(39).NextDouble()
+            };
+
+            var failureMechanism = new ClosingStructuresFailureMechanism();
+
+            var mocks = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
+            mocks.ReplayAll();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                // Call
+                FailureMechanismSectionAssemblyCategoryGroup categoryGroup = ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+                    sectionResult,
+                    failureMechanism,
+                    assessmentSection,
+                    false);
+
+                // Assert
+                FailureMechanismSectionAssembly expectedAssembly = ClosingStructuresFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+                    sectionResult,
+                    failureMechanism,
+                    assessmentSection);
+                Assert.AreEqual(expectedAssembly.Group, categoryGroup);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
         [TestCase(true)]
         [TestCase(false)]
         public void GetSectionAssemblyCategoryGroup_CalculatorThrowsException_ThrowsAssemblyException(bool useManualAssembly)
@@ -869,8 +952,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
                 if (useManualAssembly)
                 {
                     calculator.ThrowExceptionOnCalculate = true;
@@ -884,7 +967,8 @@
                 TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 var exception = Assert.Throws<AssemblyException>(call);
@@ -910,7 +994,8 @@
             // Call
             TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                 null,
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -924,7 +1009,8 @@
             // Call
             TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                 new ClosingStructuresFailureMechanism(),
-                null);
+                null,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -947,7 +1033,8 @@
             // Call
             FailureMechanismAssembly assembly = ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                 failureMechanism,
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             AssemblyToolTestHelper.AssertAreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableAssembly(), assembly);
@@ -976,7 +1063,8 @@
                 // Call
                 ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 FailureMechanismSectionAssembly expectedAssembly = ClosingStructuresFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
@@ -989,7 +1077,7 @@
         }
 
         [Test]
-        public void AssembleFailureMechanism_WithManualInput_SetsInputOnCalculator()
+        public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator()
         {
             // Setup
             var failureMechanism = new ClosingStructuresFailureMechanism();
@@ -1013,21 +1101,58 @@
                 // Call
                 ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    true);
 
                 // Assert
                 FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
-                FailureMechanismSectionAssembly expectedAssembly = sectionCalculator.AssembleManual(sectionResult.ManualAssemblyProbability,
-                                                                                                    AssemblyCategoriesInputFactory.CreateAssemblyCategoriesInput(
-                                                                                                        failureMechanism.GeneralInput.N,
-                                                                                                        failureMechanism,
-                                                                                                        assessmentSection));
+                FailureMechanismSectionAssembly expectedAssembly = sectionCalculator.AssembleManual(
+                    sectionResult.ManualAssemblyProbability,
+                    AssemblyCategoriesInputFactory.CreateAssemblyCategoriesInput(0.0, failureMechanism, assessmentSection));
                 AssemblyToolTestHelper.AssertAreEqual(expectedAssembly, calculator.FailureMechanismSectionAssemblies.Single());
                 mocks.VerifyAll();
             }
         }
 
         [Test]
+        public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsInputOnCalculator()
+        {
+            // Setup
+            var failureMechanism = new ClosingStructuresFailureMechanism();
+            FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+            {
+                FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+            });
+            ClosingStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+            sectionResult.UseManualAssemblyProbability = true;
+            sectionResult.ManualAssemblyProbability = new Random(39).NextDouble();
+
+            var mocks = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
+            mocks.ReplayAll();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+
+                // Call
+                ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
+                    failureMechanism,
+                    assessmentSection,
+                    false);
+
+                // Assert
+                FailureMechanismSectionAssembly expectedAssembly = ClosingStructuresFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+                    failureMechanism.SectionResults.Single(),
+                    failureMechanism,
+                    assessmentSection);
+                AssemblyToolTestHelper.AssertAreEqual(expectedAssembly, calculator.FailureMechanismSectionAssemblies.Single());
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
         public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput()
         {
             // Setup
@@ -1046,7 +1171,8 @@
                 FailureMechanismAssembly actualOutput =
                     ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                         failureMechanism,
-                        assessmentSection);
+                        assessmentSection,
+                        new Random(39).NextBoolean());
 
                 // Assert
                 Assert.AreSame(calculator.FailureMechanismAssemblyOutput, actualOutput);
@@ -1066,14 +1192,15 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
                 TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 var exception = Assert.Throws<AssemblyException>(call);
@@ -1093,20 +1220,22 @@
             {
                 FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
             });
+
             var mocks = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
             mocks.ReplayAll();
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculateCombinedAssembly = true;
 
                 // Call
                 TestDelegate call = () => ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 var exception = Assert.Throws<AssemblyException>(call);