public void Constructor_ValidInputWithGeneralResult_ExpectedProperties() { // Setup var random = new Random(32); double overtoppingRate = random.NextDouble(); double targetProbability = random.NextDouble(); double targetReliability = random.NextDouble(); double calculatedProbability = random.NextDouble(); double calculatedReliability = random.NextDouble(); var convergence = random.NextEnumValue <CalculationConvergence>(); GeneralResult <TopLevelFaultTreeIllustrationPoint> generalResult = new TestGeneralResultFaultTreeIllustrationPoint(); // Call var output = new OvertoppingRateOutput(overtoppingRate, targetProbability, targetReliability, calculatedProbability, calculatedReliability, convergence, generalResult); // Assert Assert.IsInstanceOf <HydraulicLoadsOutput>(output); Assert.AreEqual(overtoppingRate, output.OvertoppingRate, output.OvertoppingRate.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_ValidParameters_ReturnsOvertoppingRateOutput() { // Setup var random = new Random(22); double overtoppingRate = 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 GrassCoverErosionInwardsOvertoppingRateOutputEntity { OvertoppingRate = overtoppingRate, TargetProbability = targetProbability, TargetReliability = targetReliability, CalculatedProbability = calculatedProbability, CalculatedReliability = calculatedReliability, CalculationConvergence = Convert.ToByte(convergence) }; // Call OvertoppingRateOutput output = entity.Read(); // Assert Assert.AreEqual(overtoppingRate, output.OvertoppingRate, output.OvertoppingRate.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); }
public void Constructor_ValidInputWithGeneralResultNull_ExpectedProperties( double targetProbability, double calculatedProbability) { // Setup var random = new Random(32); double overtoppingRate = random.NextDouble(); double targetReliability = random.NextDouble(); double calculatedReliability = random.NextDouble(); var convergence = random.NextEnumValue <CalculationConvergence>(); // Call var output = new OvertoppingRateOutput(overtoppingRate, targetProbability, targetReliability, calculatedProbability, calculatedReliability, convergence, null); // Assert Assert.IsInstanceOf <HydraulicLoadsOutput>(output); Assert.AreEqual(overtoppingRate, output.OvertoppingRate, output.OvertoppingRate.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.IsFalse(output.HasGeneralResult); Assert.IsNull(output.GeneralResult); }
private static void AddEntityForOvertoppingRateOutput(GrassCoverErosionInwardsOutputEntity entity, OvertoppingRateOutput output) { if (output != null) { entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.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 OvertoppingRateOutput original = GrassCoverErosionInwardsTestDataGenerator.GetRandomOvertoppingRateOutput(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 OvertoppingRateOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, random.NextEnumValue <CalculationConvergence>(), new TestGeneralResultFaultTreeIllustrationPoint()); // Call GrassCoverErosionInwardsOvertoppingRateOutputEntity entity = output.Create(); // Assert Assert.IsNotNull(entity); GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(output.GeneralResult, entity.GeneralResultFaultTreeIllustrationPointEntity); }
private OvertoppingRateOutput CalculateOvertoppingRate(GrassCoverErosionInwardsCalculation calculation, GeneralGrassCoverErosionInwardsInput generalInput, string hydraulicBoundaryDatabaseFilePath, bool usePreprocessor, int numberOfCalculators) { if (overtoppingRateCalculator == null) { return(null); } NotifyProgress(string.Format(Resources.GrassCoverErosionInwardsCalculationService_Calculate_Executing_calculation_of_type_0, Resources.GrassCoverErosionInwardsCalculationService_OvertoppingRate), numberOfCalculators, numberOfCalculators); OvertoppingRateCalculationInput overtoppingRateCalculationInput = CreateOvertoppingRateInput( calculation, generalInput, hydraulicBoundaryDatabaseFilePath, usePreprocessor); var overtoppingRateCalculated = true; try { PerformCalculation(() => overtoppingRateCalculator.Calculate(overtoppingRateCalculationInput), () => overtoppingRateCalculator.LastErrorFileContent, () => overtoppingRateCalculator.OutputDirectory, calculation.Name, Resources.GrassCoverErosionInwardsCalculationService_OvertoppingRate); } catch (HydraRingCalculationException) { overtoppingRateCalculated = false; } if (canceled || !overtoppingRateCalculated) { return(null); } OvertoppingRateOutput output = CreateOvertoppingRateOutput(overtoppingRateCalculator, calculation.Name, overtoppingRateCalculationInput.Beta, calculation.InputParameters.OvertoppingRateTargetProbability, calculation.InputParameters.ShouldOvertoppingRateIllustrationPointsBeCalculated); return(output); }
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); } }
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="GrassCoverErosionInwardsOvertoppingRateOutputEntity"/> /// based on the information of the <see cref="OvertoppingRateOutput"/>. /// </summary> /// <param name="output">The output to create a database entity for.</param> /// <returns>A new <see cref="GrassCoverErosionInwardsOvertoppingRateOutputEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/> /// is <c>null</c>.</exception> internal static GrassCoverErosionInwardsOvertoppingRateOutputEntity Create(this OvertoppingRateOutput output) { if (output == null) { throw new ArgumentNullException(nameof(output)); } return(new GrassCoverErosionInwardsOvertoppingRateOutputEntity { OvertoppingRate = output.OvertoppingRate.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_ReturnsGrassCoverErosionInwardsOvertoppingRateOutputEntityWithOutputNull() { // Setup var random = new Random(21); var output = new OvertoppingRateOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, random.NextEnumValue <CalculationConvergence>(), null); // Call GrassCoverErosionInwardsOvertoppingRateOutputEntity entity = output.Create(); // Assert Assert.IsNotNull(entity); Assert.IsNull(entity.OvertoppingRate); 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_ReturnsOvertoppingRateOutputWithNaN() { // Setup var random = new Random(22); var convergence = random.NextEnumValue <CalculationConvergence>(); var entity = new GrassCoverErosionInwardsOvertoppingRateOutputEntity { CalculationConvergence = Convert.ToByte(convergence) }; // Call OvertoppingRateOutput output = entity.Read(); // Assert Assert.IsNaN(output.OvertoppingRate); 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 Read_ValidEntityWithGeneralResultEntity_ReturnsOvertoppingRateOutputWithGeneralResult() { // Setup var random = new Random(22); var generalResultEntity = new GeneralResultFaultTreeIllustrationPointEntity { GoverningWindDirectionName = "SSE", GoverningWindDirectionAngle = random.NextDouble() }; var convergence = random.NextEnumValue <CalculationConvergence>(); var entity = new GrassCoverErosionInwardsOvertoppingRateOutputEntity { CalculationConvergence = Convert.ToByte(convergence), GeneralResultFaultTreeIllustrationPointEntity = generalResultEntity }; // Call OvertoppingRateOutput output = entity.Read(); // Assert GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(output.GeneralResult, generalResultEntity); }
/// <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(OvertoppingRateOutput original, OvertoppingRateOutput clone) { AreClones((HydraulicLoadsOutput)original, clone); Assert.AreEqual(original.OvertoppingRate, clone.OvertoppingRate); }
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> /// 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; } }
public void GetProperties_WithData_ReturnExpectedValues() { // Setup var random = new Random(); 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 generalResult = new TestGeneralResultFaultTreeIllustrationPoint(); var overtoppingRateOutput = new OvertoppingRateOutput(overtoppingRate, overtoppingRateTargetProbability, overtoppingRateTargetReliability, overtoppingRateCalculatedProbability, overtoppingRateCalculatedReliability, overtoppingRateConvergence, generalResult); // Call var properties = new OvertoppingRateOutputProperties(overtoppingRateOutput); // Assert 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); 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)); }