Index: Ringtoets/Piping/src/Ringtoets.Piping.IO/Configurations/PipingCalculationConfigurationExporter.cs
===================================================================
diff -u -r681fe6f5c04ea2acdb99801dd749a11a174d5b42 -re8b26aea321478305dfba9eb8ed6c2146ac5c9ea
--- Ringtoets/Piping/src/Ringtoets.Piping.IO/Configurations/PipingCalculationConfigurationExporter.cs	(.../PipingCalculationConfigurationExporter.cs)	(revision 681fe6f5c04ea2acdb99801dd749a11a174d5b42)
+++ Ringtoets/Piping/src/Ringtoets.Piping.IO/Configurations/PipingCalculationConfigurationExporter.cs	(.../PipingCalculationConfigurationExporter.cs)	(revision e8b26aea321478305dfba9eb8ed6c2146ac5c9ea)
@@ -31,10 +31,10 @@
     /// <summary>
     /// Exports a piping calculation configuration and stores it as an XML file.
     /// </summary>
-    public class PipingCalculationConfigurationExporter 
+    public class PipingCalculationConfigurationExporter
         : CalculationConfigurationExporter<
-            PipingCalculationConfigurationWriter, 
-            PipingCalculation, 
+            PipingCalculationConfigurationWriter,
+            PipingCalculationScenario,
             PipingCalculationConfiguration>
     {
         /// <summary>
@@ -44,15 +44,15 @@
         /// <param name="filePath">The path of the XML file to export to.</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> is <c>null</c>.</exception>
         /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception>
-        public PipingCalculationConfigurationExporter(IEnumerable<ICalculationBase> calculations, string filePath) 
+        public PipingCalculationConfigurationExporter(IEnumerable<ICalculationBase> calculations, string filePath)
             : base(calculations, filePath) {}
 
         protected override PipingCalculationConfigurationWriter CreateWriter(string filePath)
         {
             return new PipingCalculationConfigurationWriter(filePath);
         }
 
-        protected override PipingCalculationConfiguration ToConfiguration(PipingCalculation calculation)
+        protected override PipingCalculationConfiguration ToConfiguration(PipingCalculationScenario calculation)
         {
             PipingInput input = calculation.InputParameters;
 
@@ -62,7 +62,7 @@
             {
                 calculationConfiguration.HydraulicBoundaryLocationName = input.HydraulicBoundaryLocation.Name;
             }
-            else if(input.UseAssessmentLevelManualInput)
+            else if (input.UseAssessmentLevelManualInput)
             {
                 calculationConfiguration.AssessmentLevel = input.AssessmentLevel;
             }
Index: Ringtoets/Piping/test/Ringtoets.Piping.IO.Test/Configurations/PipingCalculationConfigurationExporterTest.cs
===================================================================
diff -u -r16df8541528639fd1e8d9f2584fae28808b63fad -re8b26aea321478305dfba9eb8ed6c2146ac5c9ea
--- Ringtoets/Piping/test/Ringtoets.Piping.IO.Test/Configurations/PipingCalculationConfigurationExporterTest.cs	(.../PipingCalculationConfigurationExporterTest.cs)	(revision 16df8541528639fd1e8d9f2584fae28808b63fad)
+++ Ringtoets/Piping/test/Ringtoets.Piping.IO.Test/Configurations/PipingCalculationConfigurationExporterTest.cs	(.../PipingCalculationConfigurationExporterTest.cs)	(revision e8b26aea321478305dfba9eb8ed6c2146ac5c9ea)
@@ -28,6 +28,7 @@
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.IO.TestUtil;
 using Ringtoets.Piping.Data;
+using Ringtoets.Piping.Data.TestUtil;
 using Ringtoets.Piping.Integration.TestUtil;
 using Ringtoets.Piping.IO.Configurations;
 using Ringtoets.Piping.Primitives;
@@ -39,46 +40,52 @@
         : CustomCalculationConfigurationExporterDesignGuidelinesTestFixture<
             PipingCalculationConfigurationExporter,
             PipingCalculationConfigurationWriter,
-            PipingCalculation,
+            PipingCalculationScenario,
             PipingCalculationConfiguration>
     {
         private static IEnumerable<TestCaseData> Calculations
         {
             get
             {
+                const string testNameFormat = "{m}({0:40}.xml)";
+
                 yield return new TestCaseData("calculationWithoutHydraulicLocation",
-                                              PipingTestDataGenerator.GetPipingCalculationWithoutHydraulicLocationAndAssessmentLevel())
-                    .SetName("calculationWithoutHydraulicLocation");
+                                              PipingTestDataGenerator.GetPipingCalculationScenarioWithoutHydraulicLocationAndAssessmentLevel())
+                    .SetName(testNameFormat);
                 yield return new TestCaseData("calculationWithAssessmentLevel",
-                                              PipingTestDataGenerator.GetPipingCalculationWithAssessmentLevel())
-                    .SetName("calculationWithAssessmentLevel");
+                                              PipingTestDataGenerator.GetPipingCalculationScenarioWithAssessmentLevel())
+                    .SetName(testNameFormat);
                 yield return new TestCaseData("calculationWithoutSurfaceLine",
-                                              PipingTestDataGenerator.GetPipingCalculationWithoutSurfaceLine())
-                    .SetName("calculationWithoutSurfaceLine");
+                                              PipingTestDataGenerator.GetPipingCalculationScenarioWithoutSurfaceLine())
+                    .SetName(testNameFormat);
                 yield return new TestCaseData("calculationWithoutSoilModel",
-                                              PipingTestDataGenerator.GetPipingCalculationWithoutSoilModel())
-                    .SetName("calculationWithoutSoilModel");
+                                              PipingTestDataGenerator.GetPipingCalculationScenarioWithoutSoilModel())
+                    .SetName(testNameFormat);
                 yield return new TestCaseData("calculationWithoutSoilProfile",
-                                              PipingTestDataGenerator.GetPipingCalculationWithoutSoilProfile())
-                    .SetName("calculationWithoutSoilProfile");
+                                              PipingTestDataGenerator.GetPipingCalculationScenarioWithoutSoilProfile())
+                    .SetName(testNameFormat);
+
+                yield return new TestCaseData("calculationIrrelevant",
+                                              PipingTestDataGenerator.GetIrrelevantPipingCalculationScenario())
+                    .SetName(testNameFormat);
                 yield return new TestCaseData("calculationWithNaNs",
-                                              PipingTestDataGenerator.GetPipingCalculationWithNaNs())
-                    .SetName("calculationWithNaNs");
+                                              PipingTestDataGenerator.GetPipingCalculationScenarioWithNaNs())
+                    .SetName(testNameFormat);
                 yield return new TestCaseData("calculationWithInfinities",
-                                              PipingTestDataGenerator.GetPipingCalculationWithInfinities())
-                    .SetName("calculationWithInfinities");
+                                              PipingTestDataGenerator.GetPipingCalculationScenarioWithInfinities())
+                    .SetName(testNameFormat);
             }
         }
 
         [Test]
         public void Export_ValidData_ReturnTrueAndWritesFile()
         {
             // Setup
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculation();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenario();
             calculation.InputParameters.EntryPointL = (RoundedDouble) 0.1;
             calculation.InputParameters.ExitPointL = (RoundedDouble) 0.2;
 
-            PipingCalculation calculation2 = PipingTestDataGenerator.GetPipingCalculation();
+            PipingCalculationScenario calculation2 = PipingTestDataGenerator.GetPipingCalculationScenario();
             calculation2.Name = "PK001_0002 W1-6_4_1D1";
             calculation2.InputParameters.HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "PUNT_SCH_17", 0, 0);
             calculation2.InputParameters.SurfaceLine.Name = "PK001_0002";
