Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs
===================================================================
diff -u -r686466dda6406ee2c7fb1f33faa60494878b1fc8 -re64b4b8f531f7dc251a61efec45cb52089ab8ea7
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs	(.../StorageSqLiteIntegrationTest.cs)	(revision 686466dda6406ee2c7fb1f33faa60494878b1fc8)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs	(.../StorageSqLiteIntegrationTest.cs)	(revision e64b4b8f531f7dc251a61efec45cb52089ab8ea7)
@@ -44,7 +44,6 @@
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Data.IllustrationPoints;
-using Ringtoets.Common.Data.Probabilistics;
 using Ringtoets.Common.Data.Probability;
 using Ringtoets.Common.Data.Structures;
 using Ringtoets.Common.Data.TestUtil;
@@ -523,46 +522,55 @@
                 {
                     AssertCalculationGroup(expectedChildGroup, (CalculationGroup) actualChild);
                 }
+
                 var expectedPipingCalculation = expectedChild as PipingCalculationScenario;
                 if (expectedPipingCalculation != null)
                 {
                     AssertPipingCalculationScenario(expectedPipingCalculation, (PipingCalculationScenario) actualChild);
                 }
+
                 var expectedMacroStabilityInwardsCalculation = expectedChild as MacroStabilityInwardsCalculationScenario;
                 if (expectedMacroStabilityInwardsCalculation != null)
                 {
                     AssertMacroStabilityInwardsCalculationScenario(expectedMacroStabilityInwardsCalculation, (MacroStabilityInwardsCalculationScenario) actualChild);
                 }
+
                 var expectedGrassCoverErosionInwardsCalculation = expectedChild as GrassCoverErosionInwardsCalculation;
                 if (expectedGrassCoverErosionInwardsCalculation != null)
                 {
                     AssertGrassCoverErosionInwardsCalculation(expectedGrassCoverErosionInwardsCalculation, (GrassCoverErosionInwardsCalculation) actualChild);
                 }
+
                 var expectedGrassCoverErosionOutwardsCalculation = expectedChild as GrassCoverErosionOutwardsWaveConditionsCalculation;
                 if (expectedGrassCoverErosionOutwardsCalculation != null)
                 {
                     AssertGrassCoverErosionOutwardsWaveConditionsCalculation(expectedGrassCoverErosionOutwardsCalculation, (GrassCoverErosionOutwardsWaveConditionsCalculation) actualChild);
                 }
+
                 var expectedHeightStructuresCalculation = expectedChild as StructuresCalculation<HeightStructuresInput>;
                 if (expectedHeightStructuresCalculation != null)
                 {
                     AssertStructuresCalculation(expectedHeightStructuresCalculation, (StructuresCalculation<HeightStructuresInput>) actualChild);
                 }
+
                 var expectedClosingStructuresCalculation = expectedChild as StructuresCalculation<ClosingStructuresInput>;
                 if (expectedClosingStructuresCalculation != null)
                 {
                     AssertStructuresCalculation(expectedClosingStructuresCalculation, (StructuresCalculation<ClosingStructuresInput>) actualChild);
                 }
+
                 var expectedStabilityPointStructuresCalculation = expectedChild as StructuresCalculation<StabilityPointStructuresInput>;
                 if (expectedStabilityPointStructuresCalculation != null)
                 {
                     AssertStructuresCalculation(expectedStabilityPointStructuresCalculation, (StructuresCalculation<StabilityPointStructuresInput>) actualChild);
                 }
+
                 var expectedStabilityStoneCoverWaveConditionsCalculation = expectedChild as StabilityStoneCoverWaveConditionsCalculation;
                 if (expectedStabilityStoneCoverWaveConditionsCalculation != null)
                 {
                     AssertStabilityStoneCoverWaveConditionsCalculation(expectedStabilityStoneCoverWaveConditionsCalculation, (StabilityStoneCoverWaveConditionsCalculation) actualChild);
                 }
