Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingInputTest.cs
===================================================================
diff -u -r420c266df87245b9471d3794ef5043ee89cb482a -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingInputTest.cs	(.../DerivedPipingInputTest.cs)	(revision 420c266df87245b9471d3794ef5043ee89cb482a)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingInputTest.cs	(.../DerivedPipingInputTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -25,7 +25,6 @@
 using NUnit.Framework;
 using Ringtoets.HydraRing.Data;
 using Ringtoets.Piping.Data.Probabilistics;
-using Ringtoets.Piping.Data.Properties;
 using Ringtoets.Piping.Data.TestUtil;
 using Ringtoets.Piping.KernelWrapper.SubCalculator;
 using Ringtoets.Piping.KernelWrapper.TestUtil;
@@ -132,11 +131,11 @@
                 var factory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
                 var piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator;
 
-                Assert.AreEqual(piezometricHeadAtExitCalculator.HRiver, derivedInput.AssessmentLevel.Value, PipingCalculationFactory.GetAccuracy(derivedInput.AssessmentLevel));
+                Assert.AreEqual(piezometricHeadAtExitCalculator.HRiver, derivedInput.AssessmentLevel, derivedInput.AssessmentLevel.GetAccuracy());
                 Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder,
-                                PipingCalculationFactory.GetAccuracy(input.PhreaticLevelExit.Mean));
+                                input.PhreaticLevelExit.GetAccuracy());
                 Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit,
-                                PipingCalculationFactory.GetAccuracy(input.DampingFactorExit.Mean));
+                                input.DampingFactorExit.GetAccuracy());
             }
         }
 
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingInputTest.cs
===================================================================
diff -u -r420c266df87245b9471d3794ef5043ee89cb482a -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingInputTest.cs	(.../PipingInputTest.cs)	(revision 420c266df87245b9471d3794ef5043ee89cb482a)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingInputTest.cs	(.../PipingInputTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -385,11 +385,11 @@
                 var factory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
                 var piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator;
 
-                Assert.AreEqual(piezometricHeadAtExitCalculator.HRiver, input.AssessmentLevel.Value, PipingCalculationFactory.GetAccuracy(input.AssessmentLevel));
+                Assert.AreEqual(piezometricHeadAtExitCalculator.HRiver, input.AssessmentLevel, input.AssessmentLevel.GetAccuracy());
                 Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder,
-                                PipingCalculationFactory.GetAccuracy(input.PhreaticLevelExit.Mean));
+                                input.PhreaticLevelExit.GetAccuracy());
                 Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit,
