Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs
===================================================================
diff -u -r2de9eb158a81a1eda9d2331aa2744ecaa2efba07 -r2e72e818d425f1f8c3fc64edeec862ce88e3b074
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs	(.../AssessmentSectionAssemblyCalculator.cs)	(revision 2de9eb158a81a1eda9d2331aa2744ecaa2efba07)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs	(.../AssessmentSectionAssemblyCalculator.cs)	(revision 2e72e818d425f1f8c3fc64edeec862ce88e3b074)
@@ -55,15 +55,15 @@
         }
 
         public FailureMechanismAssembly AssembleFailureMechanisms(IEnumerable<FailureMechanismAssembly> input,
-                                                                  double signalingNorm,
-                                                                  double lowerLimitNorm)
+                                                                  double signalingNorm, double lowerLimitNorm,
+                                                                  double failureProbabilityMarginFactorInput)
         {
             try
             {
                 ICategoryLimitsCalculator categoriesKernel = factory.CreateAssemblyCategoriesKernel();
                 CategoriesList<FailureMechanismCategory> categories = categoriesKernel.CalculateFailureMechanismCategoryLimitsWbi11(
                     new AssessmentSection(1, signalingNorm, lowerLimitNorm),
-                    new FailureMechanism(1, 0.58));
+                    new FailureMechanism(1, failureProbabilityMarginFactorInput));
 
                 IAssessmentGradeAssembler kernel = factory.CreateAssessmentSectionAssemblyKernel();
                 FailureMechanismAssemblyResult output = kernel.AssembleAssessmentSectionWbi2B1(
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IAssessmentSectionAssemblyCalculator.cs
===================================================================
diff -u -r027a320bc8caa145acdbf284d3d9c54f61c2d07b -r2e72e818d425f1f8c3fc64edeec862ce88e3b074
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IAssessmentSectionAssemblyCalculator.cs	(.../IAssessmentSectionAssemblyCalculator.cs)	(revision 027a320bc8caa145acdbf284d3d9c54f61c2d07b)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IAssessmentSectionAssemblyCalculator.cs	(.../IAssessmentSectionAssemblyCalculator.cs)	(revision 2e72e818d425f1f8c3fc64edeec862ce88e3b074)
@@ -35,12 +35,15 @@
         /// <param name="input">The collection of failure mechanism assemblies to assemble for.</param>
         /// <param name="signalingNorm">The signaling norm to calculate with.</param>
         /// <param name="lowerLimitNorm">The lower limit norm to calculate with.</param>
+        /// <param name="failureProbabilityMarginFactor">The failure probability margin factor to
+        /// calculate with.</param>
         /// <returns>A <see cref="FailureMechanismAssembly"/>.</returns>
         /// <exception cref="AssessmentSectionAssemblyCalculatorException">Thrown when
         /// an error occurs while assembling.</exception>
         FailureMechanismAssembly AssembleFailureMechanisms(IEnumerable<FailureMechanismAssembly> input,
                                                            double signalingNorm,
-                                                           double lowerLimitNorm);
+                                                           double lowerLimitNorm,
+                                                           double failureProbabilityMarginFactor);
 
         /// <summary>
         /// Assembles the failure mechanisms for the given <paramref name="input"/>.
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs
===================================================================
diff -u -r2de9eb158a81a1eda9d2331aa2744ecaa2efba07 -r2e72e818d425f1f8c3fc64edeec862ce88e3b074
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs	(.../AssessmentSectionAssemblyCalculatorTest.cs)	(revision 2de9eb158a81a1eda9d2331aa2744ecaa2efba07)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs	(.../AssessmentSectionAssemblyCalculatorTest.cs)	(revision 2e72e818d425f1f8c3fc64edeec862ce88e3b074)
@@ -76,6 +76,7 @@
             var random = new Random(39);
             double signalingNorm = random.NextDouble(0, 0.5);
             double lowerLimitNorm = random.NextDouble(0.5, 1);
+            double failureProbabilityMarginFactor = random.NextDouble();
 
             var failureMechanismAssembly = new FailureMechanismAssembly(random.NextDouble(), (FailureMechanismAssemblyCategoryGroup) 99);
 
@@ -88,7 +89,7 @@
                 TestDelegate test = () => calculator.AssembleFailureMechanisms(new[]
                 {
                     failureMechanismAssembly
-                }, signalingNorm, lowerLimitNorm);
+                }, signalingNorm, lowerLimitNorm, failureProbabilityMarginFactor);
 
                 // Assert
                 var exception = Assert.Throws<AssessmentSectionAssemblyCalculatorException>(test);
@@ -104,6 +105,7 @@
             var random = new Random(39);
             double signalingNorm = random.NextDouble(0, 0.5);
             double lowerLimitNorm = random.NextDouble(0.5, 1);