+
                 var expectedWaveImpactAsphaltCoverWaveConditionsCalculation = expectedChild as WaveImpactAsphaltCoverWaveConditionsCalculation;
                 if (expectedWaveImpactAsphaltCoverWaveConditionsCalculation != null)
                 {
@@ -1086,6 +1094,7 @@
                 Assert.IsNull(actualOutput);
                 return;
             }
+
             Assert.AreEqual(expectedOutput.WaterLevel, actualOutput.WaterLevel);
             Assert.AreEqual(expectedOutput.WaveHeight, actualOutput.WaveHeight);
             Assert.AreEqual(expectedOutput.WavePeriod, actualOutput.WavePeriod);
@@ -1515,43 +1524,13 @@
             Assert.AreEqual(expectedData.Color.ToArgb(), actualData.Color.ToArgb());
             Assert.AreEqual(expectedData.UsePop, actualData.UsePop);
             Assert.AreEqual(expectedData.ShearStrengthModel, actualData.ShearStrengthModel);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = expectedData.AbovePhreaticLevel.Mean,
-                CoefficientOfVariation = expectedData.AbovePhreaticLevel.CoefficientOfVariation,
-                Shift = expectedData.AbovePhreaticLevel.Shift
-            }, actualData.AbovePhreaticLevel);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = expectedData.BelowPhreaticLevel.Mean,
-                CoefficientOfVariation = expectedData.BelowPhreaticLevel.CoefficientOfVariation,
-                Shift = expectedData.BelowPhreaticLevel.Shift
-            }, actualData.BelowPhreaticLevel);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = expectedData.Cohesion.Mean,
-                CoefficientOfVariation = expectedData.Cohesion.CoefficientOfVariation
-            }, actualData.Cohesion);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = expectedData.FrictionAngle.Mean,
-                CoefficientOfVariation = expectedData.FrictionAngle.CoefficientOfVariation
-            }, actualData.FrictionAngle);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = expectedData.ShearStrengthRatio.Mean,
-                CoefficientOfVariation = expectedData.ShearStrengthRatio.CoefficientOfVariation
-            }, actualData.ShearStrengthRatio);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = expectedData.StrengthIncreaseExponent.Mean,
-                CoefficientOfVariation = expectedData.StrengthIncreaseExponent.CoefficientOfVariation
-            }, actualData.StrengthIncreaseExponent);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = expectedData.Pop.Mean,
-                CoefficientOfVariation = expectedData.Pop.CoefficientOfVariation
-            }, actualData.Pop);
+            DistributionAssert.AreEqual(expectedData.AbovePhreaticLevel, actualData.AbovePhreaticLevel);
+            DistributionAssert.AreEqual(expectedData.BelowPhreaticLevel, actualData.BelowPhreaticLevel);
+            DistributionAssert.AreEqual(expectedData.Cohesion, actualData.Cohesion);
+            DistributionAssert.AreEqual(expectedData.FrictionAngle, actualData.FrictionAngle);
+            DistributionAssert.AreEqual(expectedData.ShearStrengthRatio, actualData.ShearStrengthRatio);
+            DistributionAssert.AreEqual(expectedData.StrengthIncreaseExponent, actualData.StrengthIncreaseExponent);
+            DistributionAssert.AreEqual(expectedData.Pop, actualData.Pop);
         }
 
         private static void AssertMacroStabilityInwardsSurfaceLine(MacroStabilityInwardsSurfaceLine expectedSurfaceLine,
@@ -2108,6 +2087,7 @@
                 Assert.IsNull(actualOutput);
                 return;
             }