-                                PipingCalculationFactory.GetAccuracy(input.DampingFactorExit.Mean));
+                                input.DampingFactorExit.GetAccuracy());
             }
         }
 
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs
===================================================================
diff -u -rcfefec5a1180c70370d17ae82a7629e0d2ac24b7 -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs	(.../PipingSemiProbabilisticOutputTest.cs)	(revision cfefec5a1180c70370d17ae82a7629e0d2ac24b7)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs	(.../PipingSemiProbabilisticOutputTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -1,7 +1,8 @@
 using System;
-using Core.Common.Base.Data;
 using NUnit.Framework;
 
+using Ringtoets.Piping.Data.TestUtil;
+
 namespace Ringtoets.Piping.Data.Test
 {
     public class PipingSemiProbabilisticOutputTest
@@ -44,26 +45,20 @@
                 pipingFactorOfSafety);
 
             // Assert
-            Assert.AreEqual(upliftFactorOfSafety, output.UpliftFactorOfSafety, GetAccuracy(output.UpliftFactorOfSafety));
-            Assert.AreEqual(upliftReliability, output.UpliftReliability, GetAccuracy(output.UpliftReliability));
-            Assert.AreEqual(upliftProbability, output.UpliftProbability, GetAccuracy(output.UpliftProbability));
-            Assert.AreEqual(heaveFactorOfSafety, output.HeaveFactorOfSafety, GetAccuracy(output.HeaveFactorOfSafety));
-            Assert.AreEqual(heaveReliability, output.HeaveReliability, GetAccuracy(output.HeaveReliability));
-            Assert.AreEqual(heaveProbability, output.HeaveProbability, GetAccuracy(output.HeaveProbability));
-            Assert.AreEqual(sellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety, GetAccuracy(output.SellmeijerFactorOfSafety));
-            Assert.AreEqual(sellmeijerReliability, output.SellmeijerReliability, GetAccuracy(output.SellmeijerReliability));
-            Assert.AreEqual(sellmeijerProbability, output.SellmeijerProbability, GetAccuracy(output.SellmeijerProbability));
-            Assert.AreEqual(requiredProbability, output.RequiredProbability, GetAccuracy(output.RequiredProbability));
-            Assert.AreEqual(requiredReliability, output.RequiredReliability, GetAccuracy(output.RequiredReliability));
-            Assert.AreEqual(pipingProbability, output.PipingProbability, GetAccuracy(output.PipingProbability));
-            Assert.AreEqual(pipingReliability, output.PipingReliability, GetAccuracy(output.PipingReliability));
-            Assert.AreEqual(pipingFactorOfSafety, output.PipingFactorOfSafety, GetAccuracy(output.PipingFactorOfSafety));
+            Assert.AreEqual(upliftFactorOfSafety, output.UpliftFactorOfSafety, output.UpliftFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(upliftReliability, output.UpliftReliability, output.UpliftReliability.GetAccuracy());
+            Assert.AreEqual(upliftProbability, output.UpliftProbability, output.UpliftProbability.GetAccuracy());
+            Assert.AreEqual(heaveFactorOfSafety, output.HeaveFactorOfSafety, output.HeaveFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(heaveReliability, output.HeaveReliability, output.HeaveReliability.GetAccuracy());
+            Assert.AreEqual(heaveProbability, output.HeaveProbability, output.HeaveProbability.GetAccuracy());
+            Assert.AreEqual(sellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(sellmeijerReliability, output.SellmeijerReliability, output.SellmeijerReliability.GetAccuracy());
+            Assert.AreEqual(sellmeijerProbability, output.SellmeijerProbability, output.SellmeijerProbability.GetAccuracy());
+            Assert.AreEqual(requiredProbability, output.RequiredProbability, output.RequiredProbability.GetAccuracy());
+            Assert.AreEqual(requiredReliability, output.RequiredReliability, output.RequiredReliability.GetAccuracy());
+            Assert.AreEqual(pipingProbability, output.PipingProbability, output.PipingProbability.GetAccuracy());
+            Assert.AreEqual(pipingReliability, output.PipingReliability, output.PipingReliability.GetAccuracy());
+            Assert.AreEqual(pipingFactorOfSafety, output.PipingFactorOfSafety, output.PipingFactorOfSafety.GetAccuracy());
         }
-
-
-        private static double GetAccuracy(RoundedDouble d)
-        {
-            return Math.Pow(10.0, -d.NumberOfDecimalPlaces);
-        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/LimitedPrecisionHelper.cs
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/LimitedPrecisionHelper.cs	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/LimitedPrecisionHelper.cs	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -0,0 +1,31 @@
+using System;
+
+using Core.Common.Base.Data;
+
+using Ringtoets.Piping.Data.Probabilistics;
+
+namespace Ringtoets.Piping.Data.TestUtil
+{
+    /// <summary>
+    /// Helper class for dealing with classes that have inherently limited precision.
+    /// </summary>
+    public static class LimitedPrecisionHelper
+    {
+        /// <summary>
+        /// Gets the accuracy for a <see cref="RoundedDouble"/>.
+        /// </summary>
+        public static double GetAccuracy(this RoundedDouble roundedDouble)
+        {
+            return Math.Pow(10.0, -roundedDouble.NumberOfDecimalPlaces);
+        }
+
+        /// <summary>
+        /// Gets the accuracy for a <see cref="IDistribution"/>.
+        /// </summary>
+        /// <remarks>Assumes that all the parameters of the distributions share the same accuracy.</remarks>
+        public static double GetAccuracy(this IDistribution distribution)
+        {
+            return distribution.Mean.GetAccuracy();
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationFactory.cs
===================================================================
diff -u -r420c266df87245b9471d3794ef5043ee89cb482a -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationFactory.cs	(.../PipingCalculationFactory.cs)	(revision 420c266df87245b9471d3794ef5043ee89cb482a)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/PipingCalculationFactory.cs	(.../PipingCalculationFactory.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -186,10 +186,5 @@
             expectedThickness = 2.2;
             return input;
         }
-
-        public static double GetAccuracy(RoundedDouble roundedDouble)
-        {
-            return Math.Pow(10.0, -roundedDouble.NumberOfDecimalPlaces);
-        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/Ringtoets.Piping.Data.TestUtil.csproj
===================================================================
diff -u -r10779bb6a6db2d00f4627b2bc190e7e35e1fee3e -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/Ringtoets.Piping.Data.TestUtil.csproj	(.../Ringtoets.Piping.Data.TestUtil.csproj)	(revision 10779bb6a6db2d00f4627b2bc190e7e35e1fee3e)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.TestUtil/Ringtoets.Piping.Data.TestUtil.csproj	(.../Ringtoets.Piping.Data.TestUtil.csproj)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -44,6 +44,7 @@
     <Reference Include="System.Core" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="LimitedPrecisionHelper.cs" />
     <Compile Include="PipingCalculationFactory.cs" />
     <Compile Include="Segment2DLoopCollectionHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingInputContextPropertiesTest.cs
===================================================================
diff -u -rba840423eb72501cbad89c1a6d88642531efa8d5 -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingInputContextPropertiesTest.cs	(.../PipingInputContextPropertiesTest.cs)	(revision ba840423eb72501cbad89c1a6d88642531efa8d5)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingInputContextPropertiesTest.cs	(.../PipingInputContextPropertiesTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -11,6 +11,7 @@
 using Ringtoets.HydraRing.Data;
 using Ringtoets.Piping.Data;
 using Ringtoets.Piping.Data.Probabilistics;
+using Ringtoets.Piping.Data.TestUtil;
 using Ringtoets.Piping.Forms.PresentationObjects;
 using Ringtoets.Piping.Forms.PropertyClasses;
 using Ringtoets.Piping.Forms.TypeConverters;
@@ -170,34 +171,34 @@
             };
 
             // Assert
-            Assert.AreEqual(assessmentLevel, inputParameters.AssessmentLevel, GetAccuracy(inputParameters.AssessmentLevel));
+            Assert.AreEqual(assessmentLevel, inputParameters.AssessmentLevel, inputParameters.AssessmentLevel.GetAccuracy());
 
-            Assert.AreEqual(dampingFactorExit.Mean.Value, inputParameters.DampingFactorExit.Mean.Value,
-                            GetAccuracy(inputParameters.DampingFactorExit));
-            Assert.AreEqual(dampingFactorExit.StandardDeviation.Value, inputParameters.DampingFactorExit.StandardDeviation.Value,
-                            GetAccuracy(inputParameters.DampingFactorExit));
+            Assert.AreEqual(dampingFactorExit.Mean, inputParameters.DampingFactorExit.Mean,
+                            inputParameters.DampingFactorExit.GetAccuracy());
+            Assert.AreEqual(dampingFactorExit.StandardDeviation, inputParameters.DampingFactorExit.StandardDeviation,
+                            inputParameters.DampingFactorExit.GetAccuracy());
 
             Assert.AreEqual(phreaticLevelExit.Mean, inputParameters.PhreaticLevelExit.Mean,
-                            GetAccuracy(inputParameters.PhreaticLevelExit));
+                            inputParameters.PhreaticLevelExit.GetAccuracy());
             Assert.AreEqual(phreaticLevelExit.StandardDeviation, inputParameters.PhreaticLevelExit.StandardDeviation,
-                            GetAccuracy(inputParameters.PhreaticLevelExit));
+                            inputParameters.PhreaticLevelExit.GetAccuracy());
 
             Assert.AreEqual(diameter70.Mean, inputParameters.Diameter70.Mean,
-                            GetAccuracy(inputParameters.Diameter70));
+                            inputParameters.Diameter70.GetAccuracy());
             Assert.AreEqual(diameter70.StandardDeviation, inputParameters.Diameter70.StandardDeviation,
-                            GetAccuracy(inputParameters.Diameter70));
+                            inputParameters.Diameter70.GetAccuracy());
 
             Assert.AreEqual(darcyPermeability.Mean, inputParameters.DarcyPermeability.Mean,
-                            GetAccuracy(inputParameters.DarcyPermeability));
+                            inputParameters.DarcyPermeability.GetAccuracy());
             Assert.AreEqual(darcyPermeability.StandardDeviation, inputParameters.DarcyPermeability.StandardDeviation,
-                            GetAccuracy(inputParameters.DarcyPermeability));
+                            inputParameters.DarcyPermeability.GetAccuracy());
 
             Assert.AreEqual(saturatedVolumicWeightOfCoverageLoayer.Mean, inputParameters.SaturatedVolumicWeightOfCoverageLayer.Mean,
-                            GetAccuracy(inputParameters.SaturatedVolumicWeightOfCoverageLayer));
+                            inputParameters.SaturatedVolumicWeightOfCoverageLayer.GetAccuracy());
             Assert.AreEqual(saturatedVolumicWeightOfCoverageLoayer.StandardDeviation, inputParameters.SaturatedVolumicWeightOfCoverageLayer.StandardDeviation,
-                            GetAccuracy(inputParameters.SaturatedVolumicWeightOfCoverageLayer));
+                            inputParameters.SaturatedVolumicWeightOfCoverageLayer.GetAccuracy());
             Assert.AreEqual(saturatedVolumicWeightOfCoverageLoayer.Shift, inputParameters.SaturatedVolumicWeightOfCoverageLayer.Shift,
-                            GetAccuracy(inputParameters.SaturatedVolumicWeightOfCoverageLayer));
+                            inputParameters.SaturatedVolumicWeightOfCoverageLayer.GetAccuracy());
 
             Assert.AreEqual(surfaceLine, inputParameters.SurfaceLine);
             Assert.AreEqual(soilProfile, inputParameters.SoilProfile);
