/// <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>
/// Create a new instance of <see cref="WaveHeightCalculator"/>.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/>
/// is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory"/>
/// equals <see cref="string.Empty"/>.</remarks>
internal WaveHeightCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
targetProbabilityParser = new ReliabilityIndexCalculationParser();
convergenceParser = new ConvergenceParser();
WaveHeight = double.NaN;
ReliabilityIndex = double.NaN;
}
/// <summary>
/// Create a new instance of <see cref="HydraulicLoadsCalculator"/>.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/>
/// is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory"/>
/// equals <see cref="string.Empty"/>.</remarks>
internal HydraulicLoadsCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
targetProbabilityParser = new ReliabilityIndexCalculationParser();
convergenceParser = new ConvergenceParser();
Value = double.NaN;
ReliabilityIndex = double.NaN;
}
/// <summary>
/// Create a new instance of <see cref="DesignWaterLevelCalculator"/>.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/>
/// is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory" />
/// equals <see cref="string.Empty"/>.</remarks>
internal DesignWaterLevelCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
targetProbabilityParser = new ReliabilityIndexCalculationParser();
convergenceParser = new ConvergenceParser();
DesignWaterLevel = double.NaN;
ReliabilityIndex = double.NaN;
}
/// <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;
}
}
/// <summary>
/// Create a new instance of <see cref="OvertoppingCalculator"/>.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/>
/// is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory"/>
/// equals <see cref="string.Empty"/>.</remarks>
internal OvertoppingCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
waveHeightParser = new OvertoppingCalculationWaveHeightParser();
ExceedanceProbabilityBeta = double.NaN;
WaveHeight = double.NaN;
IsOvertoppingDominant = false;
}
public void CreateWaveHeightCalculator_Always_ReturnsWaveHeightCalculator()
{
// Setup
HydraRingCalculationSettings settings = HydraRingCalculationSettingsTestFactory.CreateSettings();
// Call
IWaveHeightCalculator calculator = HydraRingCalculatorFactory.Instance.CreateWaveHeightCalculator(settings);
// Assert
Assert.IsInstanceOf <WaveHeightCalculator>(calculator);
}
public void CreateOvertoppingRateCalculator_Always_ReturnsHydraulicLoadsCalculator()
{
// Setup
HydraRingCalculationSettings settings = HydraRingCalculationSettingsTestFactory.CreateSettings();
// Call
IHydraulicLoadsCalculator calculator = HydraRingCalculatorFactory.Instance.CreateOvertoppingRateCalculator(settings);
// Assert
Assert.IsInstanceOf <HydraulicLoadsCalculator>(calculator);
}
public void CreateDesignWaterLevelCalculator_Always_ReturnsDesignWaterLevelCalculator()
{
// Setup
HydraRingCalculationSettings settings = HydraRingCalculationSettingsTestFactory.CreateSettings();
// Call
IDesignWaterLevelCalculator calculator = HydraRingCalculatorFactory.Instance.CreateDesignWaterLevelCalculator(settings);
// Assert
Assert.IsInstanceOf <DesignWaterLevelCalculator>(calculator);
}
public void CreateStructuresCalculator_Always_ReturnsStructuresCalculator()
{
// Setup
HydraRingCalculationSettings settings = HydraRingCalculationSettingsTestFactory.CreateSettings();
// Call
IStructuresCalculator <ExceedanceProbabilityCalculationInput> calculator = HydraRingCalculatorFactory.Instance.CreateStructuresCalculator <ExceedanceProbabilityCalculationInput>(settings);
// Assert
Assert.IsInstanceOf <StructuresCalculator <ExceedanceProbabilityCalculationInput> >(calculator);
}
public void CreateDunesBoundaryConditionsCalculator_Always_ReturnsDunesBoundaryConditionsCalculator()
{
// Setup
HydraRingCalculationSettings settings = HydraRingCalculationSettingsTestFactory.CreateSettings();
// Call
IDunesBoundaryConditionsCalculator calculator = HydraRingCalculatorFactory.Instance.CreateDunesBoundaryConditionsCalculator(settings);
// Assert
Assert.IsInstanceOf <DunesBoundaryConditionsCalculator>(calculator);
}
/// <summary>
/// Create a new instance of <see cref="DesignWaterLevelCalculator"/>.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/>
/// is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory"/>
/// equals <see cref="string.Empty"/>.</remarks>
internal DunesBoundaryConditionsCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
dunesBoundaryParser = new DunesBoundaryConditionsCalculationParser();
targetProbabilityParser = new ReliabilityIndexCalculationParser();
convergenceParser = new ConvergenceParser();
WaterLevel = double.NaN;
WaveHeight = double.NaN;
WavePeriod = double.NaN;
ReliabilityIndex = double.NaN;
}
/// <summary>
/// Create a new instance of <see cref="WaveConditionsCosineCalculator"/>.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/>
/// is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory" />
/// equals <see cref="string.Empty"/>.</remarks>
internal WaveConditionsCosineCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
waveConditionsCalculationParser = new WaveConditionsCalculationParser();
reliabilityIndexCalculationParser = new ReliabilityIndexCalculationParser();
convergenceParser = new ConvergenceParser();
WaveHeight = double.NaN;
WaveAngle = double.NaN;
WavePeakPeriod = double.NaN;
WaveDirection = double.NaN;
ReliabilityIndex = double.NaN;
}
/// <summary>
/// Creates a new instance of <see cref="HydraRingCalculatorBase"/> with a default Hydra-Ring file parser
/// initialized.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/> is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory"/>
/// equals <see cref="string.Empty"/>.</remarks>
protected HydraRingCalculatorBase(HydraRingCalculationSettings calculationSettings)
{
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
this.calculationSettings = calculationSettings;
lastErrorFileParser = new LastErrorFileParser();
illustrationPointsParser = new IllustrationPointsParser();
}
public void GenerateInitializationScript_ReturnsExpectedInitializationScript(
[Values("", "D:\\preprocessor")] string preprocessorDirectory,
[Values(true, false)] bool usePreprocessorClosure)
{
// Setup
const string hlcdFilePath = "D:\\hlcd\\HlcdFile.sqlite";
var settings = new HydraRingCalculationSettings(hlcdFilePath, preprocessorDirectory, usePreprocessorClosure);
var hydraRingInitializationService = new HydraRingInitializationService(HydraRingFailureMechanismType.StructuresStructuralFailure,
700001,
TestHelper.GetScratchPadPath(),
settings);
string expectedInitializationScript = "section = 700001" + Environment.NewLine +
"mechanism = 112" + Environment.NewLine +
"alternative = 1" + Environment.NewLine +
"layer = 1" + Environment.NewLine +
"logfile = 700001.log" + Environment.NewLine +
"outputverbosity = basic" + Environment.NewLine +
"outputtofile = file" + Environment.NewLine +
"projectdbfilename = 700001.sql" + Environment.NewLine +
"outputfilename = designTable.txt" + Environment.NewLine +
"configdbfilename = " + Path.Combine(hydraRingDirectory, "config.sqlite") + Environment.NewLine +
"hydraulicdbfilename = " + hlcdFilePath + Environment.NewLine +
"designpointOutput = sqlite";
if (preprocessorDirectory != string.Empty)
{
expectedInitializationScript += Environment.NewLine + "preprocessordbdirectory = " + preprocessorDirectory;
}
if (usePreprocessorClosure)
{
expectedInitializationScript += Environment.NewLine + "preprocessorclosingdbfilename = D:\\hlcd\\HlcdFile_preprocClosure.sqlite";
}
try
{
// Call
hydraRingInitializationService.WriteInitializationScript();
// Assert
string initializationScript = File.ReadAllText(hydraRingInitializationService.IniFilePath);
Assert.AreEqual(expectedInitializationScript, initializationScript);
}
finally
{
File.Delete(hydraRingInitializationService.IniFilePath);
}
}
public void Calculate_LastErrorFilePresent_LastErrorFileContentSet()
{
// Setup
var settings = new HydraRingCalculationSettings("D:\\HLCD.sqlite", string.Empty, false);
var calculator = new TestHydraRingCalculator(settings, new TestParser());
// Call
calculator.PublicCalculate(new TestHydraRingCalculationInput());
// Assert
var expectedContent = $"Hydraulic database {settings.HlcdFilePath} not found.\r\n";
Assert.AreEqual(expectedContent, calculator.LastErrorFileContent);
}
public void Constructor_WithArguments_ExpectedValues()
{
// Setup
const string hlcdFilePath = "hlcdFilePath";
const string preProcessorDirectory = "PreprocessorDirectory";
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
var settings = new HydraRingCalculationSettings(hlcdFilePath, preProcessorDirectory, usePreprocessorClosure);
// Assert
Assert.AreEqual(hlcdFilePath, settings.HlcdFilePath);
Assert.AreEqual(preProcessorDirectory, settings.PreprocessorDirectory);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
}
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);
}
public void ParameteredConstructor_ExpectedValues()
{
// Setup
var settings = new HydraRingCalculationSettings("D:\\hlcd\\hlcdFilePath", "D:\\preprocessor", false);
// Call
var hydraRingInitializationService = new HydraRingInitializationService(HydraRingFailureMechanismType.AssessmentLevel,
700001,
"D:\\work",
settings);
// Assert
Assert.AreEqual("D:\\work\\700001.ini", hydraRingInitializationService.IniFilePath);
Assert.AreEqual("D:\\work\\700001.sql", hydraRingInitializationService.DatabaseCreationScriptFilePath);
Assert.AreEqual(Path.Combine(hydraRingDirectory, "MechanismComputation.exe"), hydraRingInitializationService.MechanismComputationExeFilePath);
Assert.AreEqual("D:\\work", hydraRingInitializationService.TemporaryWorkingDirectory);
}
public void Calculate_NoPreprocessorDirectoryWhenRequired_ThrowsInvalidOperationException()
{
// Setup
var parser = new TestParser();
var settings = new HydraRingCalculationSettings("D:\\hlcd.sqlite", string.Empty, false);
var calculator = new TestHydraRingCalculator(settings, parser);
var hydraRingCalculationInput = new TestHydraRingCalculationInput
{
PreprocessorSetting = new PreprocessorSetting(1, 2, new NumericsSetting(1, 4, 50, 0.15, 0.05, 0.01, 0.01, 0, 2, 20000, 100000, 0.1, -6, 6))
};
// Call
void Call() => calculator.PublicCalculate(hydraRingCalculationInput);
// Assert
string message = Assert.Throws <InvalidOperationException>(Call).Message;
Assert.AreEqual("Preprocessor directory required but not specified.", message);
}
/// <summary>
/// Creates a new instance of the <see cref="HydraRingInitializationService"/> class.
/// </summary>
/// <param name="failureMechanismType">The failure mechanism type.</param>
/// <param name="sectionId">The section id.</param>
/// <param name="temporaryWorkingDirectory">The working directory.</param>
/// <param name="settings">The <see cref="HydraRingCalculationSettings"/>
/// which holds all the general information to start a Hydra-Ring calculation.</param>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory"/>
/// matches <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="settings"/> is <c>null</c>.</exception>
public HydraRingInitializationService(HydraRingFailureMechanismType failureMechanismType,
int sectionId,
string temporaryWorkingDirectory,
HydraRingCalculationSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
mechanismId = new FailureMechanismDefaultsProvider().GetFailureMechanismDefaults(failureMechanismType).MechanismId;
this.sectionId = sectionId;
TemporaryWorkingDirectory = temporaryWorkingDirectory;
hlcdFilePath = settings.HlcdFilePath;
string applicationFolder = AssemblyHelper.GetApplicationDirectory();
hydraRingDirectory = Path.Combine(applicationFolder, "Standalone", "Deltares", $"{hydraRingBinariesSubDirectory}-{HydraRingFileConstants.HydraRingVersionNumber}");
configurationDatabaseFilePath = Path.Combine(hydraRingDirectory, HydraRingFileConstants.ConfigurationDatabaseFileName);
preprocessorDirectory = settings.PreprocessorDirectory;
usePreprocessorClosure = settings.UsePreprocessorClosure;
}
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);
}
/// <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);
}
}
}
public IStructuresCalculator <TCalculationInput> CreateStructuresCalculator <TCalculationInput>(HydraRingCalculationSettings calculationSettings)
where TCalculationInput : ExceedanceProbabilityCalculationInput
{
return(new StructuresCalculator <TCalculationInput>(calculationSettings));
}
public IPipingCalculator CreatePipingCalculator(HydraRingCalculationSettings calculationSettings)
{
return(new PipingCalculator(calculationSettings));
}
/// <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);
}
/// <summary>
/// Create a new instance of <see cref="PipingCalculator"/>.
/// </summary>
/// <param name="calculationSettings">The <see cref="HydraRingCalculationSettings"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationSettings"/>
/// is <c>null</c>.</exception>
/// <remarks>Preprocessing is disabled when <see cref="HydraRingCalculationSettings.PreprocessorDirectory"/>
/// equals <see cref="string.Empty"/>.</remarks>
internal PipingCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
ExceedanceProbabilityBeta = double.NaN;
}
public TestHydraRingCalculator(HydraRingCalculationSettings calculationSettings, IHydraRingFileParser parser) : base(calculationSettings)
{
this.parser = parser;
}
public TestHydraRingCalculator(HydraRingCalculationSettings calculationSettings) : base(calculationSettings)
{
}
/// <summary>
/// Performs the provided <see cref="DuneLocationCalculation"/> and sets its output if the calculation is successful.
/// Error and status information is logged during the execution of the operation.
/// </summary>
/// <param name="duneLocationCalculation">The <see cref="DuneLocationCalculation"/> to perform.</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>
/// <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="duneLocationCalculation"/>,
/// <paramref name="calculationSettings"/> or <paramref name="messageProvider"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when:
/// <list type="bullet">
/// <item>The hydraulic boundary location database file path contains invalid characters.</item>
/// <item>The contribution of the failure mechanism is zero.</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 the hydraulic boundary database
/// 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(DuneLocationCalculation duneLocationCalculation,
double targetProbability,
HydraulicBoundaryCalculationSettings calculationSettings,
ICalculationMessageProvider messageProvider)
{
if (duneLocationCalculation == null)
{
throw new ArgumentNullException(nameof(duneLocationCalculation));
}
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
if (messageProvider == null)
{
throw new ArgumentNullException(nameof(messageProvider));
}
DuneLocation duneLocation = duneLocationCalculation.DuneLocation;
string duneLocationName = duneLocation.Name;
CalculationServiceHelper.LogCalculationBegin();
HydraRingCalculationSettings hydraRingCalculationSettings = HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings);
calculator = HydraRingCalculatorFactory.Instance.CreateDunesBoundaryConditionsCalculator(hydraRingCalculationSettings);
var exceptionThrown = false;
try
{
DunesBoundaryConditionsCalculationInput calculationInput = CreateInput(duneLocation,
targetProbability,
calculationSettings);
calculator.Calculate(calculationInput);
if (string.IsNullOrEmpty(calculator.LastErrorFileContent))
{
duneLocationCalculation.Output = CreateDuneLocationCalculationOutput(duneLocationName,
calculationInput.Beta,
targetProbability,
messageProvider);
}
}
catch (HydraRingCalculationException)
{
if (!canceled)
{
string lastErrorContent = calculator.LastErrorFileContent;
log.Error(string.IsNullOrEmpty(lastErrorContent)
? messageProvider.GetCalculationFailedMessage(duneLocationName)
: messageProvider.GetCalculationFailedWithErrorReportMessage(duneLocationName, lastErrorContent));
exceptionThrown = true;
throw;
}
}
finally
{
string lastErrorFileContent = calculator.LastErrorFileContent;
bool hasErrorOccurred = CalculationServiceHelper.HasErrorOccurred(canceled, exceptionThrown, lastErrorFileContent);
if (hasErrorOccurred)
{
log.Error(messageProvider.GetCalculationFailedWithErrorReportMessage(duneLocationName, lastErrorFileContent));
}
log.InfoFormat(Resources.DuneLocationCalculationService_Calculate_Calculation_temporary_directory_can_be_found_on_location_0,
calculator.OutputDirectory);
CalculationServiceHelper.LogCalculationEnd();
if (hasErrorOccurred)
{
throw new HydraRingCalculationException(lastErrorFileContent);
}
}
}