Index: Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy.cs
===================================================================
diff -u
--- Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy.cs	(revision 0)
+++ Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy.cs	(revision 4c5b838896048250be3167fdf0fe6ed8b89c328e)
@@ -0,0 +1,80 @@
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
+//
+// This file is part of Riskeer.
+//
+// Riskeer is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.Probability;
+
+namespace Riskeer.MacroStabilityInwards.Data
+{
+    /// <summary>
+    /// Strategy to calculate probabilities for <see cref="MacroStabilityInwardsCalculationScenario"/>.
+    /// </summary>
+    public class MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy : IFailureMechanismSectionResultCalculateProbabilityStrategy
+    {
+        private readonly AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult;
+        private readonly IEnumerable<MacroStabilityInwardsCalculationScenario> calculationScenarios;
+        private readonly MacroStabilityInwardsFailureMechanism failureMechanism;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy"/>.
+        /// </summary>
+        /// <param name="sectionResult">The <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResult"/> to get the probabilities for.</param>
+        /// <param name="calculationScenarios">All the <see cref="MacroStabilityInwardsCalculationScenario"/> of the failure mechanism. </param>
+        /// <param name="failureMechanism">The failure mechanism the calculation scenarios belong to.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+            AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
+            IEnumerable<MacroStabilityInwardsCalculationScenario> calculationScenarios,
+            MacroStabilityInwardsFailureMechanism failureMechanism)
+        {
+            if (sectionResult == null)
+            {
+                throw new ArgumentNullException(nameof(sectionResult));
+            }
+
+            if (calculationScenarios == null)
+            {
+                throw new ArgumentNullException(nameof(calculationScenarios));
+            }
+
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            this.sectionResult = sectionResult;
+            this.calculationScenarios = calculationScenarios;
+            this.failureMechanism = failureMechanism;
+        }
+
+        public double CalculateProfileProbability()
+        {
+            return sectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios, failureMechanism.GeneralInput.ModelFactor);
+        }
+
+        public double CalculateSectionProbability()
+        {
+            return CalculateProfileProbability() * failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(sectionResult.Section.Length);
+        }
+    }
+}
\ No newline at end of file
Index: Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs
===================================================================
diff -u
--- Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs	(revision 0)
+++ Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs	(revision 4c5b838896048250be3167fdf0fe6ed8b89c328e)
@@ -0,0 +1,203 @@
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
+//
+// This file is part of Riskeer.
+//
+// Riskeer is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Linq;
+using Core.Common.Base.Data;
+using NUnit.Framework;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.TestUtil;
+using Riskeer.MacroStabilityInwards.Data.TestUtil;
+
+namespace Riskeer.MacroStabilityInwards.Data.Test
+{
+    [TestFixture]
+    public class MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest
+    {
+        [Test]
+        public void Constructor_SectionResultNull_ThrowsArgumentNullException()
+        {
+            // Call
+            void Call() => new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                null, Enumerable.Empty<MacroStabilityInwardsCalculationScenario>(), new MacroStabilityInwardsFailureMechanism());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("sectionResult", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_CalculationScenariosNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+
+            // Call
+            void Call() => new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section), null, new MacroStabilityInwardsFailureMechanism());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("calculationScenarios", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+
+            // Call
+            void Call() => new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section),
+                Enumerable.Empty<MacroStabilityInwardsCalculationScenario>(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_ExpectedValues()
+        {
+            // Setup
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+
+            // Call
+            var strategy = new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section), Enumerable.Empty<MacroStabilityInwardsCalculationScenario>(),
+                new MacroStabilityInwardsFailureMechanism());
+
+            // Assert
+            Assert.IsInstanceOf<IFailureMechanismSectionResultCalculateProbabilityStrategy>(strategy);
+        }
+
+        [Test]
+        public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
+        {
+            // Setup
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
+
+            const double factorOfStability1 = 1.0 / 10.0;
+            const double factorOfStability2 = 1.0 / 20.0;
+
+            MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario1 =
+                MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability1, section);
+            MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario2 =
+                MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability2, section);
+            MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario3 =
+                MacroStabilityInwardsCalculationScenarioTestFactory.CreateIrrelevantMacroStabilityInwardsCalculationScenario(section);
+
+            macroStabilityInwardsCalculationScenario1.Contribution = (RoundedDouble) 0.2111;
+            macroStabilityInwardsCalculationScenario2.Contribution = (RoundedDouble) 0.7889;
+
+            MacroStabilityInwardsCalculationScenario[] calculations =
+            {
+                macroStabilityInwardsCalculationScenario1,
+                macroStabilityInwardsCalculationScenario2,
+                macroStabilityInwardsCalculationScenario3
+            };
+
+            var strategy = new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                sectionResult, calculations, new MacroStabilityInwardsFailureMechanism());
+
+            // Call
+            double profileProbability = strategy.CalculateProfileProbability();
+
+            // Assert
+            Assert.AreEqual(0.99012835, profileProbability, 1e-8);
+        }
+
+        [Test]
+        public void CalculateProfileProbability_NoScenarios_ReturnsNaN()
+        {
+            // Setup
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
+
+            var strategy = new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                sectionResult, Enumerable.Empty<MacroStabilityInwardsCalculationScenario>(),
+                new MacroStabilityInwardsFailureMechanism());
+
+            // Call
+            double profileProbability = strategy.CalculateProfileProbability();
+
+            // Assert
+            Assert.IsNaN(profileProbability);
+        }
+
+        [Test]
+        public void CalculateSectionProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
+        {
+            // Setup
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
+
+            const double factorOfStability1 = 1.0 / 10.0;
+            const double factorOfStability2 = 1.0 / 20.0;
+
+            MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario1 =
+                MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability1, section);
+            MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario2 =
+                MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability2, section);
+            MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario3 =
+                MacroStabilityInwardsCalculationScenarioTestFactory.CreateIrrelevantMacroStabilityInwardsCalculationScenario(section);
+
+            macroStabilityInwardsCalculationScenario1.Contribution = (RoundedDouble) 0.2111;
+            macroStabilityInwardsCalculationScenario2.Contribution = (RoundedDouble) 0.7889;
+
+            MacroStabilityInwardsCalculationScenario[] calculations =
+            {
+                macroStabilityInwardsCalculationScenario1,
+                macroStabilityInwardsCalculationScenario2,
+                macroStabilityInwardsCalculationScenario3
+            };
+
+            var strategy = new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                sectionResult, calculations, new MacroStabilityInwardsFailureMechanism());
+
+            // Call
+            double profileProbability = strategy.CalculateSectionProbability();
+
+            // Assert
+            Assert.AreEqual(0.99078184, profileProbability, 1e-8);
+        }
+
+        [Test]
+        public void CalculateSectionProbability_NoScenarios_ReturnsNaN()
+        {
+            // Setup
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
+
+            var strategy = new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
+                sectionResult, Enumerable.Empty<MacroStabilityInwardsCalculationScenario>(),
+                new MacroStabilityInwardsFailureMechanism());
+
+            // Call
+            double sectionProbability = strategy.CalculateSectionProbability();
+
+            // Assert
+            Assert.IsNaN(sectionProbability);
+        }
+    }
+}
\ No newline at end of file
Index: Riskeer/Piping/src/Riskeer.Piping.Data/Probabilistic/ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs
===================================================================
diff -u -re2aac3d024a59aeaeb5f4803e9360b046a8b24f3 -r4c5b838896048250be3167fdf0fe6ed8b89c328e
--- Riskeer/Piping/src/Riskeer.Piping.Data/Probabilistic/ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs	(.../ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs)	(revision e2aac3d024a59aeaeb5f4803e9360b046a8b24f3)
+++ Riskeer/Piping/src/Riskeer.Piping.Data/Probabilistic/ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs	(.../ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs)	(revision 4c5b838896048250be3167fdf0fe6ed8b89c328e)
@@ -31,39 +31,39 @@
     public class ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy : IFailureMechanismSectionResultCalculateProbabilityStrategy
     {
         private readonly AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult;
-        private readonly IEnumerable<ProbabilisticPipingCalculationScenario> calculations;
+        private readonly IEnumerable<ProbabilisticPipingCalculationScenario> calculationScenarios;
 
         /// <summary>
         /// Creates a new instance of <see cref="ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy"/>.
         /// </summary>
         /// <param name="sectionResult">The <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResult"/> to get the probabilities for.</param>
-        /// <param name="calculations">All the <see cref="ProbabilisticPipingCalculationScenario"/> of the failure mechanism. </param>
+        /// <param name="calculationScenarios">All the <see cref="ProbabilisticPipingCalculationScenario"/> of the failure mechanism. </param>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         public ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
-                                                                                            IEnumerable<ProbabilisticPipingCalculationScenario> calculations)
+                                                                                            IEnumerable<ProbabilisticPipingCalculationScenario> calculationScenarios)
         {
             if (sectionResult == null)
             {
                 throw new ArgumentNullException(nameof(sectionResult));
             }
 
-            if (calculations == null)
+            if (calculationScenarios == null)
             {
-                throw new ArgumentNullException(nameof(calculations));
+                throw new ArgumentNullException(nameof(calculationScenarios));
             }
 
             this.sectionResult = sectionResult;
-            this.calculations = calculations;
+            this.calculationScenarios = calculationScenarios;
         }
 
         public double CalculateProfileProbability()
         {
-            return sectionResult.GetInitialFailureMechanismResultProbability(calculations, scenario => scenario.Output.ProfileSpecificOutput);
+            return sectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios, scenario => scenario.Output.ProfileSpecificOutput);
         }
 
         public double CalculateSectionProbability()
         {
-            return sectionResult.GetInitialFailureMechanismResultProbability(calculations, scenario => scenario.Output.SectionSpecificOutput);
+            return sectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios, scenario => scenario.Output.SectionSpecificOutput);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Piping/src/Riskeer.Piping.Data/SemiProbabilistic/SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs
===================================================================
diff -u -re2aac3d024a59aeaeb5f4803e9360b046a8b24f3 -r4c5b838896048250be3167fdf0fe6ed8b89c328e
--- Riskeer/Piping/src/Riskeer.Piping.Data/SemiProbabilistic/SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs	(.../SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs)	(revision e2aac3d024a59aeaeb5f4803e9360b046a8b24f3)
+++ Riskeer/Piping/src/Riskeer.Piping.Data/SemiProbabilistic/SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs	(.../SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy.cs)	(revision 4c5b838896048250be3167fdf0fe6ed8b89c328e)
@@ -33,20 +33,20 @@
     public class SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy : IFailureMechanismSectionResultCalculateProbabilityStrategy
     {
         private readonly AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult;
-        private readonly IEnumerable<SemiProbabilisticPipingCalculationScenario> calculations;
+        private readonly IEnumerable<SemiProbabilisticPipingCalculationScenario> calculationScenarios;
         private readonly PipingFailureMechanism failureMechanism;
         private readonly IAssessmentSection assessmentSection;
 
         /// <summary>
         /// Creates a new instance of <see cref="SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy"/>.
         /// </summary>
         /// <param name="sectionResult">The <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResult"/> to get the probabilities for.</param>
-        /// <param name="calculations">All the <see cref="SemiProbabilisticPipingCalculationScenario"/> of the failure mechanism. </param>
+        /// <param name="calculationScenarios">All the <see cref="SemiProbabilisticPipingCalculationScenario"/> of the failure mechanism. </param>
         /// <param name="failureMechanism">The failure mechanism the calculation scenarios belong to.</param>
         /// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         public SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
-                                                                                                IEnumerable<SemiProbabilisticPipingCalculationScenario> calculations,
+                                                                                                IEnumerable<SemiProbabilisticPipingCalculationScenario> calculationScenarios,
                                                                                                 PipingFailureMechanism failureMechanism,
                                                                                                 IAssessmentSection assessmentSection)
         {
@@ -55,9 +55,9 @@
                 throw new ArgumentNullException(nameof(sectionResult));
             }
 
