private static void AssertDesignWaterLevelCalculationActivity(Activity activity,
HydraulicBoundaryLocation hydraulicBoundaryLocation,
string calculationIdentifier,
double targetProbability,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var calculator = new TestDesignWaterLevelCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(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 = $"Waterstand berekenen voor locatie '{hydraulicBoundaryLocation.Name}' ({calculationIdentifier}) is gestart.";
TestHelper.AssertLogMessageIsGenerated(call, expectedLogMessage);
AssessmentLevelCalculationInput designWaterLevelCalculationInput = calculator.ReceivedInputs.Single();
Assert.AreEqual(hydraulicBoundaryLocation.Id, designWaterLevelCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), designWaterLevelCalculationInput.Beta);
}
mocks.VerifyAll();
}
public void GetSubMechanismModelId_ReturnsExpectedValues()
{
// Call
var assessmentLevelCalculationInput = new AssessmentLevelCalculationInput(1, 1, 2.2);
// Assert
Assert.IsNull(assessmentLevelCalculationInput.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 TestDesignWaterLevelCalculator
{
Converged = true
};
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(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))
{
// Call
new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
calculationSettings,
targetProbability,
calculationMessageProvider);
// Assert
AssessmentLevelCalculationInput expectedInput = CreateInput(hydraulicBoundaryLocation.Id, targetProbability);
AssessmentLevelCalculationInput actualInput = calculator.ReceivedInputs.Single();
AssertInput(expectedInput, actualInput);
Assert.IsFalse(calculator.IsCanceled);
Assert.AreEqual(usePreprocessor, actualInput.PreprocessorSetting.RunPreprocessor);
}
mockRepository.VerifyAll();
}
/// <summary>
/// Creates the input for a design water level 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>An <see cref="AssessmentLevelCalculationInput"/>.</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 AssessmentLevelCalculationInput CreateInput(long hydraulicBoundaryLocationId,
double targetProbability,
HydraulicBoundaryCalculationSettings calculationSettings)
{
var assessmentLevelCalculationInput = new AssessmentLevelCalculationInput(1, hydraulicBoundaryLocationId, targetProbability);
HydraRingSettingsDatabaseHelper.AssignSettingsFromDatabase(assessmentLevelCalculationInput,
calculationSettings.HydraulicBoundaryDatabaseFilePath,
!string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory));
return(assessmentLevelCalculationInput);
}
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 TestDesignWaterLevelCalculator
{
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.CreateDesignWaterLevelCalculator(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 DesignWaterLevelCalculationActivity(new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation),
calculationSettings,
targetProbability,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
// Assert
AssessmentLevelCalculationInput designWaterLevelCalculationInput = calculator.ReceivedInputs.Single();
Assert.AreEqual(hydraulicBoundaryLocation.Id, designWaterLevelCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), designWaterLevelCalculationInput.Beta);
}
Assert.AreEqual(ActivityState.Executed, activity.State);
mockRepository.VerifyAll();
}
/// <summary>
/// Performs a calculation for the design water level.
/// </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;
AssessmentLevelCalculationInput 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 Constructor_ExpectedValues()
{
// Setup
const double targetProbability = 1.0 / 10000;
const int sectionId = 1;
const long hydraulicBoundaryLocationId = 1234;
// Call
var assessmentLevelCalculationInput = new AssessmentLevelCalculationInput(sectionId, hydraulicBoundaryLocationId, targetProbability);
// Assert
double expectedBeta = StatisticsConverter.ProbabilityToReliability(targetProbability);
Assert.IsInstanceOf<ReliabilityIndexCalculationInput>(assessmentLevelCalculationInput);
Assert.AreEqual(HydraRingFailureMechanismType.AssessmentLevel, assessmentLevelCalculationInput.FailureMechanismType);
Assert.AreEqual(9, assessmentLevelCalculationInput.CalculationTypeId);
Assert.AreEqual(26, assessmentLevelCalculationInput.VariableId);
Assert.AreEqual(1, assessmentLevelCalculationInput.FaultTreeModelId);
Assert.AreEqual(hydraulicBoundaryLocationId, assessmentLevelCalculationInput.HydraulicBoundaryLocationId);
Assert.IsNotNull(assessmentLevelCalculationInput.Section);
CollectionAssert.IsEmpty(assessmentLevelCalculationInput.ProfilePoints);
CollectionAssert.IsEmpty(assessmentLevelCalculationInput.ForelandPoints);
Assert.IsNull(assessmentLevelCalculationInput.BreakWater);
Assert.AreEqual(expectedBeta, assessmentLevelCalculationInput.Beta);
HydraRingSection section = assessmentLevelCalculationInput.Section;
Assert.AreEqual(sectionId, section.SectionId);
Assert.IsNaN(section.SectionLength);
Assert.IsNaN(section.CrossSectionNormal);
HydraRingVariable[] variables = assessmentLevelCalculationInput.Variables.ToArray();
Assert.AreEqual(1, variables.Length);
HydraRingVariable waterLevelVariable = variables.First();
Assert.IsInstanceOf<DeterministicHydraRingVariable>(waterLevelVariable);
Assert.AreEqual(26, waterLevelVariable.VariableId);
Assert.AreEqual(0.0, waterLevelVariable.Value);
}
private static void AssertInput(AssessmentLevelCalculationInput expectedInput, HydraRingCalculationInput hydraRingCalculationInput)
{
Assert.AreEqual(expectedInput.Section.SectionId, hydraRingCalculationInput.Section.SectionId);
Assert.AreEqual(expectedInput.HydraulicBoundaryLocationId, hydraRingCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(expectedInput.Beta, hydraRingCalculationInput.Beta);
}
public void Calculate(AssessmentLevelCalculationInput input)
{
Calculate(HydraRingUncertaintiesType.All, input);
}