@@ -137,9 +144,9 @@
             }, expectedXmlFilePath);
         }
 
-        protected override PipingCalculation CreateCalculation()
+        protected override PipingCalculationScenario CreateCalculation()
         {
-            return PipingTestDataGenerator.GetPipingCalculation();
+            return PipingCalculationScenarioFactory.CreatePipingCalculationScenarioWithValidInput();
         }
 
         protected override PipingCalculationConfigurationExporter CallConfigurationFilePathConstructor(IEnumerable<ICalculationBase> calculations, string filePath)
Index: Ringtoets/Piping/test/Ringtoets.Piping.IO.Test/test-data/PipingCalculationConfigurationExporter/calculationIrrelevant.xml
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.IO.Test/test-data/PipingCalculationConfigurationExporter/calculationIrrelevant.xml	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.IO.Test/test-data/PipingCalculationConfigurationExporter/calculationIrrelevant.xml	(revision e8b26aea321478305dfba9eb8ed6c2146ac5c9ea)
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="PK001_0001 W1-6_0_1D1">
+    <hrlocatie>PUNT_KAT_18</hrlocatie>
+    <profielschematisatie>PK001_0001</profielschematisatie>
+    <intredepunt>0</intredepunt>
+    <uittredepunt>10</uittredepunt>
+    <ondergrondmodel>PK001_0001_Piping</ondergrondmodel>
+    <ondergrondschematisatie>W1-6_0_1D1</ondergrondschematisatie>
+    <stochasten>
+      <stochast naam="polderpeil">
+        <verwachtingswaarde>0</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="dempingsfactor">
+        <verwachtingswaarde>0.7</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+    </stochasten>
+  </berekening>
+</configuratie>
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtil.Test/PipingTestDataGeneratorTest.cs
===================================================================
diff -u -r16df8541528639fd1e8d9f2584fae28808b63fad -re8b26aea321478305dfba9eb8ed6c2146ac5c9ea
--- Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtil.Test/PipingTestDataGeneratorTest.cs	(.../PipingTestDataGeneratorTest.cs)	(revision 16df8541528639fd1e8d9f2584fae28808b63fad)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtil.Test/PipingTestDataGeneratorTest.cs	(.../PipingTestDataGeneratorTest.cs)	(revision e8b26aea321478305dfba9eb8ed6c2146ac5c9ea)
@@ -68,72 +68,74 @@
         }
 
         [Test]
