public void Validate_SurfaceLineInvalidDitchPointsOrder_ValidationMessageForInvalidDitchPointsOrder(
int ditchDikeSidePosition,
int bottomDitchDikeSidePosition,
int bottomDitchPolderSidePosition,
int ditchPolderSidePosition)
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.SurfaceLine = new PipingSurfaceLine(string.Empty);
var input = new PipingCalculatorInput(properties);
input.SurfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 2),
new Point3D(1, 0, -3),
new Point3D(2, 0, -4),
new Point3D(3, 0, 3)
});
input.SurfaceLine.SetDitchDikeSideAt(input.SurfaceLine.Points.ElementAt(ditchDikeSidePosition));
input.SurfaceLine.SetBottomDitchDikeSideAt(input.SurfaceLine.Points.ElementAt(bottomDitchDikeSidePosition));
input.SurfaceLine.SetBottomDitchPolderSideAt(input.SurfaceLine.Points.ElementAt(bottomDitchPolderSidePosition));
input.SurfaceLine.SetDitchPolderSideAt(input.SurfaceLine.Points.ElementAt(ditchPolderSidePosition));
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("De sloot in de hoogtegeometrie is niet correct. Niet alle 4 punten zijn gedefinieerd of de volgorde is incorrect.", validationMessages.First());
}
public void Validate_SoilProfileBottomAtTopLevel_ValidationMessageForHavingTooHighBottom(double bottom)
{
// Setup
const int top = 0;
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.SoilProfile = new PipingSoilProfile(string.Empty, bottom, new[]
{
new PipingSoilLayer(top)
{
IsAquifer = true
}
}, SoilProfileType.SoilProfile1D);
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
string message = $"De onderkant({bottom}) van het ondergrondprofiel is niet laag genoeg. Het moet tenminste {0.001} m onder de bovenkant van de diepste laag ({top}) liggen.";
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual(message, validationMessages[0]);
}
public void Validate_CompleteValidInput_ReturnsNoValidationMessages()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(0, validationMessages.Count);
}
/// <summary>
/// Calculates the piezometric head at the exit point based on the values of partial piping input.
/// </summary>
/// <param name="assessmentLevel">The assessment level.</param>
/// <param name="dampingFactorExit">The design value of the damping factor at exit point.</param>
/// <param name="phreaticLevelExit">The design value of the phreatic level at exit point.</param>
/// <returns>The piezometric head at the exit point.</returns>
public static double CalculatePiezometricHeadAtExit(RoundedDouble assessmentLevel, RoundedDouble dampingFactorExit, RoundedDouble phreaticLevelExit)
{
var calculatorInput = new PipingCalculatorInput(
new PipingCalculatorInput.ConstructionProperties
{
AssessmentLevel = assessmentLevel,
DampingFactorExit = dampingFactorExit,
PhreaticLevelExit = phreaticLevelExit
});
return(new PipingCalculator(calculatorInput, PipingSubCalculatorFactory.Instance).CalculatePiezometricHeadAtExit());
}
public void Constructor_FactoryNull_ArgumentNullException()
{
// Call
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
void Call() => new PipingCalculator(input, null);
// Assert
const string expectedMessage = "IPipingSubCalculatorFactory required for creating a PipingCalculator.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentNullException>(Call, expectedMessage);
}
public void CalculateThicknessCoverageLayer_WithValidInput_ReturnsSomeThickness()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
double result = calculation.CalculateEffectiveThicknessCoverageLayer();
// Assert
Assert.AreEqual(1.0, result);
}
public void CalculatePiezometricHeadAtExit_WithValidInput_ReturnsSomeValue()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
double result = calculation.CalculatePiezometricHeadAtExit();
// Assert
Assert.IsFalse(double.IsNaN(result));
}
public void Calculate_CompleteValidInput_BottomLevelAquitardLayerAboveExitPointZUsedFromCalculator()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
var testPipingSubCalculatorFactory = new TestPipingSubCalculatorFactory();
double bottomAquitardLayerAboveExitPointZ = new Random(21).NextDouble(0, 10);
testPipingSubCalculatorFactory.LastCreatedPipingProfilePropertyCalculator.BottomAquitardLayerAboveExitPointZ = bottomAquitardLayerAboveExitPointZ;
// Call
new PipingCalculator(input, testPipingSubCalculatorFactory).Calculate();
// Assert
Assert.AreEqual(bottomAquitardLayerAboveExitPointZ, testPipingSubCalculatorFactory.LastCreatedSellmeijerCalculator.BottomLevelAquitardAboveExitPointZ);
}
public void CalculateThicknessCoverageLayer_WithExitPointLBeyondSurfaceLineInput_ReturnsNaN()
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.ExitPointXCoordinate = (RoundedDouble)2.1;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
double result = calculation.CalculateEffectiveThicknessCoverageLayer();
// Assert
Assert.IsNaN(result);
}
public void Validate_NoSoilProfileSet_ValidationMessageForHavingNoSoilProfileSelected()
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.SoilProfile = null;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("Het ondergrondprofiel is niet gedefinieerd.", validationMessages[0]);
}
public void Validate_ZeroOrNegativeSeepageLength_ValidationMessageForPipingLength(double seepageLength)
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.SeepageLength = seepageLength;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("Kwelweglengte heeft ongeldige waarde (0 of negatief).", validationMessages[0]);
}
public void Validate_VolumetricWeightWaterZero_ValidationMessageForVolumetricWeightWater()
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.WaterVolumetricWeight = 0;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("Volumiek gewicht water heeft ongeldige waarde (mag niet nul zijn).", validationMessages[0]);
}
public void Validate_ThicknessAquiferLayerZero_ValidationMessageForDAquifer()
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.ThicknessAquiferLayer = 0;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("Parameter 'DAquifer' (dikte watervoerend pakket) heeft ongeldige waarde (0 of negatief).", validationMessages[0]);
}
public void Validate_CompleteValidInput_CalculatorsValidated()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
var testPipingSubCalculatorFactory = new TestPipingSubCalculatorFactory();
var calculation = new PipingCalculator(input, testPipingSubCalculatorFactory);
// Call
calculation.Validate();
// Assert
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedEffectiveThicknessCalculator.Validated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedHeaveCalculator.Validated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedSellmeijerCalculator.Validated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedUpliftCalculator.Validated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedPipingProfilePropertyCalculator.Validated);
}
public void Validate_NegativeBeddingAngle_ValidationMessageForBeddingAngle(double beddingAngle)
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.BeddingAngle = beddingAngle;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("Rolweerstandshoek heeft een ongeldige waarde (0 of negatief).", validationMessages[0]);
}
public void Validate_DampingFactorExitZero_TwoValidationMessageForRExit()
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.AssessmentLevel = (RoundedDouble)0.1;
properties.DampingFactorExit = 0;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("Parameter 'RExit' (Dempingsfactor bij uittredepunt) mag niet nul zijn.", validationMessages[0]);
}
public void CalculateThicknessCoverageLayer_WithValidInput_UsedPiezometricHeadAtExitCalculator()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
var testPipingSubCalculatorFactory = new TestPipingSubCalculatorFactory();
var calculation = new PipingCalculator(input, testPipingSubCalculatorFactory);
// Call
calculation.CalculatePiezometricHeadAtExit();
// Assert
Assert.IsFalse(testPipingSubCalculatorFactory.LastCreatedHeaveCalculator.Calculated);
Assert.IsFalse(testPipingSubCalculatorFactory.LastCreatedSellmeijerCalculator.Calculated);
Assert.IsFalse(testPipingSubCalculatorFactory.LastCreatedUpliftCalculator.Calculated);
Assert.IsFalse(testPipingSubCalculatorFactory.LastCreatedPipingProfilePropertyCalculator.Calculated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedPiezometricHeadAtExitCalculator.Calculated);
Assert.IsFalse(testPipingSubCalculatorFactory.LastCreatedEffectiveThicknessCalculator.Calculated);
}
/// <summary>
/// Calculates the thickness of the coverage layer based on the values of partial piping input.
/// </summary>
/// <param name="waterVolumetricWeight">The volumetric weight of water.</param>
/// <param name="phreaticLevelExit">The design value of the phreatic level at the exit point.</param>
/// <param name="exitPointL">The l-coordinate of the exit point.</param>
/// <param name="surfaceLine">A surface line.</param>
/// <param name="soilProfile">A soil profile.</param>
/// <returns>The thickness of the coverage layer, or <see cref="double.NaN"/> if the thickness could not be calculated.</returns>
public static double CalculateEffectiveThicknessCoverageLayer(double waterVolumetricWeight, RoundedDouble phreaticLevelExit, RoundedDouble exitPointL, PipingSurfaceLine surfaceLine, PipingSoilProfile soilProfile)
{
try
{
var calculatorInput = new PipingCalculatorInput(
new PipingCalculatorInput.ConstructionProperties
{
WaterVolumetricWeight = waterVolumetricWeight,
PhreaticLevelExit = phreaticLevelExit,
ExitPointXCoordinate = exitPointL,
SurfaceLine = surfaceLine,
SoilProfile = soilProfile
});
return(new PipingCalculator(calculatorInput, PipingSubCalculatorFactory.Instance).CalculateEffectiveThicknessCoverageLayer());
}
catch (PipingCalculatorException)
{
return(double.NaN);
}
}
public void CalculateThicknessCoverageLayer_WithValidInputWithAquiferAboveSurfaceLine_ReturnsNegativeThickness()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
input.SurfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0.5),
new Point3D(1, 0, 1.5),
new Point3D(2, 0, -1)
});
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
double result = calculation.CalculateEffectiveThicknessCoverageLayer();
// Assert
Assert.AreEqual(result, -3.0);
}
public void Validate_DifferenceAssessmentLevelAndPhreaticLevelExitEqualToSellmeijerReductionFactorTimesThicknessCoverageLayer_ValidationMessageForHRiverHExitRcDTotal(
double assessmentLevel, double phreaticLevelExit, double sellmeijerReductionFactor, double thicknessCoverageLayer)
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.AssessmentLevel = (RoundedDouble)assessmentLevel;
properties.PhreaticLevelExit = phreaticLevelExit;
properties.SellmeijerReductionFactor = sellmeijerReductionFactor;
properties.ThicknessCoverageLayer = thicknessCoverageLayer;
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
List <string> validationMessages = calculation.Validate();
// Assert
Assert.AreEqual(1, validationMessages.Count);
Assert.AreEqual("De term HRiver - HExit - (Rc*DTotal) mag niet nul zijn.", validationMessages[0]);
}
public void CalculateThicknessCoverageLayer_SoilProfileWithoutAquiferSet_ThrowsPipingCalculatorException()
{
// Setup
PipingCalculatorInput.ConstructionProperties properties = CreateSimpleConstructionProperties();
properties.SoilProfile = new PipingSoilProfile(string.Empty, -1.0, new[]
{
new PipingSoilLayer(0)
}, SoilProfileType.SoilProfile1D);
var input = new PipingCalculatorInput(properties);
var calculation = new PipingCalculator(input, PipingSubCalculatorFactory.Instance);
// Call
void Call() => calculation.CalculateEffectiveThicknessCoverageLayer();
// Assert
var exception = Assert.Throws <PipingCalculatorException>(Call);
Assert.IsInstanceOf <NullReferenceException>(exception.InnerException);
}
public void Calculate_CompleteValidInput_ReturnsResultWithNoNaN()
{
// Setup
var input = new PipingCalculatorInput(CreateSimpleConstructionProperties());
var testPipingSubCalculatorFactory = new TestPipingSubCalculatorFactory();
// Call
PipingCalculatorResult actual = new PipingCalculator(input, testPipingSubCalculatorFactory).Calculate();
// Assert
Assert.IsNotNull(actual);
Assert.IsFalse(double.IsNaN(actual.UpliftEffectiveStress));
Assert.IsFalse(double.IsNaN(actual.UpliftFactorOfSafety));
Assert.IsFalse(double.IsNaN(actual.HeaveFactorOfSafety));
Assert.IsFalse(double.IsNaN(actual.SellmeijerFactorOfSafety));
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedHeaveCalculator.Calculated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedSellmeijerCalculator.Calculated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedUpliftCalculator.Calculated);
Assert.IsTrue(testPipingSubCalculatorFactory.LastCreatedPipingProfilePropertyCalculator.Calculated);
Assert.IsFalse(testPipingSubCalculatorFactory.LastCreatedPiezometricHeadAtExitCalculator.Calculated);
Assert.IsFalse(testPipingSubCalculatorFactory.LastCreatedEffectiveThicknessCalculator.Calculated);
}
public void Constructor_WithConstructionProperties_PropertiesAreSet()
{
// Setup
var random = new Random(22);
double volumetricWeightOfWaterValue = random.NextDouble();
double saturatedVolumicWeightOfCoverageLayer = random.NextDouble();
double modelFactorUpliftValue = random.NextDouble();
double hRiverValue = random.NextDouble();
double phiExit = random.NextDouble();
double rExitValue = random.NextDouble();
double hExitValue = random.NextDouble();
double ichValue = random.NextDouble();
double dTotalValue = random.NextDouble();
double effectiveThicknessCoverageLayerValue = random.NextDouble();
double sellmeijerModelFactorValue = random.NextDouble();
double reductionFactorValue = random.NextDouble();
double seepageLengthValue = random.NextDouble();
double sandParticlesVolumicWeightValue = random.NextDouble();
double whitesDragCoefficientValue = random.NextDouble();
double diameter70Value = random.NextDouble();
double darcyPermeabilityValue = random.NextDouble();
double waterKinematicViscosityValue = random.NextDouble();
double gravityValue = random.NextDouble();
double thicknessAquiferLayerValue = random.NextDouble();
double meanDiameter70Value = random.NextDouble();
double beddingAngleValue = random.NextDouble();
double exitPointXCoordinate = random.NextDouble();
var surfaceLine = new PipingSurfaceLine(string.Empty);
var soilProfile = new PipingSoilProfile(string.Empty, random.NextDouble(), new[]
{
new PipingSoilLayer(random.NextDouble())
{
IsAquifer = true
}
}, SoilProfileType.SoilProfile1D);
// Call
var input = new PipingCalculatorInput(
new PipingCalculatorInput.ConstructionProperties
{
WaterVolumetricWeight = volumetricWeightOfWaterValue,
SaturatedVolumicWeightOfCoverageLayer = saturatedVolumicWeightOfCoverageLayer,
UpliftModelFactor = modelFactorUpliftValue,
AssessmentLevel = hRiverValue,
PiezometricHeadExit = phiExit,
DampingFactorExit = rExitValue,
PhreaticLevelExit = hExitValue,
CriticalHeaveGradient = ichValue,
ThicknessCoverageLayer = dTotalValue,
EffectiveThicknessCoverageLayer = effectiveThicknessCoverageLayerValue,
SellmeijerModelFactor = sellmeijerModelFactorValue,
SellmeijerReductionFactor = reductionFactorValue,
SeepageLength = seepageLengthValue,
SandParticlesVolumicWeight = sandParticlesVolumicWeightValue,
WhitesDragCoefficient = whitesDragCoefficientValue,
Diameter70 = diameter70Value,
DarcyPermeability = darcyPermeabilityValue,
WaterKinematicViscosity = waterKinematicViscosityValue,
Gravity = gravityValue,
ThicknessAquiferLayer = thicknessAquiferLayerValue,
MeanDiameter70 = meanDiameter70Value,
BeddingAngle = beddingAngleValue,
ExitPointXCoordinate = exitPointXCoordinate,
SurfaceLine = surfaceLine,
SoilProfile = soilProfile
});
// Assert
Assert.AreEqual(volumetricWeightOfWaterValue, input.WaterVolumetricWeight);
Assert.AreEqual(saturatedVolumicWeightOfCoverageLayer, input.SaturatedVolumicWeightOfCoverageLayer);
Assert.AreEqual(modelFactorUpliftValue, input.UpliftModelFactor);
Assert.AreEqual(hRiverValue, input.AssessmentLevel);
Assert.AreEqual(phiExit, input.PiezometricHeadExit);
Assert.AreEqual(rExitValue, input.DampingFactorExit);
Assert.AreEqual(hExitValue, input.PhreaticLevelExit);
Assert.AreEqual(ichValue, input.CriticalHeaveGradient);
Assert.AreEqual(dTotalValue, input.ThicknessCoverageLayer);
Assert.AreEqual(effectiveThicknessCoverageLayerValue, input.EffectiveThicknessCoverageLayer);
Assert.AreEqual(sellmeijerModelFactorValue, input.SellmeijerModelFactor);
Assert.AreEqual(reductionFactorValue, input.SellmeijerReductionFactor);
Assert.AreEqual(seepageLengthValue, input.SeepageLength);
Assert.AreEqual(sandParticlesVolumicWeightValue, input.SandParticlesVolumicWeight);
Assert.AreEqual(whitesDragCoefficientValue, input.WhitesDragCoefficient);
Assert.AreEqual(diameter70Value, input.Diameter70);
Assert.AreEqual(darcyPermeabilityValue, input.DarcyPermeability);
Assert.AreEqual(waterKinematicViscosityValue, input.WaterKinematicViscosity);
Assert.AreEqual(gravityValue, input.Gravity);
Assert.AreEqual(thicknessAquiferLayerValue, input.ThicknessAquiferLayer);
Assert.AreEqual(meanDiameter70Value, input.MeanDiameter70);
Assert.AreEqual(beddingAngleValue, input.BeddingAngle);
Assert.AreEqual(exitPointXCoordinate, input.ExitPointXCoordinate);
Assert.AreSame(surfaceLine, input.SurfaceLine);
Assert.AreSame(soilProfile, input.SoilProfile);
}
