Index: Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismSectionResultDetailedAssessmentExtensions.cs
===================================================================
diff -u -r56c90cc86236bb05fc3e827bcd7029b2a604cf55 -r5a2a200c1b673118f961f0c9363eb5951610a785
--- Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismSectionResultDetailedAssessmentExtensions.cs	(.../PipingFailureMechanismSectionResultDetailedAssessmentExtensions.cs)	(revision 56c90cc86236bb05fc3e827bcd7029b2a604cf55)
+++ Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismSectionResultDetailedAssessmentExtensions.cs	(.../PipingFailureMechanismSectionResultDetailedAssessmentExtensions.cs)	(revision 5a2a200c1b673118f961f0c9363eb5951610a785)
@@ -69,7 +69,9 @@
                                                                                           calculationScenarios)
                                                                                       .ToArray();
 
-            if (relevantScenarios.Length == 0 || !relevantScenarios.All(s => s.HasOutput) || Math.Abs(sectionResult.GetTotalContribution(relevantScenarios) - 1.0) > 1e-6)
+            if (relevantScenarios.Length == 0
+                || !relevantScenarios.All(s => s.HasOutput)
+                || Math.Abs(sectionResult.GetTotalContribution<ProbabilisticPipingCalculationScenario>(relevantScenarios) - 1.0) > 1e-6)
             {
                 return double.NaN;
             }
@@ -105,7 +107,9 @@
                                                                                               calculationScenarios)
                                                                                           .ToArray();
 
-            if (relevantScenarios.Length == 0 || !relevantScenarios.All(s => s.HasOutput) || Math.Abs(sectionResult.GetTotalContribution(relevantScenarios) - 1.0) > 1e-6)
+            if (relevantScenarios.Length == 0
+                || !relevantScenarios.All(s => s.HasOutput)
+                || Math.Abs(sectionResult.GetTotalContribution<SemiProbabilisticPipingCalculationScenario>(relevantScenarios) - 1.0) > 1e-6)
             {
                 return double.NaN;
             }
@@ -126,10 +130,12 @@
         /// </summary>
         /// <param name="sectionResult">The section result to get the total contribution for.</param>
         /// <param name="calculationScenarios">The calculation scenarios to get the total contribution for.</param>
+        /// <typeparam name="T">The type of the calculation scenarios.</typeparam>
         /// <returns>The total contribution of all relevant calculation scenarios.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        public static RoundedDouble GetTotalContribution(this PipingFailureMechanismSectionResult sectionResult,
-                                                         IEnumerable<IPipingCalculationScenario<PipingInput>> calculationScenarios)
+        public static RoundedDouble GetTotalContribution<T>(this PipingFailureMechanismSectionResult sectionResult,
+                                                            IEnumerable<IPipingCalculationScenario<PipingInput>> calculationScenarios)
+            where T : IPipingCalculationScenario<PipingInput>
         {
             if (sectionResult == null)
             {
@@ -141,9 +147,9 @@
                 throw new ArgumentNullException(nameof(calculationScenarios));
             }
 
-            return (RoundedDouble) sectionResult
-                                   .GetCalculationScenarios<IPipingCalculationScenario<PipingInput>>(calculationScenarios)
-                                   .Aggregate<ICalculationScenario, double>(0, (current, calculationScenario) => current + calculationScenario.Contribution);
+            return (RoundedDouble) sectionResult.GetCalculationScenarios<T>(calculationScenarios)
+                                                .Cast<ICalculationScenario>()
+                                                .Aggregate<ICalculationScenario, double>(0, (current, calculationScenario) => current + calculationScenario.Contribution);
         }
 
         /// <summary>