-            if (calculations == null)
+            if (calculationScenarios == null)
             {
-                throw new ArgumentNullException(nameof(calculations));
+                throw new ArgumentNullException(nameof(calculationScenarios));
             }
 
             if (failureMechanism == null)
@@ -71,14 +71,14 @@
             }
 
             this.sectionResult = sectionResult;
-            this.calculations = calculations;
+            this.calculationScenarios = calculationScenarios;
             this.failureMechanism = failureMechanism;
             this.assessmentSection = assessmentSection;
         }
 
         public double CalculateProfileProbability()
         {
-            return sectionResult.GetInitialFailureMechanismResultProbability(calculations, assessmentSection.FailureMechanismContribution.Norm);
+            return sectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios, assessmentSection.FailureMechanismContribution.Norm);
         }
 
         public double CalculateSectionProbability()
Index: Riskeer/Piping/test/Riskeer.Piping.Data.Test/Probabilistic/ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs
===================================================================
diff -u -re2aac3d024a59aeaeb5f4803e9360b046a8b24f3 -r4c5b838896048250be3167fdf0fe6ed8b89c328e
--- Riskeer/Piping/test/Riskeer.Piping.Data.Test/Probabilistic/ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs	(.../ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs)	(revision e2aac3d024a59aeaeb5f4803e9360b046a8b24f3)
+++ Riskeer/Piping/test/Riskeer.Piping.Data.Test/Probabilistic/ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs	(.../ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs)	(revision 4c5b838896048250be3167fdf0fe6ed8b89c328e)
@@ -26,7 +26,6 @@
 using Riskeer.Common.Data.FailureMechanism;
 using Riskeer.Common.Data.TestUtil;
 using Riskeer.Piping.Data.Probabilistic;
