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_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_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);
}
public void Constructor_ExpectedValues()
{
// Call
var calculator = new PipingCalculator(HydraRingCalculationSettingsTestFactory.CreateSettings());
// Assert
Assert.IsInstanceOf <HydraRingCalculatorBase>(calculator);
Assert.IsNaN(calculator.ExceedanceProbabilityBeta);
Assert.IsNull(calculator.OutputDirectory);
Assert.IsNull(calculator.IllustrationPointsResult);
Assert.IsNull(calculator.IllustrationPointsParserErrorMessage);
}
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 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 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_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_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]);
}
/// <summary>
/// Performs a piping calculation based on the supplied <see cref="SemiProbabilisticPipingCalculation"/> and sets
/// <see cref="SemiProbabilisticPipingCalculation.Output"/> if the calculation was successful. Error and status
/// information is logged during the execution of the operation.
/// </summary>
/// <param name="calculation">The <see cref="SemiProbabilisticPipingCalculation"/> to base the input for the calculation upon.</param>
/// <param name="generalInput">The <see cref="GeneralPipingInput"/> to derive values from during the calculation.</param>
/// <param name="normativeAssessmentLevel">The normative assessment level to use in case the manual assessment level is not applicable.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/> or <paramref name="generalInput"/> is <c>null</c>.</exception>
/// <exception cref="PipingCalculatorException">Thrown when an unexpected error occurred during the calculation.</exception>
/// <remarks>Consider calling <see cref="Validate"/> first to see if calculation is possible.</remarks>
public static void Calculate(SemiProbabilisticPipingCalculation calculation,
GeneralPipingInput generalInput,
RoundedDouble normativeAssessmentLevel)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
CalculationServiceHelper.LogCalculationBegin();
try
{
PipingCalculatorResult pipingResult = new PipingCalculator(CreateInputFromData(calculation.InputParameters,
generalInput,
normativeAssessmentLevel),
PipingSubCalculatorFactory.Instance).Calculate();
calculation.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties
{
UpliftFactorOfSafety = pipingResult.UpliftFactorOfSafety,
HeaveFactorOfSafety = pipingResult.HeaveFactorOfSafety,
SellmeijerFactorOfSafety = pipingResult.SellmeijerFactorOfSafety,
UpliftEffectiveStress = pipingResult.UpliftEffectiveStress,
HeaveGradient = pipingResult.HeaveGradient,
SellmeijerCreepCoefficient = pipingResult.SellmeijerCreepCoefficient,
SellmeijerCriticalFall = pipingResult.SellmeijerCriticalFall,
SellmeijerReducedFall = pipingResult.SellmeijerReducedFall
});
}
catch (PipingCalculatorException e)
{
CalculationServiceHelper.LogExceptionAsError(RiskeerCommonServiceResources.CalculationService_Calculate_unexpected_error, e);
throw;
}
finally
{
CalculationServiceHelper.LogCalculationEnd();
}
}
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_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_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);
}
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);
}
private static bool LogAnyErrors(SemiProbabilisticPipingCalculation calculation, GeneralPipingInput generalInput, RoundedDouble normativeAssessmentLevel)
{
string[] messages = ValidateInput(calculation.InputParameters, generalInput, normativeAssessmentLevel).ToArray();
if (messages.Length > 0)
{
CalculationServiceHelper.LogMessagesAsError(messages);
return(true);
}
messages = new PipingCalculator(CreateInputFromData(calculation.InputParameters, generalInput, normativeAssessmentLevel),
PipingSubCalculatorFactory.Instance).Validate().ToArray();
if (messages.Length > 0)
{
CalculationServiceHelper.LogMessagesAsError(messages);
return(true);
}
return(false);
}
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);
}
