Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/DerivedPipingOutput.cs
===================================================================
diff -u
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/DerivedPipingOutput.cs	(revision 0)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/DerivedPipingOutput.cs	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -0,0 +1,231 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 Core.Common.Base.Data;
+using Ringtoets.Common.Data.Probability;
+
+namespace Ringtoets.Piping.Data
+{
+    /// <summary>
+    /// This class contains the results of a semi-probabilistic assessment of the piping
+    /// failure mechanism.
+    /// </summary>
+    public class DerivedPipingOutput
+    {
+        private double requiredProbability;
+        private double pipingProbability;
+        private double upliftProbability;
+        private double heaveProbability;
+        private double sellmeijerProbability;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="DerivedPipingOutput"/>.
+        /// </summary>
+        /// <param name="upliftFactorOfSafety">The factor of safety for the uplift sub mechanism.</param>
+        /// <param name="upliftReliability">The reliability of uplift the sub mechanism.</param>
+        /// <param name="upliftProbability">The probability of failure due to the uplift sub mechanism.</param>
+        /// <param name="heaveFactorOfSafety">The factor of safety for the heave sub mechanism.</param>
+        /// <param name="heaveReliability">The reliability of the heave sub mechanism.</param>
+        /// <param name="heaveProbability">The probability of failure due to the heave sub mechanism.</param>
+        /// <param name="sellmeijerFactorOfSafety">The factor of safety for the Sellmeijer sub mechanism.</param>
+        /// <param name="sellmeijerReliability">The reliability of the Sellmeijer sub mechanism.</param>
+        /// <param name="sellmeijerProbability">The probability of failure due to the Sellmeijer sub mechanism.</param>
+        /// <param name="requiredProbability">The required (maximum allowed) probability of failure due to piping.</param>
+        /// <param name="requiredReliability">The required (maximum allowed) reliability of the piping failure mechanism</param>
+        /// <param name="pipingProbability">The calculated probability of failing due to piping.</param>
+        /// <param name="pipingReliability">The calculated reliability of the piping failure mechanism.</param>
+        /// <param name="pipingFactorOfSafety">The factor of safety for the piping failure mechanism.</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when setting a probability that falls
+        /// outside the [0.0, 1.0] range or isn't <see cref="double.NaN"/>.</exception>
+        public DerivedPipingOutput(double upliftFactorOfSafety, double upliftReliability, double upliftProbability,
+                                             double heaveFactorOfSafety, double heaveReliability, double heaveProbability,
+                                             double sellmeijerFactorOfSafety, double sellmeijerReliability, double sellmeijerProbability,
+                                             double requiredProbability, double requiredReliability,
+                                             double pipingProbability, double pipingReliability, double pipingFactorOfSafety)
+        {
+            UpliftFactorOfSafety = new RoundedDouble(3, upliftFactorOfSafety);
+            UpliftReliability = new RoundedDouble(5, upliftReliability);
+            UpliftProbability = upliftProbability;
+            HeaveFactorOfSafety = new RoundedDouble(3, heaveFactorOfSafety);
+            HeaveReliability = new RoundedDouble(5, heaveReliability);
+            HeaveProbability = heaveProbability;
+            SellmeijerFactorOfSafety = new RoundedDouble(3, sellmeijerFactorOfSafety);
+            SellmeijerReliability = new RoundedDouble(5, sellmeijerReliability);
+            SellmeijerProbability = sellmeijerProbability;
+
+            RequiredProbability = requiredProbability;
+            RequiredReliability = new RoundedDouble(5, requiredReliability);
+            PipingProbability = pipingProbability;
+            PipingReliability = new RoundedDouble(5, pipingReliability);
+            PipingFactorOfSafety = new RoundedDouble(3, pipingFactorOfSafety);
+        }
+
+        /// <summary>
+        /// Gets the required probability of the piping failure mechanism,
+        /// which value in range [0,1].
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when setting a value that falls
+        /// outside the [0.0, 1.0] range or isn't <see cref="double.NaN"/>.</exception>
+        public double RequiredProbability
+        {
+            get
+            {
+                return requiredProbability;
+            }
+            private set
+            {
+                ProbabilityHelper.ValidateProbability(value, nameof(value), true);
+                requiredProbability = value;
+            }
+        }
+
+        /// <summary>
+        /// Get the required reliability of the piping failure mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble RequiredReliability { get; }
+
+        /// <summary>
+        /// Gets the factor of safety of the piping failure mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble PipingFactorOfSafety { get; }
+
+        /// <summary>
+        /// Gets the reliability of the piping failure mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble PipingReliability { get; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the piping failure mechanism,
+        /// which value in range [0,1].
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when setting a value that falls
+        /// outside the [0.0, 1.0] range or isn't <see cref="double.NaN"/>.</exception>
+        public double PipingProbability
+        {
+            get
+            {
+                return pipingProbability;
+            }
+            private set
+            {
+                ProbabilityHelper.ValidateProbability(value, nameof(value), true);
+                pipingProbability = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the factor of safety for the uplift sub mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble UpliftFactorOfSafety { get; }
+
+        /// <summary>
+        /// Gets the reliability for the uplift sub mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble UpliftReliability { get; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the uplift failure sub mechanism,
+        /// which value in range [0,1].
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when setting a value that falls
+        /// outside the [0.0, 1.0] range or isn't <see cref="double.NaN"/>.</exception>
+        public double UpliftProbability
+        {
+            get
+            {
+                return upliftProbability;
+            }
+            private set
+            {
+                ProbabilityHelper.ValidateProbability(value, nameof(value), true);
+                upliftProbability = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the factor of safety for the heave sub mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble HeaveFactorOfSafety { get; }
+
+        /// <summary>
+        /// Gets the reliability for the heave sub mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble HeaveReliability { get; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the heave failure sub mechanism,
+        /// which value in range [0,1].
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when setting a value that falls
+        /// outside the [0.0, 1.0] range or isn't <see cref="double.NaN"/>.</exception>
+        public double HeaveProbability
+        {
+            get
+            {
+                return heaveProbability;
+            }
+            private set
+            {
+                ProbabilityHelper.ValidateProbability(value, nameof(value), true);
+                heaveProbability = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the factor of safety for the Sellmeijer sub mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble SellmeijerFactorOfSafety { get; }
+
+        /// <summary>
+        /// Gets the reliability for the Sellmeijer sub mechanism,
+        /// which is a value greater than 0.
+        /// </summary>
+        public RoundedDouble SellmeijerReliability { get; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the Sellmeijer failure sub mechanism,
+        /// which value in range [0,1].
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when setting a value that falls
+        /// outside the [0.0, 1.0] range or isn't <see cref="double.NaN"/>.</exception>
+        public double SellmeijerProbability
+        {
+            get
+            {
+                return sellmeijerProbability;
+            }
+            private set
+            {
+                ProbabilityHelper.ValidateProbability(value, nameof(value), true);
+                sellmeijerProbability = value;
+            }
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 642a4946d235601302d544697856fed3b5c7a2bd refers to a dead (removed) revision in file `Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticOutput.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj
===================================================================
diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj	(.../Ringtoets.Piping.Data.csproj)	(revision 63fc151e9cf722527465c1eddfa6567a90feb5e6)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj	(.../Ringtoets.Piping.Data.csproj)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -22,7 +22,7 @@
     <Compile Include="PipingInput.cs" />
     <Compile Include="PipingOutput.cs" />
     <Compile Include="PipingSemiProbabilisticDesignVariableFactory.cs" />
-    <Compile Include="PipingSemiProbabilisticOutput.cs" />
+    <Compile Include="DerivedPipingOutput.cs" />
     <Compile Include="PipingSoilProfileExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/PresentationObjects/PipingOutputContext.cs
===================================================================
diff -u -rdb77ae03f93f27b25268dd9f62f0091a47fe22d8 -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/PresentationObjects/PipingOutputContext.cs	(.../PipingOutputContext.cs)	(revision db77ae03f93f27b25268dd9f62f0091a47fe22d8)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/PresentationObjects/PipingOutputContext.cs	(.../PipingOutputContext.cs)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -26,29 +26,30 @@
 namespace Ringtoets.Piping.Forms.PresentationObjects
 {
     /// <summary>
-    /// A presentation layer object which wraps a <see cref="PipingOutput"/> and a <see cref="PipingSemiProbabilisticOutput"/>.
+    /// A presentation layer object which wraps a <see cref="PipingOutput"/> and a <see cref="Data.DerivedPipingOutput"/>.
     /// </summary>
     public class PipingOutputContext : WrappedObjectContextBase<PipingOutput>
     {
         /// <summary>
         /// Creates a new instance of <see cref="PipingOutputContext"/>.
         /// </summary>
         /// <param name="pipingOutput">The <see cref="PipingOutput"/> object to wrap.</param>
-        /// <param name="semiProbabilisticOutput">The <see cref="PipingSemiProbabilisticOutput"/>
+        /// <param name="derivedOutput">The <see cref="DerivedPipingOutput"/>
         /// created from <paramref name="pipingOutput"/>.</param>
-        public PipingOutputContext(PipingOutput pipingOutput, PipingSemiProbabilisticOutput semiProbabilisticOutput)
+        public PipingOutputContext(PipingOutput pipingOutput, DerivedPipingOutput derivedOutput)
             : base(pipingOutput)
         {
-            if (semiProbabilisticOutput == null)
+            if (derivedOutput == null)
             {
-                throw new ArgumentNullException(nameof(semiProbabilisticOutput));
+                throw new ArgumentNullException(nameof(derivedOutput));
             }
-            SemiProbabilisticOutput = semiProbabilisticOutput;
+
+            DerivedOutput = derivedOutput;
         }
 
         /// <summary>
-        /// Gets the semi-probabilistic output created from the piping output.
+        /// Gets the derived output created from the piping output.
         /// </summary>
-        public PipingSemiProbabilisticOutput SemiProbabilisticOutput { get; }
+        public DerivedPipingOutput DerivedOutput { get; }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingOutputProperties.cs
===================================================================
diff -u -r1b6400211b923fc8d0c5ee4d692d71b468890f5e -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingOutputProperties.cs	(.../PipingOutputProperties.cs)	(revision 1b6400211b923fc8d0c5ee4d692d71b468890f5e)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingOutputProperties.cs	(.../PipingOutputProperties.cs)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -35,30 +35,29 @@
     /// </summary>
     public class PipingOutputProperties : ObjectProperties<PipingOutput>
     {
-        private readonly PipingSemiProbabilisticOutput semiProbabilisticOutput;
+        private readonly DerivedPipingOutput derivedOutput;
 
         /// <summary>
         /// Creates a new instance of <see cref="PipingOutputProperties"/>.
         /// </summary>
         /// <param name="output">The output to show the properties for.</param>
-        /// <param name="semiProbabilisticOutput">The semi probabilistic output to
-        /// show properties for.</param>
+        /// <param name="derivedOutput">The derived output to show properties for.</param>
         /// <exception cref="ArgumentNullException">Thrown when any parameter
         /// is <c>null</c>.</exception>
-        public PipingOutputProperties(PipingOutput output, PipingSemiProbabilisticOutput semiProbabilisticOutput)
+        public PipingOutputProperties(PipingOutput output, DerivedPipingOutput derivedOutput)
         {
-            if (output == null)
+            if (derivedOutput == null)
             {
-                throw new ArgumentNullException(nameof(output));
+                throw new ArgumentNullException(nameof(derivedOutput));
             }
 
-            if (semiProbabilisticOutput == null)
+            if (derivedOutput == null)
             {
-                throw new ArgumentNullException(nameof(semiProbabilisticOutput));
+                throw new ArgumentNullException(nameof(derivedOutput));
             }
 
             Data = output;
-            this.semiProbabilisticOutput = semiProbabilisticOutput;
+            this.derivedOutput = derivedOutput;
         }
 
         [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Uplift), 1, 4)]
@@ -81,7 +80,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.UpliftFactorOfSafety;
+                return derivedOutput.UpliftFactorOfSafety;
             }
         }
 
@@ -93,7 +92,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.UpliftReliability;
+                return derivedOutput.UpliftReliability;
             }
         }
 
@@ -105,7 +104,7 @@
         {
             get
             {
-                return ProbabilityFormattingHelper.Format(semiProbabilisticOutput.UpliftProbability);
+                return ProbabilityFormattingHelper.Format(derivedOutput.UpliftProbability);
             }
         }
 
@@ -129,7 +128,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.HeaveFactorOfSafety;
+                return derivedOutput.HeaveFactorOfSafety;
             }
         }
 
@@ -141,7 +140,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.HeaveReliability;
+                return derivedOutput.HeaveReliability;
             }
         }
 
@@ -153,7 +152,7 @@
         {
             get
             {
-                return ProbabilityFormattingHelper.Format(semiProbabilisticOutput.HeaveProbability);
+                return ProbabilityFormattingHelper.Format(derivedOutput.HeaveProbability);
             }
         }
 
@@ -201,7 +200,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.SellmeijerFactorOfSafety;
+                return derivedOutput.SellmeijerFactorOfSafety;
             }
         }
 
@@ -213,7 +212,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.SellmeijerReliability;
+                return derivedOutput.SellmeijerReliability;
             }
         }
 
@@ -225,7 +224,7 @@
         {
             get
             {
-                return ProbabilityFormattingHelper.Format(semiProbabilisticOutput.SellmeijerProbability);
+                return ProbabilityFormattingHelper.Format(derivedOutput.SellmeijerProbability);
             }
         }
 
@@ -237,7 +236,7 @@
         {
             get
             {
-                return ProbabilityFormattingHelper.Format(semiProbabilisticOutput.RequiredProbability);
+                return ProbabilityFormattingHelper.Format(derivedOutput.RequiredProbability);
             }
         }
 
@@ -249,7 +248,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.RequiredReliability;
+                return derivedOutput.RequiredReliability;
             }
         }
 
@@ -261,7 +260,7 @@
         {
             get
             {
-                return ProbabilityFormattingHelper.Format(semiProbabilisticOutput.PipingProbability);
+                return ProbabilityFormattingHelper.Format(derivedOutput.PipingProbability);
             }
         }
 
@@ -273,7 +272,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.PipingReliability;
+                return derivedOutput.PipingReliability;
             }
         }
 
@@ -285,7 +284,7 @@
         {
             get
             {
-                return semiProbabilisticOutput.PipingFactorOfSafety;
+                return derivedOutput.PipingFactorOfSafety;
             }
         }
     }
Index: Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingPlugin.cs
===================================================================
diff -u -raf990fe02513d7cd12034e597037025ecf5aa948 -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingPlugin.cs	(.../PipingPlugin.cs)	(revision af990fe02513d7cd12034e597037025ecf5aa948)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingPlugin.cs	(.../PipingPlugin.cs)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -78,7 +78,7 @@
             };
             yield return new PropertyInfo<PipingOutputContext, PipingOutputProperties>
             {
-                CreateInstance = context => new PipingOutputProperties(context.WrappedData, context.SemiProbabilisticOutput)
+                CreateInstance = context => new PipingOutputProperties(context.WrappedData, context.DerivedOutput)
             };
             yield return new PropertyInfo<PipingSurfaceLinesContext, PipingSurfaceLineCollectionProperties>
             {
Index: Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs
===================================================================
diff -u -rac96d7c315129af851634ed5a4a6800b59ede718 -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs	(.../PipingSemiProbabilisticCalculationService.cs)	(revision ac96d7c315129af851634ed5a4a6800b59ede718)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs	(.../PipingSemiProbabilisticCalculationService.cs)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -125,7 +125,7 @@
 
             calculator.Calculate();
 
-            calculation.SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(
+            calculation.SemiProbabilisticOutput = new DerivedPipingOutput(
                 calculator.upliftFactorOfSafety,
                 calculator.upliftReliability,
                 calculator.upliftProbability,
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingOutputTest.cs
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingOutputTest.cs	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingOutputTest.cs	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -0,0 +1,555 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.Common.Data.TestUtil;
+
+namespace Ringtoets.Piping.Data.Test
+{
+    [TestFixture]
+    public class DerivedPipingOutputTest
+    {
+        [Test]
+        public void Constructor_DefaultPropertiesSet()
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            var output = new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            Assert.AreEqual(3, output.HeaveFactorOfSafety.NumberOfDecimalPlaces);
+            Assert.AreEqual(upliftFactorOfSafety, output.UpliftFactorOfSafety, output.UpliftFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(5, output.UpliftReliability.NumberOfDecimalPlaces);
+            Assert.AreEqual(upliftReliability, output.UpliftReliability, output.UpliftReliability.GetAccuracy());
+            Assert.AreEqual(upliftProbability, output.UpliftProbability);
+            Assert.AreEqual(3, output.HeaveFactorOfSafety.NumberOfDecimalPlaces);
+            Assert.AreEqual(heaveFactorOfSafety, output.HeaveFactorOfSafety, output.HeaveFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(5, output.HeaveReliability.NumberOfDecimalPlaces);
+            Assert.AreEqual(heaveReliability, output.HeaveReliability, output.HeaveReliability.GetAccuracy());
+            Assert.AreEqual(heaveProbability, output.HeaveProbability);
+            Assert.AreEqual(3, output.SellmeijerFactorOfSafety.NumberOfDecimalPlaces);
+            Assert.AreEqual(sellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(5, output.SellmeijerReliability.NumberOfDecimalPlaces);
+            Assert.AreEqual(sellmeijerReliability, output.SellmeijerReliability, output.SellmeijerReliability.GetAccuracy());
+            Assert.AreEqual(sellmeijerProbability, output.SellmeijerProbability);
+            Assert.AreEqual(requiredProbability, output.RequiredProbability);
+            Assert.AreEqual(5, output.RequiredReliability.NumberOfDecimalPlaces);
+            Assert.AreEqual(requiredReliability, output.RequiredReliability, output.RequiredReliability.GetAccuracy());
+            Assert.AreEqual(pipingProbability, output.PipingProbability);
+            Assert.AreEqual(5, output.PipingReliability.NumberOfDecimalPlaces);
+            Assert.AreEqual(pipingReliability, output.PipingReliability, output.PipingReliability.GetAccuracy());
+            Assert.AreEqual(3, output.PipingFactorOfSafety.NumberOfDecimalPlaces);
+            Assert.AreEqual(pipingFactorOfSafety, output.PipingFactorOfSafety, output.PipingFactorOfSafety.GetAccuracy());
+        }
+
+        [Test]
+        [TestCase(double.NaN)]
+        [TestCase(0.0)]
+        [TestCase(0.123456789)]
+        [TestCase(1.0)]
+        public void RequiredProbability_SetValidValues_ReturnNewlySetValue(double requiredProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            var output = new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            Assert.AreEqual(requiredProbability, output.RequiredProbability);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(double.PositiveInfinity)]
+        [TestCase(double.NegativeInfinity)]
+        [TestCase(0.0 - 1e-6)]
+        [TestCase(-346587.456)]
+        [TestCase(1.0 + 1e-6)]
+        [TestCase(346587.456)]
+        public void RequiredProbability_SetInvalidValues_ThrowArgumentOutOfRangeException(double requiredProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            TestDelegate call = () => new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            const string expectedMessage = "Kans moet in het bereik [0,0, 1,0] liggen.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(double.NaN)]
+        [TestCase(0.0)]
+        [TestCase(0.123456789)]
+        [TestCase(1.0)]
+        public void SellmeijerProbability_SetValidValues_ReturnNewlySetValue(double sellmeijerProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            var output = new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            Assert.AreEqual(sellmeijerProbability, output.SellmeijerProbability);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(double.PositiveInfinity)]
+        [TestCase(double.NegativeInfinity)]
+        [TestCase(0.0 - 1e-6)]
+        [TestCase(-346587.456)]
+        [TestCase(1.0 + 1e-6)]
+        [TestCase(346587.456)]
+        public void SellmeijerProbability_SetInvalidValues_ThrowArgumentOutOfRangeException(double sellmeijerProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            TestDelegate call = () => new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            const string expectedMessage = "Kans moet in het bereik [0,0, 1,0] liggen.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(double.NaN)]
+        [TestCase(0.0)]
+        [TestCase(0.123456789)]
+        [TestCase(1.0)]
+        public void HeaveProbability_SetValidValues_ReturnNewlySetValue(double heaveProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            var output = new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            Assert.AreEqual(heaveProbability, output.HeaveProbability);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(double.PositiveInfinity)]
+        [TestCase(double.NegativeInfinity)]
+        [TestCase(0.0 - 1e-2)]
+        [TestCase(-346587.456)]
+        [TestCase(1.0 + 1e-2)]
+        [TestCase(346587.456)]
+        public void HeaveProbability_SetInvalidValues_ThrowArgumentOutOfRangeException(double heaveProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            TestDelegate call = () => new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            const string expectedMessage = "Kans moet in het bereik [0,0, 1,0] liggen.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(double.NaN)]
+        [TestCase(0.0)]
+        [TestCase(0.123456789)]
+        [TestCase(1.0)]
+        public void UpliftProbability_SetValidValues_ReturnNewlySetValue(double upliftProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            var output = new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            Assert.AreEqual(upliftProbability, output.UpliftProbability);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(double.PositiveInfinity)]
+        [TestCase(double.NegativeInfinity)]
+        [TestCase(0.0 - 1e-6)]
+        [TestCase(-346587.456)]
+        [TestCase(1.0 + 1e-6)]
+        [TestCase(346587.456)]
+        public void UpliftProbability_SetInvalidValues_ThrowArgumentOutOfRangeException(double upliftProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            TestDelegate call = () => new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            const string expectedMessage = "Kans moet in het bereik [0,0, 1,0] liggen.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(double.NaN)]
+        [TestCase(0.0)]
+        [TestCase(0.123456789)]
+        [TestCase(1.0)]
+        public void PipingProbability_SetValidValues_ReturnNewlySetValue(double pipingProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            var output = new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            Assert.AreEqual(pipingProbability, output.PipingProbability);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(double.PositiveInfinity)]
+        [TestCase(double.NegativeInfinity)]
+        [TestCase(0.0 - 1e-2)]
+        [TestCase(-346587.456)]
+        [TestCase(1.0 + 1e-2)]
+        [TestCase(346587.456)]
+        public void PipingProbability_SetInvalidValues_ThrowArgumentOutOfRangeException(double pipingProbability)
+        {
+            // Setup
+            var random = new Random(21);
+            double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
+            double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
+            double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
+            double pipingFactorOfSafety = random.NextDouble();
+
+            // Call
+            TestDelegate call = () => new DerivedPipingOutput(
+                upliftFactorOfSafety,
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety,
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety,
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
+
+            // Assert
+            const string expectedMessage = "Kans moet in het bereik [0,0, 1,0] liggen.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, expectedMessage);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationScenarioTest.cs
===================================================================
diff -u -rdb77ae03f93f27b25268dd9f62f0091a47fe22d8 -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationScenarioTest.cs	(.../PipingCalculationScenarioTest.cs)	(revision db77ae03f93f27b25268dd9f62f0091a47fe22d8)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationScenarioTest.cs	(.../PipingCalculationScenarioTest.cs)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -90,7 +90,7 @@
             var scenario = new PipingCalculationScenario(new GeneralPipingInput())
             {
                 Output = new TestPipingOutput(),
-                SemiProbabilisticOutput = new TestPipingSemiProbabilisticOutput(expectedProbability)
+                SemiProbabilisticOutput = new TestDerivedPipingOutput(expectedProbability)
             };
 
             // Call
@@ -153,7 +153,7 @@
             var scenario = new PipingCalculationScenario(new GeneralPipingInput())
             {
                 Output = new TestPipingOutput(),
-                SemiProbabilisticOutput = new TestPipingSemiProbabilisticOutput(double.NaN)
+                SemiProbabilisticOutput = new TestDerivedPipingOutput(double.NaN)
             };
 
             // Call
@@ -172,7 +172,7 @@
             var scenario = new PipingCalculationScenario(new GeneralPipingInput())
             {
                 Output = new TestPipingOutput(),
-                SemiProbabilisticOutput = new TestPipingSemiProbabilisticOutput(expectedProbability)
+                SemiProbabilisticOutput = new TestDerivedPipingOutput(expectedProbability)
             };
 
             // Call
Fisheye: Tag 642a4946d235601302d544697856fed3b5c7a2bd refers to a dead (removed) revision in file `Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj
===================================================================
diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj	(.../Ringtoets.Piping.Data.Test.csproj)	(revision 63fc151e9cf722527465c1eddfa6567a90feb5e6)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj	(.../Ringtoets.Piping.Data.Test.csproj)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -31,7 +31,7 @@
     <Compile Include="PipingInputTest.cs" />
     <Compile Include="PipingOutputTest.cs" />
     <Compile Include="PipingSemiProbabilisticDesignVariableFactoryTest.cs" />
-    <Compile Include="PipingSemiProbabilisticOutputTest.cs" />
+    <Compile Include="DerivedPipingOutputTest.cs" />
     <Compile Include="PipingSoilProfileExtensionsTest.cs" />
     <Compile Include="PipingSurfaceLineCollectionTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationScenarioFactory.cs
===================================================================
diff -u -r2076a0044928407b9710d7652bd4bc9ea0d69ef0 -r642a4946d235601302d544697856fed3b5c7a2bd
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationScenarioFactory.cs	(.../PipingCalculationScenarioFactory.cs)	(revision 2076a0044928407b9710d7652bd4bc9ea0d69ef0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationScenarioFactory.cs	(.../PipingCalculationScenarioFactory.cs)	(revision 642a4946d235601302d544697856fed3b5c7a2bd)
@@ -41,14 +41,14 @@
         /// <summary>
         /// Creates a calculated scenario for which the surface line on the input intersects with <paramref name="section"/>.
         /// </summary>
-        /// <param name="probability">The value for <see cref="PipingSemiProbabilisticOutput.PipingProbability"/>.</param>
+        /// <param name="probability">The value for <see cref="DerivedPipingOutput.PipingProbability"/>.</param>
         /// <param name="section">The section for which an intersection will be created.</param>
         /// <returns>A new <see cref="PipingCalculationScenario"/>.</returns>
         public static PipingCalculationScenario CreatePipingCalculationScenario(double probability, FailureMechanismSection section)
         {
             PipingCalculationScenario scenario = CreateNotCalculatedPipingCalculationScenario(section);
             var random = new Random(21);
-            scenario.SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(
+            scenario.SemiProbabilisticOutput = new DerivedPipingOutput(
                 random.NextDouble(),
                 random.NextDouble(),
                 random.NextDouble(),