+
             Assert.AreEqual(expectedOutput.Result, actualOutput.Result);
             Assert.AreEqual(expectedOutput.TargetProbability, actualOutput.TargetProbability);
             Assert.AreEqual(expectedOutput.TargetReliability, actualOutput.TargetReliability);
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/MacroStabilityInwards/MacroStabilityInwardsSoilLayerOneDEntityReadExtensionsTest.cs
===================================================================
diff -u -r6930768a9966428615e6b52c8dc67512c436f0d6 -re64b4b8f531f7dc251a61efec45cb52089ab8ea7
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/MacroStabilityInwards/MacroStabilityInwardsSoilLayerOneDEntityReadExtensionsTest.cs	(.../MacroStabilityInwardsSoilLayerOneDEntityReadExtensionsTest.cs)	(revision 6930768a9966428615e6b52c8dc67512c436f0d6)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/MacroStabilityInwards/MacroStabilityInwardsSoilLayerOneDEntityReadExtensionsTest.cs	(.../MacroStabilityInwardsSoilLayerOneDEntityReadExtensionsTest.cs)	(revision e64b4b8f531f7dc251a61efec45cb52089ab8ea7)
@@ -23,10 +23,8 @@
 using System.Drawing;
 using Application.Ringtoets.Storage.DbContext;
 using Application.Ringtoets.Storage.Read.MacroStabilityInwards;
-using Core.Common.Base.Data;
 using Core.Common.TestUtil;
 using NUnit.Framework;
-using Ringtoets.Common.Data.Probabilistics;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.MacroStabilityInwards.Data.SoilProfile;
 using Ringtoets.MacroStabilityInwards.Primitives;
@@ -108,49 +106,43 @@
             Assert.AreEqual(color.ToArgb(), data.Color.ToArgb());
             Assert.AreEqual(entity.MaterialName, data.MaterialName);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) abovePhreaticLevelMean,
-                CoefficientOfVariation = (RoundedDouble) abovePhreaticLevelCoefficientOfVariation,
-                Shift = (RoundedDouble) abovePhreaticLevelShift
-            }, data.AbovePhreaticLevel);
+            Assert.AreEqual(abovePhreaticLevelMean, data.AbovePhreaticLevel.Mean,
+                            data.AbovePhreaticLevel.GetAccuracy());
+            Assert.AreEqual(abovePhreaticLevelCoefficientOfVariation, data.AbovePhreaticLevel.CoefficientOfVariation,
+                            data.AbovePhreaticLevel.GetAccuracy());
+            Assert.AreEqual(abovePhreaticLevelShift, data.AbovePhreaticLevel.Shift,
+                            data.AbovePhreaticLevel.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) belowPhreaticLevelMean,
-                CoefficientOfVariation = (RoundedDouble) belowPhreaticLevelCoefficientOfVariation,
-                Shift = (RoundedDouble) belowPhreaticLevelShift
-            }, data.BelowPhreaticLevel);
+            Assert.AreEqual(belowPhreaticLevelMean, data.BelowPhreaticLevel.Mean,
+                            data.BelowPhreaticLevel.GetAccuracy());
+            Assert.AreEqual(belowPhreaticLevelCoefficientOfVariation, data.BelowPhreaticLevel.CoefficientOfVariation,
+                            data.BelowPhreaticLevel.GetAccuracy());
+            Assert.AreEqual(belowPhreaticLevelShift, data.BelowPhreaticLevel.Shift,
+                            data.BelowPhreaticLevel.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) cohesionMean,
-                CoefficientOfVariation = (RoundedDouble) cohesionCoefficientOfVariation
-            }, data.Cohesion);
+            Assert.AreEqual(cohesionMean, data.Cohesion.Mean,
+                            data.Cohesion.GetAccuracy());
+            Assert.AreEqual(cohesionCoefficientOfVariation, data.Cohesion.CoefficientOfVariation,
+                            data.Cohesion.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) frictionAngleMean,
-                CoefficientOfVariation = (RoundedDouble) frictionAngleCoefficientOfVariation
-            }, data.FrictionAngle);
+            Assert.AreEqual(frictionAngleMean, data.FrictionAngle.Mean,
+                            data.FrictionAngle.GetAccuracy());
+            Assert.AreEqual(frictionAngleCoefficientOfVariation, data.FrictionAngle.CoefficientOfVariation,
+                            data.FrictionAngle.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) shearStrengthRatioMean,
-                CoefficientOfVariation = (RoundedDouble) shearStrengthRatioCoefficientOfVariation
-            }, data.ShearStrengthRatio);
+            Assert.AreEqual(shearStrengthRatioMean, data.ShearStrengthRatio.Mean,
+                            data.ShearStrengthRatio.GetAccuracy());
+            Assert.AreEqual(shearStrengthRatioCoefficientOfVariation, data.ShearStrengthRatio.CoefficientOfVariation,
+                            data.ShearStrengthRatio.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) strengthIncreaseExponentMean,
-                CoefficientOfVariation = (RoundedDouble) strengthIncreaseExponentCoefficientOfVariation
-            }, data.StrengthIncreaseExponent);
+            Assert.AreEqual(strengthIncreaseExponentMean, data.StrengthIncreaseExponent.Mean,
+                            data.StrengthIncreaseExponent.GetAccuracy());
+            Assert.AreEqual(strengthIncreaseExponentCoefficientOfVariation, data.StrengthIncreaseExponent.CoefficientOfVariation,
+                            data.StrengthIncreaseExponent.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) popMean,
-                CoefficientOfVariation = (RoundedDouble) popCoefficientOfVariation
-            }, data.Pop);
+            Assert.AreEqual(popMean, data.Pop.Mean, data.Pop.GetAccuracy());
+            Assert.AreEqual(popCoefficientOfVariation, data.Pop.CoefficientOfVariation,
+                            data.Pop.GetAccuracy());
         }
 
         [Test]