+            double failureProbabilityMarginFactor = random.NextDouble();
 
             var failureMechanismAssembly = new FailureMechanismAssembly(random.NextDouble(),
                                                                         random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>());
@@ -124,14 +126,14 @@
                 calculator.AssembleFailureMechanisms(new[]
                 {
                     failureMechanismAssembly
-                }, signalingNorm, lowerLimitNorm);
+                }, signalingNorm, lowerLimitNorm, failureProbabilityMarginFactor);
 
                 // Assert
                 Assert.IsFalse(kernel.PartialAssembly);
                 Assert.AreEqual(signalingNorm, categoriesKernel.SignalingNorm);
                 Assert.AreEqual(lowerLimitNorm, categoriesKernel.LowerLimitNorm);
                 Assert.AreEqual(1, categoriesKernel.N);
-                Assert.AreEqual(0.58, categoriesKernel.FailureMechanismContribution);
+                Assert.AreEqual(failureProbabilityMarginFactor, categoriesKernel.FailureMechanismContribution);
 
                 FailureMechanismAssemblyResult actualFailureMechanismAssemblyInput = kernel.FailureMechanismAssemblyResults.Single();
                 Assert.AreEqual(GetGroup(failureMechanismAssembly.Group), actualFailureMechanismAssemblyInput.Category);
@@ -147,6 +149,7 @@
             var random = new Random(39);
             double signalingNorm = random.NextDouble(0, 0.5);
             double lowerLimitNorm = random.NextDouble(0.5, 1);
+            double failureProbabilityMarginFactor = random.NextDouble();
 
             using (new AssemblyToolKernelFactoryConfig())
             {
@@ -159,8 +162,7 @@
 
                 // Call
                 FailureMechanismAssembly assembly = calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssembly>(),
-                                                                                         signalingNorm,
-                                                                                         lowerLimitNorm);
+                                                                                         signalingNorm, lowerLimitNorm, failureProbabilityMarginFactor);
 
                 // Assert
                 FailureMechanismAssemblyResult expectedResult = kernel.FailureMechanismAssemblyResult;
@@ -178,6 +180,7 @@
             var random = new Random(39);
             double signalingNorm = random.NextDouble(0, 0.5);
             double lowerLimitNorm = random.NextDouble(0.5, 1);
+            double failureProbabilityMarginFactor = random.NextDouble();
 
             using (new AssemblyToolKernelFactoryConfig())
             {
@@ -190,8 +193,7 @@
 
                 // Call
                 TestDelegate test = () => calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssembly>(),
-                                                                               signalingNorm,
-                                                                               lowerLimitNorm);
+                                                                               signalingNorm, lowerLimitNorm, failureProbabilityMarginFactor);
 
                 // Assert
                 var exception = Assert.Throws<AssessmentSectionAssemblyCalculatorException>(test);
@@ -207,6 +209,7 @@
             var random = new Random(21);
             double signalingNorm = random.NextDouble(0, 0.5);
             double lowerLimitNorm = random.NextDouble(0.5, 1);
+            double failureProbabilityMarginFactor = random.NextDouble();
 
             using (new AssemblyToolKernelFactoryConfig())
             {
@@ -218,8 +221,7 @@
 
                 // Call
                 TestDelegate test = () => calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssembly>(),
-                                                                               signalingNorm,
-                                                                               lowerLimitNorm);
+                                                                               signalingNorm, lowerLimitNorm, failureProbabilityMarginFactor);
 
                 // Assert
                 var exception = Assert.Throws<AssessmentSectionAssemblyCalculatorException>(test);
@@ -235,6 +237,7 @@
             var random = new Random(21);
             double signalingNorm = random.NextDouble(0, 0.5);
             double lowerLimitNorm = random.NextDouble(0.5, 1);
+            double failureProbabilityMarginFactor = random.NextDouble();
 
             using (new AssemblyToolKernelFactoryConfig())
             {
@@ -246,8 +249,7 @@
 
                 // Call
                 TestDelegate test = () => calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssembly>(),
-                                                                               signalingNorm,
-                                                                               lowerLimitNorm);
+                                                                               signalingNorm, lowerLimitNorm, failureProbabilityMarginFactor);
 
                 // Assert
                 var exception = Assert.Throws<AssessmentSectionAssemblyCalculatorException>(test);
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorStubTest.cs
===================================================================
diff -u -r26526273b41c27da77879f295a5ade4d4a9a84bb -r2e72e818d425f1f8c3fc64edeec862ce88e3b074
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorStubTest.cs	(.../AssessmentSectionAssemblyCalculatorStubTest.cs)	(revision 26526273b41c27da77879f295a5ade4d4a9a84bb)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorStubTest.cs	(.../AssessmentSectionAssemblyCalculatorStubTest.cs)	(revision 2e72e818d425f1f8c3fc64edeec862ce88e3b074)
@@ -46,6 +46,7 @@
             Assert.IsNull(calculator.FailureMechanismsWithProbabilityInput);
             Assert.AreEqual(0.0, calculator.LowerLimitNormInput);
             Assert.AreEqual(0.0, calculator.SignalingNormInput);