@@ -428,7 +429,7 @@
             properties.HydraulicBoundaryLocation = hydraulicBoundaryLocation;
 
             // Assert
-            Assert.AreEqual(testLevel, properties.AssessmentLevel.Value, 1e-2);
+            Assert.AreEqual(testLevel, properties.AssessmentLevel, 1e-2);
 
             mocks.VerifyAll();
         }
@@ -473,16 +474,6 @@
             mocks.VerifyAll();
         }
 
-        private double GetAccuracy(RoundedDouble roundedDouble)
-        {
-            return Math.Pow(10.0, -roundedDouble.NumberOfDecimalPlaces);
-        }
-
-        private double GetAccuracy(IDistribution distribution)
-        {
-            return Math.Pow(10.0, -distribution.Mean.NumberOfDecimalPlaces);
-        }
-
         private static RingtoetsPipingSurfaceLine ValidSurfaceLine(double xMin, double xMax)
         {
             var surfaceLine = new RingtoetsPipingSurfaceLine();
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs
===================================================================
diff -u -rcfefec5a1180c70370d17ae82a7629e0d2ac24b7 -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs	(.../PipingSemiProbabilisticOutputPropertiesTest.cs)	(revision cfefec5a1180c70370d17ae82a7629e0d2ac24b7)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs	(.../PipingSemiProbabilisticOutputPropertiesTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -1,8 +1,8 @@
 using System;
-using Core.Common.Base.Data;
 using Core.Common.Gui.PropertyBag;
 using NUnit.Framework;
 using Ringtoets.Piping.Data;
+using Ringtoets.Piping.Data.TestUtil;
 using Ringtoets.Piping.Forms.PropertyClasses;
 
 namespace Ringtoets.Piping.Forms.Test.PropertyClasses
@@ -64,26 +64,20 @@
             };
 
             // Call & Assert
-            Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety, GetAccuracy(properties.UpliftFactorOfSafety));
-            Assert.AreEqual(upliftReliability, properties.UpliftReliability, GetAccuracy(properties.UpliftReliability));
-            Assert.AreEqual(upliftProbability, properties.UpliftProbability, GetAccuracy(properties.UpliftProbability));
-            Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety, GetAccuracy(properties.HeaveFactorOfSafety));
-            Assert.AreEqual(heaveReliability, properties.HeaveReliability, GetAccuracy(properties.HeaveReliability));
-            Assert.AreEqual(heaveProbability, properties.HeaveProbability, GetAccuracy(properties.HeaveProbability));
-            Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety, GetAccuracy(properties.SellmeijerFactorOfSafety));
-            Assert.AreEqual(sellmeijerReliability, properties.SellmeijerReliability, GetAccuracy(properties.SellmeijerReliability));
-            Assert.AreEqual(sellmeijerProbability, properties.SellmeijerProbability, GetAccuracy(properties.SellmeijerProbability));
-            Assert.AreEqual(requiredProbability, properties.RequiredProbability, GetAccuracy(properties.RequiredProbability));
-            Assert.AreEqual(requiredReliability, properties.RequiredReliability, GetAccuracy(properties.RequiredReliability));
-            Assert.AreEqual(pipingProbability, properties.PipingProbability, GetAccuracy(properties.PipingProbability));
-            Assert.AreEqual(pipingReliability, properties.PipingReliability, GetAccuracy(properties.PipingReliability));
-            Assert.AreEqual(pipingFactorOfSafety, properties.PipingFactorOfSafety, GetAccuracy(properties.PipingFactorOfSafety));
+            Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety, properties.UpliftFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(upliftReliability, properties.UpliftReliability, properties.UpliftReliability.GetAccuracy());
+            Assert.AreEqual(upliftProbability, properties.UpliftProbability, properties.UpliftProbability.GetAccuracy());
+            Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety, properties.HeaveFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(heaveReliability, properties.HeaveReliability, properties.HeaveReliability.GetAccuracy());
+            Assert.AreEqual(heaveProbability, properties.HeaveProbability, properties.HeaveProbability.GetAccuracy());
+            Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety.GetAccuracy());
+            Assert.AreEqual(sellmeijerReliability, properties.SellmeijerReliability, properties.SellmeijerReliability.GetAccuracy());
+            Assert.AreEqual(sellmeijerProbability, properties.SellmeijerProbability, properties.SellmeijerProbability.GetAccuracy());
+            Assert.AreEqual(requiredProbability, properties.RequiredProbability, properties.RequiredProbability.GetAccuracy());
+            Assert.AreEqual(requiredReliability, properties.RequiredReliability, properties.RequiredReliability.GetAccuracy());
+            Assert.AreEqual(pipingProbability, properties.PipingProbability, properties.PipingProbability.GetAccuracy());
+            Assert.AreEqual(pipingReliability, properties.PipingReliability, properties.PipingReliability.GetAccuracy());
+            Assert.AreEqual(pipingFactorOfSafety, properties.PipingFactorOfSafety, properties.PipingFactorOfSafety.GetAccuracy());
         }
