public void Run_InvalidHydraulicBoundaryDatabase_PerformValidationAndLogStartAndEndAndError()
{
// Setup
string invalidFilePath = Path.Combine(testDataPath, "notexisting.sqlite");
const string calculationIdentifier = "1/100";
const string locationName = "locationName";
var settings = new HydraulicBoundaryCalculationSettings(invalidFilePath,
validHlcdFilePath,
false,
string.Empty);
var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
settings,
0.01,
calculationIdentifier);
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{locationName}' ({calculationIdentifier}) is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. Fout bij het lezen van bestand", msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
public void Run_InvalidPreprocessorDirectory_PerformValidationAndLogStartAndEndAndError()
{
// Setup
const string calculationIdentifier = "1/100";
const string locationName = "locationName";
var settings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
"NonExistingPreprocessorDirectory");
var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
settings,
0.01,
calculationIdentifier);
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{locationName}' ({calculationIdentifier}) is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
Assert.AreEqual("De bestandsmap waar de preprocessor bestanden opslaat is ongeldig. De bestandsmap bestaat niet.", msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
/// <summary>
/// Asserts whether the <see cref="HydraRingCalculationSettings"/> contains the correct
/// data from <see cref="HydraulicBoundaryCalculationSettings"/>.
/// </summary>
/// <param name="expectedSettings">The <see cref="HydraulicBoundaryCalculationSettings"/>
/// to assert against.</param>
/// <param name="actualSettings">The <see cref="HydraRingCalculationSettings"/> to be asserted.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>The HLCD file paths do not match.</item>
/// <item>The preprocessor directories do not match.</item>
/// <item>The use preprocessor closure indicators do not match.</item>
/// </list>
/// </exception>
public static void AssertHydraRingCalculationSettings(HydraulicBoundaryCalculationSettings expectedSettings,
HydraRingCalculationSettings actualSettings)
{
Assert.AreEqual(expectedSettings.HlcdFilePath, actualSettings.HlcdFilePath);
Assert.AreEqual(expectedSettings.PreprocessorDirectory, actualSettings.PreprocessorDirectory);
Assert.AreEqual(expectedSettings.UsePreprocessorClosure, actualSettings.UsePreprocessorClosure);
}
/// <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);
}
/// <summary>
/// Performs a piping calculation based on the supplied <see cref="ProbabilisticPipingCalculation"/> and sets <see cref="ProbabilisticPipingCalculation.Output"/>
/// if the calculation was successful. Error and status information is logged during the execution of the operation.
/// </summary>
/// <param name="calculation">The <see cref="ProbabilisticPipingCalculation"/> that holds all the information required to perform the calculation.</param>
/// <param name="generalInput">The <see cref="GeneralPipingInput"/> to derive values from during the calculation.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <param name="sectionLength">The length of the section the calculation belongs to.</param>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="generalInput"/>
/// or <paramref name="calculationSettings"/> 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="HydraRingFileParserException">Thrown when an error occurs during parsing of the Hydra-Ring output.</exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs during the calculation.</exception>
internal void Calculate(ProbabilisticPipingCalculation calculation, GeneralPipingInput generalInput,
HydraulicBoundaryCalculationSettings calculationSettings, double sectionLength)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
string hydraulicBoundaryDatabaseFilePath = calculationSettings.HydraulicBoundaryDatabaseFilePath;
bool usePreprocessor = !string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory);
HydraRingCalculationSettings hydraRingCalculationSettings = HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings);
profileSpecificCalculator = HydraRingCalculatorFactory.Instance.CreatePipingCalculator(
hydraRingCalculationSettings);
sectionSpecificCalculator = HydraRingCalculatorFactory.Instance.CreatePipingCalculator(
hydraRingCalculationSettings);
CalculationServiceHelper.LogCalculationBegin();
try
{
IPartialProbabilisticPipingOutput profileSpecificOutput = CalculateProfileSpecific(
calculation, generalInput, hydraulicBoundaryDatabaseFilePath, usePreprocessor);
if (canceled)
{
return;
}
IPartialProbabilisticPipingOutput sectionSpecificOutput = CalculateSectionSpecific(
calculation, generalInput, sectionLength, hydraulicBoundaryDatabaseFilePath, usePreprocessor);
if (canceled)
{
return;
}
calculation.Output = new ProbabilisticPipingOutput(sectionSpecificOutput, profileSpecificOutput);
}
finally
{
CalculationServiceHelper.LogCalculationEnd();
profileSpecificCalculator = null;
sectionSpecificCalculator = null;
}
}
public void Calculate_ValidData_CalculationStartedWithRightParameters(bool usePreprocessor)
{
// Setup
const double targetProbability = 1.0 / 30;
string preprocessorDirectory = usePreprocessor
? validPreprocessorDirectory
: string.Empty;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var calculator = new TestDunesBoundaryConditionsCalculator
{
Converged = true
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var duneLocation = new DuneLocation(1300001, "test", new Point2D(0, 0),
new DuneLocation.ConstructionProperties
{
CoastalAreaId = 0,
Offset = 0,
Orientation = 0,
D50 = 0.000007
});
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new DuneLocationCalculationService().Calculate(new DuneLocationCalculation(duneLocation),
targetProbability,
calculationSettings,
calculationMessageProvider);
// Assert
DunesBoundaryConditionsCalculationInput expectedInput = CreateInput(duneLocation, targetProbability);
DunesBoundaryConditionsCalculationInput actualInput = calculator.ReceivedInputs.Single();
AssertInput(expectedInput, actualInput);
Assert.AreEqual(usePreprocessor, actualInput.PreprocessorSetting.RunPreprocessor);
}
mockRepository.VerifyAll();
}
public void CreateSettings_WithHydraulicBoundaryDatabaseWithVariousPreprocessorConfigurations_ReturnsExpectedSettings(
HydraulicBoundaryDatabase database,
string expectedPreprocessorDirectory)
{
// Call
HydraulicBoundaryCalculationSettings settings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(database);
// Assert
Assert.AreEqual(expectedPreprocessorDirectory, settings.PreprocessorDirectory);
}
public void Calculate_PreprocessorDirectorySet_InputPropertiesCorrectlySentToCalculator(bool usePreprocessor)
{
// Setup
string preprocessorDirectory = usePreprocessor
? validPreprocessorDirectory
: string.Empty;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mockRepository);
var calculator = new TestStructuresCalculator <StructuresOvertoppingCalculationInput>();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
calculationSettings);
// Assert
StructuresOvertoppingCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, calculationInputs.Length);
StructuresOvertoppingCalculationInput actualInput = calculationInputs[0];
Assert.AreEqual(usePreprocessor, actualInput.PreprocessorSetting.RunPreprocessor);
}
mockRepository.VerifyAll();
}
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 a new instance of a <see cref="HydraRingCalculationSettings"/>
/// based on a <see cref="HydraulicBoundaryCalculationSettings"/>.
/// </summary>
/// <param name="hydraulicBoundaryCalculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/>
/// to create a <see cref="HydraRingCalculationSettings"/> for.</param>
/// <returns>A <see cref="HydraRingCalculationSettings"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryCalculationSettings"/>
/// is <c>null</c>.</exception>
public static HydraRingCalculationSettings CreateSettings(HydraulicBoundaryCalculationSettings hydraulicBoundaryCalculationSettings)
{
if (hydraulicBoundaryCalculationSettings == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryCalculationSettings));
}
return(new HydraRingCalculationSettings(hydraulicBoundaryCalculationSettings.HlcdFilePath,
hydraulicBoundaryCalculationSettings.PreprocessorDirectory,
hydraulicBoundaryCalculationSettings.UsePreprocessorClosure));
}
/// <summary>
/// Creates the input used in the calculation.
/// </summary>
/// <param name="duneLocation">The <see cref="DuneLocation"/> to create the input for.</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="DunesBoundaryConditionsCalculationInput"/> with all needed
/// input data.</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 DunesBoundaryConditionsCalculationInput CreateInput(DuneLocation duneLocation,
double targetProbability,
HydraulicBoundaryCalculationSettings calculationSettings)
{
var dunesBoundaryConditionsCalculationInput = new DunesBoundaryConditionsCalculationInput(1, duneLocation.Id, targetProbability);
HydraRingSettingsDatabaseHelper.AssignSettingsFromDatabase(dunesBoundaryConditionsCalculationInput,
calculationSettings.HydraulicBoundaryDatabaseFilePath,
!string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory));
return(dunesBoundaryConditionsCalculationInput);
}
public DuneLocationCalculationActivityWithState(DuneLocationCalculation duneLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
string calculationIdentifier,
ActivityState state)
: base(duneLocationCalculation,
calculationSettings,
targetProbability,
calculationIdentifier)
{
State = state;
}
public TestDesignWaterLevelCalculationActivity(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
string calculationIdentifier,
ActivityState state)
: base(hydraulicBoundaryLocationCalculation,
calculationSettings,
targetProbability,
calculationIdentifier)
{
State = state;
}
/// <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();
}
public void Run_ValidInput_PerformValidationAndCalculationAndLogStartAndEnd()
{
// Setup
const string locationName = "locationName";
const string calculationIdentifier = "1/100";
const double targetProbability = 0.01;
var calculator = new TestDesignWaterLevelCalculator
{
Converged = true
};
HydraulicBoundaryCalculationSettings calculationSettings = CreateCalculationSettings();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(locationName);
var activity = new DesignWaterLevelCalculationActivity(new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation),
calculationSettings,
targetProbability,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, m =>
{
string[] messages = m.ToArray();
Assert.AreEqual(6, messages.Length);
Assert.AreEqual($"{GetActivityDescription(locationName, calculationIdentifier)} is gestart.", messages[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messages[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messages[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messages[3]);
StringAssert.StartsWith("Waterstand berekening is uitgevoerd op de tijdelijke locatie", messages[4]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messages[5]);
});
}
Assert.AreEqual(ActivityState.Executed, activity.State);
mockRepository.VerifyAll();
}
public void CreateSettings_WithHydraulicBoundaryCalculationSettings_ReturnsExpectedSettings()
{
// Setup
var hydraulicBoundaryCalculationSettings = new HydraulicBoundaryCalculationSettings("HydraulicBoundaryDataBaseFilePath",
"hlcdFilePath",
false,
"preprocessorDirectory");
// Call
HydraRingCalculationSettings hydraRingCalculationSettings = HydraRingCalculationSettingsFactory.CreateSettings(hydraulicBoundaryCalculationSettings);
// Assert
Assert.AreEqual(hydraulicBoundaryCalculationSettings.HlcdFilePath, hydraRingCalculationSettings.HlcdFilePath);
Assert.AreEqual(hydraulicBoundaryCalculationSettings.PreprocessorDirectory, hydraRingCalculationSettings.PreprocessorDirectory);
Assert.AreEqual(hydraulicBoundaryCalculationSettings.UsePreprocessorClosure, hydraRingCalculationSettings.UsePreprocessorClosure);
}
/// <summary>
/// Performs validation on the given input parameters. Error and status information is logged during the execution of the operation.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <returns><c>true</c> if there were no validation errors; <c>false</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/> is <c>null</c>.</exception>
public bool Validate(HydraulicBoundaryCalculationSettings calculationSettings)
{
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
var isValid = true;
CalculationServiceHelper.LogValidationBegin();
string preprocessorDirectory = calculationSettings.PreprocessorDirectory;
string databaseFilePathValidationProblem = HydraulicBoundaryDatabaseHelper.ValidateFilesForCalculation(
calculationSettings.HydraulicBoundaryDatabaseFilePath,
calculationSettings.HlcdFilePath,
preprocessorDirectory,
calculationSettings.UsePreprocessorClosure);
if (!string.IsNullOrEmpty(databaseFilePathValidationProblem))
{
CalculationServiceHelper.LogMessagesAsError(Resources.Hydraulic_boundary_database_connection_failed_0_,
new[]
{
databaseFilePathValidationProblem
});
isValid = false;
}
string preprocessorDirectoryValidationProblem = HydraulicBoundaryDatabaseHelper.ValidatePreprocessorDirectory(preprocessorDirectory);
if (!string.IsNullOrEmpty(preprocessorDirectoryValidationProblem))
{
CalculationServiceHelper.LogMessagesAsError(new[]
{
preprocessorDirectoryValidationProblem
});
isValid = false;
}
CalculationServiceHelper.LogValidationEnd();
return(isValid);
}
public void Constructor_WithArguments_ExpectedValues(string preprocessorDirectory)
{
// Setup
const string hydraulicBoundaryDatabaseFilePath = "D:\\HydraulicBoundaryDatabaseFilePath";
const string hlcdFilePath = "D:\\hlcdFilePath";
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
var settings = new HydraulicBoundaryCalculationSettings(hydraulicBoundaryDatabaseFilePath,
hlcdFilePath,
usePreprocessorClosure,
preprocessorDirectory);
// Assert
Assert.AreEqual(hydraulicBoundaryDatabaseFilePath, settings.HydraulicBoundaryDatabaseFilePath);
Assert.AreEqual(hlcdFilePath, settings.HlcdFilePath);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual(preprocessorDirectory, settings.PreprocessorDirectory);
}
/// <summary>
/// Creates a new instance of <see cref="DesignWaterLevelCalculationActivity"/>.
/// </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="calculationIdentifier">The calculation identifier to use in all messages.</param>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculation"/> or
/// <paramref name="calculationSettings"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="calculationIdentifier"/> is <c>null</c> or empty.</exception>
public DesignWaterLevelCalculationActivity(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
string calculationIdentifier)
: base(hydraulicBoundaryLocationCalculation)
{
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
messageProvider = new DesignWaterLevelCalculationMessageProvider(calculationIdentifier);
this.hydraulicBoundaryLocationCalculation = hydraulicBoundaryLocationCalculation;
this.calculationSettings = calculationSettings;
this.targetProbability = targetProbability;
calculationService = new DesignWaterLevelCalculationService();
Description = messageProvider.GetActivityDescription(hydraulicBoundaryLocationCalculation.HydraulicBoundaryLocation.Name);
}
/// <summary>
/// Creates a collection of <see cref="CalculatableActivity"/> based on <paramref name="calculations"/>.
/// </summary>
/// <param name="calculations">The calculations to create activities for.</param>
/// <param name="assessmentSection">The assessment section the calculations belong to.</param>
/// <param name="targetProbability">The target probability to use during the calculations.</param>
/// <param name="calculationIdentifier">The calculation identifier to use in all messages.</param>
/// <returns>A collection of <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> or
/// <paramref name="assessmentSection"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="calculationIdentifier"/> is <c>null</c> or empty.</exception>
public static IEnumerable <CalculatableActivity> CreateCalculationActivities(IEnumerable <DuneLocationCalculation> calculations,
IAssessmentSection assessmentSection,
double targetProbability,
string calculationIdentifier)
{
if (calculations == null)
{
throw new ArgumentNullException(nameof(calculations));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
HydraulicBoundaryCalculationSettings settings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
return(calculations.Select(calculation => new DuneLocationCalculationActivity(calculation,
settings,
targetProbability,
calculationIdentifier)).ToArray());
}
/// <summary>
/// Creates a new instance of <see cref="DuneLocationCalculationActivity"/>.
/// </summary>
/// <param name="duneLocationCalculation">The <see cref="DuneLocationCalculation"/> 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="calculationIdentifier">The calculation identifier to use in all messages.</param>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="duneLocationCalculation"/>
/// or <paramref name="calculationSettings"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="calculationIdentifier"/> is <c>null</c> or empty.</exception>
public DuneLocationCalculationActivity(DuneLocationCalculation duneLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
string calculationIdentifier)
: base(duneLocationCalculation)
{
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
messageProvider = new DuneLocationCalculationMessageProvider(calculationIdentifier);
this.duneLocationCalculation = duneLocationCalculation;
this.calculationSettings = calculationSettings;
this.targetProbability = targetProbability;
DuneLocation duneLocation = duneLocationCalculation.DuneLocation;
Description = messageProvider.GetActivityDescription(duneLocation.Name);
calculationService = new DuneLocationCalculationService();
}
public void CreateSettings_WithHydraulicBoundaryDatabaseWithFilePath_ReturnsExpectedSettings()
{
// Setup
const string hydraulicBoundaryDatabaseFilePath = "some//FilePath//HRD dutch coast south.sqlite";
const string hlcdFilePath = "some//FilePath//HLCD dutch coast south.sqlite";
bool usePreprocessorClosure = new Random(21).NextBoolean();
var database = new HydraulicBoundaryDatabase
{
FilePath = hydraulicBoundaryDatabaseFilePath
};
database.HydraulicLocationConfigurationSettings.SetValues(hlcdFilePath, string.Empty, 10, string.Empty,
usePreprocessorClosure, null, null, null, null, null, null);
// Call
HydraulicBoundaryCalculationSettings settings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(database);
// Assert
Assert.AreEqual(hydraulicBoundaryDatabaseFilePath, settings.HydraulicBoundaryDatabaseFilePath);
Assert.AreEqual(hlcdFilePath, settings.HlcdFilePath);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
}
public void Validate_UsePreprocessorClosureTrueAndWithoutPreprocessorClosure_LogsErrorAndReturnsFalse()
{
// Setup
var valid = true;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
true,
string.Empty);
// Call
void Call() => valid = calculationService.Validate(calculationSettings);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. Fout bij het lezen van bestand", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(valid);
}
public void Validate_InvalidPreprocessorDirectory_LogsErrorAndReturnsFalse()
{
// Setup
const string invalidPreprocessorDirectory = "NonExistingPreprocessorDirectory";
var valid = true;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
invalidPreprocessorDirectory);
// Call
void Call() => valid = calculationService.Validate(calculationSettings);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual("De bestandsmap waar de preprocessor bestanden opslaat is ongeldig. De bestandsmap bestaat niet.", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(valid);
}
/// <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;
}
private int CreateCalculators(GrassCoverErosionInwardsCalculation calculation,
HydraulicBoundaryCalculationSettings calculationSettings)
{
var numberOfCalculators = 1;
HydraRingCalculationSettings hydraRingCalculationSettings = HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings);
overtoppingCalculator = HydraRingCalculatorFactory.Instance.CreateOvertoppingCalculator(
hydraRingCalculationSettings);
if (calculation.InputParameters.ShouldDikeHeightBeCalculated)
{
dikeHeightCalculator = HydraRingCalculatorFactory.Instance.CreateDikeHeightCalculator(hydraRingCalculationSettings);
numberOfCalculators++;
}
if (calculation.InputParameters.ShouldOvertoppingRateBeCalculated)
{
overtoppingRateCalculator = HydraRingCalculatorFactory.Instance.CreateOvertoppingRateCalculator(hydraRingCalculationSettings);
numberOfCalculators++;
}
return(numberOfCalculators);
}
public void Validate_ValidHydraulicBoundaryDatabaseWithoutSettings_LogsErrorAndReturnsFalse()
{
// Setup
string invalidHydraulicBoundaryDatabaseFilePath = Path.Combine(testDataPath, "HRD nosettings.sqlite");
var valid = false;
var calculationSettings = new HydraulicBoundaryCalculationSettings(invalidHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
string.Empty);
// Call
void Call() => valid = calculationService.Validate(calculationSettings);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. Fout bij het lezen van bestand", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(valid);
}
/// <summary>
/// Performs a structures calculation based on the supplied <see cref="StructuresCalculation{T}"/> and sets <see cref="StructuresCalculation{T}.Output"/>
/// if the calculation was successful. Error and status information is logged during the execution of the operation.
/// </summary>
/// <param name="calculation">The <see cref="StructuresCalculation{T}"/> that holds all the information required to perform the calculation.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when the hydraulic boundary database file path
/// contains invalid characters.</exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when an unexpected
/// enum value is encountered.</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 while performing the calculation.</exception>
public void Calculate(StructuresCalculation <TStructureInput> calculation,
TGeneralInput generalInput,
HydraulicBoundaryCalculationSettings calculationSettings)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
TCalculationInput input = CreateInput(calculation.InputParameters,
generalInput,
calculationSettings.HydraulicBoundaryDatabaseFilePath,
!string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory));
calculator = HydraRingCalculatorFactory.Instance.CreateStructuresCalculator <TCalculationInput>(
HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings));
string calculationName = calculation.Name;
CalculationServiceHelper.LogCalculationBegin();
var exceptionThrown = false;
try
{
PerformCalculation(calculation, input);
}
catch (HydraRingCalculationException)
{
if (!canceled)
{
string lastErrorFileContent = calculator.LastErrorFileContent;
string message = string.IsNullOrEmpty(lastErrorFileContent)
? messageProvider.GetCalculationFailedMessage(calculationName)
: messageProvider.GetCalculationFailedWithErrorReportMessage(calculationName, lastErrorFileContent);
log.Error(message);
exceptionThrown = true;
throw;
}
}
finally
{
string lastErrorFileContent = calculator.LastErrorFileContent;
bool errorOccurred = CalculationServiceHelper.HasErrorOccurred(canceled, exceptionThrown, lastErrorFileContent);
if (errorOccurred)
{
log.Error(messageProvider.GetCalculationFailedWithErrorReportMessage(calculationName, lastErrorFileContent));
}
log.Info(messageProvider.GetCalculationPerformedMessage(calculator.OutputDirectory));
CalculationServiceHelper.LogCalculationEnd();
if (errorOccurred)
{
throw new HydraRingCalculationException(lastErrorFileContent);
}
}
}
/// <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>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculation"/>,
/// <paramref name="calculationSettings"/> or <paramref name="messageProvider"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when
/// <list type="bullet">
/// <item>the hydraulic boundary database file path contains invalid characters.</item>
/// <item>The target probability or the calculated probability falls outside the [0.0, 1.0] range and is not <see cref="double.NaN"/>.</item>
/// </list></exception>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of 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>
public void Calculate(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
ICalculationMessageProvider messageProvider)
{
if (hydraulicBoundaryLocationCalculation == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryLocationCalculation));
}
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
if (messageProvider == null)
{
throw new ArgumentNullException(nameof(messageProvider));
}
HydraulicBoundaryLocation hydraulicBoundaryLocation = hydraulicBoundaryLocationCalculation.HydraulicBoundaryLocation;
CalculationServiceHelper.LogCalculationBegin();
HydraRingCalculationSettings hydraRingCalculationSettings = HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings);
calculator = HydraRingCalculatorFactory.Instance.CreateDesignWaterLevelCalculator(hydraRingCalculationSettings);
var exceptionThrown = false;
try
{
PerformCalculation(hydraulicBoundaryLocationCalculation,
calculationSettings,
targetProbability,
messageProvider);
}
catch (HydraRingCalculationException)
{
if (!canceled)
{
string lastErrorContent = calculator.LastErrorFileContent;
log.Error(string.IsNullOrEmpty(lastErrorContent)
? messageProvider.GetCalculationFailedMessage(hydraulicBoundaryLocation.Name)
: messageProvider.GetCalculationFailedWithErrorReportMessage(hydraulicBoundaryLocation.Name, lastErrorContent));
exceptionThrown = true;
throw;
}
}
finally
{
string lastErrorFileContent = calculator.LastErrorFileContent;
bool errorOccurred = CalculationServiceHelper.HasErrorOccurred(canceled, exceptionThrown, lastErrorFileContent);
if (errorOccurred)
{
log.Error(messageProvider.GetCalculationFailedWithErrorReportMessage(hydraulicBoundaryLocation.Name, lastErrorFileContent));
}
log.InfoFormat(Resources.DesignWaterLevelCalculationService_Calculate_Calculation_temporary_directory_can_be_found_on_location_0, calculator.OutputDirectory);
CalculationServiceHelper.LogCalculationEnd();
if (errorOccurred)
{
throw new HydraRingCalculationException(lastErrorFileContent);
}
}
}
