public void Constructor_ValidInputWithGeneralResult_ExpectedProperties()
{
// Setup
var random = new Random(32);
double dikeHeight = random.NextDouble();
double targetProbability = random.NextDouble();
double targetReliability = random.NextDouble();
double calculatedProbability = random.NextDouble();
double calculatedReliability = random.NextDouble();
var convergence = random.NextEnumValue <CalculationConvergence>();
var generalResult = new TestGeneralResultFaultTreeIllustrationPoint();
// Call
var output = new DikeHeightOutput(dikeHeight,
targetProbability,
targetReliability,
calculatedProbability,
calculatedReliability,
convergence,
generalResult);
// Assert
Assert.IsInstanceOf <HydraulicLoadsOutput>(output);
Assert.AreEqual(dikeHeight, output.DikeHeight, output.DikeHeight.GetAccuracy());
Assert.AreEqual(targetProbability, output.TargetProbability);
Assert.AreEqual(targetReliability, output.TargetReliability, output.TargetReliability.GetAccuracy());
Assert.AreEqual(calculatedProbability, output.CalculatedProbability);
Assert.AreEqual(calculatedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy());
Assert.AreEqual(convergence, output.CalculationConvergence);
Assert.IsTrue(output.HasGeneralResult);
Assert.AreSame(generalResult, output.GeneralResult);
}
public void Read_WithGeneralResultEntity_ReturnsDikeHeightOutputWithGeneralResult()
{
// Setup
var random = new Random(22);
var generalResultEntity = new GeneralResultFaultTreeIllustrationPointEntity
{
GoverningWindDirectionName = "SSE",
GoverningWindDirectionAngle = random.NextDouble()
};
var convergence = random.NextEnumValue <CalculationConvergence>();
var entity = new GrassCoverErosionInwardsDikeHeightOutputEntity
{
CalculationConvergence = Convert.ToByte(convergence),
GeneralResultFaultTreeIllustrationPointEntity = generalResultEntity
};
// Call
DikeHeightOutput output = entity.Read();
// Assert
GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(output.GeneralResult,
generalResultEntity);
}
public void Read_ValidParameters_ReturnsDikeHeightOutput()
{
// Setup
var random = new Random(22);
double dikeHeight = random.NextDouble();
double targetProbability = random.NextDouble();
double targetReliability = random.NextDouble();
double calculatedProbability = random.NextDouble();
double calculatedReliability = random.NextDouble();
var convergence = random.NextEnumValue <CalculationConvergence>();
var entity = new GrassCoverErosionInwardsDikeHeightOutputEntity
{
DikeHeight = dikeHeight,
TargetProbability = targetProbability,
TargetReliability = targetReliability,
CalculatedProbability = calculatedProbability,
CalculatedReliability = calculatedReliability,
CalculationConvergence = Convert.ToByte(convergence)
};
// Call
DikeHeightOutput output = entity.Read();
// Assert
Assert.AreEqual(dikeHeight, output.DikeHeight, output.DikeHeight.GetAccuracy());
Assert.AreEqual(targetProbability, output.TargetProbability);
Assert.AreEqual(targetReliability, output.TargetReliability, output.TargetReliability.GetAccuracy());
Assert.AreEqual(calculatedProbability, output.CalculatedProbability);
Assert.AreEqual(calculatedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy());
Assert.AreEqual(convergence, output.CalculationConvergence);
Assert.IsNull(output.GeneralResult);
}
private static void AddEntityForDikeHeightOutput(GrassCoverErosionInwardsOutputEntity entity,
DikeHeightOutput output)
{
if (output != null)
{
entity.GrassCoverErosionInwardsDikeHeightOutputEntities.Add(output.Create());
}
}
/// <summary>
/// Creates a random instance of <see cref="GrassCoverErosionInwardsOutput"/>.
/// </summary>
/// <returns>A random instance of <see cref="GrassCoverErosionInwardsOutput"/>.</returns>
public static GrassCoverErosionInwardsOutput GetRandomGrassCoverErosionInwardsOutput()
{
OvertoppingOutput overtoppingOutput = GetRandomOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint());
DikeHeightOutput dikeHeightOutput = GetRandomDikeHeightOutput(new TestGeneralResultFaultTreeIllustrationPoint());
OvertoppingRateOutput overtoppingRateOutput = GetRandomOvertoppingRateOutput(new TestGeneralResultFaultTreeIllustrationPoint());
return(new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, overtoppingRateOutput));
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
DikeHeightOutput original = GrassCoverErosionInwardsTestDataGenerator.GetRandomDikeHeightOutput(new TestGeneralResultFaultTreeIllustrationPoint());
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionInwardsCloneAssert.AreClones);
}
public void Create_WithGeneralResult_ReturnsGrassCoverErosionInwardsDikeHeightOutputEntityWithGeneralResultEntity()
{
// Setup
var random = new Random(21);
var output = new DikeHeightOutput(double.NaN, double.NaN, double.NaN,
double.NaN, double.NaN, random.NextEnumValue <CalculationConvergence>(),
new TestGeneralResultFaultTreeIllustrationPoint());
// Call
GrassCoverErosionInwardsDikeHeightOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(output.GeneralResult, entity.GeneralResultFaultTreeIllustrationPointEntity);
}
public void PropertyAttributes_WithDikeHeightOrOvertoppingRateCalculated_ReturnExpectedValues(bool dikeHeightCalculated,
bool overtoppingRateCalculated)
{
// Setup
DikeHeightOutput dikeHeightOutput = null;
OvertoppingRateOutput overtoppingRateOutput = null;
var resultOutput = new OvertoppingOutput(2,
true,
0,
null);
if (dikeHeightCalculated)
{
dikeHeightOutput = new TestDikeHeightOutput(double.NaN);
}
if (overtoppingRateCalculated)
{
overtoppingRateOutput = new TestOvertoppingRateOutput(double.NaN);
}
var output = new GrassCoverErosionInwardsOutput(resultOutput,
dikeHeightOutput,
overtoppingRateOutput);
// Call
var properties = new GrassCoverErosionInwardsOutputProperties(output);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(10, dynamicProperties.Count);
AssertResultOutputProperties(dynamicProperties);
if (dikeHeightCalculated)
{
AssertDikeHeightOutputProperties(dynamicProperties, firstHydraulicLoadsOutputIndex);
}
if (overtoppingRateCalculated)
{
AssertOvertoppingRateOutputProperties(dynamicProperties, firstHydraulicLoadsOutputIndex);
}
}
private DikeHeightOutput CalculateDikeHeight(GrassCoverErosionInwardsCalculation calculation,
GeneralGrassCoverErosionInwardsInput generalInput,
string hydraulicBoundaryDatabaseFilePath,
bool usePreprocessor,
int numberOfCalculators)
{
if (dikeHeightCalculator == null)
{
return(null);
}
NotifyProgress(string.Format(Resources.GrassCoverErosionInwardsCalculationService_Calculate_Executing_calculation_of_type_0,
Resources.GrassCoverErosionInwardsCalculationService_DikeHeight),
2, numberOfCalculators);
DikeHeightCalculationInput dikeHeightCalculationInput = CreateDikeHeightInput(
calculation, generalInput, hydraulicBoundaryDatabaseFilePath, usePreprocessor);
var dikeHeightCalculated = true;
try
{
PerformCalculation(() => dikeHeightCalculator.Calculate(dikeHeightCalculationInput),
() => dikeHeightCalculator.LastErrorFileContent,
() => dikeHeightCalculator.OutputDirectory,
calculation.Name,
Resources.GrassCoverErosionInwardsCalculationService_DikeHeight);
}
catch (HydraRingCalculationException)
{
dikeHeightCalculated = false;
}
if (canceled || !dikeHeightCalculated)
{
return(null);
}
DikeHeightOutput output = CreateDikeHeightOutput(dikeHeightCalculator,
calculation.Name,
dikeHeightCalculationInput.Beta,
calculation.InputParameters.DikeHeightTargetProbability,
calculation.InputParameters.ShouldDikeHeightIllustrationPointsBeCalculated);
return(output);
}
public void Create_ValidInput_ReturnGrassCoverErosionInwardsOutputEntity()
{
// Setup
var random = new Random(456);
var overtoppingOutput = new OvertoppingOutput(random.NextDouble(), false, random.NextDouble(), null);
var dikeHeightConvergence = random.NextEnumValue <CalculationConvergence>();
var overtoppingRateConvergence = random.NextEnumValue <CalculationConvergence>();
var dikeHeightOutput = new DikeHeightOutput(random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble(),
random.NextDouble(), dikeHeightConvergence, null);
var overtoppingRateOutput = new OvertoppingRateOutput(random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble(),
random.NextDouble(), overtoppingRateConvergence, null);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, overtoppingRateOutput);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
Assert.AreEqual(overtoppingOutput.WaveHeight.Value, entity.WaveHeight);
Assert.AreEqual(Convert.ToByte(overtoppingOutput.IsOvertoppingDominant), entity.IsOvertoppingDominant);
Assert.AreEqual(overtoppingOutput.Reliability, entity.Reliability);
Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity);
GrassCoverErosionInwardsDikeHeightOutputEntity dikeHeightEntity = entity.GrassCoverErosionInwardsDikeHeightOutputEntities.Single();
Assert.AreEqual(dikeHeightOutput.DikeHeight, dikeHeightEntity.DikeHeight, dikeHeightOutput.DikeHeight.GetAccuracy());
Assert.AreEqual(dikeHeightOutput.TargetProbability, dikeHeightEntity.TargetProbability);
Assert.AreEqual(dikeHeightOutput.TargetReliability, dikeHeightEntity.TargetReliability, dikeHeightOutput.TargetReliability.GetAccuracy());
Assert.AreEqual(dikeHeightOutput.CalculatedProbability, dikeHeightEntity.CalculatedProbability);
Assert.AreEqual(dikeHeightOutput.CalculatedReliability, dikeHeightEntity.CalculatedReliability, dikeHeightOutput.CalculatedReliability.GetAccuracy());
Assert.AreEqual((byte)dikeHeightOutput.CalculationConvergence, dikeHeightEntity.CalculationConvergence);
GrassCoverErosionInwardsOvertoppingRateOutputEntity overtoppingRateEntity = entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Single();
Assert.AreEqual(overtoppingRateOutput.OvertoppingRate, overtoppingRateEntity.OvertoppingRate, overtoppingRateOutput.OvertoppingRate.GetAccuracy());
Assert.AreEqual(overtoppingRateOutput.TargetProbability, overtoppingRateEntity.TargetProbability);
Assert.AreEqual(overtoppingRateOutput.TargetReliability, overtoppingRateEntity.TargetReliability, overtoppingRateOutput.TargetReliability.GetAccuracy());
Assert.AreEqual(overtoppingRateOutput.CalculatedProbability, overtoppingRateEntity.CalculatedProbability);
Assert.AreEqual(overtoppingRateOutput.CalculatedReliability, overtoppingRateEntity.CalculatedReliability, overtoppingRateOutput.CalculatedReliability.GetAccuracy());
Assert.AreEqual((byte)overtoppingRateOutput.CalculationConvergence, overtoppingRateEntity.CalculationConvergence);
}
/// <summary>
/// Creates a <see cref="GrassCoverErosionInwardsDikeHeightOutputEntity"/>
/// based on the information of the <see cref="DikeHeightOutput"/>.
/// </summary>
/// <param name="output">The output to create a database entity for.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsDikeHeightOutputEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/>
/// is <c>null</c>.</exception>
internal static GrassCoverErosionInwardsDikeHeightOutputEntity Create(this DikeHeightOutput output)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
return(new GrassCoverErosionInwardsDikeHeightOutputEntity
{
DikeHeight = output.DikeHeight.ToNaNAsNull(),
TargetProbability = output.TargetProbability.ToNaNAsNull(),
TargetReliability = output.TargetReliability.ToNaNAsNull(),
CalculatedProbability = output.CalculatedProbability.ToNaNAsNull(),
CalculatedReliability = output.CalculatedReliability.ToNaNAsNull(),
CalculationConvergence = Convert.ToByte(output.CalculationConvergence),
GeneralResultFaultTreeIllustrationPointEntity = output.GeneralResult?.CreateGeneralResultFaultTreeIllustrationPointEntity()
});
}
public void Create_WithNaNParameters_ReturnsGrassCoverErosionInwardsDikeHeightOutputEntityWithOutputNull()
{
// Setup
var random = new Random(21);
var output = new DikeHeightOutput(double.NaN, double.NaN, double.NaN,
double.NaN, double.NaN, random.NextEnumValue <CalculationConvergence>(), null);
// Call
GrassCoverErosionInwardsDikeHeightOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
Assert.IsNull(entity.DikeHeight);
Assert.IsNull(entity.TargetProbability);
Assert.IsNull(entity.TargetReliability);
Assert.IsNull(entity.CalculatedProbability);
Assert.IsNull(entity.CalculatedReliability);
Assert.AreEqual((byte)output.CalculationConvergence, entity.CalculationConvergence);
Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity);
}
public void Read_NullParameters_ReturnsDikeHeightOutputWithNaN()
{
// Setup
var random = new Random(22);
var convergence = random.NextEnumValue <CalculationConvergence>();
var entity = new GrassCoverErosionInwardsDikeHeightOutputEntity
{
CalculationConvergence = Convert.ToByte(convergence)
};
// Call
DikeHeightOutput output = entity.Read();
// Assert
Assert.IsNaN(output.DikeHeight);
Assert.IsNaN(output.TargetProbability);
Assert.IsNaN(output.TargetReliability);
Assert.IsNaN(output.CalculatedProbability);
Assert.IsNaN(output.CalculatedReliability);
Assert.AreEqual(convergence, output.CalculationConvergence);
Assert.IsNull(output.GeneralResult);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var random = new Random(39);
double waveHeight = random.NextDouble();
bool isOvertoppingDominant = Convert.ToBoolean(random.Next(0, 2));
double reliability = random.NextDouble();
double dikeHeight = random.NextDouble();
double dikeHeightTargetProbability = random.NextDouble();
double dikeHeightTargetReliability = random.NextDouble();
double dikeHeightCalculatedProbability = random.NextDouble();
double dikeHeightCalculatedReliability = random.NextDouble();
var dikeHeightConvergence = random.NextEnumValue <CalculationConvergence>();
double overtoppingRate = random.NextDouble();
double overtoppingRateTargetProbability = random.NextDouble();
double overtoppingRateTargetReliability = random.NextDouble();
double overtoppingRateCalculatedProbability = random.NextDouble();
double overtoppingRateCalculatedReliability = random.NextDouble();
var overtoppingRateConvergence = random.NextEnumValue <CalculationConvergence>();
var resultOutput = new OvertoppingOutput(waveHeight,
isOvertoppingDominant,
reliability,
null);
var dikeHeightOutput = new DikeHeightOutput(dikeHeight,
dikeHeightTargetProbability,
dikeHeightTargetReliability,
dikeHeightCalculatedProbability,
dikeHeightCalculatedReliability,
dikeHeightConvergence,
null);
var overtoppingRateOutput = new OvertoppingRateOutput(overtoppingRate,
overtoppingRateTargetProbability,
overtoppingRateTargetReliability,
overtoppingRateCalculatedProbability,
overtoppingRateCalculatedReliability,
overtoppingRateConvergence,
null);
var output = new GrassCoverErosionInwardsOutput(resultOutput, dikeHeightOutput, overtoppingRateOutput);
// Call
var properties = new GrassCoverErosionInwardsOutputProperties(output);
// Assert
Assert.AreEqual(2, properties.WaveHeight.NumberOfDecimalPlaces);
Assert.AreEqual(waveHeight, properties.WaveHeight, properties.WaveHeight.GetAccuracy());
Assert.AreEqual(reliability, properties.Reliability, properties.Reliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), properties.Probability);
Assert.AreEqual(isOvertoppingDominant, properties.IsOvertoppingDominant);
Assert.AreEqual(2, properties.DikeHeight.NumberOfDecimalPlaces);
Assert.AreEqual(dikeHeight, properties.DikeHeight, properties.DikeHeight.GetAccuracy());
Assert.AreEqual(dikeHeightTargetProbability, properties.DikeHeightTargetProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetProbability));
Assert.AreEqual(dikeHeightTargetReliability, properties.DikeHeightTargetReliability, properties.DikeHeightTargetReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetReliability));
Assert.AreEqual(dikeHeightCalculatedProbability, properties.DikeHeightCalculatedProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedProbability));
Assert.AreEqual(dikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedReliability));
string dikeHeightConvergenceValue = EnumDisplayNameHelper.GetDisplayName(dikeHeightConvergence);
Assert.AreEqual(dikeHeightConvergenceValue, properties.DikeHeightConvergence);
Assert.AreEqual(2, properties.OvertoppingRate.NumberOfDecimalPlaces);
Assert.AreEqual(overtoppingRate * 1000, properties.OvertoppingRate, properties.OvertoppingRate.GetAccuracy());
Assert.AreEqual(overtoppingRateTargetProbability, properties.OvertoppingRateTargetProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetProbability));
Assert.AreEqual(overtoppingRateTargetReliability, properties.OvertoppingRateTargetReliability, properties.OvertoppingRateTargetReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetReliability));
Assert.AreEqual(overtoppingRateCalculatedProbability, properties.OvertoppingRateCalculatedProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedProbability));
Assert.AreEqual(overtoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedReliability));
string overtoppingRateConvergenceValue = EnumDisplayNameHelper.GetDisplayName(overtoppingRateConvergence);
Assert.AreEqual(overtoppingRateConvergenceValue, properties.OvertoppingRateConvergence);
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(DikeHeightOutput original, DikeHeightOutput clone)
{
AreClones((HydraulicLoadsOutput)original, clone);
Assert.AreEqual(original.DikeHeight, clone.DikeHeight);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var random = new Random();
double dikeHeight = random.NextDouble();
double dikeHeightTargetProbability = random.NextDouble();
double dikeHeightTargetReliability = random.NextDouble();
double dikeHeightCalculatedProbability = random.NextDouble();
double dikeHeightCalculatedReliability = random.NextDouble();
var dikeHeightConvergence = random.NextEnumValue <CalculationConvergence>();
var generalResult = new TestGeneralResultFaultTreeIllustrationPoint();
var dikeHeightOutput = new DikeHeightOutput(dikeHeight,
dikeHeightTargetProbability,
dikeHeightTargetReliability,
dikeHeightCalculatedProbability,
dikeHeightCalculatedReliability,
dikeHeightConvergence,
generalResult);
// Call
var properties = new DikeHeightOutputProperties(dikeHeightOutput);
// Assert
Assert.AreEqual(2, properties.DikeHeight.NumberOfDecimalPlaces);
Assert.AreEqual(dikeHeight, properties.DikeHeight, properties.DikeHeight.GetAccuracy());
Assert.AreEqual(dikeHeightTargetProbability, properties.DikeHeightTargetProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetProbability));
Assert.AreEqual(dikeHeightTargetReliability, properties.DikeHeightTargetReliability, properties.DikeHeightTargetReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetReliability));
Assert.AreEqual(dikeHeightCalculatedProbability, properties.DikeHeightCalculatedProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedProbability));
Assert.AreEqual(dikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedReliability));
string dikeHeightConvergenceValue = EnumDisplayNameHelper.GetDisplayName(dikeHeightConvergence);
Assert.AreEqual(dikeHeightConvergenceValue, properties.DikeHeightConvergence);
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.AlphaValues));
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.Durations));
int nrOfExpectedStochasts = generalResult.Stochasts.Count();
Assert.AreEqual(nrOfExpectedStochasts, properties.AlphaValues.Length);
Assert.AreEqual(nrOfExpectedStochasts, properties.Durations.Length);
Stochast expectedStochast = generalResult.Stochasts.First();
Assert.AreEqual(expectedStochast.Alpha, properties.AlphaValues[0].Alpha);
Assert.AreEqual(expectedStochast.Duration, properties.Durations[0].Duration);
TestHelper.AssertTypeConverter <StructuresOutputProperties, ExpandableArrayConverter>(
nameof(StructuresOutputProperties.IllustrationPoints));
int nrOfExpectedTopLevelIllustrationPoints = generalResult.TopLevelIllustrationPoints.Count();
Assert.AreEqual(nrOfExpectedTopLevelIllustrationPoints, properties.IllustrationPoints.Length);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(i => i.Data));
}
/// <summary>
/// Performs a grass cover erosion inwards calculation based on the supplied <see cref="GrassCoverErosionInwardsCalculation"/>
/// and sets <see cref="GrassCoverErosionInwardsCalculation.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="GrassCoverErosionInwardsCalculation"/> 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="generalInput">Calculation input parameters that apply to all <see cref="GrassCoverErosionInwardsCalculation"/> instances.</param>
/// <exception cref="ArgumentNullException">Thrown when one of the following parameters is <c>null</c>:
/// <list type="bullet">
/// <item><paramref name="calculation"/></item>
/// <item><paramref name="assessmentSection"/></item>
/// <item><paramref name="generalInput"/></item>
/// </list></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="SecurityException">Thrown when the temporary working directory can't be accessed due to missing permissions.</exception>
/// <exception cref="IOException">Thrown when the specified path is not valid, the network name is not known
/// or an I/O error occurred while opening the file.</exception>
/// <exception cref="UnauthorizedAccessException">Thrown when the directory can't be created due to missing
/// the required permissions.</exception>
/// <exception cref="NotSupportedException">Thrown when <see cref="HydraRingCalculationInput.FailureMechanismType"/>
/// is not the same with already added input.</exception>
/// <exception cref="Win32Exception">Thrown when there was an error in opening the associated file
/// or the wait setting could not be accessed.</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>
internal void Calculate(GrassCoverErosionInwardsCalculation calculation,
IAssessmentSection assessmentSection,
GeneralGrassCoverErosionInwardsInput generalInput)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
HydraulicBoundaryCalculationSettings calculationSettings =
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
int numberOfCalculators = CreateCalculators(calculation, calculationSettings);
string hydraulicBoundaryDatabaseFilePath = calculationSettings.HydraulicBoundaryDatabaseFilePath;
bool usePreprocessor = !string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory);
CalculationServiceHelper.LogCalculationBegin();
try
{
OvertoppingOutput overtoppingOutput = CalculateOvertopping(calculation,
generalInput,
hydraulicBoundaryDatabaseFilePath,
usePreprocessor,
numberOfCalculators);
if (canceled)
{
return;
}
DikeHeightOutput dikeHeightOutput = CalculateDikeHeight(calculation,
generalInput,
hydraulicBoundaryDatabaseFilePath,
usePreprocessor,
numberOfCalculators);
if (canceled)
{
return;
}
OvertoppingRateOutput overtoppingRateOutput = CalculateOvertoppingRate(calculation,
generalInput,
hydraulicBoundaryDatabaseFilePath,
usePreprocessor,
numberOfCalculators);
if (canceled)
{
return;
}
calculation.Output = new GrassCoverErosionInwardsOutput(
overtoppingOutput,
dikeHeightOutput,
overtoppingRateOutput);
}
finally
{
CalculationServiceHelper.LogCalculationEnd();
overtoppingCalculator = null;
dikeHeightCalculator = null;
overtoppingRateCalculator = null;
}
}
