Index: Demo/Ringtoets/test/Demo.Ringtoets.Test/Commands/AddNewDemoAssessmentSectionCommandTest.cs =================================================================== diff -u -r1f0cd3fafaa7340a446612870810629587474302 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Demo/Ringtoets/test/Demo.Ringtoets.Test/Commands/AddNewDemoAssessmentSectionCommandTest.cs (.../AddNewDemoAssessmentSectionCommandTest.cs) (revision 1f0cd3fafaa7340a446612870810629587474302) +++ Demo/Ringtoets/test/Demo.Ringtoets.Test/Commands/AddNewDemoAssessmentSectionCommandTest.cs (.../AddNewDemoAssessmentSectionCommandTest.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -417,24 +417,24 @@ Assert.AreEqual(1300001, inputParameters.HydraulicBoundaryLocation.Id); Assert.AreEqual(5.78, inputParameters.HydraulicBoundaryLocation.DesignWaterLevel, 1e-3); - Assert.AreEqual(0.875, PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(inputParameters).GetDesignValue(), + Assert.AreEqual(0.875, PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(inputParameters).GetDesignValue(), inputParameters.DampingFactorExit.GetAccuracy()); - Assert.AreEqual(2.836, PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), + Assert.AreEqual(2.836, PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), inputParameters.PhreaticLevelExit.GetAccuracy()); - Assert.AreEqual(0.011453, PipingSemiProbabilisticDesignValueFactory.GetDiameter70(inputParameters).GetDesignValue(), + Assert.AreEqual(0.011453, PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue(), inputParameters.Diameter70.GetAccuracy()); - Assert.AreEqual(1.179896, PipingSemiProbabilisticDesignValueFactory.GetDarcyPermeability(inputParameters).GetDesignValue(), + Assert.AreEqual(1.179896, PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(inputParameters).GetDesignValue(), inputParameters.DarcyPermeability.GetAccuracy()); - Assert.AreEqual(17.5, PipingSemiProbabilisticDesignValueFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(), + Assert.AreEqual(17.5, PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(), inputParameters.SaturatedVolumicWeightOfCoverageLayer.GetAccuracy()); Assert.AreEqual(5.41, inputParameters.PiezometricHeadExit, 1e-2); Assert.AreEqual(106.13, inputParameters.ExitPointL, 1e-2); - Assert.AreEqual(81.18, PipingSemiProbabilisticDesignValueFactory.GetSeepageLength(inputParameters).GetDesignValue(), + Assert.AreEqual(81.18, PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(inputParameters).GetDesignValue(), inputParameters.DampingFactorExit.GetAccuracy()); - Assert.AreEqual(5.86, PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(inputParameters).GetDesignValue(), + Assert.AreEqual(5.86, PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(inputParameters).GetDesignValue(), inputParameters.DampingFactorExit.GetAccuracy()); - Assert.AreEqual(20.13, PipingSemiProbabilisticDesignValueFactory.GetThicknessAquiferLayer(inputParameters).GetDesignValue(), + Assert.AreEqual(20.13, PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(inputParameters).GetDesignValue(), inputParameters.DampingFactorExit.GetAccuracy()); } Fisheye: Tag b807a83a281be5e9f4645d35ba7da968a0a5e26f refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSemiProbabilisticDesignValueFactory.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.cs (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -0,0 +1,120 @@ +// 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 . +// +// 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 Ringtoets.Common.Data.Probabilistics; +using Ringtoets.MacroStabilityInwards.Primitives.MacroStabilityInwardsSoilUnderSurfaceLine; + +namespace Ringtoets.MacroStabilityInwards.Data +{ + /// + /// Factory for creating design variables based on probabilistic distributions for macrostability. + /// + public static class MacroStabilityInwardsSemiProbabilisticDesignVariableFactory + { + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetAbovePhreaticLevel(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine properties) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(properties.AbovePhreaticLevel) + { + Percentile = 0.5 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetBelowPhreaticLevel(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine properties) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(properties.BelowPhreaticLevel) + { + Percentile = 0.5 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetCohesion(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine properties) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(properties.Cohesion) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetFrictionAngle(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine properties) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(properties.FrictionAngle) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetShearStrengthRatio(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine properties) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(properties.ShearStrengthRatio) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetStrengthIncreaseExponent(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine properties) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(properties.StrengthIncreaseExponent) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetPop(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine properties) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(properties.Pop) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetPreconsolidationStress(MacroStabilityInwardsPreconsolidationStressUnderSurfaceLine preconsolidationStressUnderSurfaceLine) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(preconsolidationStressUnderSurfaceLine.PreconsolidationStress) + { + Percentile = 0.05 + }; + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/Ringtoets.MacroStabilityInwards.Data.csproj =================================================================== diff -u -r3ac5065bf73f4816c743eed9668504af7485b4bc -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/Ringtoets.MacroStabilityInwards.Data.csproj (.../Ringtoets.MacroStabilityInwards.Data.csproj) (revision 3ac5065bf73f4816c743eed9668504af7485b4bc) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/Ringtoets.MacroStabilityInwards.Data.csproj (.../Ringtoets.MacroStabilityInwards.Data.csproj) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -48,7 +48,7 @@ - + Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/SoilProfile/MacroStabilityInwardsSoilProfileUnderSurfaceLineFactory.cs =================================================================== diff -u -reae3622163e0c8bdfc32f73eda6f5bd8d3b02484 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/SoilProfile/MacroStabilityInwardsSoilProfileUnderSurfaceLineFactory.cs (.../MacroStabilityInwardsSoilProfileUnderSurfaceLineFactory.cs) (revision eae3622163e0c8bdfc32f73eda6f5bd8d3b02484) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/SoilProfile/MacroStabilityInwardsSoilProfileUnderSurfaceLineFactory.cs (.../MacroStabilityInwardsSoilProfileUnderSurfaceLineFactory.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -144,21 +144,21 @@ }); macroStabilityInwardsPreconsolidationStressUnderSurfaceLine.PreconsolidationStressDesignVariable = - MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetPreconsolidationStress(macroStabilityInwardsPreconsolidationStressUnderSurfaceLine) - .GetDesignValue(); + MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetPreconsolidationStress(macroStabilityInwardsPreconsolidationStressUnderSurfaceLine) + .GetDesignValue(); return macroStabilityInwardsPreconsolidationStressUnderSurfaceLine; } private static void SetDesignVariablesOfProperties(MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine props) { - props.AbovePhreaticLevelDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetAbovePhreaticLevel(props).GetDesignValue(); - props.BelowPhreaticLevelDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetBelowPhreaticLevel(props).GetDesignValue(); - props.CohesionDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetCohesion(props).GetDesignValue(); - props.FrictionAngleDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetFrictionAngle(props).GetDesignValue(); - props.StrengthIncreaseExponentDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetStrengthIncreaseExponent(props).GetDesignValue(); - props.ShearStrengthRatioDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetShearStrengthRatio(props).GetDesignValue(); - props.PopDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetPop(props).GetDesignValue(); + props.AbovePhreaticLevelDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetAbovePhreaticLevel(props).GetDesignValue(); + props.BelowPhreaticLevelDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetBelowPhreaticLevel(props).GetDesignValue(); + props.CohesionDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetCohesion(props).GetDesignValue(); + props.FrictionAngleDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetFrictionAngle(props).GetDesignValue(); + props.StrengthIncreaseExponentDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetStrengthIncreaseExponent(props).GetDesignValue(); + props.ShearStrengthRatioDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetShearStrengthRatio(props).GetDesignValue(); + props.PopDesignVariable = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetPop(props).GetDesignValue(); } private static Point2D[] RingToPoints(Ring ring) Fisheye: Tag b807a83a281be5e9f4645d35ba7da968a0a5e26f refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSemiProbabilisticDesignValueFactoryTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSemiProbabilisticDesignVariableFactoryTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSemiProbabilisticDesignVariableFactoryTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSemiProbabilisticDesignVariableFactoryTest.cs (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -0,0 +1,205 @@ +// 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 . +// +// 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 NUnit.Framework; +using Ringtoets.Common.Data.Probabilistics; +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.MacroStabilityInwards.Primitives.MacroStabilityInwardsSoilUnderSurfaceLine; + +namespace Ringtoets.MacroStabilityInwards.Data.Test +{ + [TestFixture] + public class MacroStabilityInwardsSemiProbabilisticDesignVariableFactoryTest + { + private Random random; + private double mean; + private double coefficientOfVariation; + + [SetUp] + public void Setup() + { + random = new Random(21); + mean = random.NextDouble(); + coefficientOfVariation = random.NextDouble(); + } + + [Test] + public void GetAbovePhreaticLevel_ValidSoilLayerProperties_CreateDesignVariableForAbovePhreaticLevel() + { + // Setup + var properties = new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine( + new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine.ConstructionProperties + { + AbovePhreaticLevelMean = mean, + AbovePhreaticLevelCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable abovePhreaticLevel = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetAbovePhreaticLevel(properties); + + // Assert + DistributionAssert.AreEqual(properties.AbovePhreaticLevel, abovePhreaticLevel.Distribution); + AssertPercentile(0.5, abovePhreaticLevel); + } + + [Test] + public void GetBelowPhreaticLevel_ValidSoilLayerProperties_CreateDesignVariableForBelowPhreaticLevel() + { + // Setup + var properties = new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine( + new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine.ConstructionProperties + { + BelowPhreaticLevelMean = mean, + BelowPhreaticLevelCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable belowPhreaticLevel = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetBelowPhreaticLevel(properties); + + // Assert + DistributionAssert.AreEqual(properties.BelowPhreaticLevel, belowPhreaticLevel.Distribution); + AssertPercentile(0.5, belowPhreaticLevel); + } + + [Test] + public void GetCohesion_ValidSoilLayerProperties_CreateDesignVariableForCohesion() + { + // Setup + var properties = new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine( + new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine.ConstructionProperties + { + CohesionMean = mean, + CohesionCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable cohesion = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetCohesion(properties); + + // Assert + DistributionAssert.AreEqual(properties.Cohesion, cohesion.Distribution); + AssertPercentile(0.05, cohesion); + } + + [Test] + public void GetFrictionAngle_ValidSoilLayerProperties_CreateDesignVariableForFrictionAngle() + { + // Setup + var properties = new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine( + new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine.ConstructionProperties + { + FrictionAngleMean = mean, + FrictionAngleCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable frictionAngle = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetFrictionAngle(properties); + + // Assert + DistributionAssert.AreEqual(properties.FrictionAngle, frictionAngle.Distribution); + AssertPercentile(0.05, frictionAngle); + } + + [Test] + public void GetShearStrengthRatio_ValidSoilLayerProperties_CreateDesignVariableForShearStrengthRatio() + { + // Setup + var properties = new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine( + new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine.ConstructionProperties + { + ShearStrengthRatioMean = mean, + ShearStrengthRatioCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable shearStrengthRatio = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetShearStrengthRatio(properties); + + // Assert + DistributionAssert.AreEqual(properties.ShearStrengthRatio, shearStrengthRatio.Distribution); + AssertPercentile(0.05, shearStrengthRatio); + } + + [Test] + public void GetStrengthIncreaseExponent_ValidSoilLayerProperties_CreateDesignVariableForStrengthIncreaseExponent() + { + // Setup + var properties = new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine( + new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine.ConstructionProperties + { + StrengthIncreaseExponentMean = mean, + StrengthIncreaseExponentCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable strengthIncreaseExponent = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetStrengthIncreaseExponent(properties); + + // Assert + DistributionAssert.AreEqual(properties.StrengthIncreaseExponent, strengthIncreaseExponent.Distribution); + AssertPercentile(0.05, strengthIncreaseExponent); + } + + [Test] + public void GetPop_ValidSoilLayerProperties_CreateDesignVariableForPop() + { + // Setup + var properties = new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine( + new MacroStabilityInwardsSoilLayerPropertiesUnderSurfaceLine.ConstructionProperties + { + PopMean = mean, + PopCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable pop = MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetPop(properties); + + // Assert + DistributionAssert.AreEqual(properties.Pop, pop.Distribution); + AssertPercentile(0.05, pop); + } + + [Test] + public void GetPreconsolidationStress_ValidPreconsolidationStress_CreateDesignVariableForPreconsolidationStress() + { + // Setup + var preconsolidationStressUnderSurfaceLine = new MacroStabilityInwardsPreconsolidationStressUnderSurfaceLine( + new MacroStabilityInwardsPreconsolidationStressUnderSurfaceLine.ConstructionProperties + { + PreconsolidationStressMean = mean, + PreconsolidationStressCoefficientOfVariation = coefficientOfVariation + }); + + // Call + VariationCoefficientDesignVariable preconsoldationStress = + MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetPreconsolidationStress(preconsolidationStressUnderSurfaceLine); + + // Assert + DistributionAssert.AreEqual(preconsolidationStressUnderSurfaceLine.PreconsolidationStress, preconsoldationStress.Distribution); + AssertPercentile(0.05, preconsoldationStress); + } + + private static void AssertPercentile(double percentile, VariationCoefficientDesignVariable designVariable) + { + Assert.IsInstanceOf(designVariable); + var percentileBasedDesignVariable = (VariationCoefficientLogNormalDistributionDesignVariable) designVariable; + Assert.AreEqual(percentile, percentileBasedDesignVariable.Percentile); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj =================================================================== diff -u -r3ac5065bf73f4816c743eed9668504af7485b4bc -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj (.../Ringtoets.MacroStabilityInwards.Data.Test.csproj) (revision 3ac5065bf73f4816c743eed9668504af7485b4bc) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj (.../Ringtoets.MacroStabilityInwards.Data.Test.csproj) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -61,7 +61,7 @@ - + Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/SoilProfile/MacroStabilityInwardsSoilProfileUnderSurfaceLineFactoryTest.cs =================================================================== diff -u -reae3622163e0c8bdfc32f73eda6f5bd8d3b02484 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/SoilProfile/MacroStabilityInwardsSoilProfileUnderSurfaceLineFactoryTest.cs (.../MacroStabilityInwardsSoilProfileUnderSurfaceLineFactoryTest.cs) (revision eae3622163e0c8bdfc32f73eda6f5bd8d3b02484) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/SoilProfile/MacroStabilityInwardsSoilProfileUnderSurfaceLineFactoryTest.cs (.../MacroStabilityInwardsSoilProfileUnderSurfaceLineFactoryTest.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -586,7 +586,7 @@ preconsolidationStressUnderSurfaceLine.PreconsolidationStress.CoefficientOfVariation, preconsolidationStressUnderSurfaceLine.PreconsolidationStress.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetPreconsolidationStress(preconsolidationStressUnderSurfaceLine).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetPreconsolidationStress(preconsolidationStressUnderSurfaceLine).GetDesignValue(), preconsolidationStressUnderSurfaceLine.PreconsolidationStressDesignVariable); } @@ -603,49 +603,49 @@ properties.AbovePhreaticLevel.Mean.GetAccuracy()); Assert.AreEqual(abovePhreaticLevelCoefficientOfVariation, properties.AbovePhreaticLevel.CoefficientOfVariation, properties.AbovePhreaticLevel.CoefficientOfVariation.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetAbovePhreaticLevel(properties).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetAbovePhreaticLevel(properties).GetDesignValue(), properties.AbovePhreaticLevelDesignVariable); Assert.AreEqual(belowPhreaticLevelMean, properties.BelowPhreaticLevel.Mean, properties.BelowPhreaticLevel.Mean.GetAccuracy()); Assert.AreEqual(belowPhreaticLevelCoefficientOfVariation, properties.BelowPhreaticLevel.CoefficientOfVariation, properties.BelowPhreaticLevel.CoefficientOfVariation.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetBelowPhreaticLevel(properties).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetBelowPhreaticLevel(properties).GetDesignValue(), properties.BelowPhreaticLevelDesignVariable); Assert.AreEqual(cohesionMean, properties.Cohesion.Mean, properties.Cohesion.Mean.GetAccuracy()); Assert.AreEqual(cohesionCoefficientOfVariation, properties.Cohesion.CoefficientOfVariation, properties.Cohesion.CoefficientOfVariation.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetCohesion(properties).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetCohesion(properties).GetDesignValue(), properties.CohesionDesignVariable); Assert.AreEqual(frictionAngleMean, properties.FrictionAngle.Mean, properties.FrictionAngle.Mean.GetAccuracy()); Assert.AreEqual(frictionAngleCoefficientOfVariation, properties.FrictionAngle.CoefficientOfVariation, properties.FrictionAngle.CoefficientOfVariation.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetFrictionAngle(properties).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetFrictionAngle(properties).GetDesignValue(), properties.FrictionAngleDesignVariable); Assert.AreEqual(shearStrengthRatioMean, properties.ShearStrengthRatio.Mean, properties.ShearStrengthRatio.Mean.GetAccuracy()); Assert.AreEqual(shearStrengthRatioCoefficientOfVariation, properties.ShearStrengthRatio.CoefficientOfVariation, properties.ShearStrengthRatio.CoefficientOfVariation.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetShearStrengthRatio(properties).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetShearStrengthRatio(properties).GetDesignValue(), properties.ShearStrengthRatioDesignVariable); Assert.AreEqual(strengthIncreaseExponentMean, properties.StrengthIncreaseExponent.Mean, properties.StrengthIncreaseExponent.Mean.GetAccuracy()); Assert.AreEqual(strengthIncreaseExponentCoefficientOfVariation, properties.StrengthIncreaseExponent.CoefficientOfVariation, properties.StrengthIncreaseExponent.CoefficientOfVariation.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetStrengthIncreaseExponent(properties).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetStrengthIncreaseExponent(properties).GetDesignValue(), properties.StrengthIncreaseExponentDesignVariable); Assert.AreEqual(popMean, properties.Pop.Mean, properties.Pop.Mean.GetAccuracy()); Assert.AreEqual(popCoefficientOfVariation, properties.Pop.CoefficientOfVariation, properties.Pop.CoefficientOfVariation.GetAccuracy()); - Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignValueFactory.GetPop(properties).GetDesignValue(), + Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetPop(properties).GetDesignValue(), properties.PopDesignVariable); } Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/DerivedPipingInput.cs =================================================================== diff -u -r26f527fb809a2325c8f883ece9da01a8f8040eb3 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/src/Ringtoets.Piping.Data/DerivedPipingInput.cs (.../DerivedPipingInput.cs) (revision 26f527fb809a2325c8f883ece9da01a8f8040eb3) +++ Ringtoets/Piping/src/Ringtoets.Piping.Data/DerivedPipingInput.cs (.../DerivedPipingInput.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -62,8 +62,8 @@ { get { - RoundedDouble dampingFactorExit = PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(); - RoundedDouble phreaticLevelExit = PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(); + RoundedDouble dampingFactorExit = PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(); + RoundedDouble phreaticLevelExit = PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(); return new RoundedDouble(2, InputParameterCalculationService.CalculatePiezometricHeadAtExit(input.AssessmentLevel, dampingFactorExit, @@ -246,7 +246,7 @@ var weightedMean = new RoundedDouble(GetNumberOfDecimals(effectiveThicknessCoverageLayerDistribution), InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile)); Fisheye: Tag b807a83a281be5e9f4645d35ba7da968a0a5e26f refers to a dead (removed) revision in file `Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticDesignValueFactory.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticDesignVariableFactory.cs =================================================================== diff -u --- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticDesignVariableFactory.cs (revision 0) +++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticDesignVariableFactory.cs (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -0,0 +1,153 @@ +// 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 . +// +// 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 Ringtoets.Common.Data.Probabilistics; + +namespace Ringtoets.Piping.Data +{ + /// + /// Factory for creating design variables based on probabilistic distributions for piping. + /// + public static class PipingSemiProbabilisticDesignVariableFactory + { + #region General parameters + + /// + /// Creates the design variable for . + /// + public static DesignVariable GetSaturatedVolumicWeightOfCoverageLayer(PipingInput parameters) + { + if (double.IsNaN(parameters.ThicknessCoverageLayer.Mean)) + { + return new DeterministicDesignVariable(parameters.SaturatedVolumicWeightOfCoverageLayer); + } + + return new LogNormalDistributionDesignVariable(parameters.SaturatedVolumicWeightOfCoverageLayer) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static DesignVariable GetThicknessCoverageLayer(PipingInput parameters) + { + if (double.IsNaN(parameters.ThicknessCoverageLayer.Mean)) + { + return new DeterministicDesignVariable(parameters.ThicknessCoverageLayer); + } + + return new LogNormalDistributionDesignVariable(parameters.ThicknessCoverageLayer) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static DesignVariable GetEffectiveThicknessCoverageLayer(PipingInput parameters) + { + if (double.IsNaN(parameters.ThicknessCoverageLayer.Mean)) + { + return new DeterministicDesignVariable(parameters.EffectiveThicknessCoverageLayer); + } + + return new LogNormalDistributionDesignVariable(parameters.EffectiveThicknessCoverageLayer) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static DesignVariable GetPhreaticLevelExit(PipingInput parameters) + { + return new NormalDistributionDesignVariable(parameters.PhreaticLevelExit) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static DesignVariable GetDampingFactorExit(PipingInput parameters) + { + return new LogNormalDistributionDesignVariable(parameters.DampingFactorExit) + { + Percentile = 0.95 + }; + } + + #endregion + + #region Piping parameters + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetSeepageLength(PipingInput parameters) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(parameters.SeepageLength) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetDiameter70(PipingInput parameters) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(parameters.Diameter70) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for . + /// + public static VariationCoefficientDesignVariable GetDarcyPermeability(PipingInput parameters) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(parameters.DarcyPermeability) + { + Percentile = 0.95 + }; + } + + /// + /// Creates the design variable for . + /// + public static DesignVariable GetThicknessAquiferLayer(PipingInput parameters) + { + return new LogNormalDistributionDesignVariable(parameters.ThicknessAquiferLayer) + { + Percentile = 0.95 + }; + } + + #endregion + } +} \ No newline at end of file Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj =================================================================== diff -u -r26f527fb809a2325c8f883ece9da01a8f8040eb3 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj (.../Ringtoets.Piping.Data.csproj) (revision 26f527fb809a2325c8f883ece9da01a8f8040eb3) +++ Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj (.../Ringtoets.Piping.Data.csproj) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -49,7 +49,7 @@ - + Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingInputContextProperties.cs =================================================================== diff -u -r26f527fb809a2325c8f883ece9da01a8f8040eb3 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingInputContextProperties.cs (.../PipingInputContextProperties.cs) (revision 26f527fb809a2325c8f883ece9da01a8f8040eb3) +++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingInputContextProperties.cs (.../PipingInputContextProperties.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -228,7 +228,7 @@ get { return new LogNormalDistributionDesignVariableProperties(DistributionPropertiesReadOnly.None, - PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(data.WrappedData), + PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(data.WrappedData), propertyChangeHandler); } } @@ -243,7 +243,7 @@ get { return new NormalDistributionDesignVariableProperties(DistributionPropertiesReadOnly.None, - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(data.WrappedData), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(data.WrappedData), propertyChangeHandler); } } @@ -376,7 +376,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignValueFactory.GetSeepageLength(data.WrappedData)); + PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(data.WrappedData)); } } @@ -390,7 +390,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(data.WrappedData)); + PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(data.WrappedData)); } } @@ -404,7 +404,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignValueFactory.GetEffectiveThicknessCoverageLayer(data.WrappedData)); + PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(data.WrappedData)); } } @@ -418,7 +418,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignValueFactory.GetThicknessAquiferLayer(data.WrappedData)); + PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(data.WrappedData)); } } @@ -432,7 +432,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignValueFactory.GetDarcyPermeability(data.WrappedData)); + PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(data.WrappedData)); } } @@ -446,7 +446,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignValueFactory.GetDiameter70(data.WrappedData)); + PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(data.WrappedData)); } } @@ -460,7 +460,7 @@ get { return new ShiftedLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignValueFactory.GetSaturatedVolumicWeightOfCoverageLayer(data.WrappedData)); + PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(data.WrappedData)); } } Index: Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingCalculationService.cs =================================================================== diff -u -r92210258706d0f57e05552037b676bd941a6fe19 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingCalculationService.cs (.../PipingCalculationService.cs) (revision 92210258706d0f57e05552037b676bd941a6fe19) +++ Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingCalculationService.cs (.../PipingCalculationService.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -227,12 +227,12 @@ } else { - if (double.IsNaN(PipingSemiProbabilisticDesignValueFactory.GetDarcyPermeability(inputParameters).GetDesignValue())) + if (double.IsNaN(PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(inputParameters).GetDesignValue())) { validationResult.Add(Resources.PipingCalculationService_ValidateInput_Cannot_derive_DarcyPermeability); } - if (double.IsNaN(PipingSemiProbabilisticDesignValueFactory.GetDiameter70(inputParameters).GetDesignValue())) + if (double.IsNaN(PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue())) { validationResult.Add(Resources.PipingCalculationService_ValidateInput_Cannot_derive_Diameter70); } @@ -248,7 +248,7 @@ if (hasConsecutiveCoverageLayers) { RoundedDouble saturatedVolumicWeightOfCoverageLayer = - PipingSemiProbabilisticDesignValueFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(); + PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(); if (double.IsNaN(saturatedVolumicWeightOfCoverageLayer)) { @@ -303,7 +303,7 @@ { var warnings = new List(); - RoundedDouble diameter70Value = PipingSemiProbabilisticDesignValueFactory.GetDiameter70(inputParameters).GetDesignValue(); + RoundedDouble diameter70Value = PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue(); if (!double.IsNaN(diameter70Value) && (diameter70Value < 6.3e-5 || diameter70Value > 0.5e-3)) { @@ -349,25 +349,25 @@ new PipingCalculatorInput.ConstructionProperties { WaterVolumetricWeight = inputParameters.WaterVolumetricWeight, - SaturatedVolumicWeightOfCoverageLayer = PipingSemiProbabilisticDesignValueFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(), + SaturatedVolumicWeightOfCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(), UpliftModelFactor = inputParameters.UpliftModelFactor, AssessmentLevel = inputParameters.AssessmentLevel, PiezometricHeadExit = inputParameters.PiezometricHeadExit, - DampingFactorExit = PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(inputParameters).GetDesignValue(), - PhreaticLevelExit = PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), + DampingFactorExit = PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(inputParameters).GetDesignValue(), + PhreaticLevelExit = PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), CriticalHeaveGradient = inputParameters.CriticalHeaveGradient, - ThicknessCoverageLayer = PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(inputParameters).GetDesignValue(), - EffectiveThicknessCoverageLayer = PipingSemiProbabilisticDesignValueFactory.GetEffectiveThicknessCoverageLayer(inputParameters).GetDesignValue(), + ThicknessCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(inputParameters).GetDesignValue(), + EffectiveThicknessCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(inputParameters).GetDesignValue(), SellmeijerModelFactor = inputParameters.SellmeijerModelFactor, SellmeijerReductionFactor = inputParameters.SellmeijerReductionFactor, - SeepageLength = PipingSemiProbabilisticDesignValueFactory.GetSeepageLength(inputParameters).GetDesignValue(), + SeepageLength = PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(inputParameters).GetDesignValue(), SandParticlesVolumicWeight = inputParameters.SandParticlesVolumicWeight, WhitesDragCoefficient = inputParameters.WhitesDragCoefficient, - Diameter70 = PipingSemiProbabilisticDesignValueFactory.GetDiameter70(inputParameters).GetDesignValue(), - DarcyPermeability = PipingSemiProbabilisticDesignValueFactory.GetDarcyPermeability(inputParameters).GetDesignValue(), + Diameter70 = PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue(), + DarcyPermeability = PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(inputParameters).GetDesignValue(), WaterKinematicViscosity = inputParameters.WaterKinematicViscosity, Gravity = inputParameters.Gravity, - ThicknessAquiferLayer = PipingSemiProbabilisticDesignValueFactory.GetThicknessAquiferLayer(inputParameters).GetDesignValue(), + ThicknessAquiferLayer = PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(inputParameters).GetDesignValue(), MeanDiameter70 = inputParameters.MeanDiameter70, BeddingAngle = inputParameters.BeddingAngle, ExitPointXCoordinate = inputParameters.ExitPointL, Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingInputTest.cs =================================================================== diff -u -rad0f4a7a0f8b9f065da77eda1a450ac3696b8f7f -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingInputTest.cs (.../DerivedPipingInputTest.cs) (revision ad0f4a7a0f8b9f065da77eda1a450ac3696b8f7f) +++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/DerivedPipingInputTest.cs (.../DerivedPipingInputTest.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -80,9 +80,9 @@ PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator; Assert.AreEqual(piezometricHeadAtExitCalculator.HRiver, input.AssessmentLevel, input.AssessmentLevel.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, input.PhreaticLevelExit.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, input.DampingFactorExit.GetAccuracy()); } } Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingInputTest.cs =================================================================== diff -u -rb85ea570b1c4b07ac07df0912089909bc5304cbc -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingInputTest.cs (.../PipingInputTest.cs) (revision b85ea570b1c4b07ac07df0912089909bc5304cbc) +++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingInputTest.cs (.../PipingInputTest.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -789,9 +789,9 @@ PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator; Assert.AreEqual(piezometricHeadAtExitCalculator.HRiver, input.AssessmentLevel, input.AssessmentLevel.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, input.PhreaticLevelExit.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, input.DampingFactorExit.GetAccuracy()); } } Fisheye: Tag b807a83a281be5e9f4645d35ba7da968a0a5e26f refers to a dead (removed) revision in file `Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticDesignValueFactoryTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticDesignVariableFactoryTest.cs =================================================================== diff -u --- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticDesignVariableFactoryTest.cs (revision 0) +++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticDesignVariableFactoryTest.cs (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -0,0 +1,242 @@ +// 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 . +// +// 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.Linq; +using Core.Common.Base.Data; +using NUnit.Framework; +using Ringtoets.Common.Data.Probabilistics; +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Piping.Data.TestUtil; + +namespace Ringtoets.Piping.Data.Test +{ + [TestFixture] + public class PipingSemiProbabilisticDesignVariableFactoryTest + { + private static void AssertPercentile(double percentile, DesignVariable designVariable) where T : IDistribution + { + Assert.IsInstanceOf>(designVariable); + var percentileBasedDesignVariable = (PercentileBasedDesignVariable) designVariable; + Assert.AreEqual(percentile, percentileBasedDesignVariable.Percentile); + } + + private static void AssertPercentile(double percentile, VariationCoefficientDesignVariable designVariable) + { + Assert.IsInstanceOf(designVariable); + var percentileBasedDesignVariable = (VariationCoefficientLogNormalDistributionDesignVariable) designVariable; + Assert.AreEqual(percentile, percentileBasedDesignVariable.Percentile); + } + + #region General parameters + + [Test] + public void GetThicknessCoverageLayer_PipingInputWithCoverLayer_CreatePercentileBasedDesignVariableForThicknessCoverageLayer() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + + // Call + DesignVariable thicknessCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(thicknessCoverageLayer); + DistributionAssert.AreEqual(inputParameters.ThicknessCoverageLayer, thicknessCoverageLayer.Distribution); + AssertPercentile(0.05, thicknessCoverageLayer); + } + + [Test] + public void GetThicknessCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForThicknessCoverageLayer() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable thicknessCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(thicknessCoverageLayer); + DistributionAssert.AreEqual(inputParameters.ThicknessCoverageLayer, thicknessCoverageLayer.Distribution); + Assert.AreEqual(new RoundedDouble(2), thicknessCoverageLayer.GetDesignValue()); + } + + [Test] + public void GetEffectiveThicknessCoverageLayer_PipingInputWithCoverLayer_CreatePercentileBasedDesignVariableForEffectiveThicknessCoverageLayer() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + + // Call + DesignVariable effectiveThicknessCoverageLayer = + PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(effectiveThicknessCoverageLayer); + DistributionAssert.AreEqual(inputParameters.EffectiveThicknessCoverageLayer, effectiveThicknessCoverageLayer.Distribution); + AssertPercentile(0.05, effectiveThicknessCoverageLayer); + } + + [Test] + public void GetEffectiveThicknessCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForEffectiveThicknessCoverageLayer() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable effectiveThicknessCoverageLayer = + PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(effectiveThicknessCoverageLayer); + DistributionAssert.AreEqual(inputParameters.EffectiveThicknessCoverageLayer, effectiveThicknessCoverageLayer.Distribution); + Assert.AreEqual(new RoundedDouble(2), effectiveThicknessCoverageLayer.GetDesignValue()); + } + + [Test] + public void GetPhreaticLevelExit_ValidPipingCalculation_CreateDesignVariableForPhreaticLevelExit() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable freaticLevelExit = + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(inputParameters); + + // Assert + Assert.AreSame(inputParameters.PhreaticLevelExit, freaticLevelExit.Distribution); + AssertPercentile(0.05, freaticLevelExit); + } + + [Test] + public void GetDampingFactorExit_ValidPipingCalculation_CreateDesignVariableForDampingFactorExit() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable dampingFactorExit = + PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(inputParameters); + + // Assert + Assert.AreSame(inputParameters.DampingFactorExit, dampingFactorExit.Distribution); + AssertPercentile(0.95, dampingFactorExit); + } + + #endregion + + #region Piping parameters + + [Test] + public void GetSeepageLength_ValidPipingCalculation_CreateDesignVariableForSeepageLength() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + VariationCoefficientDesignVariable seepageLength = + PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(inputParameters); + + // Assert + DistributionAssert.AreEqual(inputParameters.SeepageLength, seepageLength.Distribution); + AssertPercentile(0.05, seepageLength); + } + + [Test] + public void GetDiameter70_ValidPipingCalculation_CreateDesignVariableForDiameter70() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + VariationCoefficientDesignVariable d70 = + PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters); + + // Assert + DistributionAssert.AreEqual(inputParameters.Diameter70, d70.Distribution); + AssertPercentile(0.05, d70); + } + + [Test] + public void GetDarcyPermeability_ValidPipingCalculation_CreateDesignVariableForDarcyPermeability() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + VariationCoefficientDesignVariable darcyPermeability = + PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(inputParameters); + + // Assert + DistributionAssert.AreEqual(inputParameters.DarcyPermeability, darcyPermeability.Distribution); + AssertPercentile(0.95, darcyPermeability); + } + + [Test] + public void GetSaturatedVolumicWeightOfCoverageLayer_PipingInputWithCoverLayerWithSaturatedDefinition_CreateDesignVariableForSaturatedVolumicWeightOfCoverageLayer() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + inputParameters.StochasticSoilProfile.SoilProfile.Layers.ElementAt(0).BelowPhreaticLevelMean = 3.2; + + // Call + DesignVariable saturatedVolumicWeightOfCoverageLayer = + PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters); + + // Assert + DistributionAssert.AreEqual( + inputParameters.SaturatedVolumicWeightOfCoverageLayer, + saturatedVolumicWeightOfCoverageLayer.Distribution); + AssertPercentile(0.05, saturatedVolumicWeightOfCoverageLayer); + } + + [Test] + public void GetSaturatedVolumicWeightOfCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForSaturatedVolumicWeightOfCoverageLayer() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable saturatedVolumicWeightOfCoverageLayer = + PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(saturatedVolumicWeightOfCoverageLayer); + DistributionAssert.AreEqual(inputParameters.SaturatedVolumicWeightOfCoverageLayer, saturatedVolumicWeightOfCoverageLayer.Distribution); + Assert.AreEqual(new RoundedDouble(2), saturatedVolumicWeightOfCoverageLayer.GetDesignValue()); + } + + [Test] + public void GetThicknessAquiferLayer_ValidPipingCalculation_CreateDesignVariableForThicknessAquiferLayer() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable thicknessAquiferLayer = + PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(inputParameters); + + // Assert + DistributionAssert.AreEqual(inputParameters.ThicknessAquiferLayer, thicknessAquiferLayer.Distribution); + AssertPercentile(0.95, thicknessAquiferLayer); + } + + #endregion + } +} \ No newline at end of file Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj =================================================================== diff -u -ra1fa1538918813373bcc864f0bce092bf28fd0ce -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj (.../Ringtoets.Piping.Data.Test.csproj) (revision a1fa1538918813373bcc864f0bce092bf28fd0ce) +++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj (.../Ringtoets.Piping.Data.Test.csproj) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -67,7 +67,7 @@ - + Index: Ringtoets/Piping/test/Ringtoets.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs =================================================================== diff -u -r99f686f22091051a65ff1ee20abd68ffad713647 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/test/Ringtoets.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs (.../InputParameterCalculationServiceTest.cs) (revision 99f686f22091051a65ff1ee20abd68ffad713647) +++ Ringtoets/Piping/test/Ringtoets.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs (.../InputParameterCalculationServiceTest.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -63,7 +63,7 @@ PipingInput input = invalidPipingCalculation.InputParameters; double result = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile); @@ -112,7 +112,7 @@ // Call double thickness = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile); @@ -155,7 +155,7 @@ // Call double thickness = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile); @@ -176,8 +176,8 @@ // Call double result = InputParameterCalculationService.CalculatePiezometricHeadAtExit( input.AssessmentLevel, - PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue()); + PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue()); // Assert Assert.IsFalse(double.IsNaN(result)); @@ -196,7 +196,7 @@ PipingInput inputParameters = validPipingCalculation.InputParameters; InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( inputParameters.WaterVolumetricWeight, - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), inputParameters.ExitPointL, inputParameters.SurfaceLine, inputParameters.StochasticSoilProfile.SoilProfile); @@ -206,7 +206,7 @@ EffectiveThicknessCalculatorStub effectiveThicknessCalculator = testFactory.LastCreatedEffectiveThicknessCalculator; Assert.AreEqual(input.ExitPointL.Value, effectiveThicknessCalculator.ExitPointXCoordinate); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), effectiveThicknessCalculator.PhreaticLevel, input.PhreaticLevelExit.GetAccuracy()); AssertEqualSoilProfiles(input.StochasticSoilProfile.SoilProfile, effectiveThicknessCalculator.SoilProfile); @@ -228,18 +228,18 @@ PipingInput input1 = validPipingCalculation.InputParameters; InputParameterCalculationService.CalculatePiezometricHeadAtExit( input1.AssessmentLevel, - PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input1).GetDesignValue(), - PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input1).GetDesignValue()); + PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input1).GetDesignValue(), + PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input1).GetDesignValue()); // Assert var testFactory = (TestPipingSubCalculatorFactory) PipingSubCalculatorFactory.Instance; PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = testFactory.LastCreatedPiezometricHeadAtExitCalculator; Assert.AreEqual(input.AssessmentLevel.Value, piezometricHeadAtExitCalculator.HRiver); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, input.PhreaticLevelExit.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, input.DampingFactorExit.GetAccuracy()); } Index: Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs =================================================================== diff -u -r99f686f22091051a65ff1ee20abd68ffad713647 -rb807a83a281be5e9f4645d35ba7da968a0a5e26f --- Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs (.../PipingCalculationServiceTest.cs) (revision 99f686f22091051a65ff1ee20abd68ffad713647) +++ Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs (.../PipingCalculationServiceTest.cs) (revision b807a83a281be5e9f4645d35ba7da968a0a5e26f) @@ -1031,45 +1031,45 @@ UpliftCalculatorStub upliftCalculator = testFactory.LastCreatedUpliftCalculator; SellmeijerCalculatorStub sellmeijerCalculator = testFactory.LastCreatedSellmeijerCalculator; - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(input).GetDesignValue(), heaveCalculator.DTotal, input.ThicknessCoverageLayer.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), heaveCalculator.HExit, input.PhreaticLevelExit.GetAccuracy()); Assert.AreEqual(input.CriticalHeaveGradient, heaveCalculator.Ich); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), heaveCalculator.PhiPolder, input.PhreaticLevelExit.GetAccuracy()); Assert.AreEqual(input.PiezometricHeadExit.Value, heaveCalculator.PhiExit); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), heaveCalculator.RExit, input.DampingFactorExit.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), upliftCalculator.HExit, 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(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), upliftCalculator.PhiPolder, input.PhreaticLevelExit.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDampingFactorExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), upliftCalculator.RExit, input.DampingFactorExit.GetAccuracy()); Assert.AreEqual(input.WaterVolumetricWeight, upliftCalculator.VolumetricWeightOfWater); - RoundedDouble effectiveThickness = PipingSemiProbabilisticDesignValueFactory.GetEffectiveThicknessCoverageLayer(input).GetDesignValue(); - RoundedDouble saturatedVolumicWeight = PipingSemiProbabilisticDesignValueFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue(); + RoundedDouble effectiveThickness = PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(input).GetDesignValue(); + RoundedDouble saturatedVolumicWeight = PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue(); RoundedDouble effectiveStress = effectiveThickness * (saturatedVolumicWeight - input.WaterVolumetricWeight); Assert.AreEqual(effectiveStress, upliftCalculator.EffectiveStress, effectiveStress.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetSeepageLength(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(input).GetDesignValue(), sellmeijerCalculator.SeepageLength, input.SeepageLength.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), sellmeijerCalculator.HExit, input.PhreaticLevelExit.GetAccuracy()); Assert.AreEqual(input.AssessmentLevel.Value, sellmeijerCalculator.HRiver); @@ -1079,17 +1079,17 @@ Assert.AreEqual(input.WaterVolumetricWeight, sellmeijerCalculator.VolumetricWeightOfWater); Assert.AreEqual(input.WhitesDragCoefficient, sellmeijerCalculator.WhitesDragCoefficient); Assert.AreEqual(input.BeddingAngle, sellmeijerCalculator.BeddingAngle); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetThicknessCoverageLayer(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(input).GetDesignValue(), sellmeijerCalculator.DTotal, input.ThicknessCoverageLayer.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDiameter70(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(input).GetDesignValue(), sellmeijerCalculator.D70, input.Diameter70.GetAccuracy()); Assert.AreEqual(input.MeanDiameter70, sellmeijerCalculator.D70Mean); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetThicknessAquiferLayer(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(input).GetDesignValue(), sellmeijerCalculator.DAquifer, input.ThicknessAquiferLayer.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignValueFactory.GetDarcyPermeability(input).GetDesignValue(), + Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(input).GetDesignValue(), sellmeijerCalculator.DarcyPermeability, input.DarcyPermeability.GetAccuracy()); Assert.AreEqual(input.SandParticlesVolumicWeight, sellmeijerCalculator.GammaSubParticles);