private static IEnumerable<ExportableWaveConditions> CreateExportableWaveConditions(IEnumerable<StabilityStoneCoverWaveConditionsCalculation> exportableCalculations,
Func<WaveConditionsInput, string> getTargetProbabilityFunc)
{
var exportableWaveConditions = new List<ExportableWaveConditions>();
foreach (StabilityStoneCoverWaveConditionsCalculation calculation in exportableCalculations)
{
StabilityStoneCoverWaveConditionsCalculationType calculationType = calculation.InputParameters.CalculationType;
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both
|| calculationType == StabilityStoneCoverWaveConditionsCalculationType.Blocks)
{
exportableWaveConditions.AddRange(
ExportableWaveConditionsFactory.CreateExportableWaveConditionsCollection(
calculation.Name, calculation.InputParameters, calculation.Output.BlocksOutput, CoverType.StoneCoverBlocks, getTargetProbabilityFunc));
}
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both
|| calculationType == StabilityStoneCoverWaveConditionsCalculationType.Columns)
{
exportableWaveConditions.AddRange(
ExportableWaveConditionsFactory.CreateExportableWaveConditionsCollection(
calculation.Name, calculation.InputParameters, calculation.Output.ColumnsOutput, CoverType.StoneCoverColumns, getTargetProbabilityFunc));
}
}
return exportableWaveConditions;
}
public void ConvertFrom_ValidStabilityStoneCoverWaveConditionsCalculationType_ReturnConfigurationStabilityStoneCoverCalculationType(
StabilityStoneCoverWaveConditionsCalculationType originalValue, ConfigurationStabilityStoneCoverCalculationType expectedValue)
{
// Setup
var converter = new ConfigurationStabilityStoneCoverCalculationTypeConverter();
// Call
object convertedValue = converter.ConvertFrom(originalValue);
// Assert
Assert.AreEqual(expectedValue, convertedValue);
}
public void ConvertTo_ValidConfigurationStabilityStoneCoverCalculationType_ReturnStabilityStoneCoverWaveConditionsCalculationType(
ConfigurationStabilityStoneCoverCalculationType originalValue, StabilityStoneCoverWaveConditionsCalculationType expectedResult)
{
// Setup
var converter = new ConfigurationStabilityStoneCoverCalculationTypeConverter();
// Call
object calculationType = converter.ConvertTo(null, CultureInfo.CurrentCulture, originalValue, typeof(StabilityStoneCoverWaveConditionsCalculationType));
// Assert
Assert.AreEqual(expectedResult, calculationType);
}
public void ConvertTo_InvalidConfigurationStabilityStoneCoverCalculationType_ThrowInvalidEnumArgumentException(Type destinationType)
{
// Setup
const StabilityStoneCoverWaveConditionsCalculationType invalidValue = (StabilityStoneCoverWaveConditionsCalculationType)99;
var converter = new ConfigurationStabilityStoneCoverCalculationTypeConverter();
// Call
TestDelegate call = () => converter.ConvertTo(invalidValue, destinationType);
// Assert
string expectedMessage = $"The value of argument 'value' ({invalidValue}) is invalid for Enum type '{nameof(ConfigurationStabilityStoneCoverCalculationType)}'.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(call, expectedMessage);
}
private static StabilityStoneCoverWaveConditionsOutput CreateOutput(StabilityStoneCoverWaveConditionsCalculationType calculationType,
IEnumerable <WaveConditionsOutput> blocksOutputs,
IEnumerable <WaveConditionsOutput> columnsOutputs)
{
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Blocks)
{
return(StabilityStoneCoverWaveConditionsOutputFactory.CreateOutputWithBlocks(blocksOutputs));
}
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Columns)
{
return(StabilityStoneCoverWaveConditionsOutputFactory.CreateOutputWithColumns(columnsOutputs));
}
return(StabilityStoneCoverWaveConditionsOutputFactory.CreateOutputWithColumnsAndBlocks(columnsOutputs, blocksOutputs));
}
public void DynamicVisibleValidationMethod_DependingOnRelevancy_ReturnExpectedVisibility(
StabilityStoneCoverWaveConditionsCalculationType calculationType, bool blocksVisible, bool columnsVisible)
{
// Setup
StabilityStoneCoverWaveConditionsOutput output = StabilityStoneCoverWaveConditionsOutputTestFactory.Create();
var input = new StabilityStoneCoverWaveConditionsInput
{
CalculationType = calculationType
};
var properties = new StabilityStoneCoverWaveConditionsOutputProperties(output, input);
// Call & Assert
Assert.AreEqual(blocksVisible, properties.DynamicVisibleValidationMethod(nameof(properties.Blocks)));
Assert.AreEqual(columnsVisible, properties.DynamicVisibleValidationMethod(nameof(properties.Columns)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(null));
}
public void Constructor_CalculationTypeBlocksOrColumns_PropertiesHaveExpectedAttributesValues(StabilityStoneCoverWaveConditionsCalculationType calculationType)
{
// Setup
var blocksOutput = new[]
{
new TestWaveConditionsOutput()
};
var columnsOutput = new[]
{
new TestWaveConditionsOutput()
};
StabilityStoneCoverWaveConditionsOutput stabilityStoneCoverWaveConditionsOutput = StabilityStoneCoverWaveConditionsOutputTestFactory.Create(
columnsOutput, blocksOutput);
var input = new StabilityStoneCoverWaveConditionsInput
{
CalculationType = calculationType
};
// Call
var properties = new StabilityStoneCoverWaveConditionsOutputProperties(
stabilityStoneCoverWaveConditionsOutput, input);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(1, dynamicProperties.Count);
const string resultCategory = "Resultaat";
string revetmentType = null;
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Blocks)
{
revetmentType = "blokken";
}
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Columns)
{
revetmentType = "zuilen";
}
PropertyDescriptor outputProperty = dynamicProperties[0];
Assert.IsInstanceOf <ExpandableArrayConverter>(outputProperty.Converter);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(outputProperty,
resultCategory,
$"Hydraulische belastingen voor {revetmentType}",
$"Berekende hydraulische belastingen voor {revetmentType}.",
true);
}
/// <summary>
/// Performs a wave conditions calculation for the stability of stone revetment failure mechanism based on the supplied
/// <see cref="StabilityStoneCoverWaveConditionsCalculation"/> and sets
/// <see cref="StabilityStoneCoverWaveConditionsCalculation.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="StabilityStoneCoverWaveConditionsCalculation"/> that holds all the information required to perform the calculation.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that holds information about the target probability used in the calculation.</param>
/// <param name="generalWaveConditionsInput">Calculation input parameters that apply to all <see cref="StabilityStoneCoverWaveConditionsCalculation"/> instances.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="assessmentSection"/>
/// or <paramref name="generalWaveConditionsInput"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when the hydraulic boundary database file path contains invalid characters.</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>
public void Calculate(StabilityStoneCoverWaveConditionsCalculation calculation,
IAssessmentSection assessmentSection,
GeneralStabilityStoneCoverWaveConditionsInput generalWaveConditionsInput)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (generalWaveConditionsInput == null)
{
throw new ArgumentNullException(nameof(generalWaveConditionsInput));
}
StabilityStoneCoverWaveConditionsInput calculationInput = calculation.InputParameters;
StabilityStoneCoverWaveConditionsCalculationType calculationType = calculationInput.CalculationType;
if (!Enum.IsDefined(typeof(StabilityStoneCoverWaveConditionsCalculationType), calculationType))
{
throw new InvalidEnumArgumentException(nameof(calculationType), (int)calculationType,
typeof(StabilityStoneCoverWaveConditionsCalculationType));
}
CalculationServiceHelper.LogCalculationBegin();
double targetProbability = WaveConditionsInputHelper.GetTargetProbability(calculationInput, assessmentSection);
RoundedDouble assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(calculationInput, assessmentSection);
int waterLevelCount = calculationInput.GetWaterLevels(assessmentLevel).Count();
TotalWaterLevelCalculations = calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both
? waterLevelCount * 2
: waterLevelCount;
try
{
IEnumerable <WaveConditionsOutput> blocksOutputs = null;
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both ||
calculationType == StabilityStoneCoverWaveConditionsCalculationType.Blocks)
{
CurrentCalculationType = Resources.StabilityStoneCoverWaveConditions_Blocks_DisplayName;
blocksOutputs = CalculateBlocks(calculation, assessmentSection, assessmentLevel,
generalWaveConditionsInput.GeneralBlocksWaveConditionsInput, targetProbability);
}
if (Canceled)
{
return;
}
IEnumerable <WaveConditionsOutput> columnsOutputs = null;
if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both ||
calculationType == StabilityStoneCoverWaveConditionsCalculationType.Columns)
{
CurrentCalculationType = Resources.StabilityStoneCoverWaveConditions_Columns_DisplayName;
columnsOutputs = CalculateColumns(calculation, assessmentSection, assessmentLevel,
generalWaveConditionsInput.GeneralColumnsWaveConditionsInput, targetProbability);
}
if (!Canceled)
{
calculation.Output = CreateOutput(calculationType, blocksOutputs, columnsOutputs);
}
}
finally
{
CalculationServiceHelper.LogCalculationEnd();
}
}