-
-
-        private static double GetAccuracy(RoundedDouble d)
-        {
-            return Math.Pow(10.0, -d.NumberOfDecimalPlaces);
-        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs
===================================================================
diff -u -r238411e28abf2f71dc0a5715ca940c6e87df9392 -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs	(.../InputParameterCalculationServiceTest.cs)	(revision 238411e28abf2f71dc0a5715ca940c6e87df9392)
+++ Ringtoets/Piping/test/Ringtoets.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs	(.../InputParameterCalculationServiceTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -133,7 +133,7 @@
                 Assert.AreEqual(
                     PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), 
                     effectiveThicknessCalculator.PhreaticLevel,
-                    GetAccuracy(input.PhreaticLevelExit.Mean));
+                    input.PhreaticLevelExit.GetAccuracy());
                 AssertEqualSoilProfiles(input.SoilProfile, effectiveThicknessCalculator.SoilProfile);
                 AssertEqualSurfaceLines(input.SurfaceLine, effectiveThicknessCalculator.SurfaceLine);
                 Assert.AreEqual(input.WaterVolumetricWeight, effectiveThicknessCalculator.VolumicWeightOfWater);
@@ -162,9 +162,9 @@
 
                 Assert.AreEqual(input.AssessmentLevel.Value, piezometricHeadAtExitCalculator.HRiver);
                 Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder,
