public static void CalculatePiezometricHeadAtExit_CompleteInput_InputSetOnSubCalculator()
{
// Setup
RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble();
var validPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
PipingInput input = validPipingCalculation.InputParameters;
using (new PipingSubCalculatorFactoryConfig())
{
// Call
InputParameterCalculationService.CalculatePiezometricHeadAtExit(
assessmentLevel,
SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue());
// Assert
var testFactory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = testFactory.LastCreatedPiezometricHeadAtExitCalculator;
Assert.AreEqual(assessmentLevel.Value, piezometricHeadAtExitCalculator.HRiver);
Assert.AreEqual(PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
piezometricHeadAtExitCalculator.PhiPolder,
input.PhreaticLevelExit.GetAccuracy());
Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
piezometricHeadAtExitCalculator.RExit,
input.DampingFactorExit.GetAccuracy());
}
}
public void GetPiezometricHeadExit_ValidInput_SetsParametersForCalculatorAndReturnsNotNaN()
{
// Setup
var input = new TestPipingInput();
using (new PipingSubCalculatorFactoryConfig())
{
// Setup
var assessmentLevel = (RoundedDouble)1.1;
// Call
RoundedDouble piezometricHead = DerivedSemiProbabilisticPipingInput.GetPiezometricHeadExit(input, assessmentLevel);
// Assert
Assert.AreEqual(2, piezometricHead.NumberOfDecimalPlaces);
Assert.IsFalse(double.IsNaN(piezometricHead));
var factory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator;
Assert.AreEqual(assessmentLevel, piezometricHeadAtExitCalculator.HRiver, assessmentLevel.GetAccuracy());
Assert.AreEqual(PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder,
input.PhreaticLevelExit.GetAccuracy());
Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit,
input.DampingFactorExit.GetAccuracy());
}
}
public void GetDampingFactorExit_PipingInputNull_ThrowsArgumentNullException()
{
// Call
void Call() => SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("pipingInput", exception.ParamName);
}
public void GetCriticalHeaveGradientDesignVariable_GeneralPipingInputNull_ThrowsArgumentNullException()
{
// Call
void Call() => SemiProbabilisticPipingDesignVariableFactory.GetCriticalHeaveGradientDesignVariable(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("generalPipingInput", exception.ParamName);
}
private static IEnumerable <string> ValidateCoverageLayers(PipingInput input, GeneralPipingInput generalInput)
{
if (!double.IsNaN(DerivedPipingInput.GetThicknessCoverageLayer(input).Mean))
{
RoundedDouble saturatedVolumicWeightOfCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue();
if (!double.IsNaN(saturatedVolumicWeightOfCoverageLayer) && saturatedVolumicWeightOfCoverageLayer < generalInput.WaterVolumetricWeight)
{
yield return(Resources.SemiProbabilisticPipingCalculationService_ValidateInput_SaturatedVolumicWeightCoverageLayer_must_be_larger_than_WaterVolumetricWeight);
}
}
}
public void GetUpliftModelFactorDesignVariable_GeneralPipingInput_CreateDeterministicDesignVariableForUpliftModelFactor()
{
// Setup
var generalPipingInput = new GeneralPipingInput();
// Call
DeterministicDesignVariable <LogNormalDistribution> upliftModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(generalPipingInput);
// Assert
DistributionAssert.AreEqual(generalPipingInput.UpliftModelFactor, upliftModelFactor.Distribution);
Assert.AreEqual(generalPipingInput.UpliftModelFactor.Mean, upliftModelFactor.GetDesignValue());
}
public void GetDarcyPermeability_ValidPipingInput_CreateDesignVariableForDarcyPermeability()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> darcyPermeability =
SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetDarcyPermeability(pipingInput), darcyPermeability.Distribution);
AssertPercentile(0.95, darcyPermeability);
}
public void GetDiameter70_ValidPipingInput_CreateDesignVariableForDiameter70()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> d70 =
SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetDiameterD70(pipingInput), d70.Distribution);
AssertPercentile(0.05, d70);
}
public void GetSeepageLength_ValidPipingInput_CreateDesignVariableForSeepageLength()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> seepageLength =
SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetSeepageLength(pipingInput), seepageLength.Distribution);
AssertPercentile(0.05, seepageLength);
}
public void GetThicknessCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForThicknessCoverageLayer()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> thicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(pipingInput);
// Assert
Assert.IsInstanceOf <DeterministicDesignVariable <LogNormalDistribution> >(thicknessCoverageLayer);
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessCoverageLayer(pipingInput), thicknessCoverageLayer.Distribution);
Assert.AreEqual(new RoundedDouble(2), thicknessCoverageLayer.GetDesignValue());
}
public void GetThicknessCoverageLayer_PipingInputWithCoverLayer_CreatePercentileBasedDesignVariableForThicknessCoverageLayer()
{
// Setup
PipingInput pipingInput = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer <TestPipingInput>();
// Call
DesignVariable <LogNormalDistribution> thicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(pipingInput);
// Assert
Assert.IsInstanceOf <PercentileBasedDesignVariable <LogNormalDistribution> >(thicknessCoverageLayer);
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessCoverageLayer(pipingInput), thicknessCoverageLayer.Distribution);
AssertPercentile(0.05, thicknessCoverageLayer);
}
public void GetThicknessAquiferLayer_ValidPipingInput_CreateDesignVariableForThicknessAquiferLayer()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> thicknessAquiferLayer =
SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessAquiferLayer(pipingInput), thicknessAquiferLayer.Distribution);
AssertPercentile(0.95, thicknessAquiferLayer);
}
public void GetDampingFactorExit_ValidPipingInput_CreateDesignVariableForDampingFactorExit()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> dampingFactorExit =
SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(pipingInput);
// Assert
Assert.AreSame(pipingInput.DampingFactorExit, dampingFactorExit.Distribution);
AssertPercentile(0.95, dampingFactorExit);
}
public static void CalculatePiezometricHeadAtExit_Always_ReturnsResult()
{
// Setup
var input = new TestPipingInput();
// Call
double result = InputParameterCalculationService.CalculatePiezometricHeadAtExit(
(RoundedDouble)0.0,
SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue());
// Assert
Assert.IsFalse(double.IsNaN(result));
}
private static void LogAnyWarnings(SemiProbabilisticPipingCalculation calculation)
{
CalculationServiceHelper.LogMessagesAsWarning(PipingCalculationValidationHelper.GetValidationWarnings(calculation.InputParameters).ToArray());
RoundedDouble diameter70Value = SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(calculation.InputParameters).GetDesignValue();
if (!double.IsNaN(diameter70Value) && (diameter70Value < 6.3e-5 || diameter70Value > 0.5e-3))
{
CalculationServiceHelper.LogMessagesAsWarning(new[]
{
string.Format(Resources.SemiProbabilisticPipingCalculationService_GetInputWarnings_Specified_DiameterD70_value_0_not_in_valid_range_of_model, diameter70Value)
});
}
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var handler = mocks.Stub <IFailureMechanismPropertyChangeHandler <PipingFailureMechanism> >();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
// Call
var properties = new PipingFailureMechanismProperties(failureMechanism, handler);
// Assert
Assert.IsInstanceOf <PipingFailureMechanismPropertiesBase>(properties);
Assert.AreEqual(failureMechanism.Name, properties.Name);
Assert.AreEqual(failureMechanism.Code, properties.Code);
GeneralPipingInput generalInput = failureMechanism.GeneralInput;
Assert.AreEqual(generalInput.UpliftModelFactor.Mean, properties.UpliftModelFactor.Mean);
Assert.AreEqual(generalInput.UpliftModelFactor.StandardDeviation, properties.UpliftModelFactor.StandardDeviation);
Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(generalInput).GetDesignValue(),
properties.UpliftModelFactor.DesignValue);
Assert.AreEqual(generalInput.SellmeijerModelFactor.Mean, properties.SellmeijerModelFactor.Mean);
Assert.AreEqual(generalInput.SellmeijerModelFactor.StandardDeviation, properties.SellmeijerModelFactor.StandardDeviation);
Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(generalInput).GetDesignValue(),
properties.SellmeijerModelFactor.DesignValue);
Assert.AreEqual(generalInput.WaterVolumetricWeight, properties.WaterVolumetricWeight);
Assert.AreEqual(generalInput.CriticalHeaveGradient.Mean, properties.CriticalHeaveGradient.Mean);
Assert.AreEqual(generalInput.CriticalHeaveGradient.StandardDeviation, properties.CriticalHeaveGradient.StandardDeviation);
Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetCriticalHeaveGradientDesignVariable(generalInput).GetDesignValue(),
properties.CriticalHeaveGradient.DesignValue);
Assert.AreEqual(generalInput.SandParticlesVolumicWeight, properties.SandParticlesVolumicWeight);
Assert.AreEqual(generalInput.WhitesDragCoefficient, properties.WhitesDragCoefficient);
Assert.AreEqual(generalInput.BeddingAngle, properties.BeddingAngle);
Assert.AreEqual(generalInput.WaterKinematicViscosity, properties.WaterKinematicViscosity);
Assert.AreEqual(generalInput.Gravity, properties.Gravity);
Assert.AreEqual(generalInput.MeanDiameter70, properties.MeanDiameter70);
Assert.AreEqual(generalInput.SellmeijerReductionFactor, properties.SellmeijerReductionFactor);
mocks.VerifyAll();
}
public void GetSaturatedVolumicWeightOfCoverageLayer_PipingInputWithCoverLayerWithSaturatedDefinition_CreateDesignVariableForSaturatedVolumicWeightOfCoverageLayer()
{
// Setup
PipingInput pipingInput = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer <TestPipingInput>();
pipingInput.StochasticSoilProfile.SoilProfile.Layers.First().BelowPhreaticLevel = new LogNormalDistribution
{
Mean = (RoundedDouble)3.2
};
// Call
DesignVariable <LogNormalDistribution> saturatedVolumicWeightOfCoverageLayer =
SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetSaturatedVolumicWeightOfCoverageLayer(pipingInput),
saturatedVolumicWeightOfCoverageLayer.Distribution);
AssertPercentile(0.05, saturatedVolumicWeightOfCoverageLayer);
}
private static PipingCalculatorInput CreateInputFromData(SemiProbabilisticPipingInput input,
GeneralPipingInput generalPipingInput,
RoundedDouble normativeAssessmentLevel)
{
RoundedDouble effectiveAssessmentLevel = GetEffectiveAssessmentLevel(input, normativeAssessmentLevel);
return(new PipingCalculatorInput(
new PipingCalculatorInput.ConstructionProperties
{
WaterVolumetricWeight = generalPipingInput.WaterVolumetricWeight,
SaturatedVolumicWeightOfCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue(),
UpliftModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(generalPipingInput).GetDesignValue(),
AssessmentLevel = effectiveAssessmentLevel,
PiezometricHeadExit = DerivedSemiProbabilisticPipingInput.GetPiezometricHeadExit(input, effectiveAssessmentLevel),
DampingFactorExit = SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
PhreaticLevelExit = PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
CriticalHeaveGradient = SemiProbabilisticPipingDesignVariableFactory.GetCriticalHeaveGradientDesignVariable(generalPipingInput).GetDesignValue(),
ThicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(input).GetDesignValue(),
EffectiveThicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(input, generalPipingInput).GetDesignValue(),
SellmeijerModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(generalPipingInput).GetDesignValue(),
SellmeijerReductionFactor = generalPipingInput.SellmeijerReductionFactor,
SeepageLength = SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(input).GetDesignValue(),
SandParticlesVolumicWeight = generalPipingInput.SandParticlesVolumicWeight,
WhitesDragCoefficient = generalPipingInput.WhitesDragCoefficient,
Diameter70 = SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(input).GetDesignValue(),
DarcyPermeability = SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(input).GetDesignValue(),
WaterKinematicViscosity = generalPipingInput.WaterKinematicViscosity,
Gravity = generalPipingInput.Gravity,
ThicknessAquiferLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(input).GetDesignValue(),
MeanDiameter70 = generalPipingInput.MeanDiameter70,
BeddingAngle = generalPipingInput.BeddingAngle,
ExitPointXCoordinate = input.ExitPointL,
SurfaceLine = input.SurfaceLine,
SoilProfile = input.StochasticSoilProfile?.SoilProfile
}));
}
public void GetCriticalHeaveGradientDesignVariable_GeneralPipingInput_CreateDeterministicDesignVariableForCriticalHeaveGradient()
{
// Setup
var generalPipingInput = new GeneralPipingInput();
// Call
DeterministicDesignVariable <LogNormalDistribution> criticalHeaveGradient = SemiProbabilisticPipingDesignVariableFactory.GetCriticalHeaveGradientDesignVariable(generalPipingInput);
// Assert
DistributionAssert.AreEqual(generalPipingInput.CriticalHeaveGradient, criticalHeaveGradient.Distribution);
Assert.AreEqual(0.3, criticalHeaveGradient.GetDesignValue());
}