Index: Riskeer/Piping/test/Riskeer.Piping.Data.Test/PipingFailureMechanismSectionResultDetailedAssessmentExtensionsTest.cs
===================================================================
diff -u -r56c90cc86236bb05fc3e827bcd7029b2a604cf55 -r5a2a200c1b673118f961f0c9363eb5951610a785
--- Riskeer/Piping/test/Riskeer.Piping.Data.Test/PipingFailureMechanismSectionResultDetailedAssessmentExtensionsTest.cs	(.../PipingFailureMechanismSectionResultDetailedAssessmentExtensionsTest.cs)	(revision 56c90cc86236bb05fc3e827bcd7029b2a604cf55)
+++ Riskeer/Piping/test/Riskeer.Piping.Data.Test/PipingFailureMechanismSectionResultDetailedAssessmentExtensionsTest.cs	(.../PipingFailureMechanismSectionResultDetailedAssessmentExtensionsTest.cs)	(revision 5a2a200c1b673118f961f0c9363eb5951610a785)
@@ -42,7 +42,7 @@
         public void GetTotalContribution_SectionResultNull_ThrowsArgumentNullException()
         {
             // Call
-            void Call() => PipingFailureMechanismSectionResultDetailedAssessmentExtensions.GetTotalContribution(
+            void Call() => PipingFailureMechanismSectionResultDetailedAssessmentExtensions.GetTotalContribution<IPipingCalculationScenario<PipingInput>>(
                 null, Enumerable.Empty<SemiProbabilisticPipingCalculationScenario>());
 
             // Assert
@@ -58,17 +58,17 @@
             var sectionResult = new PipingFailureMechanismSectionResult(section);
 
             // Call
-            void Call() => sectionResult.GetTotalContribution(null);
+            void Call() => sectionResult.GetTotalContribution<IPipingCalculationScenario<PipingInput>>(null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("calculationScenarios", exception.ParamName);
         }
 
         [Test]
-        public void GetTotalContribution_WithScenarios_ReturnsTotalRelevantScenarioContribution()
+        public void GivenSectionResultWithScenarios_WhenGetTotalContributionForSemiProbabilistic_ThenReturnsTotalRelevantSemiProbabilisticScenarioContribution()
         {
-            // Setup
+            // Given
             FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
             var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section);
 
@@ -81,22 +81,59 @@
             pipingCalculationScenario2.Contribution = (RoundedDouble) 0.5435;
 
             SemiProbabilisticPipingCalculationScenario pipingCalculationScenario3 = CreateIrrelevantSemiProbabilisticPipingCalculationScenario(section);
+            var pipingCalculationScenario4 = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
+            pipingCalculationScenario4.Contribution = (RoundedDouble) 0.1;
 
-            SemiProbabilisticPipingCalculationScenario[] calculationScenarios =
+            IPipingCalculationScenario<PipingInput>[] calculationScenarios =
             {
                 pipingCalculationScenario1,
                 pipingCalculationScenario2,
-                pipingCalculationScenario3
+                pipingCalculationScenario3,
+                pipingCalculationScenario4
             };
 
-            // Call
-            RoundedDouble totalContribution = failureMechanismSectionResult.GetTotalContribution(calculationScenarios);
+            // When
+            RoundedDouble totalContribution = failureMechanismSectionResult.GetTotalContribution<SemiProbabilisticPipingCalculationScenario>(calculationScenarios);
 
-            // Assert
+            // Then
             Assert.AreEqual((RoundedDouble) 0.8646, totalContribution);
         }
 
         [Test]
+        public void GivenSectionResultWithScenarios_WhenGetTotalContributionForProbabilistic_ThenReturnsTotalRelevantProbabilisticScenarioContribution()
+        {
+            // Given
+            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+            var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section);
+
+            var pipingCalculationScenario1 =
+                SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation<SemiProbabilisticPipingCalculationScenario>(section);
+            pipingCalculationScenario1.Contribution = (RoundedDouble) 0.3211;
+
+            var pipingCalculationScenario2 = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
+            pipingCalculationScenario2.Contribution = (RoundedDouble) 0.1;
+
+            var pipingCalculationScenario3 = ProbabilisticPipingCalculationTestFactory.CreateCalculation<ProbabilisticPipingCalculationScenario>(section);
+            pipingCalculationScenario3.Contribution = (RoundedDouble) 0.4651;
+
+            ProbabilisticPipingCalculationScenario pipingCalculationScenario4 = CreateIrrelevantProbabilisticPipingCalculationScenario(section);
+
+            IPipingCalculationScenario<PipingInput>[] calculationScenarios =
+            {
+                pipingCalculationScenario1,
+                pipingCalculationScenario2,
+                pipingCalculationScenario3,
+                pipingCalculationScenario4
+            };
+
+            // When
+            RoundedDouble totalContribution = failureMechanismSectionResult.GetTotalContribution<ProbabilisticPipingCalculationScenario>(calculationScenarios);
+
+            // Then
+            Assert.AreEqual((RoundedDouble) 0.5651, totalContribution);
+        }
+
+        [Test]
         public void GetCalculationScenarios_SectionResultNull_ThrowsArgumentNullException()
         {
             // Call