private static void AssertWaveHeightCalculationActivity(Activity activity,
HydraulicBoundaryLocation hydraulicBoundaryLocation,
string calculationIdentifier,
double targetProbability,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var calculator = new TestWaveHeightCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
Action call = activity.Run;
string expectedLogMessage = $"Golfhoogte berekenen voor locatie '{hydraulicBoundaryLocation.Name}' ({calculationIdentifier}) is gestart.";
TestHelper.AssertLogMessageIsGenerated(call, expectedLogMessage);
WaveHeightCalculationInput waveHeightCalculationInput = calculator.ReceivedInputs.Single();
Assert.AreEqual(hydraulicBoundaryLocation.Id, waveHeightCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), waveHeightCalculationInput.Beta);
}
mocks.VerifyAll();
}
public void GetSubMechanismModelId_ReturnsExpectedValues()
{
// Call
var waveHeightCalculationInput = new WaveHeightCalculationInput(1, 1, 2.2);
// Assert
Assert.IsNull(waveHeightCalculationInput.GetSubMechanismModelId(1));
}
public void Calculate_ValidData_StartsCalculationWithRightParameters(bool usePreprocessor)
{
// Setup
const double targetProbability = 1.0 / 30;
string preprocessorDirectory = usePreprocessor
? validPreprocessorDirectory
: string.Empty;
var calculator = new TestWaveHeightCalculator
{
Converged = true
};
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
new WaveHeightCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
calculationSettings,
targetProbability,
calculationMessageProvider);
// Assert
AssessmentLevelCalculationInput expectedInput = CreateInput(hydraulicBoundaryLocation.Id, targetProbability);
WaveHeightCalculationInput actualInput = calculator.ReceivedInputs.Single();
AssertInput(expectedInput, actualInput);
Assert.IsFalse(calculator.IsCanceled);
Assert.AreEqual(usePreprocessor, actualInput.PreprocessorSetting.RunPreprocessor);
}
mockRepository.VerifyAll();
}
/// <summary>
/// Creates the input for an wave height calculation.
/// </summary>
/// <param name="hydraulicBoundaryLocationId">The id of the hydraulic boundary location.</param>
/// <param name="targetProbability">The target probability to use during the calculation.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <returns>A <see cref="WaveHeightCalculationInput"/>.</returns>
/// <exception cref="ArgumentException">Thrown when the hydraulic boundary location 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 WaveHeightCalculationInput CreateInput(long hydraulicBoundaryLocationId,
double targetProbability,
HydraulicBoundaryCalculationSettings calculationSettings)
{
var waveHeightCalculationInput = new WaveHeightCalculationInput(1, hydraulicBoundaryLocationId, targetProbability);
HydraRingSettingsDatabaseHelper.AssignSettingsFromDatabase(waveHeightCalculationInput,
calculationSettings.HydraulicBoundaryDatabaseFilePath,
!string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory));
return(waveHeightCalculationInput);
}
public void Run_ValidInput_PerformCalculationWithCorrectInput(bool usePreprocessor)
{
// Setup
const string locationName = "locationName";
const string calculationIdentifier = "1/100";
const double targetProbability = 0.01;
var calculator = new TestWaveHeightCalculator
{
Converged = true
};
string preprocessorDirectory = usePreprocessor ? validPreprocessorDirectory : string.Empty;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(locationName);
var activity = new WaveHeightCalculationActivity(new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation),
calculationSettings,
targetProbability,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
// Assert
WaveHeightCalculationInput waveHeightCalculationInput = calculator.ReceivedInputs.Single();
Assert.AreEqual(hydraulicBoundaryLocation.Id, waveHeightCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), waveHeightCalculationInput.Beta);
}
Assert.AreEqual(ActivityState.Executed, activity.State);
mockRepository.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
const double targetProbability = 1.0 / 10000;
const int sectionId = 1;
const long hydraulicBoundaryLocationId = 1234;
// Call
var waveHeightCalculationInput = new WaveHeightCalculationInput(sectionId, hydraulicBoundaryLocationId, targetProbability);
// Assert
double expectedBeta = StatisticsConverter.ProbabilityToReliability(targetProbability);
Assert.IsInstanceOf <ReliabilityIndexCalculationInput>(waveHeightCalculationInput);
Assert.AreEqual(HydraRingFailureMechanismType.WaveHeight, waveHeightCalculationInput.FailureMechanismType);
Assert.AreEqual(9, waveHeightCalculationInput.CalculationTypeId);
Assert.AreEqual(28, waveHeightCalculationInput.VariableId);
Assert.AreEqual(11, waveHeightCalculationInput.FaultTreeModelId);
Assert.AreEqual(hydraulicBoundaryLocationId, waveHeightCalculationInput.HydraulicBoundaryLocationId);
Assert.IsNotNull(waveHeightCalculationInput.Section);
CollectionAssert.IsEmpty(waveHeightCalculationInput.ProfilePoints);
CollectionAssert.IsEmpty(waveHeightCalculationInput.ForelandPoints);
Assert.IsNull(waveHeightCalculationInput.BreakWater);
Assert.AreEqual(expectedBeta, waveHeightCalculationInput.Beta);
HydraRingSection section = waveHeightCalculationInput.Section;
Assert.AreEqual(sectionId, section.SectionId);
Assert.IsNaN(section.SectionLength);
Assert.IsNaN(section.CrossSectionNormal);
HydraRingVariable[] variables = waveHeightCalculationInput.Variables.ToArray();
Assert.AreEqual(1, variables.Length);
HydraRingVariable waveHeightVariable = variables.First();
Assert.IsInstanceOf <DeterministicHydraRingVariable>(waveHeightVariable);
Assert.AreEqual(28, waveHeightVariable.VariableId);
Assert.AreEqual(0.0, waveHeightVariable.Value);
}
/// <summary>
/// Performs a calculation for the wave height.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation to perform.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <param name="targetProbability">The target probability to use during the calculation.</param>
/// <param name="messageProvider">The object which is used to build log messages.</param>
/// <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 while performing the calculation.</exception>
private void PerformCalculation(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
ICalculationMessageProvider messageProvider)
{
HydraulicBoundaryLocation hydraulicBoundaryLocation = hydraulicBoundaryLocationCalculation.HydraulicBoundaryLocation;
WaveHeightCalculationInput calculationInput = CreateInput(hydraulicBoundaryLocation.Id, targetProbability, calculationSettings);
calculator.Calculate(calculationInput);
if (canceled || !string.IsNullOrEmpty(calculator.LastErrorFileContent))
{
return;
}
GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult = null;
try
{
generalResult = hydraulicBoundaryLocationCalculation.InputParameters.ShouldIllustrationPointsBeCalculated
? GetGeneralResult(calculator.IllustrationPointsResult)
: null;
}
catch (ArgumentException e)
{
log.Warn(string.Format(Resources.CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1,
hydraulicBoundaryLocation.Name,
e.Message));
}
HydraulicBoundaryLocationCalculationOutput hydraulicBoundaryLocationCalculationOutput = CreateOutput(
messageProvider, hydraulicBoundaryLocation.Name, calculationInput.Beta, targetProbability, calculator.Converged, generalResult);
hydraulicBoundaryLocationCalculation.Output = hydraulicBoundaryLocationCalculationOutput;
}
public void Calculate(WaveHeightCalculationInput input)
{
Calculate(HydraRingUncertaintiesType.All, input);
}
