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);
}
