private static void ReadCalculationOutputs(StabilityStoneCoverWaveConditionsCalculationEntity entity, StabilityStoneCoverWaveConditionsCalculation calculation) { if (!entity.StabilityStoneCoverWaveConditionsOutputEntities.Any()) { return; } var columnsOutput = new List <WaveConditionsOutput>(); var blocksOutput = new List <WaveConditionsOutput>(); foreach (StabilityStoneCoverWaveConditionsOutputEntity conditionsOutputEntity in entity.StabilityStoneCoverWaveConditionsOutputEntities.OrderBy(oe => oe.Order)) { WaveConditionsOutput output = conditionsOutputEntity.Read(); if (conditionsOutputEntity.OutputType == Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns)) { columnsOutput.Add(output); } else if (conditionsOutputEntity.OutputType == Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Blocks)) { blocksOutput.Add(output); } } calculation.Output = CreateStabilityStoneCoverWaveConditionsOutput(columnsOutput, blocksOutput); }
public void CreateOutput_ValidParameters_ReturnsExpectedValues(bool?convergence, CalculationConvergence expectedConvergence) { // Setup const double waterLevel = 1.1; const double waveHeight = 2.2; const double wavePeakPeriod = 3.3; const double waveAngle = 4.4; const double waveDirection = 5.5; const double targetProbability = 1 / 6.6; const double calculatedReliability = -7.7; // Call WaveConditionsOutput output = WaveConditionsOutputFactory.CreateOutput(waterLevel, waveHeight, wavePeakPeriod, waveAngle, waveDirection, targetProbability, calculatedReliability, convergence); // Assert Assert.AreEqual(waterLevel, output.WaterLevel, output.WaterLevel.GetAccuracy()); Assert.AreEqual(waveHeight, output.WaveHeight, output.WaveHeight.GetAccuracy()); Assert.AreEqual(wavePeakPeriod, output.WavePeakPeriod, output.WavePeakPeriod.GetAccuracy()); Assert.AreEqual(waveAngle, output.WaveAngle, output.WaveAngle.GetAccuracy()); Assert.AreEqual(waveDirection, output.WaveDirection, output.WaveDirection.GetAccuracy()); Assert.AreEqual(targetProbability, output.TargetProbability, 1e-6); Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), output.TargetReliability, output.TargetReliability.GetAccuracy()); Assert.AreEqual(calculatedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy()); Assert.AreEqual(StatisticsConverter.ReliabilityToProbability(calculatedReliability), output.CalculatedProbability, 1e-6); Assert.AreEqual(expectedConvergence, output.CalculationConvergence); }
public void Constructor_ExpectedValues(double targetProbability, double calculatedProbability) { // Setup const double waterLevel = 3.09378; const double waveHeight = 4.29884; const double wavePeakPeriod = 0.19435; const double waveAngle = 180.62353; const double waveDirection = 230.67893; const double targetReliability = 3000; const double calculatedReliability = 4000; const CalculationConvergence calculationConvergence = CalculationConvergence.NotCalculated; // Call var output = new WaveConditionsOutput(waterLevel, waveHeight, wavePeakPeriod, waveAngle, waveDirection, targetProbability, targetReliability, calculatedProbability, calculatedReliability, calculationConvergence); // Assert Assert.IsInstanceOf <CloneableObservable>(output); Assert.IsInstanceOf <ICalculationOutput>(output); Assert.AreEqual(waterLevel, output.WaterLevel, output.WaterLevel.GetAccuracy()); Assert.AreEqual(waveHeight, output.WaveHeight, output.WaveHeight.GetAccuracy()); Assert.AreEqual(wavePeakPeriod, output.WavePeakPeriod, output.WavePeakPeriod.GetAccuracy()); Assert.AreEqual(waveAngle, output.WaveAngle, output.WaveAngle.GetAccuracy()); Assert.AreEqual(waveDirection, output.WaveDirection, output.WaveDirection.GetAccuracy()); Assert.AreEqual(targetProbability, output.TargetProbability); Assert.AreEqual(5, output.TargetReliability.NumberOfDecimalPlaces); Assert.AreEqual(targetReliability, output.TargetReliability, output.TargetReliability.GetAccuracy()); Assert.AreEqual(calculatedProbability, output.CalculatedProbability); Assert.AreEqual(5, output.CalculatedReliability.NumberOfDecimalPlaces); Assert.AreEqual(calculatedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy()); Assert.AreEqual(calculationConvergence, output.CalculationConvergence); }
public void Read_ValidEntityWithNullParameterValues_ReturnOutputWithNaNValues() { // Setup var entity = new WaveImpactAsphaltCoverWaveConditionsOutputEntity { CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated), WaterLevel = null, WaveHeight = null, WavePeakPeriod = null, WaveAngle = null, WaveDirection = null, TargetProbability = null, TargetReliability = null, CalculatedProbability = null, CalculatedReliability = null }; // Call WaveConditionsOutput output = entity.Read(); // Assert Assert.IsNaN(output.WaterLevel); Assert.IsNaN(output.WaveHeight); Assert.IsNaN(output.WavePeakPeriod); Assert.IsNaN(output.WaveAngle); Assert.IsNaN(output.WaveDirection); Assert.IsNaN(output.TargetProbability); Assert.IsNaN(output.TargetReliability); Assert.IsNaN(output.CalculatedProbability); Assert.IsNaN(output.CalculatedReliability); }
/// <summary> /// Creates a new instance of <see cref="ExportableWaveConditions"/>. /// </summary> /// <param name="name">The name of the parent calculation.</param> /// <param name="waveConditionsInput">The input parameters of the parent calculation.</param> /// <param name="waveConditionsOutput">The output parameters of the parent calculation.</param> /// <param name="coverType">The type of dike cover.</param> /// <param name="targetProbability">The target probability to use.</param> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown when <see cref="WaveConditionsInput.HydraulicBoundaryLocation"/> /// is <c>null</c> in <paramref name="waveConditionsInput"/>.</exception> public ExportableWaveConditions(string name, WaveConditionsInput waveConditionsInput, WaveConditionsOutput waveConditionsOutput, CoverType coverType, string targetProbability) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (waveConditionsInput == null) { throw new ArgumentNullException(nameof(waveConditionsInput)); } if (waveConditionsOutput == null) { throw new ArgumentNullException(nameof(waveConditionsOutput)); } if (coverType == null) { throw new ArgumentNullException(nameof(coverType)); } if (targetProbability == null) { throw new ArgumentNullException(nameof(targetProbability)); } if (waveConditionsInput.HydraulicBoundaryLocation == null) { throw new ArgumentException(@"HydraulicBoundaryLocation is null.", nameof(waveConditionsInput)); } CalculationName = name; LocationName = waveConditionsInput.HydraulicBoundaryLocation.Name; LocationXCoordinate = waveConditionsInput.HydraulicBoundaryLocation.Location.X; LocationYCoordinate = waveConditionsInput.HydraulicBoundaryLocation.Location.Y; if (waveConditionsInput.ForeshoreProfile != null) { ForeshoreId = waveConditionsInput.ForeshoreProfile.Id; } UseForeshore = waveConditionsInput.UseForeshore; UseBreakWater = waveConditionsInput.UseBreakWater; CoverType = coverType; TargetProbability = targetProbability; WaterLevel = waveConditionsOutput.WaterLevel; WaveHeight = waveConditionsOutput.WaveHeight; WavePeriod = waveConditionsOutput.WavePeakPeriod; WaveAngle = waveConditionsOutput.WaveAngle; WaveDirection = waveConditionsOutput.WaveDirection; }
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues() { // Setup WaveConditionsOutput original = WaveConditionsTestDataGenerator.GetRandomWaveConditionsOutput(); // Call object clone = original.Clone(); // Assert CoreCloneAssert.AreObjectClones(original, clone, WaveConditionsCloneAssert.AreClones); }
public void Read_ValidEntity_ReturnOutputWithValues() { // Setup var random = new Random(12); var entity = new WaveImpactAsphaltCoverWaveConditionsOutputEntity { WaterLevel = random.NextDouble(), WaveHeight = random.NextDouble(), WavePeakPeriod = random.NextDouble(), WaveAngle = random.NextDouble(), WaveDirection = random.NextDouble(), TargetProbability = random.NextDouble(), TargetReliability = random.NextDouble(), CalculatedProbability = random.NextDouble(), CalculatedReliability = random.NextDouble(), CalculationConvergence = Convert.ToByte(CalculationConvergence.CalculatedConverged) }; // Call WaveConditionsOutput output = entity.Read(); // Assert Assert.IsNotNull(entity.WaterLevel); Assert.AreEqual(entity.WaterLevel.Value, output.WaterLevel, output.WaterLevel.GetAccuracy()); Assert.IsNotNull(entity.WaveHeight); Assert.AreEqual(entity.WaveHeight.Value, output.WaveHeight, output.WaveHeight.GetAccuracy()); Assert.IsNotNull(entity.WavePeakPeriod); Assert.AreEqual(entity.WavePeakPeriod.Value, output.WavePeakPeriod, output.WavePeakPeriod.GetAccuracy()); Assert.IsNotNull(entity.WaveAngle); Assert.AreEqual(entity.WaveAngle.Value, output.WaveAngle, output.WaveAngle.GetAccuracy()); Assert.IsNotNull(entity.WaveDirection); Assert.AreEqual(entity.WaveDirection.Value, output.WaveDirection, output.WaveDirection.GetAccuracy()); Assert.IsNotNull(entity.TargetProbability); Assert.AreEqual(entity.TargetProbability.Value, output.TargetProbability); Assert.IsNotNull(entity.TargetReliability); Assert.AreEqual(entity.TargetReliability.Value, output.TargetReliability, output.TargetReliability.GetAccuracy()); Assert.IsNotNull(entity.CalculatedProbability); Assert.AreEqual(entity.CalculatedProbability.Value, output.CalculatedProbability); Assert.IsNotNull(entity.CalculatedReliability); Assert.AreEqual(entity.CalculatedReliability.Value, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy()); Assert.IsNotNull(entity.CalculationConvergence); Assert.AreEqual(CalculationConvergence.CalculatedConverged, output.CalculationConvergence); }
/// <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(WaveConditionsOutput original, WaveConditionsOutput clone) { Assert.AreEqual(original.CalculatedProbability, clone.CalculatedProbability); Assert.AreEqual(original.CalculatedReliability, clone.CalculatedReliability); Assert.AreEqual(original.CalculationConvergence, clone.CalculationConvergence); Assert.AreEqual(original.TargetProbability, clone.TargetProbability); Assert.AreEqual(original.TargetReliability, clone.TargetReliability); Assert.AreEqual(original.WaterLevel, clone.WaterLevel); Assert.AreEqual(original.WaveAngle, clone.WaveAngle); Assert.AreEqual(original.WaveDirection, clone.WaveDirection); Assert.AreEqual(original.WaveHeight, clone.WaveHeight); Assert.AreEqual(original.WavePeakPeriod, clone.WavePeakPeriod); }
/// <summary> /// Asserts the <see cref="WaveConditionsOutput"/> after a calculation has failed. /// </summary> /// <param name="waterLevel">The water level for which the calculation was performed for.</param> /// <param name="targetProbability">The target probability for which the calculation was calculated for.</param> /// <param name="actualOutput">The actual <see cref="WaveConditionsOutput"/>.</param> /// <exception cref="AssertionException">Thrown when differences are found between /// the expected output and the actual output.</exception> public static void AssertFailedOutput(double waterLevel, double targetProbability, WaveConditionsOutput actualOutput) { double targetReliability = StatisticsConverter.ProbabilityToReliability(targetProbability); Assert.IsNotNull(actualOutput); Assert.AreEqual(waterLevel, actualOutput.WaterLevel, actualOutput.WaterLevel.GetAccuracy()); Assert.IsNaN(actualOutput.WaveHeight); Assert.IsNaN(actualOutput.WavePeakPeriod); Assert.IsNaN(actualOutput.WaveAngle); Assert.IsNaN(actualOutput.WaveDirection); Assert.AreEqual(targetProbability, actualOutput.TargetProbability); Assert.AreEqual(targetReliability, actualOutput.TargetReliability, actualOutput.TargetReliability.GetAccuracy()); Assert.IsNaN(actualOutput.CalculatedProbability); Assert.IsNaN(actualOutput.CalculatedReliability); Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, actualOutput.CalculationConvergence); }
/// <summary> /// Creates a <see cref="WaveImpactAsphaltCoverWaveConditionsOutputEntity"/> based on the information /// of the <see cref="WaveConditionsOutput"/>. /// </summary> /// <param name="output">The calculation output for wave impact asphalt cover mechanism to /// create a database entity for.</param> /// <param name="order">The position of <paramref name="output"/> in the list of all outputs.</param> /// <returns>A new <see cref="WaveImpactAsphaltCoverWaveConditionsOutputEntity"/>.</returns> internal static WaveImpactAsphaltCoverWaveConditionsOutputEntity CreateWaveImpactAsphaltCoverWaveConditionsOutputEntity( this WaveConditionsOutput output, int order) { var entity = new WaveImpactAsphaltCoverWaveConditionsOutputEntity { Order = order, WaterLevel = output.WaterLevel.ToNaNAsNull(), WaveHeight = output.WaveHeight.ToNaNAsNull(), WavePeakPeriod = output.WavePeakPeriod.ToNaNAsNull(), WaveAngle = output.WaveAngle.ToNaNAsNull(), WaveDirection = output.WaveDirection.ToNaNAsNull(), TargetProbability = output.TargetProbability.ToNaNAsNull(), TargetReliability = output.TargetReliability.ToNaNAsNull(), CalculatedProbability = output.CalculatedProbability.ToNaNAsNull(), CalculatedReliability = output.CalculatedReliability.ToNaNAsNull(), CalculationConvergence = Convert.ToByte(output.CalculationConvergence) }; return(entity); }
public void CreateFailedOutput_ValidParameters_ReturnsExpectedValues() { // Setup const double waterLevel = 1.1; const double targetProbability = 1 / 2.2; // Call WaveConditionsOutput output = WaveConditionsOutputFactory.CreateFailedOutput(waterLevel, targetProbability); // Assert Assert.AreEqual(waterLevel, output.WaterLevel, output.WaterLevel.GetAccuracy()); Assert.IsNaN(output.WaveHeight); Assert.IsNaN(output.WavePeakPeriod); Assert.IsNaN(output.WaveAngle); Assert.IsNaN(output.WaveDirection); Assert.AreEqual(targetProbability, output.TargetProbability, 1e-6); Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), output.TargetReliability, output.TargetReliability.GetAccuracy()); Assert.IsNaN(output.CalculatedProbability); Assert.IsNaN(output.CalculatedReliability); Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, output.CalculationConvergence); }
/// <summary> /// Creates a <see cref="GrassCoverErosionOutwardsWaveConditionsOutputEntity"/> based on the information /// of the <see cref="WaveConditionsOutput"/>. /// </summary> /// <param name="output">The calculation output for grass cover erosion outwards failure mechanism to /// create a database entity for.</param> /// <param name="type">The type of <see cref="GrassCoverErosionOutwardsWaveConditionsOutputType"/>.</param> /// <param name="order">The position of <paramref name="output"/> in the list of all outputs.</param> /// <returns>A new <see cref="GrassCoverErosionOutwardsWaveConditionsOutputEntity"/>.</returns> internal static GrassCoverErosionOutwardsWaveConditionsOutputEntity CreateGrassCoverErosionOutwardsWaveConditionsOutputEntity( this WaveConditionsOutput output, GrassCoverErosionOutwardsWaveConditionsOutputType type, int order) { var entity = new GrassCoverErosionOutwardsWaveConditionsOutputEntity { Order = order, OutputType = Convert.ToByte(type), WaterLevel = output.WaterLevel.ToNaNAsNull(), WaveHeight = output.WaveHeight.ToNaNAsNull(), WavePeakPeriod = output.WavePeakPeriod.ToNaNAsNull(), WaveAngle = output.WaveAngle.ToNaNAsNull(), WaveDirection = output.WaveDirection.ToNaNAsNull(), TargetProbability = output.TargetProbability.ToNaNAsNull(), TargetReliability = output.TargetReliability.ToNaNAsNull(), CalculatedProbability = output.CalculatedProbability.ToNaNAsNull(), CalculatedReliability = output.CalculatedReliability.ToNaNAsNull(), CalculationConvergence = Convert.ToByte(output.CalculationConvergence) }; return(entity); }
public void Data_WithCalculationOutput_ReturnsExpectedValues() { // Setup var items = new[] { new TestWaveConditionsOutput() }; var waveImpactAsphaltCoverWaveConditionsOutput = new WaveImpactAsphaltCoverWaveConditionsOutput(items); // Call var properties = new WaveImpactAsphaltCoverWaveConditionsOutputProperties { Data = waveImpactAsphaltCoverWaveConditionsOutput }; // Assert CollectionAssert.AllItemsAreInstancesOfType(properties.Items, typeof(WaveConditionsOutputProperties)); Assert.AreEqual(items.Length, properties.Items.Length); WaveConditionsOutput expectedOutputProperty = items[0]; WaveConditionsOutputProperties firstOutputProperties = properties.Items[0]; Assert.AreEqual(expectedOutputProperty.WaterLevel, firstOutputProperties.WaterLevel); Assert.AreEqual(expectedOutputProperty.WaveHeight, firstOutputProperties.WaveHeight); Assert.AreEqual(expectedOutputProperty.WavePeakPeriod, firstOutputProperties.WavePeakPeriod); Assert.AreEqual(expectedOutputProperty.WaveAngle, firstOutputProperties.WaveAngle); Assert.AreEqual(expectedOutputProperty.WaveDirection, firstOutputProperties.WaveDirection); Assert.AreEqual(expectedOutputProperty.TargetProbability, firstOutputProperties.TargetProbability); Assert.AreEqual(expectedOutputProperty.TargetReliability, firstOutputProperties.TargetReliability, firstOutputProperties.TargetReliability.GetAccuracy()); Assert.AreEqual(expectedOutputProperty.TargetProbability, firstOutputProperties.TargetProbability); Assert.AreEqual(expectedOutputProperty.TargetReliability, firstOutputProperties.TargetReliability, firstOutputProperties.TargetReliability.GetAccuracy()); string convergenceValue = EnumDisplayNameHelper.GetDisplayName(expectedOutputProperty.CalculationConvergence); Assert.AreEqual(convergenceValue, firstOutputProperties.Convergence); }
public void Create_AllOutputValuesNaN_ReturnEntityWithNullValues() { // Setup var output = new WaveConditionsOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, CalculationConvergence.NotCalculated); // Call WaveImpactAsphaltCoverWaveConditionsOutputEntity entity = output.CreateWaveImpactAsphaltCoverWaveConditionsOutputEntity(22); // Assert Assert.IsNull(entity.WaterLevel); Assert.IsNull(entity.WaveHeight); Assert.IsNull(entity.WavePeakPeriod); Assert.IsNull(entity.WaveAngle); Assert.IsNull(entity.WaveDirection); Assert.IsNull(entity.TargetProbability); Assert.IsNull(entity.TargetReliability); Assert.IsNull(entity.CalculatedProbability); Assert.IsNull(entity.CalculatedReliability); Assert.IsNull(entity.WaveImpactAsphaltCoverWaveConditionsCalculationEntity); }
public void Create_AllOutputValuesNaN_ReturnEntityWithNullValues(StabilityStoneCoverWaveConditionsOutputType outputType) { // Setup var output = new WaveConditionsOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, CalculationConvergence.NotCalculated); // Call StabilityStoneCoverWaveConditionsOutputEntity entity = output.CreateStabilityStoneCoverWaveConditionsOutputEntity(outputType, 22); // Assert Assert.IsNull(entity.WaterLevel); Assert.IsNull(entity.WaveHeight); Assert.IsNull(entity.WavePeakPeriod); Assert.IsNull(entity.WaveAngle); Assert.AreEqual(Convert.ToByte(outputType), entity.OutputType); Assert.IsNull(entity.WaveDirection); Assert.IsNull(entity.TargetProbability); Assert.IsNull(entity.TargetReliability); Assert.IsNull(entity.CalculatedProbability); Assert.IsNull(entity.CalculatedReliability); Assert.AreEqual(0, entity.StabilityStoneCoverWaveConditionsOutputEntityId); Assert.AreEqual(0, entity.StabilityStoneCoverWaveConditionsCalculationEntityId); }
/// <summary> /// Performs a wave conditions calculation based on the supplied <see cref="WaveConditionsInput"/> /// and returns the output. Error and status information is logged during the execution /// of the operation. /// </summary> /// <param name="waveConditionsInput">The <see cref="WaveConditionsInput"/> that holds all the information /// required to perform the calculation.</param> /// <param name="assessmentLevel">The assessment level to use for determining water levels.</param> /// <param name="a">The 'a' factor decided on failure mechanism level.</param> /// <param name="b">The 'b' factor decided on failure mechanism level.</param> /// <param name="c">The 'c' factor decided on failure mechanism level.</param> /// <param name="targetProbability">The target probability to use.</param> /// <param name="hydraulicBoundaryDatabase">The hydraulic boundary database to perform the calculations with.</param> /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="WaveConditionsOutput"/>.</returns> /// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks> /// <exception cref="ArgumentNullException">Thrown when <paramref name="waveConditionsInput"/> or /// <paramref name="hydraulicBoundaryDatabase"/> 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="HydraRingCalculationException">Thrown when an error occurs during /// the calculations.</exception> protected IEnumerable <WaveConditionsOutput> CalculateWaveConditions(WaveConditionsInput waveConditionsInput, RoundedDouble assessmentLevel, RoundedDouble a, RoundedDouble b, RoundedDouble c, double targetProbability, HydraulicBoundaryDatabase hydraulicBoundaryDatabase) { if (waveConditionsInput == null) { throw new ArgumentNullException(nameof(waveConditionsInput)); } if (hydraulicBoundaryDatabase == null) { throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase)); } var calculationsFailed = 0; var outputs = new List <WaveConditionsOutput>(); RoundedDouble[] waterLevels = waveConditionsInput.GetWaterLevels(assessmentLevel).ToArray(); foreach (RoundedDouble waterLevel in waterLevels.TakeWhile(waterLevel => !Canceled)) { try { log.Info(string.Format(CultureInfo.CurrentCulture, Resources.WaveConditionsCalculationService_OnRun_Calculation_for_waterlevel_0_started, waterLevel)); NotifyProgress(waterLevel, currentStep++, TotalWaterLevelCalculations); WaveConditionsOutput output = CalculateWaterLevel(waterLevel, a, b, c, targetProbability, waveConditionsInput, HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase)); if (output != null) { outputs.Add(output); } else { calculationsFailed++; outputs.Add(WaveConditionsOutputFactory.CreateFailedOutput(waterLevel, targetProbability)); } } finally { log.Info(string.Format(CultureInfo.CurrentCulture, Resources.WaveConditionsCalculationService_OnRun_Calculation_for_waterlevel_0_ended, waterLevel)); } } if (calculationsFailed == waterLevels.Length) { string message = string.Format(CultureInfo.CurrentCulture, Resources.WaveConditionsCalculationService_CalculateWaterLevel_Error_in_wave_conditions_calculation_for_all_waterlevels); log.Error(message); throw new HydraRingCalculationException(message); } return(outputs); }