/// <summary>
/// Creates the input for a calculation for the given <paramref name="waterLevel"/>.
/// </summary>
/// <param name="waterLevel">The level of the water.</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="input">The input that is different per calculation.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> containing all data
/// to perform a hydraulic boundary calculation.</param>
/// <returns>A <see cref="WaveConditionsCalculationInput"/>.</returns>
/// <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>
private static WaveConditionsCosineCalculationInput CreateInput(RoundedDouble waterLevel,
RoundedDouble a,
RoundedDouble b,
RoundedDouble c,
double targetProbability,
WaveConditionsInput input,
HydraulicBoundaryCalculationSettings calculationSettings)
{
var waveConditionsCosineCalculationInput = new WaveConditionsCosineCalculationInput(
1,
input.Orientation,
input.HydraulicBoundaryLocation.Id,
targetProbability,
HydraRingInputParser.ParseForeshore(input),
HydraRingInputParser.ParseBreakWater(input),
waterLevel,
a,
b,
c);
HydraRingSettingsDatabaseHelper.AssignSettingsFromDatabase(waveConditionsCosineCalculationInput,
calculationSettings.HydraulicBoundaryDatabaseFilePath,
!string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory));
return(waveConditionsCosineCalculationInput);
}
public void Calculate_Always_InputPropertiesCorrectlySentToCalculator(BreakWaterType breakWaterType)
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
WaveImpactAsphaltCoverWaveConditionsCalculation calculation = GetValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
calculation.InputParameters.BreakWater.Type = breakWaterType;
var waveImpactAsphaltCoverFailureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var calculator = new TestWaveConditionsCosineCalculator();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(calculator)
.Repeat
.Times(3);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new WaveImpactAsphaltCoverWaveConditionsCalculationService().Calculate(
calculation,
assessmentSection,
waveImpactAsphaltCoverFailureMechanism.GeneralInput);
// Assert
WaveConditionsCosineCalculationInput[] waveConditionsInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(3, waveConditionsInputs.Length);
var waterLevelIndex = 0;
foreach (WaveConditionsCosineCalculationInput actualInput in waveConditionsInputs)
{
GeneralWaveConditionsInput generalInput = waveImpactAsphaltCoverFailureMechanism.GeneralInput;
WaveConditionsInput input = calculation.InputParameters;
var expectedInput = new WaveConditionsCosineCalculationInput(1,
input.Orientation,
input.HydraulicBoundaryLocation.Id,
assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability,
input.ForeshoreProfile.Geometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
GetWaterLevels(calculation, assessmentSection).ElementAt(waterLevelIndex++),
generalInput.A,
generalInput.B,
generalInput.C);
HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
}
}
mockRepository.VerifyAll();
}
public void Calculate_WithoutBreakWater_StartsCalculationWithRightParameters(bool useForeshore)
{
// Setup
var waterLevel = (RoundedDouble)4.20;
var a = (RoundedDouble)1.0;
var b = (RoundedDouble)0.8;
var c = (RoundedDouble)0.4;
const double targetProbability = 0.2;
var input = new WaveConditionsInput
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
ForeshoreProfile = new TestForeshoreProfile(true),
UpperBoundaryRevetment = (RoundedDouble)4,
LowerBoundaryRevetment = (RoundedDouble)3,
StepSize = WaveConditionsInputStepSize.Two,
UseBreakWater = false,
UseForeshore = useForeshore,
Orientation = (RoundedDouble)0
};
var calculator = new TestWaveConditionsCosineCalculator();
RoundedDouble[] waterLevels = input.GetWaterLevels(waterLevel).ToArray();
int nrOfCalculators = waterLevels.Length;
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(calculator)
.Repeat
.Times(nrOfCalculators);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new TestWaveConditionsCalculationService().PublicCalculate(a,
b,
c,
targetProbability,
input,
waterLevel,
GetValidHydraulicBoundaryDatabase());
// Assert
for (var i = 0; i < nrOfCalculators; i++)
{
WaveConditionsCosineCalculationInput expectedInput = CreateInput(waterLevels[i], a, b, c, targetProbability, input, useForeshore, false);
HydraRingDataEqualityHelper.AreEqual(expectedInput, calculator.ReceivedInputs.ElementAt(i));
}
}
mockRepository.VerifyAll();
}
public void GetSubMechanismModelId_Always_ReturnsExpectedValues(int subMechanismModelId, int?expectedSubMechanismModelId)
{
// Call
var waveConditionsCosineCalculationInput = new WaveConditionsCosineCalculationInput(111,
1.1,
222,
333,
Enumerable.Empty <HydraRingForelandPoint>(),
new HydraRingBreakWater(1, 4.4),
5.5,
6.6,
7.7,
8.8);
// Assert
Assert.AreEqual(expectedSubMechanismModelId, waveConditionsCosineCalculationInput.GetSubMechanismModelId(subMechanismModelId));
}
public void Constructor_Always_ExpectedValues()
{
// Setup
const int sectionId = 111;
const double sectionNormal = 90;
const int hydraulicBoundaryLocationId = 222;
const double targetProbability = 0.333;
IEnumerable <HydraRingForelandPoint> forelandPoints = Enumerable.Empty <HydraRingForelandPoint>();
var breakWater = new HydraRingBreakWater(1, 4.4);
const double waterLevel = 5.5;
const double a = 6.6;
const double b = 7.7;
const double c = 8.8;
// Call
var waveConditionsCosineCalculationInput = new WaveConditionsCosineCalculationInput(sectionId,
sectionNormal,
hydraulicBoundaryLocationId,
targetProbability,
forelandPoints,
breakWater,
waterLevel,
a,
b,
c);
// Assert
double expectedBeta = StatisticsConverter.ProbabilityToReliability(targetProbability);
Assert.IsInstanceOf <WaveConditionsCalculationInput>(waveConditionsCosineCalculationInput);
Assert.AreEqual(HydraRingFailureMechanismType.QVariant, waveConditionsCosineCalculationInput.FailureMechanismType);
Assert.AreEqual(8, waveConditionsCosineCalculationInput.CalculationTypeId);
Assert.AreEqual(114, waveConditionsCosineCalculationInput.VariableId);
Assert.AreEqual(hydraulicBoundaryLocationId, waveConditionsCosineCalculationInput.HydraulicBoundaryLocationId);
Assert.IsNotNull(waveConditionsCosineCalculationInput.Section);
Assert.AreEqual(sectionId, waveConditionsCosineCalculationInput.Section.SectionId);
Assert.AreEqual(sectionNormal, waveConditionsCosineCalculationInput.Section.CrossSectionNormal);
HydraRingDataEqualityHelper.AreEqual(GetExpectedVariables(waterLevel, a, b, c).ToArray(), waveConditionsCosineCalculationInput.Variables.ToArray());
Assert.AreSame(forelandPoints, waveConditionsCosineCalculationInput.ForelandPoints);
Assert.AreSame(breakWater, waveConditionsCosineCalculationInput.BreakWater);
Assert.AreEqual(expectedBeta, waveConditionsCosineCalculationInput.Beta);
}
public void Run_Always_InputPropertiesCorrectlySentToService(BreakWaterType breakWaterType)
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
calculation.InputParameters.BreakWater.Type = breakWaterType;
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation,
failureMechanism,
assessmentSection);
var waveConditionsCosineCalculator = new TestWaveConditionsCosineCalculator();
RoundedDouble[] waterLevels = GetWaterLevels(calculation, assessmentSection).ToArray();
int nrOfCalculators = GetNrOfCalculators(calculation, assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(waveConditionsCosineCalculator)
.Repeat
.Times(nrOfCalculators);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
// Assert
WaveConditionsCosineCalculationInput[] waveConditionsInputs = waveConditionsCosineCalculator.ReceivedInputs.ToArray();
Assert.AreEqual(nrOfCalculators, waveConditionsInputs.Length);
WaveConditionsInput input = calculation.InputParameters;
double targetProbability = assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability;
var waterLevelIndex = 0;
GeneralGrassCoverErosionOutwardsInput generalInput = failureMechanism.GeneralInput;
for (var i = 0; i < waveConditionsInputs.Length / 2; i++)
{
var expectedInput = new WaveConditionsCosineCalculationInput(1,
input.Orientation,
input.HydraulicBoundaryLocation.Id,
targetProbability,
input.ForeshoreProfile.Geometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
waterLevels[waterLevelIndex++],
generalInput.GeneralWaveRunUpWaveConditionsInput.A,
generalInput.GeneralWaveRunUpWaveConditionsInput.B,
generalInput.GeneralWaveRunUpWaveConditionsInput.C);
HydraRingDataEqualityHelper.AreEqual(expectedInput, waveConditionsInputs[i]);
}
waterLevelIndex = 0;
for (int i = waveConditionsInputs.Length / 2; i < waveConditionsInputs.Length; i++)
{
var expectedInput = new WaveConditionsCosineCalculationInput(1,
input.Orientation,
input.HydraulicBoundaryLocation.Id,
targetProbability,
input.ForeshoreProfile.Geometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
waterLevels[waterLevelIndex++],
generalInput.GeneralWaveImpactWaveConditionsInput.A,
generalInput.GeneralWaveImpactWaveConditionsInput.B,
generalInput.GeneralWaveImpactWaveConditionsInput.C);
HydraRingDataEqualityHelper.AreEqual(expectedInput, waveConditionsInputs[i]);
}
}
mockRepository.VerifyAll();
}
/// <summary>
/// Calculates values for a single water level.
/// </summary>
/// <param name="waterLevel">The level of the water.</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="input">The input that is different per calculation.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> containing all data
/// to perform a hydraulic boundary calculation.</param>
/// <returns>A <see cref="WaveConditionsOutput"/> if the calculation was successful; or <c>null</c> if it was canceled.</returns>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <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>
private WaveConditionsOutput CalculateWaterLevel(RoundedDouble waterLevel,
RoundedDouble a,
RoundedDouble b,
RoundedDouble c,
double targetProbability,
WaveConditionsInput input,
HydraulicBoundaryCalculationSettings calculationSettings)
{
HydraRingCalculationSettings settings = HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings);
calculator = HydraRingCalculatorFactory.Instance.CreateWaveConditionsCosineCalculator(settings);
WaveConditionsCosineCalculationInput calculationInput = CreateInput(waterLevel, a, b, c, targetProbability, input, calculationSettings);
WaveConditionsOutput output;
var exceptionThrown = false;
try
{
calculator.Calculate(calculationInput);
output = WaveConditionsOutputFactory.CreateOutput(waterLevel,
calculator.WaveHeight,
calculator.WavePeakPeriod,
calculator.WaveAngle,
calculator.WaveDirection,
targetProbability,
calculator.ReliabilityIndex,
calculator.Converged);
}
catch (Exception e) when(e is HydraRingCalculationException || e is ArgumentOutOfRangeException)
{
if (!Canceled)
{
string lastErrorContent = calculator.LastErrorFileContent;
if (string.IsNullOrEmpty(lastErrorContent))
{
log.ErrorFormat(CultureInfo.CurrentCulture,
Resources.WaveConditionsCalculationService_CalculateWaterLevel_Error_in_wave_conditions_calculation_for_waterlevel_0_no_error_report,
waterLevel);
}
else
{
log.ErrorFormat(CultureInfo.CurrentCulture,
Resources.WaveConditionsCalculationService_CalculateWaterLevel_Error_in_wave_conditions_calculation_for_waterlevel_0_click_details_for_last_error_report_1,
waterLevel,
lastErrorContent);
}
exceptionThrown = true;
}
output = null;
}
finally
{
string lastErrorFileContent = calculator.LastErrorFileContent;
bool errorOccurred = CalculationServiceHelper.HasErrorOccurred(Canceled, exceptionThrown, lastErrorFileContent);
if (errorOccurred)
{
log.ErrorFormat(CultureInfo.CurrentCulture,
Resources.WaveConditionsCalculationService_CalculateWaterLevel_Error_in_wave_conditions_calculation_for_waterlevel_0_click_details_for_last_error_report_1,
waterLevel,
lastErrorFileContent);
}
log.InfoFormat(CultureInfo.CurrentCulture,
Resources.WaveConditionsCalculationService_CalculateWaterLevel_Calculation_temporary_directory_can_be_found_on_location_0,
calculator.OutputDirectory);
if (errorOccurred)
{
output = null;
}
}
return(output);
}
public void Calculate(WaveConditionsCosineCalculationInput input)
{
Calculate(HydraRingUncertaintiesType.All, input);
}