-using Riskeer.Piping.Data.TestUtil;
 using Riskeer.Piping.Data.TestUtil.Probabilistic;
 
 namespace Riskeer.Piping.Data.Test.Probabilistic
@@ -47,7 +46,7 @@
         }
 
         [Test]
-        public void Constructor_CalculationsNull_ThrowsArgumentNullException()
+        public void Constructor_CalculationScenariosNull_ThrowsArgumentNullException()
         {
             // Setup
             FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
@@ -58,7 +57,7 @@
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
-            Assert.AreEqual("calculations", exception.ParamName);
+            Assert.AreEqual("calculationScenarios", exception.ParamName);
         }
 
         [Test]
@@ -74,8 +73,6 @@
             // Assert
             Assert.IsInstanceOf<IFailureMechanismSectionResultCalculateProbabilityStrategy>(strategy);
         }
-        
-        #region CalculateProfileProbability
 
         [Test]
         public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
@@ -130,126 +127,6 @@
         }
 
         [Test]
-        public void CalculateProfileProbability_NoRelevantScenarios_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            calculationScenario.IsRelevant = false;
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new[]
-                {
-                    calculationScenario
-                });
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-
-        [Test]
-        public void CalculateProfileProbability_ScenarioNotCalculated_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = ProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<ProbabilisticPipingCalculationScenario>(
-                section);
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new[]
-                {
-                    calculationScenario
-                });
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-
-        [Test]
-        public void CalculateProfileProbability_ScenarioWithNaNResults_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            const double contribution1 = 0.2;
-            const double contribution2 = 0.8;
-
-            var calculationScenario1 =
-                ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 =
-                ProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<ProbabilisticPipingCalculationScenario>(section);
-
-            calculationScenario1.IsRelevant = true;
-            calculationScenario1.Contribution = (RoundedDouble) contribution1;
-
-            calculationScenario2.IsRelevant = true;
-            calculationScenario2.Contribution = (RoundedDouble) contribution2;
-            calculationScenario2.Output = new ProbabilisticPipingOutput(new TestPartialProbabilisticPipingOutput(double.NaN, null),
-                                                                        new TestPartialProbabilisticPipingOutput(double.NaN, null));
-
-            ProbabilisticPipingCalculationScenario[] calculations =
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations);
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-
-        [Test]
-        [TestCase(0.0, 0.0)]
-        [TestCase(0.0, 0.5)]
-        [TestCase(0.3, 0.7 + 1e-4)]
-        public void CalculateProfileProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contribution1, double contribution2)
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario1 = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            calculationScenario1.Contribution = (RoundedDouble) contribution1;
-            calculationScenario2.Contribution = (RoundedDouble) contribution2;
-
-            ProbabilisticPipingCalculationScenario[] calculations =
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations);
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-        
-        #endregion
-        
-        #region CalculateSectionProbability
-
-        [Test]
         public void CalculateSectionProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
         {
             // Setup
@@ -300,123 +177,5 @@
             // Assert
             Assert.IsNaN(sectionProbability);
         }
