Index: Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructure.cs
===================================================================
diff -u -r0d0fc614ee67c51983412fcec6509f8fad4151e3 -rc10a30c04073ef3a1fc90dce4ccc081c02836b1c
--- Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructure.cs	(.../ClosingStructure.cs)	(revision 0d0fc614ee67c51983412fcec6509f8fad4151e3)
+++ Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.Data/ClosingStructure.cs	(.../ClosingStructure.cs)	(revision c10a30c04073ef3a1fc90dce4ccc081c02836b1c)
@@ -39,12 +39,12 @@
         /// <param name="id">The identifier of the closing structure.</param>
         /// <param name="location">The location of the closing structure.</param>
         /// <param name="storageStructureAreaMean">The mean of the storage area of the closing structure.</param>
-        /// <param name="storageStructureAreaStandardDeviation">The standard deviation of the storage area of the closing structure.</param>
+        /// <param name="storageStructureAreaCoefficientOfVariation">The coefficient of variation of the storage area of the closing structure.</param>
         /// <param name="allowedLevelIncreaseStorageMean">The mean allowed increase of level for storage of the closing structure.</param>
         /// <param name="allowedLevelIncreaseStorageStandardDeviation">The standard deviation of allowed increase of level for storage of the closing structure.</param>
         /// <param name="structureNormalOrientation">The orientation of the closing structure, relative to north.</param>
         /// <param name="widthFlowAperturesMean">The mean of the width of the flow apertures of the closing structure.</param>
-        /// <param name="widthFlowAperturesStandardDeviation">The standard deviation of the width of the flow apertures of the closing structure.</param>
+        /// <param name="widthFlowAperturesCoefficientOfVariation">The coefficient of variation of the width of the flow apertures of the closing structure.</param>
         /// <param name="levelCrestStructureNotClosingMean">The mean crest level of the opened closing structure.</param>
         /// <param name="levelCrestStructureNotClosingStandardDeviation">The standard deviation of the crest level of the opened closing structure.</param>
         /// <param name="insideWaterLevelMean">The mean interior water level of the closing structure.</param>
@@ -54,7 +54,7 @@
         /// <param name="areaFlowAperturesMean">The mean area of the flow aperture of the closing structure.</param>
         /// <param name="areaFlowAperturesStandardDeviation">The standard deviation of the area of the flow aperture of the closing structure.</param>
         /// <param name="criticalOvertoppingDischargeMean">The mean critical overtopping discharge of the closing structure.</param>
-        /// <param name="criticalOvertoppingDischargeStandardDeviation">The standard deviation of critical overtopping discharge of the closing structure.</param>
+        /// <param name="criticalOvertoppingDischargeCoefficientOfVariation">The coefficient of variation of critical overtopping discharge of the closing structure.</param>
         /// <param name="flowWidthAtBottomProtectionMean">The mean flow width of the closing structure at the bottom protection.</param>
         /// <param name="flowWidthAtBottomProtectionStandardDeviation">The standard deviation of the flow width of the closing structure at the bottom protection.</param>
         /// <param name="probabilityOpenStructureBeforeFlooding">The probability of the closing structure being open before flooding.</param>
