/// <summary>
/// Creates output for the wave conditions calculation.
/// </summary>
/// <param name="calculationType">The type of the calculation.</param>
/// <param name="waveRunUpOutput">The output of the wave run up calculation.</param>
/// <param name="waveImpactOutput">The output of the wave impact calculation.</param>
/// <param name="waveImpactWithWaveDirectionOutput">The output of the wave impact with wave direction calculation.</param>
/// <returns>The created <see cref="GrassCoverErosionOutwardsWaveConditionsOutput"/>.</returns>
/// <exception cref="NotSupportedException">Thrown when <see cref="GrassCoverErosionOutwardsWaveConditionsCalculationType"/>
/// is a valid value, but unsupported.</exception>
private static GrassCoverErosionOutwardsWaveConditionsOutput CreateOutput(GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType,
IEnumerable <WaveConditionsOutput> waveRunUpOutput,
IEnumerable <WaveConditionsOutput> waveImpactOutput,
IEnumerable <WaveConditionsOutput> waveImpactWithWaveDirectionOutput)
{
switch (calculationType)
{
case GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUp:
return(GrassCoverErosionOutwardsWaveConditionsOutputFactory.CreateOutputWithWaveRunUp(waveRunUpOutput));
case GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveImpact:
return(GrassCoverErosionOutwardsWaveConditionsOutputFactory.CreateOutputWithWaveImpact(waveImpactOutput));
case GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpact:
return(GrassCoverErosionOutwardsWaveConditionsOutputFactory.CreateOutputWithWaveRunUpAndWaveImpact(waveRunUpOutput, waveImpactOutput));
case GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveImpactWithWaveDirection:
return(GrassCoverErosionOutwardsWaveConditionsOutputFactory.CreateOutputWithWaveImpactWithWaveDirection(waveImpactWithWaveDirectionOutput));
case GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpactWithWaveDirection:
return(GrassCoverErosionOutwardsWaveConditionsOutputFactory.CreateOutputWithWaveRunUpAndWaveImpactWithWaveDirection(waveRunUpOutput, waveImpactWithWaveDirectionOutput));
case GrassCoverErosionOutwardsWaveConditionsCalculationType.All:
return(GrassCoverErosionOutwardsWaveConditionsOutputFactory.CreateOutputWithWaveRunUpWaveImpactAndWaveImpactWithWaveDirection(waveRunUpOutput, waveImpactOutput, waveImpactWithWaveDirectionOutput));
default:
throw new NotSupportedException();
}
}
public void Constructor_CalculationTypeWaveRunUpOrWaveImpact_PropertiesHaveExpectedAttributesValues(
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType, string expectedDisplayName, string expectedDescription)
{
// Setup
GrassCoverErosionOutwardsWaveConditionsOutput output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
var input = new GrassCoverErosionOutwardsWaveConditionsInput
{
CalculationType = calculationType
};
// Call
var properties = new GrassCoverErosionOutwardsWaveConditionsOutputProperties(output, input);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(1, dynamicProperties.Count);
PropertyDescriptor outputProperty = dynamicProperties[0];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(outputProperty,
"Resultaat",
expectedDisplayName,
expectedDescription,
true);
}
private static bool ShouldCalculateWaveRunUp(GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType)
{
return(calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpact ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUp ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.All ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpactWithWaveDirection);
}
private static IEnumerable <ExportableWaveConditions> CreateExportableWaveConditionsCollection(IEnumerable <GrassCoverErosionOutwardsWaveConditionsCalculation> calculations,
Func <WaveConditionsInput, string> getTargetProbabilityFunc)
{
if (calculations == null)
{
throw new ArgumentNullException(nameof(calculations));
}
if (getTargetProbabilityFunc == null)
{
throw new ArgumentNullException(nameof(getTargetProbabilityFunc));
}
var exportableWaveConditions = new List <ExportableWaveConditions>();
IEnumerable <GrassCoverErosionOutwardsWaveConditionsCalculation> exportableCalculations =
calculations.Where(c => c.HasOutput && c.InputParameters.HydraulicBoundaryLocation != null);
foreach (GrassCoverErosionOutwardsWaveConditionsCalculation calculation in exportableCalculations)
{
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType = calculation.InputParameters.CalculationType;
if (calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpact ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUp ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpactWithWaveDirection ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.All)
{
exportableWaveConditions.AddRange(
ExportableWaveConditionsFactory.CreateExportableWaveConditionsCollection(
calculation.Name, calculation.InputParameters, calculation.Output.WaveRunUpOutput, CoverType.GrassWaveRunUp, getTargetProbabilityFunc));
}
if (calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpact ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveImpact ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.All)
{
exportableWaveConditions.AddRange(
ExportableWaveConditionsFactory.CreateExportableWaveConditionsCollection(
calculation.Name, calculation.InputParameters, calculation.Output.WaveImpactOutput, CoverType.GrassWaveImpact, getTargetProbabilityFunc));
}
if (calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveImpactWithWaveDirection ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpactWithWaveDirection ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.All)
{
exportableWaveConditions.AddRange(
ExportableWaveConditionsFactory.CreateExportableWaveConditionsCollection(
calculation.Name, calculation.InputParameters, calculation.Output.WaveImpactWithWaveDirectionOutput, CoverType.GrassWaveImpactWithWaveDirection, getTargetProbabilityFunc));
}
}
return(exportableWaveConditions);
}
public void ConvertFrom_ValidGrassCoverErosionOutwardsWaveConditionsCalculationType_ReturnConfigurationGrassCoverErosionOutwardsCalculationType(
GrassCoverErosionOutwardsWaveConditionsCalculationType originalValue, ConfigurationGrassCoverErosionOutwardsCalculationType expectedValue)
{
// Setup
var converter = new ConfigurationGrassCoverErosionOutwardsCalculationTypeConverter();
// Call
object convertedValue = converter.ConvertFrom(originalValue);
// Assert
Assert.AreEqual(expectedValue, convertedValue);
}
public void ConvertTo_ValidConfigurationGrassCoverErosionOutwardsCalculationType_ReturnGrassCoverErosionOutwardsWaveConditionsCalculationType(
ConfigurationGrassCoverErosionOutwardsCalculationType originalValue, GrassCoverErosionOutwardsWaveConditionsCalculationType expectedResult)
{
// Setup
var converter = new ConfigurationGrassCoverErosionOutwardsCalculationTypeConverter();
// Call
object calculationType = converter.ConvertTo(null, CultureInfo.CurrentCulture, originalValue, typeof(GrassCoverErosionOutwardsWaveConditionsCalculationType));
// Assert
Assert.AreEqual(expectedResult, calculationType);
}
public void ConvertTo_InvalidConfigurationGrassCoverErosionOutwardsCalculationType_ThrowInvalidEnumArgumentException(Type destinationType)
{
// Setup
const GrassCoverErosionOutwardsWaveConditionsCalculationType invalidValue = (GrassCoverErosionOutwardsWaveConditionsCalculationType)99;
var converter = new ConfigurationGrassCoverErosionOutwardsCalculationTypeConverter();
// Call
TestDelegate call = () => converter.ConvertTo(invalidValue, destinationType);
// Assert
string expectedMessage = $"The value of argument 'value' ({invalidValue}) is invalid for Enum type '{nameof(ConfigurationGrassCoverErosionOutwardsCalculationType)}'.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(call, expectedMessage);
}
public void DynamicVisibleValidationMethod_DependingOnRelevancy_ReturnExpectedVisibility(
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType, bool waveRunUpVisible, bool waveImpactVisible, bool waveImpactWithWaveDirectionVisible)
{
// Setup
GrassCoverErosionOutwardsWaveConditionsOutput output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
var input = new GrassCoverErosionOutwardsWaveConditionsInput
{
CalculationType = calculationType
};
var properties = new GrassCoverErosionOutwardsWaveConditionsOutputProperties(output, input);
// Call & Assert
Assert.AreEqual(waveRunUpVisible, properties.DynamicVisibleValidationMethod(nameof(properties.WaveRunUpOutput)));
Assert.AreEqual(waveImpactVisible, properties.DynamicVisibleValidationMethod(nameof(properties.WaveImpactOutput)));
Assert.AreEqual(waveImpactWithWaveDirectionVisible, properties.DynamicVisibleValidationMethod(nameof(properties.WaveImpactWithWaveDirectionOutput)));
Assert.IsFalse(properties.DynamicVisibleValidationMethod(null));
}
private void DetermineTotalWaterLevelCalculations(GrassCoverErosionOutwardsWaveConditionsInput calculationInput,
RoundedDouble assessmentLevel)
{
int waterLevelCount = calculationInput.GetWaterLevels(assessmentLevel).Count();
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType = calculationInput.CalculationType;
if (calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.All)
{
TotalWaterLevelCalculations = waterLevelCount * 3;
return;
}
if (calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpact ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpactWithWaveDirection)
{
TotalWaterLevelCalculations = waterLevelCount * 2;
return;
}
TotalWaterLevelCalculations = waterLevelCount;
}
/// <summary>
/// Performs a wave conditions calculation for the grass cover erosion outwards failure mechanism based on the supplied
/// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> and sets
/// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation.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="GrassCoverErosionOutwardsWaveConditionsCalculation"/> that holds all the information required to perform the calculation.</param>
/// <param name="failureMechanism">The grass cover erosion outwards failure mechanism, which contains general parameters that apply to all
/// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> instances.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that holds information about the target probability used in the calculation.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="failureMechanism"/>
/// or <paramref name="assessmentSection"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when:
/// <list type="bullet">
/// <item>the hydraulic boundary database file path contains invalid characters.</item>
/// <item><paramref name="failureMechanism"/> has no (0) contribution.</item>
/// </list></exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when an unexpected
/// enum value is encountered.</exception>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of the hydraulic boundary database file path
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list>
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown when the target probability or
/// calculated probability falls outside the [0.0, 1.0] range and is not <see cref="double.NaN"/>.</exception>
/// <exception cref="HydraRingFileParserException">Thrown when an error occurs during parsing of the Hydra-Ring output.</exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs during the calculation.</exception>
/// <exception cref="NotSupportedException">Thrown when <see cref="GrassCoverErosionOutwardsWaveConditionsCalculationType"/>
/// is a valid value, but unsupported.</exception>
public void Calculate(GrassCoverErosionOutwardsWaveConditionsCalculation calculation,
GrassCoverErosionOutwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
GrassCoverErosionOutwardsWaveConditionsInput calculationInput = calculation.InputParameters;
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType = calculationInput.CalculationType;
if (!Enum.IsDefined(typeof(GrassCoverErosionOutwardsWaveConditionsCalculationType), calculationType))
{
throw new InvalidEnumArgumentException(nameof(calculationType), (int)calculationType,
typeof(GrassCoverErosionOutwardsWaveConditionsCalculationType));
}
CalculationServiceHelper.LogCalculationBegin();
RoundedDouble assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(calculationInput, assessmentSection);
double targetProbability = WaveConditionsInputHelper.GetTargetProbability(calculationInput, assessmentSection);
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
DetermineTotalWaterLevelCalculations(calculationInput, assessmentLevel);
try
{
IEnumerable <WaveConditionsOutput> waveRunUpOutput = null;
if (ShouldCalculateWaveRunUp(calculationType))
{
CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveRunUp_DisplayName;
waveRunUpOutput = CalculateWaveRunUp(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
}
if (Canceled)
{
return;
}
IEnumerable <WaveConditionsOutput> waveImpactOutput = null;
if (ShouldCalculateWaveImpact(calculationType))
{
CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpact_DisplayName;
waveImpactOutput = CalculateWaveImpact(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
}
IEnumerable <WaveConditionsOutput> waveImpactWithWaveDirectionOutput = null;
if (ShouldCalculateWaveImpactWithWaveDirection(calculationType))
{
CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpactWithWaveDirection_DisplayName;
waveImpactWithWaveDirectionOutput = CalculateWaveImpactWithWaveDirection(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
}
if (!Canceled)
{
calculation.Output = CreateOutput(calculationType, waveRunUpOutput, waveImpactOutput, waveImpactWithWaveDirectionOutput);
}
}
finally
{
CalculationServiceHelper.LogCalculationEnd();
}
}