-
-        [Test]
-        public void CalculateSectionProbability_NoRelevantScenarios_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            calculationScenario.IsRelevant = false;
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new[]
-                {
-                    calculationScenario
-                });
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-
-        [Test]
-        public void CalculateSectionProbability_ScenarioNotCalculated_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = ProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<ProbabilisticPipingCalculationScenario>(
-                section);
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new[]
-                {
-                    calculationScenario
-                });
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-
-        [Test]
-        public void CalculateSectionProbability_ScenarioWithNaNResults_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            const double contribution1 = 0.2;
-            const double contribution2 = 0.8;
-
-            var calculationScenario1 =
-                ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 =
-                ProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<ProbabilisticPipingCalculationScenario>(section);
-
-            calculationScenario1.IsRelevant = true;
-            calculationScenario1.Contribution = (RoundedDouble) contribution1;
-
-            calculationScenario2.IsRelevant = true;
-            calculationScenario2.Contribution = (RoundedDouble) contribution2;
-            calculationScenario2.Output = new ProbabilisticPipingOutput(new TestPartialProbabilisticPipingOutput(double.NaN, null),
-                                                                        new TestPartialProbabilisticPipingOutput(double.NaN, null));
-
-            ProbabilisticPipingCalculationScenario[] calculations =
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations);
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-
-        [Test]
-        [TestCase(0.0, 0.0)]
-        [TestCase(0.0, 0.5)]
-        [TestCase(0.3, 0.7 + 1e-4)]
-        public void CalculateSectionProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contribution1, double contribution2)
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario1 = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
-            calculationScenario1.Contribution = (RoundedDouble) contribution1;
-            calculationScenario2.Contribution = (RoundedDouble) contribution2;
-
-            ProbabilisticPipingCalculationScenario[] calculations =
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations);
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-        
-        #endregion
     }
 }