+            Assert.AreEqual(0.0, calculator.FailureProbabilityMarginFactorInput);
             Assert.AreEqual((FailureMechanismAssemblyCategoryGroup) 0,
                             calculator.FailureMechanismsWithoutProbabilityInput);
         }
@@ -59,7 +60,8 @@
 
             // Call
             FailureMechanismAssembly output = calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssembly>(),
-                                                                                   random.NextDouble(), random.NextDouble());
+                                                                                   random.NextDouble(), random.NextDouble(),
+                                                                                   random.NextDouble());
 
             // Assert
             Assert.AreEqual(0.75, output.Probability);
@@ -79,7 +81,8 @@
 
             // Call
             FailureMechanismAssembly output = calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssembly>(),
-                                                                                   random.NextDouble(), random.NextDouble());
+                                                                                   random.NextDouble(), random.NextDouble(),
+                                                                                   random.NextDouble());
 
             // Assert
             Assert.AreSame(calculator.AssembleFailureMechanismsAssemblyOutput, output);
@@ -92,18 +95,20 @@
             var random = new Random(21);
             double lowerLimitNorm = random.NextDouble();
             double signalingNorm = random.NextDouble();
+            double failureProbabilityMarginFactorInput = random.NextDouble();
 
             IEnumerable<FailureMechanismAssembly> failureMechanisms = Enumerable.Empty<FailureMechanismAssembly>();
 
             var calculator = new AssessmentSectionAssemblyCalculatorStub();
 
             // Call
-            calculator.AssembleFailureMechanisms(failureMechanisms, signalingNorm, lowerLimitNorm);
+            calculator.AssembleFailureMechanisms(failureMechanisms, signalingNorm, lowerLimitNorm, failureProbabilityMarginFactorInput);
 
             // Assert
             Assert.AreSame(failureMechanisms, calculator.FailureMechanismAssemblyInput);
             Assert.AreEqual(lowerLimitNorm, calculator.LowerLimitNormInput);
             Assert.AreEqual(signalingNorm, calculator.SignalingNormInput);
+            Assert.AreEqual(failureProbabilityMarginFactorInput, calculator.FailureProbabilityMarginFactorInput);
         }
 
         [Test]
@@ -118,7 +123,7 @@
 
             // Call
             TestDelegate call = () => calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssembly>(),