@@ -67,15 +67,15 @@
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="location"/> is <c>null</c>.</exception>
         /// <exception cref="ArgumentOutOfRangeException">Thrown when any parameter is out of range.</exception>
         public ClosingStructure(string name, string id, Point2D location,
-                                double storageStructureAreaMean, double storageStructureAreaStandardDeviation,
+                                double storageStructureAreaMean, double storageStructureAreaCoefficientOfVariation,
                                 double allowedLevelIncreaseStorageMean, double allowedLevelIncreaseStorageStandardDeviation,
                                 double structureNormalOrientation,
-                                double widthFlowAperturesMean, double widthFlowAperturesStandardDeviation,
+                                double widthFlowAperturesMean, double widthFlowAperturesCoefficientOfVariation,
                                 double levelCrestStructureNotClosingMean, double levelCrestStructureNotClosingStandardDeviation,
                                 double insideWaterLevelMean, double insideWaterLevelStandardDeviation,
                                 double thresholdHeightOpenWeirMean, double thresholdHeightOpenWeirStandardDeviation,
                                 double areaFlowAperturesMean, double areaFlowAperturesStandardDeviation,
-                                double criticalOvertoppingDischargeMean, double criticalOvertoppingDischargeStandardDeviation,
+                                double criticalOvertoppingDischargeMean, double criticalOvertoppingDischargeCoefficientOfVariation,
                                 double flowWidthAtBottomProtectionMean, double flowWidthAtBottomProtectionStandardDeviation,
                                 double probabilityOpenStructureBeforeFlooding,
                                 double failureProbablityOpenStructure,
@@ -85,21 +85,21 @@
             )
             : base(name, id, location)
         {
-            StorageStructureArea = new LogNormalDistribution(2)
+            StorageStructureArea = new VariationCoefficientLogNormalDistribution(2)
             {
                 Mean = new RoundedDouble(2, storageStructureAreaMean),
-                StandardDeviation = new RoundedDouble(2, storageStructureAreaStandardDeviation)
+                CoefficientOfVariation = new RoundedDouble(2, storageStructureAreaCoefficientOfVariation)
             };
             AllowedLevelIncreaseStorage = new LogNormalDistribution(2)
             {
                 Mean = new RoundedDouble(2, allowedLevelIncreaseStorageMean),
                 StandardDeviation = new RoundedDouble(2, allowedLevelIncreaseStorageStandardDeviation)
             };
             StructureNormalOrientation = new RoundedDouble(2, structureNormalOrientation);
-            WidthFlowApertures = new NormalDistribution(2)
+            WidthFlowApertures = new VariationCoefficientNormalDistribution(2)
             {
                 Mean = new RoundedDouble(2, widthFlowAperturesMean),
-                StandardDeviation = new RoundedDouble(2, widthFlowAperturesStandardDeviation)
+                CoefficientOfVariation = new RoundedDouble(2, widthFlowAperturesCoefficientOfVariation)
             };
             LevelCrestStructureNotClosing = new NormalDistribution(2)
             {
@@ -121,10 +121,10 @@
                 Mean = new RoundedDouble(2, areaFlowAperturesMean),
                 StandardDeviation = new RoundedDouble(2, areaFlowAperturesStandardDeviation)
             };
-            CriticalOvertoppingDischarge = new LogNormalDistribution(2)
+            CriticalOvertoppingDischarge = new VariationCoefficientLogNormalDistribution(2)
             {
                 Mean = new RoundedDouble(2, criticalOvertoppingDischargeMean),
-                StandardDeviation = new RoundedDouble(2, criticalOvertoppingDischargeStandardDeviation)
+                CoefficientOfVariation = new RoundedDouble(2, criticalOvertoppingDischargeCoefficientOfVariation)
             };
             FlowWidthAtBottomProtection = new LogNormalDistribution(2)
             {
@@ -141,7 +141,7 @@
         /// <summary>
         /// Gets the storage area of the closing structure.
         /// </summary>
-        public LogNormalDistribution StorageStructureArea { get; private set; }
+        public VariationCoefficientLogNormalDistribution StorageStructureArea { get; private set; }
 
         /// <summary>
         /// Gets the allowed increase of level for storage of the closing structure.
@@ -156,7 +156,7 @@
         /// <summary>
         /// Gets the width of the flow apertures of the closing structure.
         /// </summary>
-        public NormalDistribution WidthFlowApertures { get; private set; }
+        public VariationCoefficientNormalDistribution WidthFlowApertures { get; private set; }
 
         /// <summary>
         /// Gets the crest level of the opened closing structure.
@@ -181,7 +181,7 @@
         /// <summary>
         /// Gets the critical overtopping discharge of the closing structure.
         /// </summary>
-        public LogNormalDistribution CriticalOvertoppingDischarge { get; private set; }
+        public VariationCoefficientLogNormalDistribution CriticalOvertoppingDischarge { get; private set; }
 
         /// <summary>
         /// Gets the flow width of the closing structure at the bottom protection.
Index: Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructureTest.cs
===================================================================
diff -u -r2f6400116d57c2b49f7089dbc9c8cd935c185a36 -rc10a30c04073ef3a1fc90dce4ccc081c02836b1c
--- Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructureTest.cs	(.../ClosingStructureTest.cs)	(revision 2f6400116d57c2b49f7089dbc9c8cd935c185a36)
+++ Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructureTest.cs	(.../ClosingStructureTest.cs)	(revision c10a30c04073ef3a1fc90dce4ccc081c02836b1c)
@@ -62,15 +62,13 @@
             Assert.AreEqual(location.X, structure.Location.X);
             Assert.AreEqual(location.Y, structure.Location.Y);
 
-            var storageStructureArea = structure.StorageStructureArea;
-            Assert.IsInstanceOf<LogNormalDistribution>(storageStructureArea);
+            VariationCoefficientLogNormalDistribution storageStructureArea = structure.StorageStructureArea;
             Assert.AreEqual(2, storageStructureArea.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(123.46, storageStructureArea.Mean.Value);
-            Assert.AreEqual(2, storageStructureArea.StandardDeviation.NumberOfDecimalPlaces);
-            Assert.AreEqual(0.12, storageStructureArea.StandardDeviation.Value);
+            Assert.AreEqual(2, storageStructureArea.CoefficientOfVariation.NumberOfDecimalPlaces);
+            Assert.AreEqual(0.12, storageStructureArea.CoefficientOfVariation.Value);
 
-            var allowedLevelIncreaseStorage = structure.AllowedLevelIncreaseStorage;
-            Assert.IsInstanceOf<LogNormalDistribution>(allowedLevelIncreaseStorage);
+            LogNormalDistribution allowedLevelIncreaseStorage = structure.AllowedLevelIncreaseStorage;
             Assert.AreEqual(2, allowedLevelIncreaseStorage.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(234.57, allowedLevelIncreaseStorage.Mean.Value);
             Assert.AreEqual(2, allowedLevelIncreaseStorage.StandardDeviation.NumberOfDecimalPlaces);
@@ -80,50 +78,43 @@
             Assert.AreEqual(2, structure.StructureNormalOrientation.NumberOfDecimalPlaces);
             Assert.AreEqual(345.68, structure.StructureNormalOrientation.Value);
 
-            var widthFlowApertures = structure.WidthFlowApertures;
-            Assert.IsInstanceOf<NormalDistribution>(widthFlowApertures);
+            VariationCoefficientNormalDistribution widthFlowApertures = structure.WidthFlowApertures;
             Assert.AreEqual(2, widthFlowApertures.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(456.79, widthFlowApertures.Mean.Value);
-            Assert.AreEqual(2, widthFlowApertures.StandardDeviation.NumberOfDecimalPlaces);
-            Assert.AreEqual(0.46, widthFlowApertures.StandardDeviation.Value);
+            Assert.AreEqual(2, widthFlowApertures.CoefficientOfVariation.NumberOfDecimalPlaces);
+            Assert.AreEqual(0.46, widthFlowApertures.CoefficientOfVariation.Value);
 
-            var levelCrestStructureNotClosing = structure.LevelCrestStructureNotClosing;
-            Assert.IsInstanceOf<NormalDistribution>(levelCrestStructureNotClosing);
+            NormalDistribution levelCrestStructureNotClosing = structure.LevelCrestStructureNotClosing;
             Assert.AreEqual(2, levelCrestStructureNotClosing.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(567.89, levelCrestStructureNotClosing.Mean.Value);
             Assert.AreEqual(2, levelCrestStructureNotClosing.StandardDeviation.NumberOfDecimalPlaces);
             Assert.AreEqual(0.57, levelCrestStructureNotClosing.StandardDeviation.Value);
 
-            var insideWaterLevel = structure.InsideWaterLevel;
-            Assert.IsInstanceOf<NormalDistribution>(insideWaterLevel);
+            NormalDistribution insideWaterLevel = structure.InsideWaterLevel;
             Assert.AreEqual(2, insideWaterLevel.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(678.90, insideWaterLevel.Mean.Value);
             Assert.AreEqual(2, insideWaterLevel.StandardDeviation.NumberOfDecimalPlaces);
             Assert.AreEqual(0.68, insideWaterLevel.StandardDeviation.Value);
 
-            var thresholdHeightOpenWeir = structure.ThresholdHeightOpenWeir;
-            Assert.IsInstanceOf<NormalDistribution>(thresholdHeightOpenWeir);
+            NormalDistribution thresholdHeightOpenWeir = structure.ThresholdHeightOpenWeir;
             Assert.AreEqual(2, thresholdHeightOpenWeir.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(789.01, thresholdHeightOpenWeir.Mean.Value);
             Assert.AreEqual(2, thresholdHeightOpenWeir.StandardDeviation.NumberOfDecimalPlaces);
             Assert.AreEqual(0.79, thresholdHeightOpenWeir.StandardDeviation.Value);
 
-            var areaFlowApertures = structure.AreaFlowApertures;
-            Assert.IsInstanceOf<LogNormalDistribution>(areaFlowApertures);
+            LogNormalDistribution areaFlowApertures = structure.AreaFlowApertures;
             Assert.AreEqual(2, areaFlowApertures.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(890.12, areaFlowApertures.Mean.Value);
             Assert.AreEqual(2, areaFlowApertures.StandardDeviation.NumberOfDecimalPlaces);
             Assert.AreEqual(0.89, areaFlowApertures.StandardDeviation.Value);
 
-            var criticalOvertoppingDischarge = structure.CriticalOvertoppingDischarge;
-            Assert.IsInstanceOf<LogNormalDistribution>(criticalOvertoppingDischarge);
+            VariationCoefficientLogNormalDistribution criticalOvertoppingDischarge = structure.CriticalOvertoppingDischarge;
             Assert.AreEqual(2, criticalOvertoppingDischarge.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(901.23, criticalOvertoppingDischarge.Mean.Value);
-            Assert.AreEqual(2, criticalOvertoppingDischarge.StandardDeviation.NumberOfDecimalPlaces);
-            Assert.AreEqual(0.90, criticalOvertoppingDischarge.StandardDeviation.Value);
+            Assert.AreEqual(2, criticalOvertoppingDischarge.CoefficientOfVariation.NumberOfDecimalPlaces);
+            Assert.AreEqual(0.90, criticalOvertoppingDischarge.CoefficientOfVariation.Value);
 
-            var flowWidthAtBottomProtection = structure.FlowWidthAtBottomProtection;
-            Assert.IsInstanceOf<LogNormalDistribution>(flowWidthAtBottomProtection);
+            LogNormalDistribution flowWidthAtBottomProtection = structure.FlowWidthAtBottomProtection;
             Assert.AreEqual(2, flowWidthAtBottomProtection.Mean.NumberOfDecimalPlaces);
             Assert.AreEqual(111.22, flowWidthAtBottomProtection.Mean.Value);
             Assert.AreEqual(2, flowWidthAtBottomProtection.StandardDeviation.NumberOfDecimalPlaces);