-                                GetAccuracy(input.PhreaticLevelExit.Mean));
+                                input.PhreaticLevelExit.GetAccuracy());
                 Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit,
-                                GetAccuracy(input.DampingFactorExit.Mean));
+                                input.DampingFactorExit.GetAccuracy());
             }
         }
 
@@ -212,10 +212,5 @@
                 Assert.AreEqual(pipingProfile.Layers.ElementAt(i).Top, otherPipingProfile.Layers[i].TopLevel);
             }
         }
-
-        private static double GetAccuracy(RoundedDouble roundedDouble)
-        {
-            return Math.Pow(10.0, -roundedDouble.NumberOfDecimalPlaces);
-        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs
===================================================================
diff -u -r420c266df87245b9471d3794ef5043ee89cb482a -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs	(.../PipingCalculationServiceTest.cs)	(revision 420c266df87245b9471d3794ef5043ee89cb482a)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs	(.../PipingCalculationServiceTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -1,13 +1,9 @@
 using System;
 using System.Linq;
 using Core.Common.Base.Data;
-using Core.Common.Base.Geometry;
 using Core.Common.TestUtil;
-using Deltares.WTIPiping;
 using NUnit.Framework;
-using Rhino.Mocks;
 using Ringtoets.Piping.Data;
-using Ringtoets.Piping.Data.Probabilistics;
 using Ringtoets.Piping.Data.TestUtil;
 using Ringtoets.Piping.KernelWrapper.SubCalculator;
 using Ringtoets.Piping.KernelWrapper.TestUtil;
@@ -184,35 +180,35 @@
             var sellmeijerCalculator = testFactory.LastCreatedSellmeijerCalculator;
 
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(input).GetDesignValue(), heaveCalculator.DTotal,
-                            GetAccuracy(input.ThicknessCoverageLayer.Mean));
+                            input.ThicknessCoverageLayer.GetAccuracy());
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), heaveCalculator.HExit,
-                            GetAccuracy(input.PhreaticLevelExit.Mean));
+                            input.PhreaticLevelExit.GetAccuracy());
             Assert.AreEqual(input.CriticalHeaveGradient, heaveCalculator.Ich);
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), heaveCalculator.PhiPolder,
-                            GetAccuracy(input.PhreaticLevelExit.Mean));
+                            input.PhreaticLevelExit.GetAccuracy());
             Assert.AreEqual(input.PiezometricHeadExit.Value, heaveCalculator.PhiExit);
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), heaveCalculator.RExit,
-                            GetAccuracy(input.DampingFactorExit.Mean));
+                            input.DampingFactorExit.GetAccuracy());
 
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), upliftCalculator.HExit,
-                            GetAccuracy(input.PhreaticLevelExit.Mean));
+                            input.PhreaticLevelExit.GetAccuracy());
             Assert.AreEqual(input.AssessmentLevel.Value, upliftCalculator.HRiver);
             Assert.AreEqual(input.UpliftModelFactor, upliftCalculator.ModelFactorUplift);
             Assert.AreEqual(input.PiezometricHeadExit.Value, upliftCalculator.PhiExit);
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), upliftCalculator.PhiPolder,
-                            GetAccuracy(input.PhreaticLevelExit.Mean));
+                            input.PhreaticLevelExit.GetAccuracy());
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), upliftCalculator.RExit,
-                            GetAccuracy(input.DampingFactorExit.Mean));
+                            input.DampingFactorExit.GetAccuracy());
             Assert.AreEqual(input.WaterVolumetricWeight, upliftCalculator.VolumetricWeightOfWater);
             RoundedDouble effectiveStress = PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(input).GetDesignValue()*
                                             (PipingSemiProbabilisticDesignValueFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue() - input.WaterVolumetricWeight);
             Assert.AreEqual(effectiveStress, upliftCalculator.EffectiveStress,
-                            GetAccuracy(effectiveStress));
+                            effectiveStress.GetAccuracy());
 
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetSeepageLength(input).GetDesignValue(), sellmeijerCalculator.SeepageLength,
-                            GetAccuracy(input.SeepageLength.Mean));
+                            input.SeepageLength.GetAccuracy());
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), sellmeijerCalculator.HExit,
-                            GetAccuracy(input.PhreaticLevelExit.Mean));
+                            input.PhreaticLevelExit.GetAccuracy());
             Assert.AreEqual(input.AssessmentLevel.Value, sellmeijerCalculator.HRiver);
             Assert.AreEqual(input.WaterKinematicViscosity, sellmeijerCalculator.KinematicViscosityWater);
             Assert.AreEqual(input.SellmeijerModelFactor, sellmeijerCalculator.ModelFactorPiping);