-                                                                           random.NextDouble(),
+                                                                           random.NextDouble(), random.NextDouble(),
                                                                            random.NextDouble());
 
             // Assert
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/AssessmentSectionAssemblyCalculatorStub.cs
===================================================================
diff -u -r4d033419fd3e2d2aa8a3242fb6ed1e40bba1cecf -r2e72e818d425f1f8c3fc64edeec862ce88e3b074
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/AssessmentSectionAssemblyCalculatorStub.cs	(.../AssessmentSectionAssemblyCalculatorStub.cs)	(revision 4d033419fd3e2d2aa8a3242fb6ed1e40bba1cecf)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/AssessmentSectionAssemblyCalculatorStub.cs	(.../AssessmentSectionAssemblyCalculatorStub.cs)	(revision 2e72e818d425f1f8c3fc64edeec862ce88e3b074)
@@ -34,17 +34,23 @@
     {
         /// <summary>
         /// Gets the lower norm input when assembling the assessment section with failure mechanisms
-        /// with probability;
+        /// with probability.
         /// </summary>
         public double LowerLimitNormInput { get; private set; }
 
         /// <summary>
         /// Gets the lower norm input when assembling the assessment section with failure mechanisms
-        /// with probability;
+        /// with probability.
         /// </summary>
         public double SignalingNormInput { get; private set; }
 
         /// <summary>
+        /// Gets the failure probability margin factory input when assembling the assessment section
+        /// with failure mechanisms with probability.
+        /// </summary>
+        public double FailureProbabilityMarginFactorInput { get; private set; }
+
+        /// <summary>
         /// Gets the collection of failure mechanism assembly input when assembling the
         /// assessment section with failure mechanisms with probability.
         /// </summary>
@@ -106,7 +112,8 @@
 
         public FailureMechanismAssembly AssembleFailureMechanisms(IEnumerable<FailureMechanismAssembly> input,
                                                                   double signalingNorm,
-                                                                  double lowerLimitNorm)
+                                                                  double lowerLimitNorm,
+                                                                  double failureProbabilityMarginFactor)
         {
             if (ThrowExceptionOnCalculate)
             {
@@ -116,6 +123,7 @@
             FailureMechanismAssemblyInput = input;
             LowerLimitNormInput = lowerLimitNorm;
             SignalingNormInput = signalingNorm;
+            FailureProbabilityMarginFactorInput = failureProbabilityMarginFactor;
 
             return AssembleFailureMechanismsAssemblyOutput ??
                    (AssembleFailureMechanismsAssemblyOutput = new FailureMechanismAssembly(0.75, FailureMechanismAssemblyCategoryGroup.IIIt));
Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs
===================================================================
diff -u -r4e3025c88acd58d4f9e63b3e0cf0c87a81db6166 -r2e72e818d425f1f8c3fc64edeec862ce88e3b074
--- Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs	(.../AssessmentSectionAssemblyFactory.cs)	(revision 4e3025c88acd58d4f9e63b3e0cf0c87a81db6166)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs	(.../AssessmentSectionAssemblyFactory.cs)	(revision 2e72e818d425f1f8c3fc64edeec862ce88e3b074)
@@ -72,7 +72,8 @@
                 FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
                 return calculator.AssembleFailureMechanisms(GetFailureMechanismWithProbabilityAssemblyResults(assessmentSection),
                                                             failureMechanismContribution.SignalingNorm,
-                                                            failureMechanismContribution.LowerLimitNorm);
+                                                            failureMechanismContribution.LowerLimitNorm,
+                                                            assessmentSection.FailureProbabilityMarginFactor);
             }
             catch (AssessmentSectionAssemblyCalculatorException e)
             {
Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs
===================================================================
diff -u -r77f6f342957303bd16538c7c4060ab502720045d -r2e72e818d425f1f8c3fc64edeec862ce88e3b074
--- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs	(.../AssessmentSectionAssemblyFactoryTest.cs)	(revision 77f6f342957303bd16538c7c4060ab502720045d)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs	(.../AssessmentSectionAssemblyFactoryTest.cs)	(revision 2e72e818d425f1f8c3fc64edeec862ce88e3b074)
@@ -61,12 +61,12 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
                 failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput = new FailureMechanismAssembly(
                     random.NextDouble(), random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>());
 
-                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
 
                 // Call
                 AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection);
@@ -75,6 +75,7 @@
                 FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
                 Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, assessmentSectionAssemblyCalculator.LowerLimitNormInput);
                 Assert.AreEqual(failureMechanismContribution.SignalingNorm, assessmentSectionAssemblyCalculator.SignalingNormInput);
+                Assert.AreEqual(assessmentSection.FailureProbabilityMarginFactor, assessmentSectionAssemblyCalculator.FailureProbabilityMarginFactorInput);
 
                 AssertGroup1And2FailureMechanismInputs(assessmentSection,
                                                        failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput,
@@ -91,8 +92,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.AssembleFailureMechanismsAssemblyOutput = new FailureMechanismAssembly(
                     random.NextDouble(), random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>());
 
@@ -110,8 +111,8 @@
             // Setup
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
@@ -131,8 +132,8 @@
             // Setup
             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
@@ -166,11 +167,11 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
                 failureMechanismAssemblyCalculator.FailureMechanismAssemblyCategoryGroupOutput = random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>();
 
-                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
 
                 // Call
                 AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection);
@@ -191,8 +192,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.AssembleFailureMechanismsAssemblyCategoryGroupOutput = random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>();
 
                 // Call
@@ -209,8 +210,8 @@
             // Setup
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
@@ -230,8 +231,8 @@
             // Setup
             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
@@ -265,10 +266,10 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
-                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyOutput = new FailureMechanismAssembly(
                     random.NextDouble(), random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>());
                 assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyCategoryGroupOutput = random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>();
@@ -301,8 +302,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.AssembleFailureMechanismsAssemblyOutput = new FailureMechanismAssembly(
                     random.NextDouble(), random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>());
                 calculator.AssembleAssessmentSectionCategoryGroupOutput = random.NextEnumValue<AssessmentSectionAssemblyCategoryGroup>();
@@ -321,8 +322,8 @@
             // Setup
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
@@ -342,8 +343,8 @@
             // Setup
             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
@@ -377,8 +378,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssembly[0];
 
                 // Call
@@ -415,8 +416,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.CombinedFailureMechanismSectionAssemblyOutput = new[]
                 {
                     CreateCombinedFailureMechanismSectionAssembly(assessmentSection, 20),
@@ -477,8 +478,8 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
@@ -502,8 +503,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