@@ -171,49 +163,29 @@
             Assert.AreEqual(entity.MaterialName, data.MaterialName);
 
             Assert.IsNaN(layer.Top);
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN,
-                Shift = RoundedDouble.NaN
-            }, data.AbovePhreaticLevel);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN,
-                Shift = RoundedDouble.NaN
-            }, data.BelowPhreaticLevel);
+            Assert.IsNaN(data.AbovePhreaticLevel.Mean);
+            Assert.IsNaN(data.AbovePhreaticLevel.CoefficientOfVariation);
+            Assert.IsNaN(data.AbovePhreaticLevel.Shift);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.Cohesion);
+            Assert.IsNaN(data.BelowPhreaticLevel.Mean);
+            Assert.IsNaN(data.BelowPhreaticLevel.CoefficientOfVariation);
+            Assert.IsNaN(data.BelowPhreaticLevel.Shift);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.FrictionAngle);
+            Assert.IsNaN(data.Cohesion.Mean);
+            Assert.IsNaN(data.Cohesion.CoefficientOfVariation);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.ShearStrengthRatio);
+            Assert.IsNaN(data.FrictionAngle.Mean);
+            Assert.IsNaN(data.FrictionAngle.CoefficientOfVariation);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.StrengthIncreaseExponent);
+            Assert.IsNaN(data.ShearStrengthRatio.Mean);
+            Assert.IsNaN(data.ShearStrengthRatio.CoefficientOfVariation);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.Pop);
+            Assert.IsNaN(data.StrengthIncreaseExponent.Mean);
+            Assert.IsNaN(data.StrengthIncreaseExponent.CoefficientOfVariation);
+
+            Assert.IsNaN(data.Pop.Mean);
+            Assert.IsNaN(data.Pop.CoefficientOfVariation);
         }
     }
 }
\ No newline at end of file
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/MacroStabilityInwards/MacroStabilityInwardsSoilLayerTwoDEntityReadExtensionsTest.cs
===================================================================
diff -u -r6930768a9966428615e6b52c8dc67512c436f0d6 -re64b4b8f531f7dc251a61efec45cb52089ab8ea7
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/MacroStabilityInwards/MacroStabilityInwardsSoilLayerTwoDEntityReadExtensionsTest.cs	(.../MacroStabilityInwardsSoilLayerTwoDEntityReadExtensionsTest.cs)	(revision 6930768a9966428615e6b52c8dc67512c436f0d6)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/MacroStabilityInwards/MacroStabilityInwardsSoilLayerTwoDEntityReadExtensionsTest.cs	(.../MacroStabilityInwardsSoilLayerTwoDEntityReadExtensionsTest.cs)	(revision e64b4b8f531f7dc251a61efec45cb52089ab8ea7)
@@ -26,10 +26,8 @@
 using Application.Ringtoets.Storage.Read.MacroStabilityInwards;
 using Application.Ringtoets.Storage.Serializers;
 using Application.Ringtoets.Storage.TestUtil.MacroStabilityInwards;
