Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -rad293d6badd8dffa7c2e3c6fb122728dee29a67c -rc5a7095a0ac52bdc50d22bb7a6d266fad43b8824
--- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision ad293d6badd8dffa7c2e3c6fb122728dee29a67c)
+++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision c5a7095a0ac52bdc50d22bb7a6d266fad43b8824)
@@ -246,13 +246,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="MacroStabilityInwardsFailureMechanismSectionResult.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(MacroStabilityInwardsFailureMechanismSectionResult failureMechanismSectionResult,
                                                                                                    MacroStabilityInwardsFailureMechanism failureMechanism,
-                                                                                                   IAssessmentSection assessmentSection)
+                                                                                                   IAssessmentSection assessmentSection,
+                                                                                                   bool useManual)
         {
             if (failureMechanismSectionResult == null)
             {
@@ -269,21 +272,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="MacroStabilityInwardsFailureMechanismSectionResult.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(
             MacroStabilityInwardsFailureMechanism failureMechanism,
-            IAssessmentSection assessmentSection)
+            IAssessmentSection assessmentSection,
+            bool useManual)
         {
             if (failureMechanism == null)
             {
@@ -305,7 +311,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 =
@@ -329,15 +335,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="MacroStabilityInwardsFailureMechanismSectionResult.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(MacroStabilityInwardsFailureMechanismSectionResult failureMechanismSectionResult,
                                                                           MacroStabilityInwardsFailureMechanism failureMechanism,
-                                                                          IAssessmentSection assessmentSection)
+                                                                          IAssessmentSection assessmentSection,
+                                                                          bool useManual)
         {
             FailureMechanismSectionAssembly sectionAssembly;
-            if (failureMechanismSectionResult.UseManualAssemblyProbability)
+            if (failureMechanismSectionResult.UseManualAssemblyProbability && useManual)
             {
                 sectionAssembly = AssembleManualAssessment(failureMechanismSectionResult,
                                                            failureMechanism,
Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Forms/Views/MacroStabilityInwardsFailureMechanismResultView.cs
===================================================================
diff -u -re2d3933efb7550b981eb917efa5e7ff68786138b -rc5a7095a0ac52bdc50d22bb7a6d266fad43b8824
--- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Forms/Views/MacroStabilityInwardsFailureMechanismResultView.cs	(.../MacroStabilityInwardsFailureMechanismResultView.cs)	(revision e2d3933efb7550b981eb917efa5e7ff68786138b)
+++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Forms/Views/MacroStabilityInwardsFailureMechanismResultView.cs	(.../MacroStabilityInwardsFailureMechanismResultView.cs)	(revision c5a7095a0ac52bdc50d22bb7a6d266fad43b8824)
@@ -179,7 +179,7 @@
 
         protected override void UpdateAssemblyResultControl()
         {
-            FailureMechanismAssemblyResultControl.SetAssemblyResult(MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(FailureMechanism, assessmentSection));
+            FailureMechanismAssemblyResultControl.SetAssemblyResult(MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(FailureMechanism, assessmentSection, true));
         }
 
         protected override bool HasManualAssemblyResults()
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs
===================================================================
diff -u -rc1ad8e8431d65da2f22adeb93f9deddd9fae77e3 -rc5a7095a0ac52bdc50d22bb7a6d266fad43b8824
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision c1ad8e8431d65da2f22adeb93f9deddd9fae77e3)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision c5a7095a0ac52bdc50d22bb7a6d266fad43b8824)
@@ -82,8 +82,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
 
                 // Call
                 MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult);