\ No newline at end of file
Index: Riskeer/Piping/test/Riskeer.Piping.Data.Test/SemiProbabilistic/SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs
===================================================================
diff -u -re2aac3d024a59aeaeb5f4803e9360b046a8b24f3 -r4c5b838896048250be3167fdf0fe6ed8b89c328e
--- Riskeer/Piping/test/Riskeer.Piping.Data.Test/SemiProbabilistic/SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs	(.../SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs)	(revision e2aac3d024a59aeaeb5f4803e9360b046a8b24f3)
+++ Riskeer/Piping/test/Riskeer.Piping.Data.Test/SemiProbabilistic/SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs	(.../SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs)	(revision 4c5b838896048250be3167fdf0fe6ed8b89c328e)
@@ -55,7 +55,7 @@
         }
 
         [Test]
-        public void Constructor_CalculationsNull_ThrowsArgumentNullException()
+        public void Constructor_CalculationScenariosNull_ThrowsArgumentNullException()
         {
             // Setup
             var mocks = new MockRepository();
@@ -70,7 +70,7 @@
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
-            Assert.AreEqual("calculations", exception.ParamName);
+            Assert.AreEqual("calculationScenarios", exception.ParamName);
             mocks.VerifyAll();
         }
 
@@ -130,9 +130,7 @@
             Assert.IsInstanceOf<IFailureMechanismSectionResultCalculateProbabilityStrategy>(strategy);
             mocks.VerifyAll();
         }