@@ -221,21 +217,16 @@
             Assert.AreEqual(input.WhitesDragCoefficient, sellmeijerCalculator.WhitesDragCoefficient);
             Assert.AreEqual(input.BeddingAngle, sellmeijerCalculator.BeddingAngle);
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(input).GetDesignValue(), sellmeijerCalculator.DTotal,
-                            GetAccuracy(input.ThicknessCoverageLayer.Mean));
+                            input.ThicknessCoverageLayer.GetAccuracy());
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDiameter70(input).GetDesignValue(), sellmeijerCalculator.D70,
-                            GetAccuracy(input.Diameter70.Mean));
+                            input.Diameter70.GetAccuracy());
             Assert.AreEqual(input.MeanDiameter70, sellmeijerCalculator.D70Mean);
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetThicknessAquiferLayer(input).GetDesignValue(), sellmeijerCalculator.DAquifer,
-                            GetAccuracy(input.ThicknessAquiferLayer.Mean));
+                            input.ThicknessAquiferLayer.GetAccuracy());
             Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDarcyPermeability(input).GetDesignValue(), sellmeijerCalculator.DarcyPermeability,
-                            GetAccuracy(input.DarcyPermeability.Mean));
+                            input.DarcyPermeability.GetAccuracy());
             Assert.AreEqual(input.SandParticlesVolumicWeight, sellmeijerCalculator.GammaSubParticles);
             Assert.AreEqual(input.Gravity, sellmeijerCalculator.Gravity);
         }