-        public void GetPipingCalculation_Always_ReturnCalculationWithDataSet()
+        public void GetPipingCalculationScenario_Always_ReturnCalculationWithDataSet()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculation();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenario();
 
             // Assert
-            AssertCalculation(calculation);
+            AssertCalculationScenario(calculation);
         }
 
         [Test]
-        public void GetPipingCalculationWithoutHydraulicLocationAndAssessmentLevel_Always_ReturnCalculationWithoutHydraulicLocationAndAssessmentLevel()
+        public void GetPipingCalculationScenarioWithoutHydraulicLocationAndAssessmentLevel_Always_ReturnCalculationScenarioWithoutHydraulicLocationAndAssessmentLevel()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculationWithoutHydraulicLocationAndAssessmentLevel();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenarioWithoutHydraulicLocationAndAssessmentLevel();
 
             // Assert
-            AssertCalculation(calculation, false);
+            AssertCalculationScenario(calculation, false);
         }
 
         [Test]
-        public void GetPipingCalculationWithAssessmentLevel_Always_ReturnCalculationWithAssessmentLevel()
+        public void GetPipingCalculationScenarioWithAssessmentLevel_Always_ReturnCalculationScenarioWithAssessmentLevel()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculationWithAssessmentLevel();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenarioWithAssessmentLevel();
 
             // Assert
-            AssertCalculation(calculation, false, true);
+            AssertCalculationScenario(calculation, false, true);
         }
 
         [Test]