-using Core.Common.Base.Data;
 using Core.Common.TestUtil;
 using NUnit.Framework;
-using Ringtoets.Common.Data.Probabilistics;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.MacroStabilityInwards.Primitives;
 using Ringtoets.MacroStabilityInwards.Primitives.TestUtil;
@@ -106,49 +104,28 @@
             MacroStabilityInwardsSoilLayerData data = layer.Data;
             Assert.AreEqual(entity.MaterialName, data.MaterialName);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN,
-                Shift = RoundedDouble.NaN
-            }, data.AbovePhreaticLevel);
+            Assert.IsNaN(data.AbovePhreaticLevel.Mean);
+            Assert.IsNaN(data.AbovePhreaticLevel.CoefficientOfVariation);
+            Assert.IsNaN(data.AbovePhreaticLevel.Shift);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN,
-                Shift = RoundedDouble.NaN
-            }, data.BelowPhreaticLevel);
+            Assert.IsNaN(data.BelowPhreaticLevel.Mean);
+            Assert.IsNaN(data.BelowPhreaticLevel.CoefficientOfVariation);
+            Assert.IsNaN(data.BelowPhreaticLevel.Shift);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.Cohesion);
+            Assert.IsNaN(data.Cohesion.Mean);
+            Assert.IsNaN(data.Cohesion.CoefficientOfVariation);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.FrictionAngle);
+            Assert.IsNaN(data.FrictionAngle.Mean);
+            Assert.IsNaN(data.FrictionAngle.CoefficientOfVariation);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.ShearStrengthRatio);
+            Assert.IsNaN(data.ShearStrengthRatio.Mean);
+            Assert.IsNaN(data.ShearStrengthRatio.CoefficientOfVariation);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.StrengthIncreaseExponent);
+            Assert.IsNaN(data.StrengthIncreaseExponent.Mean);
+            Assert.IsNaN(data.StrengthIncreaseExponent.CoefficientOfVariation);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = RoundedDouble.NaN,
-                CoefficientOfVariation = RoundedDouble.NaN
-            }, data.Pop);
+            Assert.IsNaN(data.Pop.Mean);
+            Assert.IsNaN(data.Pop.CoefficientOfVariation);
         }
 
         private static void AssertMacroStabilityInwardsSoilLayer2D(MacroStabilityInwardsSoilLayerTwoDEntity entity,
@@ -160,49 +137,43 @@
             Assert.AreEqual(entity.Color, data.Color.ToInt64());
             Assert.AreEqual(entity.MaterialName, data.MaterialName);
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) entity.AbovePhreaticLevelMean.ToNullAsNaN(),
-                CoefficientOfVariation = (RoundedDouble) entity.AbovePhreaticLevelCoefficientOfVariation.ToNullAsNaN(),
-                Shift = (RoundedDouble) entity.AbovePhreaticLevelShift.ToNullAsNaN()
-            }, data.AbovePhreaticLevel);
+            Assert.AreEqual(entity.AbovePhreaticLevelMean ?? double.NaN, data.AbovePhreaticLevel.Mean,
+                            data.AbovePhreaticLevel.GetAccuracy());
+            Assert.AreEqual(entity.AbovePhreaticLevelCoefficientOfVariation ?? double.NaN, data.AbovePhreaticLevel.CoefficientOfVariation,
+                            data.AbovePhreaticLevel.GetAccuracy());
+            Assert.AreEqual(entity.AbovePhreaticLevelShift ?? double.NaN, data.AbovePhreaticLevel.Shift,
+                            data.AbovePhreaticLevel.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) entity.BelowPhreaticLevelMean.ToNullAsNaN(),
-                CoefficientOfVariation = (RoundedDouble) entity.BelowPhreaticLevelCoefficientOfVariation.ToNullAsNaN(),
-                Shift = (RoundedDouble) entity.BelowPhreaticLevelShift.ToNullAsNaN()
-            }, data.BelowPhreaticLevel);
+            Assert.AreEqual(entity.BelowPhreaticLevelMean ?? double.NaN, data.BelowPhreaticLevel.Mean,
+                            data.BelowPhreaticLevel.GetAccuracy());
+            Assert.AreEqual(entity.BelowPhreaticLevelCoefficientOfVariation ?? double.NaN, data.BelowPhreaticLevel.CoefficientOfVariation,
+                            data.BelowPhreaticLevel.GetAccuracy());
+            Assert.AreEqual(entity.BelowPhreaticLevelShift ?? double.NaN, data.BelowPhreaticLevel.Shift,
+                            data.BelowPhreaticLevel.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) entity.CohesionMean.ToNullAsNaN(),
-                CoefficientOfVariation = (RoundedDouble) entity.CohesionCoefficientOfVariation.ToNullAsNaN()
-            }, data.Cohesion);
+            Assert.AreEqual(entity.CohesionMean ?? double.NaN, data.Cohesion.Mean,
+                            data.Cohesion.GetAccuracy());
+            Assert.AreEqual(entity.CohesionCoefficientOfVariation ?? double.NaN, data.Cohesion.CoefficientOfVariation,
+                            data.Cohesion.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) entity.FrictionAngleMean.ToNullAsNaN(),
-                CoefficientOfVariation = (RoundedDouble) entity.FrictionAngleCoefficientOfVariation.ToNullAsNaN()
-            }, data.FrictionAngle);
+            Assert.AreEqual(entity.FrictionAngleMean ?? double.NaN, data.FrictionAngle.Mean,
+                            data.FrictionAngle.GetAccuracy());
+            Assert.AreEqual(entity.FrictionAngleCoefficientOfVariation ?? double.NaN, data.FrictionAngle.CoefficientOfVariation,
+                            data.FrictionAngle.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) entity.ShearStrengthRatioMean.ToNullAsNaN(),
-                CoefficientOfVariation = (RoundedDouble) entity.ShearStrengthRatioCoefficientOfVariation.ToNullAsNaN()
-            }, data.ShearStrengthRatio);
+            Assert.AreEqual(entity.ShearStrengthRatioMean ?? double.NaN, data.ShearStrengthRatio.Mean,
+                            data.ShearStrengthRatio.GetAccuracy());
+            Assert.AreEqual(entity.ShearStrengthRatioCoefficientOfVariation ?? double.NaN, data.ShearStrengthRatio.CoefficientOfVariation,
+                            data.ShearStrengthRatio.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) entity.StrengthIncreaseExponentMean.ToNullAsNaN(),
-                CoefficientOfVariation = (RoundedDouble) entity.StrengthIncreaseExponentCoefficientOfVariation.ToNullAsNaN()
-            }, data.StrengthIncreaseExponent);
+            Assert.AreEqual(entity.StrengthIncreaseExponentMean ?? double.NaN, data.StrengthIncreaseExponent.Mean,
+                            data.StrengthIncreaseExponent.GetAccuracy());
+            Assert.AreEqual(entity.StrengthIncreaseExponentCoefficientOfVariation ?? double.NaN, data.StrengthIncreaseExponent.CoefficientOfVariation,
+                            data.StrengthIncreaseExponent.GetAccuracy());
 
-            DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) entity.PopMean.ToNullAsNaN(),
-                CoefficientOfVariation = (RoundedDouble) entity.PopCoefficientOfVariation.ToNullAsNaN()
-            }, data.Pop);
+            Assert.AreEqual(entity.PopMean ?? double.NaN, data.Pop.Mean, data.Pop.GetAccuracy());
+            Assert.AreEqual(entity.PopCoefficientOfVariation ?? double.NaN, data.Pop.CoefficientOfVariation,
+                            data.Pop.GetAccuracy());
 
             CollectionAssert.AreEqual(new Point2DXmlSerializer().FromXml(entity.OuterRingXml),
                                       layer.OuterRing.Points);