@@ -102,8 +102,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 =
@@ -124,8 +124,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
@@ -270,6 +270,7 @@
         {
             // Setup
             var failureMechanism = new MacroStabilityInwardsFailureMechanism();
+
             var assessmentSection = new AssessmentSectionStub();
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
 
@@ -282,8 +283,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 =
@@ -307,6 +308,7 @@
         {
             // Setup
             var failureMechanism = new MacroStabilityInwardsFailureMechanism();
+
             var assessmentSection = new AssessmentSectionStub();
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
 
@@ -319,8 +321,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
@@ -477,8 +479,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
@@ -714,8 +716,8 @@
 
             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
@@ -750,7 +752,8 @@
             TestDelegate call = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 null,
                 new MacroStabilityInwardsFailureMechanism(),
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -770,7 +773,8 @@
             TestDelegate call = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 new MacroStabilityInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
                 null,
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -785,7 +789,8 @@
             TestDelegate call = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 new MacroStabilityInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
                 new MacroStabilityInwardsFailureMechanism(),
-                null);
+                null,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -812,7 +817,8 @@
                 MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 FailureMechanismSectionAssembly expectedSimpleAssembly = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(
@@ -835,7 +841,7 @@
         }
 
         [Test]
-        public void GetSectionAssemblyCategoryGroup_WithManualInput_SetsInputOnCalculator()
+        public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualTrue_SetsInputOnCalculator()
         {
             // Setup
             var sectionResult = new MacroStabilityInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
@@ -859,15 +865,57 @@
                 MacroStabilityInwardsFailureMechanismAssemblyFactory.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 MacroStabilityInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+            {
+                UseManualAssemblyProbability = true,
+                ManualAssemblyProbability = random.NextDouble(),
+                TailorMadeAssessmentResult = random.NextEnumValue<TailorMadeAssessmentProbabilityCalculationResultType>(),
+                TailorMadeAssessmentProbability = random.NextDouble()
+            };
+
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism();
+
+            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
+                MacroStabilityInwardsFailureMechanismAssemblyFactory.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
@@ -884,7 +932,8 @@
                 FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 FailureMechanismSectionAssembly expectedAssembly = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
@@ -898,7 +947,7 @@
         }
 
         [Test]
-        public void GetSectionAssemblyCategoryGroup_WithManualInput_ReturnsOutput()
+        public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualTrue_ReturnsOutput()
         {
             // Setup
             var sectionResult = new MacroStabilityInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
@@ -922,7 +971,8 @@
                 FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    true);
 
                 // Assert
                 FailureMechanismSectionAssembly expectedAssembly = calculator.AssembleManual(
@@ -934,6 +984,42 @@
         }
 
         [Test]
+        public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualFalse_ReturnsOutput()
+        {
+            // Setup
+            var sectionResult = new MacroStabilityInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
+            {
+                UseManualAssemblyProbability = true,
+                ManualAssemblyProbability = new Random(39).NextDouble()
+            };
+
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism();
+
+            var mocks = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
+            mocks.ReplayAll();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                // Call
+                FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+                    sectionResult,
+                    failureMechanism,
+                    assessmentSection,
+                    false);
+
+                // Assert
+                FailureMechanismSectionAssembly expectedAssembly = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+                    sectionResult,
+                    Enumerable.Empty<MacroStabilityInwardsCalculationScenario>(),
+                    failureMechanism,
+                    assessmentSection);
+                Assert.AreEqual(expectedAssembly.Group, categoryGroup);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
         [TestCase(true)]
         [TestCase(false)]
         public void GetSectionAssemblyCategoryGroup_CalculatorThrowsException_ThrowsAssemblyException(bool useManualAssembly)
@@ -951,8 +1037,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;
@@ -966,7 +1052,8 @@
                 TestDelegate call = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                     sectionResult,
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 var exception = Assert.Throws<AssemblyException>(call);
@@ -992,7 +1079,8 @@
             // Call
             TestDelegate call = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                 null,
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -1006,7 +1094,8 @@
             // Call
             TestDelegate call = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                 new MacroStabilityInwardsFailureMechanism(),
-                null);
+                null,
+                new Random(39).NextBoolean());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -1029,7 +1118,8 @@
             // Call
             FailureMechanismAssembly assembly = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                 failureMechanism,
-                assessmentSection);
+                assessmentSection,
+                new Random(39).NextBoolean());
 
             // Assert
             AssemblyToolTestHelper.AssertAreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableAssembly(), assembly);
@@ -1058,7 +1148,8 @@
                 // Call
                 MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 FailureMechanismSectionAssembly expectedAssembly = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
@@ -1072,7 +1163,7 @@
         }
 
         [Test]
-        public void AssembleFailureMechanism_WithManualInput_SetsInputOnCalculator()
+        public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator()
         {
             // Setup
             var failureMechanism = new MacroStabilityInwardsFailureMechanism();
@@ -1096,7 +1187,8 @@
                 // Call
                 MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    true);
 
                 // Assert
                 FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
@@ -1109,6 +1201,45 @@
         }
 
         [Test]
+        public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsInputOnCalculator()
+        {
+            // Setup
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism();
+            FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+            {
+                FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+            });
+            MacroStabilityInwardsFailureMechanismSectionResult 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
+                MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
+                    failureMechanism,
+                    assessmentSection,
+                    false);
+
+                // Assert
+                FailureMechanismSectionAssembly expectedAssembly = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+                    failureMechanism.SectionResults.Single(),
+                    Enumerable.Empty<MacroStabilityInwardsCalculationScenario>(),
+                    failureMechanism,
+                    assessmentSection);
+                AssemblyToolTestHelper.AssertAreEqual(expectedAssembly, calculator.FailureMechanismSectionAssemblies.Single());
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
         public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput()
         {
             // Setup
@@ -1127,7 +1258,8 @@
                 FailureMechanismAssembly actualOutput =
                     MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                         failureMechanism,
-                        assessmentSection);
+                        assessmentSection,
+                        new Random(39).NextBoolean());
 
                 // Assert
                 Assert.AreSame(calculator.FailureMechanismAssemblyOutput, actualOutput);
@@ -1147,14 +1279,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 = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 var exception = Assert.Throws<AssemblyException>(call);
@@ -1181,14 +1314,15 @@
 
             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 = () => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
                     failureMechanism,
-                    assessmentSection);
+                    assessmentSection,
+                    new Random(39).NextBoolean());
 
                 // Assert
                 var exception = Assert.Throws<AssemblyException>(call);