Index: Riskeer/Piping/src/Riskeer.Piping.Data/DerivedPipingInput.cs =================================================================== diff -u -ra593a57320414e3eef4aa0666758aa4b263fcbb8 -r204265dc343093a3145565384151e84c888e4db5 --- Riskeer/Piping/src/Riskeer.Piping.Data/DerivedPipingInput.cs (.../DerivedPipingInput.cs) (revision a593a57320414e3eef4aa0666758aa4b263fcbb8) +++ Riskeer/Piping/src/Riskeer.Piping.Data/DerivedPipingInput.cs (.../DerivedPipingInput.cs) (revision 204265dc343093a3145565384151e84c888e4db5) @@ -52,8 +52,8 @@ throw new ArgumentNullException(nameof(input)); } - RoundedDouble dampingFactorExit = PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(); - RoundedDouble phreaticLevelExit = PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(); + RoundedDouble dampingFactorExit = SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(); + RoundedDouble phreaticLevelExit = SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(); return new RoundedDouble(2, InputParameterCalculationService.CalculatePiezometricHeadAtExit(assessmentLevel, dampingFactorExit, @@ -276,7 +276,7 @@ var weightedMean = new RoundedDouble(GetNumberOfDecimals(effectiveThicknessCoverageLayerDistribution), InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile)); Fisheye: Tag 204265dc343093a3145565384151e84c888e4db5 refers to a dead (removed) revision in file `Riskeer/Piping/src/Riskeer.Piping.Data/SemiProbabilistic/PipingSemiProbabilisticDesignVariableFactory.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Piping/src/Riskeer.Piping.Data/SemiProbabilistic/SemiProbabilisticPipingDesignVariableFactory.cs =================================================================== diff -u --- Riskeer/Piping/src/Riskeer.Piping.Data/SemiProbabilistic/SemiProbabilisticPipingDesignVariableFactory.cs (revision 0) +++ Riskeer/Piping/src/Riskeer.Piping.Data/SemiProbabilistic/SemiProbabilisticPipingDesignVariableFactory.cs (revision 204265dc343093a3145565384151e84c888e4db5) @@ -0,0 +1,181 @@ +// Copyright (C) Stichting Deltares 2019. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer 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 Riskeer.Common.Data.Probabilistics; + +namespace Riskeer.Piping.Data.SemiProbabilistic +{ + /// + /// Factory for creating design variables based on probabilistic distributions for piping. + /// + public static class SemiProbabilisticPipingDesignVariableFactory + { + #region General parameters + + /// + /// Creates the deterministic design variable for the uplift model factor. + /// + /// The piping input. + /// The created . + public static DeterministicDesignVariable GetUpliftModelFactorDesignVariable(PipingInput parameters) + { + return new DeterministicDesignVariable(parameters.UpliftModelFactor, parameters.UpliftModelFactor.Mean); + } + + /// + /// Creates the deterministic design variable for the sellmeijer model factor. + /// + /// The piping input. + /// The created . + public static DeterministicDesignVariable GetSellmeijerModelFactorDesignVariable(PipingInput parameters) + { + return new DeterministicDesignVariable(parameters.SellmeijerModelFactor, parameters.SellmeijerModelFactor.Mean); + } + + /// + /// Creates the design variable for the volumic weight of the saturated coverage layer. + /// + public static DesignVariable GetSaturatedVolumicWeightOfCoverageLayer(PipingInput parameters) + { + LogNormalDistribution thicknessCoverageLayer = DerivedPipingInput.GetThicknessCoverageLayer(parameters); + LogNormalDistribution saturatedVolumicWeightOfCoverageLayer = DerivedPipingInput.GetSaturatedVolumicWeightOfCoverageLayer(parameters); + + if (double.IsNaN(thicknessCoverageLayer.Mean)) + { + return new DeterministicDesignVariable(saturatedVolumicWeightOfCoverageLayer); + } + + return new LogNormalDistributionDesignVariable(saturatedVolumicWeightOfCoverageLayer) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for the total thickness of the coverage layers at the exit point. + /// + public static DesignVariable GetThicknessCoverageLayer(PipingInput parameters) + { + LogNormalDistribution thicknessCoverageLayer = DerivedPipingInput.GetThicknessCoverageLayer(parameters); + + if (double.IsNaN(thicknessCoverageLayer.Mean)) + { + return new DeterministicDesignVariable(thicknessCoverageLayer); + } + + return new LogNormalDistributionDesignVariable(thicknessCoverageLayer) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for the effective thickness of the coverage layers at the exit point. + /// + public static DesignVariable GetEffectiveThicknessCoverageLayer(PipingInput parameters) + { + LogNormalDistribution thicknessCoverageLayer = DerivedPipingInput.GetThicknessCoverageLayer(parameters); + LogNormalDistribution effectiveThicknessCoverageLayer = DerivedPipingInput.GetEffectiveThicknessCoverageLayer(parameters); + + if (double.IsNaN(thicknessCoverageLayer.Mean)) + { + return new DeterministicDesignVariable(effectiveThicknessCoverageLayer); + } + + return new LogNormalDistributionDesignVariable(effectiveThicknessCoverageLayer) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for the phreatic level at the exit point. + /// + public static DesignVariable GetPhreaticLevelExit(PipingInput parameters) + { + return new NormalDistributionDesignVariable(parameters.PhreaticLevelExit) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for the damping factor at the exit point. + /// + public static DesignVariable GetDampingFactorExit(PipingInput parameters) + { + return new LogNormalDistributionDesignVariable(parameters.DampingFactorExit) + { + Percentile = 0.95 + }; + } + + #endregion + + #region Piping parameters + + /// + /// Creates the design variable for the horizontal distance between entry and exit point. + /// + public static VariationCoefficientDesignVariable GetSeepageLength(PipingInput parameters) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(DerivedPipingInput.GetSeepageLength(parameters)) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for the sieve size through which 70% of the grains of the top part of the aquifer pass. + /// + public static VariationCoefficientDesignVariable GetDiameter70(PipingInput parameters) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(DerivedPipingInput.GetDiameterD70(parameters)) + { + Percentile = 0.05 + }; + } + + /// + /// Creates the design variable for the Darcy-speed with which water flows through the aquifer layer. + /// + public static VariationCoefficientDesignVariable GetDarcyPermeability(PipingInput parameters) + { + return new VariationCoefficientLogNormalDistributionDesignVariable(DerivedPipingInput.GetDarcyPermeability(parameters)) + { + Percentile = 0.95 + }; + } + + /// + /// Creates the design variable for the total thickness of the aquifer layers at the exit point. + /// + public static DesignVariable GetThicknessAquiferLayer(PipingInput parameters) + { + return new LogNormalDistributionDesignVariable(DerivedPipingInput.GetThicknessAquiferLayer(parameters)) + { + Percentile = 0.95 + }; + } + + #endregion + } +} \ No newline at end of file Index: Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/PipingInputContextProperties.cs =================================================================== diff -u -ra593a57320414e3eef4aa0666758aa4b263fcbb8 -r204265dc343093a3145565384151e84c888e4db5 --- Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/PipingInputContextProperties.cs (.../PipingInputContextProperties.cs) (revision a593a57320414e3eef4aa0666758aa4b263fcbb8) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/PipingInputContextProperties.cs (.../PipingInputContextProperties.cs) (revision 204265dc343093a3145565384151e84c888e4db5) @@ -249,7 +249,7 @@ get { return new LogNormalDistributionDesignVariableProperties(DistributionReadOnlyProperties.None, - PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(data.WrappedData), + SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(data.WrappedData), propertyChangeHandler); } } @@ -264,7 +264,7 @@ get { return new NormalDistributionDesignVariableProperties(DistributionReadOnlyProperties.None, - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(data.WrappedData), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(data.WrappedData), propertyChangeHandler); } } @@ -397,7 +397,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(data.WrappedData)); } } @@ -411,7 +411,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(data.WrappedData)); } } @@ -425,7 +425,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(data.WrappedData)); } } @@ -439,7 +439,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(data.WrappedData)); } } @@ -453,7 +453,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(data.WrappedData)); } } @@ -467,7 +467,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(data.WrappedData)); } } @@ -481,7 +481,7 @@ get { return new ShiftedLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(data.WrappedData)); } } Index: Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/ProbabilisticPipingInputContextProperties.cs =================================================================== diff -u -ra593a57320414e3eef4aa0666758aa4b263fcbb8 -r204265dc343093a3145565384151e84c888e4db5 --- Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/ProbabilisticPipingInputContextProperties.cs (.../ProbabilisticPipingInputContextProperties.cs) (revision a593a57320414e3eef4aa0666758aa4b263fcbb8) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/ProbabilisticPipingInputContextProperties.cs (.../ProbabilisticPipingInputContextProperties.cs) (revision 204265dc343093a3145565384151e84c888e4db5) @@ -168,7 +168,7 @@ get { return new LogNormalDistributionDesignVariableProperties(DistributionReadOnlyProperties.None, - PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(data.WrappedData), + SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(data.WrappedData), propertyChangeHandler); } } @@ -183,7 +183,7 @@ get { return new NormalDistributionDesignVariableProperties(DistributionReadOnlyProperties.None, - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(data.WrappedData), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(data.WrappedData), propertyChangeHandler); } } @@ -316,7 +316,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(data.WrappedData)); } } @@ -330,7 +330,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(data.WrappedData)); } } @@ -344,7 +344,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(data.WrappedData)); } } @@ -358,7 +358,7 @@ get { return new LogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(data.WrappedData)); } } @@ -372,7 +372,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(data.WrappedData)); } } @@ -386,7 +386,7 @@ get { return new VariationCoefficientLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(data.WrappedData)); } } @@ -400,7 +400,7 @@ get { return new ShiftedLogNormalDistributionDesignVariableProperties( - PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(data.WrappedData)); + SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(data.WrappedData)); } } Index: Riskeer/Piping/src/Riskeer.Piping.Service/PipingCalculationService.cs =================================================================== diff -u -rd2d48d2bd3050679db76ec126d31b8f9d9546395 -r204265dc343093a3145565384151e84c888e4db5 --- Riskeer/Piping/src/Riskeer.Piping.Service/PipingCalculationService.cs (.../PipingCalculationService.cs) (revision d2d48d2bd3050679db76ec126d31b8f9d9546395) +++ Riskeer/Piping/src/Riskeer.Piping.Service/PipingCalculationService.cs (.../PipingCalculationService.cs) (revision 204265dc343093a3145565384151e84c888e4db5) @@ -238,12 +238,12 @@ } else { - if (double.IsNaN(PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(inputParameters).GetDesignValue())) + if (double.IsNaN(SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(inputParameters).GetDesignValue())) { validationResult.Add(Resources.PipingCalculationService_ValidateInput_Cannot_derive_DarcyPermeability); } - if (double.IsNaN(PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue())) + if (double.IsNaN(SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue())) { validationResult.Add(Resources.PipingCalculationService_ValidateInput_Cannot_derive_Diameter70); } @@ -260,7 +260,7 @@ if (hasConsecutiveCoverageLayers) { RoundedDouble saturatedVolumicWeightOfCoverageLayer = - PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(); + SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(); if (double.IsNaN(saturatedVolumicWeightOfCoverageLayer)) { @@ -317,7 +317,7 @@ { var warnings = new List(); - RoundedDouble diameter70Value = PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue(); + RoundedDouble diameter70Value = SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue(); if (!double.IsNaN(diameter70Value) && (diameter70Value < 6.3e-5 || diameter70Value > 0.5e-3)) { @@ -368,25 +368,25 @@ new PipingCalculatorInput.ConstructionProperties { WaterVolumetricWeight = inputParameters.WaterVolumetricWeight, - SaturatedVolumicWeightOfCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(), - UpliftModelFactor = PipingSemiProbabilisticDesignVariableFactory.GetUpliftModelFactorDesignVariable(inputParameters).GetDesignValue(), + SaturatedVolumicWeightOfCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters).GetDesignValue(), + UpliftModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(inputParameters).GetDesignValue(), AssessmentLevel = effectiveAssessmentLevel, PiezometricHeadExit = DerivedPipingInput.GetPiezometricHeadExit(inputParameters, effectiveAssessmentLevel), - DampingFactorExit = PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(inputParameters).GetDesignValue(), - PhreaticLevelExit = PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), + DampingFactorExit = SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(inputParameters).GetDesignValue(), + PhreaticLevelExit = SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), CriticalHeaveGradient = inputParameters.CriticalHeaveGradient, - ThicknessCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(inputParameters).GetDesignValue(), - EffectiveThicknessCoverageLayer = PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(inputParameters).GetDesignValue(), - SellmeijerModelFactor = PipingSemiProbabilisticDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(inputParameters).GetDesignValue(), + ThicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(inputParameters).GetDesignValue(), + EffectiveThicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(inputParameters).GetDesignValue(), + SellmeijerModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(inputParameters).GetDesignValue(), SellmeijerReductionFactor = inputParameters.SellmeijerReductionFactor, - SeepageLength = PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(inputParameters).GetDesignValue(), + SeepageLength = SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(inputParameters).GetDesignValue(), SandParticlesVolumicWeight = inputParameters.SandParticlesVolumicWeight, WhitesDragCoefficient = inputParameters.WhitesDragCoefficient, - Diameter70 = PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue(), - DarcyPermeability = PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(inputParameters).GetDesignValue(), + Diameter70 = SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(inputParameters).GetDesignValue(), + DarcyPermeability = SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(inputParameters).GetDesignValue(), WaterKinematicViscosity = inputParameters.WaterKinematicViscosity, Gravity = inputParameters.Gravity, - ThicknessAquiferLayer = PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(inputParameters).GetDesignValue(), + ThicknessAquiferLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(inputParameters).GetDesignValue(), MeanDiameter70 = inputParameters.MeanDiameter70, BeddingAngle = inputParameters.BeddingAngle, ExitPointXCoordinate = inputParameters.ExitPointL, Index: Riskeer/Piping/test/Riskeer.Piping.Data.Test/DerivedPipingInputTest.cs =================================================================== diff -u -ra593a57320414e3eef4aa0666758aa4b263fcbb8 -r204265dc343093a3145565384151e84c888e4db5 --- Riskeer/Piping/test/Riskeer.Piping.Data.Test/DerivedPipingInputTest.cs (.../DerivedPipingInputTest.cs) (revision a593a57320414e3eef4aa0666758aa4b263fcbb8) +++ Riskeer/Piping/test/Riskeer.Piping.Data.Test/DerivedPipingInputTest.cs (.../DerivedPipingInputTest.cs) (revision 204265dc343093a3145565384151e84c888e4db5) @@ -69,9 +69,9 @@ PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator; Assert.AreEqual(assessmentLevel, piezometricHeadAtExitCalculator.HRiver, assessmentLevel.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, input.PhreaticLevelExit.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, input.DampingFactorExit.GetAccuracy()); } } Fisheye: Tag 204265dc343093a3145565384151e84c888e4db5 refers to a dead (removed) revision in file `Riskeer/Piping/test/Riskeer.Piping.Data.Test/SemiProbabilistic/PipingSemiProbabilisticDesignVariableFactoryTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Piping/test/Riskeer.Piping.Data.Test/SemiProbabilistic/SemiProbabilisticPipingDesignVariableFactoryTest.cs =================================================================== diff -u --- Riskeer/Piping/test/Riskeer.Piping.Data.Test/SemiProbabilistic/SemiProbabilisticPipingDesignVariableFactoryTest.cs (revision 0) +++ Riskeer/Piping/test/Riskeer.Piping.Data.Test/SemiProbabilistic/SemiProbabilisticPipingDesignVariableFactoryTest.cs (revision 204265dc343093a3145565384151e84c888e4db5) @@ -0,0 +1,274 @@ +// Copyright (C) Stichting Deltares 2019. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer 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 Riskeer.Common.Data.Probabilistics; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Piping.Data.SemiProbabilistic; +using Riskeer.Piping.Data.TestUtil; + +namespace Riskeer.Piping.Data.Test.SemiProbabilistic +{ + [TestFixture] + public class SemiProbabilisticPipingDesignVariableFactoryTest + { + 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 GetUpliftModelFactorDesignVariable_PipingInputWithCoverLayer_CreateDeterministicDesignVariableForUpliftModelFactor() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + + // Call + DeterministicDesignVariable upliftModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(inputParameters); + + // Assert + DistributionAssert.AreEqual(inputParameters.UpliftModelFactor, upliftModelFactor.Distribution); + Assert.AreEqual(inputParameters.UpliftModelFactor.Mean, upliftModelFactor.GetDesignValue()); + } + + [Test] + public void GetSellmeijerModelFactorDesignVariable_PipingInputWithCoverLayer_CreateDeterministicDesignVariableForSellmeijerModelFactor() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + + // Call + DeterministicDesignVariable sellmeijerModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(inputParameters); + + // Assert + DistributionAssert.AreEqual(inputParameters.SellmeijerModelFactor, sellmeijerModelFactor.Distribution); + Assert.AreEqual(inputParameters.SellmeijerModelFactor.Mean, sellmeijerModelFactor.GetDesignValue()); + } + + [Test] + public void GetThicknessCoverageLayer_PipingInputWithCoverLayer_CreatePercentileBasedDesignVariableForThicknessCoverageLayer() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + + // Call + DesignVariable thicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(thicknessCoverageLayer); + DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessCoverageLayer(inputParameters), thicknessCoverageLayer.Distribution); + AssertPercentile(0.05, thicknessCoverageLayer); + } + + [Test] + public void GetThicknessCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForThicknessCoverageLayer() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable thicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(thicknessCoverageLayer); + DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessCoverageLayer(inputParameters), thicknessCoverageLayer.Distribution); + Assert.AreEqual(new RoundedDouble(2), thicknessCoverageLayer.GetDesignValue()); + } + + [Test] + public void GetEffectiveThicknessCoverageLayer_PipingInputWithCoverLayer_CreatePercentileBasedDesignVariableForEffectiveThicknessCoverageLayer() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + + // Call + DesignVariable effectiveThicknessCoverageLayer = + SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(effectiveThicknessCoverageLayer); + DistributionAssert.AreEqual(DerivedPipingInput.GetEffectiveThicknessCoverageLayer(inputParameters), effectiveThicknessCoverageLayer.Distribution); + AssertPercentile(0.05, effectiveThicknessCoverageLayer); + } + + [Test] + public void GetEffectiveThicknessCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForEffectiveThicknessCoverageLayer() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable effectiveThicknessCoverageLayer = + SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(effectiveThicknessCoverageLayer); + DistributionAssert.AreEqual(DerivedPipingInput.GetEffectiveThicknessCoverageLayer(inputParameters), 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 = + SemiProbabilisticPipingDesignVariableFactory.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 = + SemiProbabilisticPipingDesignVariableFactory.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 = + SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(inputParameters); + + // Assert + DistributionAssert.AreEqual(DerivedPipingInput.GetSeepageLength(inputParameters), seepageLength.Distribution); + AssertPercentile(0.05, seepageLength); + } + + [Test] + public void GetDiameter70_ValidPipingCalculation_CreateDesignVariableForDiameter70() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + VariationCoefficientDesignVariable d70 = + SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(inputParameters); + + // Assert + DistributionAssert.AreEqual(DerivedPipingInput.GetDiameterD70(inputParameters), d70.Distribution); + AssertPercentile(0.05, d70); + } + + [Test] + public void GetDarcyPermeability_ValidPipingCalculation_CreateDesignVariableForDarcyPermeability() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + VariationCoefficientDesignVariable darcyPermeability = + SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(inputParameters); + + // Assert + DistributionAssert.AreEqual(DerivedPipingInput.GetDarcyPermeability(inputParameters), darcyPermeability.Distribution); + AssertPercentile(0.95, darcyPermeability); + } + + [Test] + public void GetSaturatedVolumicWeightOfCoverageLayer_PipingInputWithCoverLayerWithSaturatedDefinition_CreateDesignVariableForSaturatedVolumicWeightOfCoverageLayer() + { + // Setup + PipingInput inputParameters = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer(); + inputParameters.StochasticSoilProfile.SoilProfile.Layers.First().BelowPhreaticLevel = new LogNormalDistribution + { + Mean = (RoundedDouble) 3.2 + }; + + // Call + DesignVariable saturatedVolumicWeightOfCoverageLayer = + SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters); + + // Assert + DistributionAssert.AreEqual(DerivedPipingInput.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters), + saturatedVolumicWeightOfCoverageLayer.Distribution); + AssertPercentile(0.05, saturatedVolumicWeightOfCoverageLayer); + } + + [Test] + public void GetSaturatedVolumicWeightOfCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForSaturatedVolumicWeightOfCoverageLayer() + { + // Setup + var inputParameters = new PipingInput(new GeneralPipingInput()); + + // Call + DesignVariable saturatedVolumicWeightOfCoverageLayer = + SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters); + + // Assert + Assert.IsInstanceOf>(saturatedVolumicWeightOfCoverageLayer); + DistributionAssert.AreEqual(DerivedPipingInput.GetSaturatedVolumicWeightOfCoverageLayer(inputParameters), + 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 = + SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(inputParameters); + + // Assert + DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessAquiferLayer(inputParameters), thicknessAquiferLayer.Distribution); + AssertPercentile(0.95, thicknessAquiferLayer); + } + + #endregion + } +} \ No newline at end of file Index: Riskeer/Piping/test/Riskeer.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs =================================================================== diff -u -rd2d48d2bd3050679db76ec126d31b8f9d9546395 -r204265dc343093a3145565384151e84c888e4db5 --- Riskeer/Piping/test/Riskeer.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs (.../InputParameterCalculationServiceTest.cs) (revision d2d48d2bd3050679db76ec126d31b8f9d9546395) +++ Riskeer/Piping/test/Riskeer.Piping.InputParameterCalculation.Test/InputParameterCalculationServiceTest.cs (.../InputParameterCalculationServiceTest.cs) (revision 204265dc343093a3145565384151e84c888e4db5) @@ -66,7 +66,7 @@ PipingInput input = invalidPipingCalculation.InputParameters; double result = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile); @@ -115,7 +115,7 @@ // Call double thickness = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile); @@ -158,7 +158,7 @@ // Call double thickness = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( input.WaterVolumetricWeight, - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), input.ExitPointL, input.SurfaceLine, input.StochasticSoilProfile.SoilProfile); @@ -176,8 +176,8 @@ // Call double result = InputParameterCalculationService.CalculatePiezometricHeadAtExit( (RoundedDouble) 0.0, - PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue()); + SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue()); // Assert Assert.IsFalse(double.IsNaN(result)); @@ -196,7 +196,7 @@ PipingInput inputParameters = validPipingCalculation.InputParameters; InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer( inputParameters.WaterVolumetricWeight, - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(), + SemiProbabilisticPipingDesignVariableFactory.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(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), effectiveThicknessCalculator.PhreaticLevel, input.PhreaticLevelExit.GetAccuracy()); AssertEqualSoilProfiles(input.StochasticSoilProfile.SoilProfile, effectiveThicknessCalculator.SoilProfile); @@ -228,18 +228,18 @@ // Call InputParameterCalculationService.CalculatePiezometricHeadAtExit( assessmentLevel, - PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), - PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue()); + SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), + SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue()); // Assert var testFactory = (TestPipingSubCalculatorFactory) PipingSubCalculatorFactory.Instance; PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = testFactory.LastCreatedPiezometricHeadAtExitCalculator; Assert.AreEqual(assessmentLevel.Value, piezometricHeadAtExitCalculator.HRiver); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder, input.PhreaticLevelExit.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit, input.DampingFactorExit.GetAccuracy()); } Index: Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingCalculationServiceTest.cs =================================================================== diff -u -r8da4704f43ae462b1eeae911f401e9b41cb3ce50 -r204265dc343093a3145565384151e84c888e4db5 --- Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingCalculationServiceTest.cs (.../PipingCalculationServiceTest.cs) (revision 8da4704f43ae462b1eeae911f401e9b41cb3ce50) +++ Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingCalculationServiceTest.cs (.../PipingCalculationServiceTest.cs) (revision 204265dc343093a3145565384151e84c888e4db5) @@ -1111,12 +1111,12 @@ UpliftCalculatorStub upliftCalculator = testFactory.LastCreatedUpliftCalculator; SellmeijerCalculatorStub sellmeijerCalculator = testFactory.LastCreatedSellmeijerCalculator; - RoundedDouble expectedThicknessCoverageLayerDesignValue = PipingSemiProbabilisticDesignVariableFactory.GetThicknessCoverageLayer(input).GetDesignValue(); + RoundedDouble expectedThicknessCoverageLayerDesignValue = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(input).GetDesignValue(); double thicknessCoverageLayerAccuracy = DerivedPipingInput.GetThicknessCoverageLayer(input).GetAccuracy(); - RoundedDouble expectedPhreaticLevelExitDesignValue = PipingSemiProbabilisticDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(); + RoundedDouble expectedPhreaticLevelExitDesignValue = SemiProbabilisticPipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(); double phreaticLevelExitDesignAccuracy = input.PhreaticLevelExit.GetAccuracy(); double expectedPiezometricHeadExit = DerivedPipingInput.GetPiezometricHeadExit(input, expectedAssessmentLevel).Value; - RoundedDouble expectedDampingFactorExitDesignValue = PipingSemiProbabilisticDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(); + RoundedDouble expectedDampingFactorExitDesignValue = SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(); double dampingFactorExitAccuracy = input.DampingFactorExit.GetAccuracy(); Assert.AreEqual(expectedThicknessCoverageLayerDesignValue, heaveCalculator.DTotal, thicknessCoverageLayerAccuracy); @@ -1127,37 +1127,37 @@ Assert.AreEqual(expectedDampingFactorExitDesignValue, heaveCalculator.RExit, dampingFactorExitAccuracy); Assert.AreEqual(expectedPhreaticLevelExitDesignValue, upliftCalculator.HExit, phreaticLevelExitDesignAccuracy); Assert.AreEqual(expectedAssessmentLevel, upliftCalculator.HRiver); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetUpliftModelFactorDesignVariable(input).GetDesignValue(), upliftCalculator.ModelFactorUplift); + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(input).GetDesignValue(), upliftCalculator.ModelFactorUplift); Assert.AreEqual(expectedPiezometricHeadExit, upliftCalculator.PhiExit); Assert.AreEqual(expectedPhreaticLevelExitDesignValue, upliftCalculator.PhiPolder, phreaticLevelExitDesignAccuracy); Assert.AreEqual(expectedDampingFactorExitDesignValue, upliftCalculator.RExit, dampingFactorExitAccuracy); Assert.AreEqual(input.WaterVolumetricWeight, upliftCalculator.VolumetricWeightOfWater); - RoundedDouble effectiveThickness = PipingSemiProbabilisticDesignVariableFactory.GetEffectiveThicknessCoverageLayer(input).GetDesignValue(); - RoundedDouble saturatedVolumicWeight = PipingSemiProbabilisticDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue(); + RoundedDouble effectiveThickness = SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(input).GetDesignValue(); + RoundedDouble saturatedVolumicWeight = SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue(); RoundedDouble expectedEffectiveStress = effectiveThickness * (saturatedVolumicWeight - input.WaterVolumetricWeight); Assert.AreEqual(expectedEffectiveStress, upliftCalculator.EffectiveStress, expectedEffectiveStress.GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetSeepageLength(input).GetDesignValue(), + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(input).GetDesignValue(), sellmeijerCalculator.SeepageLength, DerivedPipingInput.GetSeepageLength(input).GetAccuracy()); Assert.AreEqual(expectedPhreaticLevelExitDesignValue, sellmeijerCalculator.HExit, phreaticLevelExitDesignAccuracy); Assert.AreEqual(expectedAssessmentLevel, sellmeijerCalculator.HRiver); Assert.AreEqual(input.WaterKinematicViscosity, sellmeijerCalculator.KinematicViscosityWater); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(input).GetDesignValue(), sellmeijerCalculator.ModelFactorPiping); + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(input).GetDesignValue(), sellmeijerCalculator.ModelFactorPiping); Assert.AreEqual(input.SellmeijerReductionFactor, sellmeijerCalculator.Rc); Assert.AreEqual(input.WaterVolumetricWeight, sellmeijerCalculator.VolumetricWeightOfWater); Assert.AreEqual(input.WhitesDragCoefficient, sellmeijerCalculator.WhitesDragCoefficient); Assert.AreEqual(input.BeddingAngle, sellmeijerCalculator.BeddingAngle); Assert.AreEqual(expectedThicknessCoverageLayerDesignValue, sellmeijerCalculator.DTotal, thicknessCoverageLayerAccuracy); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDiameter70(input).GetDesignValue(), + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(input).GetDesignValue(), sellmeijerCalculator.D70, DerivedPipingInput.GetDiameterD70(input).GetAccuracy()); Assert.AreEqual(input.MeanDiameter70, sellmeijerCalculator.D70Mean); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetThicknessAquiferLayer(input).GetDesignValue(), + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(input).GetDesignValue(), sellmeijerCalculator.DAquifer, DerivedPipingInput.GetThicknessAquiferLayer(input).GetAccuracy()); - Assert.AreEqual(PipingSemiProbabilisticDesignVariableFactory.GetDarcyPermeability(input).GetDesignValue(), + Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(input).GetDesignValue(), sellmeijerCalculator.DarcyPermeability, DerivedPipingInput.GetDarcyPermeability(input).GetAccuracy()); Assert.AreEqual(input.SandParticlesVolumicWeight, sellmeijerCalculator.GammaSubParticles);