-        public void GetPipingCalculationWithoutSurfaceLine_Always_ReturnCalculationWithoutSurfaceLine()
+        public void GetPipingCalculationScenarioWithoutSurfaceLine_Always_ReturnCalculationScenarioWithoutSurfaceLine()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculationWithoutSurfaceLine();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenarioWithoutSurfaceLine();
 
             // Assert
-            AssertCalculation(calculation, true, false, false);
+            AssertCalculationScenario(calculation, true, false, false);
         }
 
         [Test]
-        public void GetPipingCalculationWithoutSoilModel_Always_ReturnCalculationWithoutSoilModel()
+        public void GetPipingCalculationScenarioWithoutSoilModel_Always_ReturnCalculationScenarioWithoutSoilModel()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculationWithoutSoilModel();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenarioWithoutSoilModel();
 
             // Assert
-            AssertCalculation(calculation, true, false, true, false);
+            AssertCalculationScenario(calculation, true, false, true, false);
         }
 
         [Test]
-        public void GetPipingCalculationWithoutSoilProfile_Always_ReturnCalculationWithoutSoilProfile()
+        public void GetPipingCalculationScenarioWithoutSoilProfile_Always_ReturnCalculationScenarioWithoutSoilProfile()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculationWithoutSoilProfile();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenarioWithoutSoilProfile();
 
             // Assert
-            AssertCalculation(calculation, true, false, true, true, false);
+            AssertCalculationScenario(calculation, true, false, true, true, false);
         }
 
         [Test]
-        public void GetPipingCalculationWithNaNs_Always_ReturnCalculationWithNaNs()
+        public void GetPipingCalculationScenarioWithNaNs_Always_ReturnCalculationScenarioWithNaNs()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculationWithNaNs();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenarioWithNaNs();
 
             // Assert
+            Assert.IsTrue(calculation.IsRelevant);
+            Assert.AreEqual(double.NaN, calculation.Contribution);
             Assert.AreEqual("PK001_0001 W1-6_0_1D1", calculation.Name);
             Assert.AreEqual(double.NaN, calculation.InputParameters.AssessmentLevel.Value);
             Assert.AreEqual("PK001_0001", calculation.InputParameters.SurfaceLine.Name);
@@ -148,12 +150,14 @@
         }
 
         [Test]
-        public void GetPipingCalculationWithInfinities_Always_ReturnCalculationWithInfinities()
+        public void GetPipingCalculationScenarioWithInfinities_Always_ReturnCalculationScenarioWithInfinities()
         {
             // Call
-            PipingCalculation calculation = PipingTestDataGenerator.GetPipingCalculationWithInfinities();
+            PipingCalculationScenario calculation = PipingTestDataGenerator.GetPipingCalculationScenarioWithInfinities();
 
             // Assert
+            Assert.IsTrue(calculation.IsRelevant);
+            Assert.AreEqual(double.PositiveInfinity, calculation.Contribution);
             Assert.AreEqual("PK001_0001 W1-6_0_1D1", calculation.Name);
             Assert.AreEqual(double.NegativeInfinity, calculation.InputParameters.AssessmentLevel.Value);
             Assert.AreEqual("PK001_0001", calculation.InputParameters.SurfaceLine.Name);
@@ -167,13 +171,15 @@
             Assert.AreEqual(double.PositiveInfinity, calculation.InputParameters.DampingFactorExit.StandardDeviation.Value);
         }
 