-        
-        #region CalculateProfileProbability
-        
+
         [Test]
         public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
         {
@@ -190,121 +188,6 @@
         }
 
         [Test]
-        public void CalculateProfileProbability_NoRelevantScenarios_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            calculationScenario.IsRelevant = false;
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new []
-                {
-                    calculationScenario
-                },
-                new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-
-        [Test]
-        public void CalculateProfileProbability_ScenarioNotCalculated_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new []
-                {
-                    calculationScenario
-                },
-                new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-
-        [Test]
-        public void CalculateProfileProbability_ScenarioWithNaNResults_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-
-            calculationScenario1.IsRelevant = true;
-            calculationScenario1.Contribution = (RoundedDouble) 0.2;
-
-            calculationScenario2.IsRelevant = true;
-            calculationScenario2.Contribution = (RoundedDouble) 0.8;
-            calculationScenario2.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
-
-            SemiProbabilisticPipingCalculationScenario[] calculations =
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-
-        [Test]
-        [TestCase(0.0, 0.0)]
-        [TestCase(0.0, 0.5)]
-        [TestCase(0.3, 0.7 + 1e-4)]
-        public void CalculateProfileProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contribution1, double contribution2)
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-            
-            var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            calculationScenario1.Contribution = (RoundedDouble) contribution1;
-            calculationScenario2.Contribution = (RoundedDouble) contribution2;
-
-            SemiProbabilisticPipingCalculationScenario[] calculations = new[]
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double profileProbability = strategy.CalculateProfileProbability();
-
-            // Assert
-            Assert.IsNaN(profileProbability);
-        }
-        
-        #endregion
-        
-        #region CalculateSectionProbability
-        
-        [Test]
         public void CalculateSectionProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
         {
             // Setup
@@ -359,118 +242,5 @@
             // Assert
             Assert.IsNaN(sectionProbability);
         }
-
-        [Test]
-        public void CalculateSectionProbability_NoRelevantScenarios_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            calculationScenario.IsRelevant = false;
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new []
-                {
-                    calculationScenario
-                },
-                new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-
-        [Test]
-        public void CalculateSectionProbability_ScenarioNotCalculated_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario = SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, new []
-                {
-                    calculationScenario
-                },
-                new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-
-        [Test]
-        public void CalculateSectionProbability_ScenarioWithNaNResults_ReturnsNaN()
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-
-            var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-
-            calculationScenario1.IsRelevant = true;
-            calculationScenario1.Contribution = (RoundedDouble) 0.2;
-
-            calculationScenario2.IsRelevant = true;
-            calculationScenario2.Contribution = (RoundedDouble) 0.8;
-            calculationScenario2.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
-
-            SemiProbabilisticPipingCalculationScenario[] calculations =
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-
-        [Test]
-        [TestCase(0.0, 0.0)]
-        [TestCase(0.0, 0.5)]
-        [TestCase(0.3, 0.7 + 1e-4)]
-        public void CalculateSectionProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contribution1, double contribution2)
-        {
-            // Setup
-            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
-            var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
-            
-            var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation<SemiProbabilisticPipingCalculationScenario>(section);
-            calculationScenario1.Contribution = (RoundedDouble) contribution1;
-            calculationScenario2.Contribution = (RoundedDouble) contribution2;
-
-            SemiProbabilisticPipingCalculationScenario[] calculations = new[]
-            {
-                calculationScenario1,
-                calculationScenario2
-            };
-
-            var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
-                sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub());
-
-            // Call
-            double sectionProbability = strategy.CalculateSectionProbability();
-
-            // Assert
-            Assert.IsNaN(sectionProbability);
-        }
-        
-        #endregion
     }
 }
\ No newline at end of file