-
-        private static double GetAccuracy(RoundedDouble roundedDouble)
-        {
-            return Math.Pow(10.0, -roundedDouble.NumberOfDecimalPlaces);
-        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs
===================================================================
diff -u -r23ecc584602719f982f2206ad49a329fbf5dc028 -r3721b5bb1ae327907884a90d1a9bd300042e0540
--- Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs	(.../PipingSemiProbabilisticCalculationServiceTest.cs)	(revision 23ecc584602719f982f2206ad49a329fbf5dc028)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs	(.../PipingSemiProbabilisticCalculationServiceTest.cs)	(revision 3721b5bb1ae327907884a90d1a9bd300042e0540)
@@ -3,6 +3,7 @@
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Ringtoets.Piping.Data;
+using Ringtoets.Piping.Data.TestUtil;
 
 namespace Ringtoets.Piping.Service.Test
 {
@@ -31,7 +32,7 @@
             RoundedDouble result = calculation.SemiProbabilisticOutput.UpliftProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
+            Assert.AreEqual(expectedResult, result, result.GetAccuracy());
         }
 
         [Test]
@@ -56,7 +57,7 @@
             RoundedDouble result = calculation.SemiProbabilisticOutput.HeaveProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
+            Assert.AreEqual(expectedResult, result, result.GetAccuracy());
         }
 
         [Test]
@@ -81,7 +82,7 @@
             RoundedDouble result = calculation.SemiProbabilisticOutput.SellmeijerProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
+            Assert.AreEqual(expectedResult, result, result.GetAccuracy());
         }
 
         [Test]
@@ -108,7 +109,7 @@
             RoundedDouble result = calculation.SemiProbabilisticOutput.PipingReliability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
+            Assert.AreEqual(expectedResult, result, result.GetAccuracy());
         }
 
         [Test]
@@ -134,7 +135,7 @@
             RoundedDouble result = calculation.SemiProbabilisticOutput.RequiredReliability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
+            Assert.AreEqual(expectedResult, result, result.GetAccuracy());
         }
 
         [Test]
@@ -165,7 +166,7 @@
             RoundedDouble result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, GetAccuracy(result));
+            Assert.AreEqual(expectedResult, result, result.GetAccuracy());
         }
 
         [Test]
@@ -195,7 +196,7 @@
             RoundedDouble result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
 
             // Assert
-            Assert.AreEqual(calculation.SemiProbabilisticOutput.RequiredReliability / calculation.SemiProbabilisticOutput.PipingReliability, result, GetAccuracy(result));
+            Assert.AreEqual(calculation.SemiProbabilisticOutput.RequiredReliability / calculation.SemiProbabilisticOutput.PipingReliability, result, result.GetAccuracy());
         }
 
         [Test]
@@ -220,7 +221,7 @@
 
             // Assert
             RoundedDouble result = pipingCalculation.SemiProbabilisticOutput.PipingFactorOfSafety;
-            Assert.AreEqual(1.134713444, result, GetAccuracy(result));
+            Assert.AreEqual(1.134713444, result, result.GetAccuracy());
         }
 
         [Test]
@@ -244,10 +245,5 @@
                 Output = pipingOutput
             };
         }
-
-        private static double GetAccuracy(RoundedDouble d)
-        {
-            return Math.Pow(10.0, -d.NumberOfDecimalPlaces);
-        }
     }
 }
\ No newline at end of file