-        private static void AssertCalculation(PipingCalculation calculation,
-                                              bool hasHydraulicLocation = true,
-                                              bool hasAssessmentLevel = false,
-                                              bool hasSurfaceLine = true,
-                                              bool hasSoilModel = true,
-                                              bool hasSoilProfile = true)
+        private static void AssertCalculationScenario(PipingCalculationScenario calculation,
+                                                      bool hasHydraulicLocation = true,
+                                                      bool hasAssessmentLevel = false,
+                                                      bool hasSurfaceLine = true,
+                                                      bool hasSoilModel = true,
+                                                      bool hasSoilProfile = true)
         {
+            Assert.IsTrue(calculation.IsRelevant);
+            Assert.AreEqual(1.0, calculation.Contribution, calculation.Contribution.GetAccuracy());
             Assert.AreEqual("PK001_0001 W1-6_0_1D1", calculation.Name);
 
             if (hasHydraulicLocation)
Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtil/PipingTestDataGenerator.cs
===================================================================
diff -u -r16df8541528639fd1e8d9f2584fae28808b63fad -re8b26aea321478305dfba9eb8ed6c2146ac5c9ea
--- Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtil/PipingTestDataGenerator.cs	(.../PipingTestDataGenerator.cs)	(revision 16df8541528639fd1e8d9f2584fae28808b63fad)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtil/PipingTestDataGenerator.cs	(.../PipingTestDataGenerator.cs)	(revision e8b26aea321478305dfba9eb8ed6c2146ac5c9ea)
@@ -50,73 +50,87 @@
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/> without hydraulic boundary location or design water level.
+        /// Gets a <see cref="PipingCalculationScenario"/> without hydraulic boundary location or design water level.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/> without hydraulic boundary location or design water level.</returns>
-        public static PipingCalculation GetPipingCalculationWithoutHydraulicLocationAndAssessmentLevel()
+        /// <returns>A <see cref="PipingCalculationScenario"/> without hydraulic boundary location or design water level.</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenarioWithoutHydraulicLocationAndAssessmentLevel()
         {
-            PipingCalculation calculation = GetPipingCalculation();
+            PipingCalculationScenario calculation = GetPipingCalculationScenario();
             calculation.InputParameters.HydraulicBoundaryLocation = null;
 
             return calculation;
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/> with manual design water level set.
+        /// Gets a <see cref="PipingCalculationScenario"/> with manual design water level set.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/> with a manual design water level.</returns>
-        public static PipingCalculation GetPipingCalculationWithAssessmentLevel()
+        /// <returns>A <see cref="PipingCalculationScenario"/> with a manual design water level.</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenarioWithAssessmentLevel()
         {
-            PipingCalculation calculation = GetPipingCalculation();
+            PipingCalculationScenario calculation = GetPipingCalculationScenario();
             calculation.InputParameters.UseAssessmentLevelManualInput = true;
             calculation.InputParameters.AssessmentLevel = (RoundedDouble) 3.0;
 
             return calculation;
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/> without surface line.
+        /// Gets a <see cref="PipingCalculationScenario"/> without surface line.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/> without surface line.</returns>
-        public static PipingCalculation GetPipingCalculationWithoutSurfaceLine()
+        /// <returns>A <see cref="PipingCalculationScenario"/> without surface line.</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenarioWithoutSurfaceLine()
         {
-            PipingCalculation calculation = GetPipingCalculation();
+            PipingCalculationScenario calculation = GetPipingCalculationScenario();
             calculation.InputParameters.SurfaceLine = null;
 
             return calculation;
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/> without soil model.
+        /// Gets a <see cref="PipingCalculationScenario"/> without soil model.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/> without soil model .</returns>
-        public static PipingCalculation GetPipingCalculationWithoutSoilModel()
+        /// <returns>A <see cref="PipingCalculationScenario"/> without soil model .</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenarioWithoutSoilModel()
         {
-            PipingCalculation calculation = GetPipingCalculation();
+            PipingCalculationScenario calculation = GetPipingCalculationScenario();
             calculation.InputParameters.StochasticSoilModel = null;
             calculation.InputParameters.StochasticSoilProfile = null;
 
             return calculation;
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/> without soil profile.
+        /// Gets a <see cref="PipingCalculationScenario"/> without soil profile.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/> without soil profile.</returns>
-        public static PipingCalculation GetPipingCalculationWithoutSoilProfile()
+        /// <returns>A <see cref="PipingCalculationScenario"/> without soil profile.</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenarioWithoutSoilProfile()
         {
-            PipingCalculation calculation = GetPipingCalculation();
+            PipingCalculationScenario calculation = GetPipingCalculationScenario();
             calculation.InputParameters.StochasticSoilProfile = null;
 
             return calculation;
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/>.
+        /// Gets a <see cref="PipingCalculationScenario"/> with relevance set to <c>false</c>.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/>.</returns>
-        public static PipingCalculation GetPipingCalculation()
+        /// <returns>A <see cref="PipingCalculationScenario"/> with relevance set to <c>false</c>
+        /// .</returns>
+        public static PipingCalculationScenario GetIrrelevantPipingCalculationScenario()
         {
+            PipingCalculationScenario calculation = GetPipingCalculationScenario();
+            calculation.Contribution = (RoundedDouble) 0.5;
+            calculation.IsRelevant = false;
+
+            return calculation;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="PipingCalculationScenario"/>.
+        /// </summary>
+        /// <returns>A <see cref="PipingCalculationScenario"/>.</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenario()
+        {
             var surfaceline = new RingtoetsPipingSurfaceLine
             {
                 ReferenceLineIntersectionWorldPoint = new Point2D(0, 5),
@@ -128,7 +142,7 @@
                 new Point3D(0, 10, 0)
             });
 
-            var calculation = new PipingCalculation(new GeneralPipingInput())
+            var calculation = new PipingCalculationScenario(new GeneralPipingInput())
             {
                 Name = "PK001_0001 W1-6_0_1D1",
                 InputParameters =
@@ -160,12 +174,13 @@
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/> with <c>double.NaN</c> values set.
+        /// Gets a <see cref="PipingCalculationScenario"/> with <c>double.NaN</c> values set.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/> with <c>double.NaN</c> values.</returns>
-        public static PipingCalculation GetPipingCalculationWithNaNs()
+        /// <returns>A <see cref="PipingCalculationScenario"/> with <c>double.NaN</c> values.</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenarioWithNaNs()
         {
-            PipingCalculation calculation = GetPipingCalculationWithAssessmentLevel();
+            PipingCalculationScenario calculation = GetPipingCalculationScenarioWithAssessmentLevel();
+            calculation.Contribution = RoundedDouble.NaN;
             calculation.InputParameters.AssessmentLevel = RoundedDouble.NaN;
             calculation.InputParameters.EntryPointL = RoundedDouble.NaN;
             calculation.InputParameters.ExitPointL = RoundedDouble.NaN;
@@ -184,12 +199,15 @@
         }
 
         /// <summary>
-        /// Gets a <see cref="PipingCalculation"/> with <c>double.NegativeInfinity</c> and <c>double.PositiveInfinity</c> values set.
+        /// Gets a <see cref="PipingCalculationScenario"/> with <c>double.NegativeInfinity</c> 
+        /// and <c>double.PositiveInfinity</c> values set.
         /// </summary>
-        /// <returns>A <see cref="PipingCalculation"/> with <c>double.NegativeInfinity</c> and <c>double.PositiveInfinity</c> values.</returns>
-        public static PipingCalculation GetPipingCalculationWithInfinities()
+        /// <returns>A <see cref="PipingCalculationScenario"/> with <c>double.NegativeInfinity</c> 
+        /// and <c>double.PositiveInfinity</c> values.</returns>
+        public static PipingCalculationScenario GetPipingCalculationScenarioWithInfinities()
         {
-            PipingCalculation calculation = GetPipingCalculationWithAssessmentLevel();
+            PipingCalculationScenario calculation = GetPipingCalculationScenarioWithAssessmentLevel();
+            calculation.Contribution = (RoundedDouble) double.PositiveInfinity;
 
             calculation.InputParameters.SurfaceLine.SetGeometry(new[]
             {