private static IUpliftVanCalculator GetCalculator(MacroStabilityInwardsCalculation calculation, GeneralMacroStabilityInwardsInput generalInput, RoundedDouble normativeAssessmentLevel)
{
UpliftVanCalculatorInput upliftVanCalculatorInput = CreateInputFromData(calculation.InputParameters, generalInput, normativeAssessmentLevel);
IUpliftVanCalculator calculator = MacroStabilityInwardsCalculatorFactory.Instance.CreateUpliftVanCalculator(upliftVanCalculatorInput, MacroStabilityInwardsKernelWrapperFactory.Instance);
return(calculator);
}
public void CreateUpliftVanCalculator_WithUpliftVanCalculatorInput_ReturnsUpliftVanCalculator()
{
// Setup
IMacroStabilityInwardsCalculatorFactory factory = MacroStabilityInwardsCalculatorFactory.Instance;
using (new MacroStabilityInwardsKernelFactoryConfig())
{
// Call
IUpliftVanCalculator upliftVanCalculator = factory.CreateUpliftVanCalculator(
new UpliftVanCalculatorInput(new UpliftVanCalculatorInput.ConstructionProperties
{
SurfaceLine = new MacroStabilityInwardsSurfaceLine("test"),
SoilProfile = new TestSoilProfile(),
PhreaticLineOffsetsExtreme = new PhreaticLineOffsets(),
PhreaticLineOffsetsDaily = new PhreaticLineOffsets(),
DrainageConstruction = new DrainageConstruction(),
SlipPlane = new UpliftVanSlipPlane()
}),
MacroStabilityInwardsKernelWrapperFactory.Instance);
// Assert
Assert.IsInstanceOf <UpliftVanCalculator>(upliftVanCalculator);
}
}
/// <summary>
/// Performs validation over the values on the given <paramref name="calculation"/>. Error and status information is logged during
/// the execution of the operation.
/// </summary>
/// <param name="calculation">The <see cref="MacroStabilityInwardsCalculation"/> for which to validate the values.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="normativeAssessmentLevel">The normative assessment level to use in case the manual assessment level is not applicable.</param>
/// <returns><c>false</c> if <paramref name="calculation"/> contains validation errors; <c>true</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static bool Validate(MacroStabilityInwardsCalculation calculation, GeneralMacroStabilityInwardsInput generalInput, RoundedDouble normativeAssessmentLevel)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
CalculationServiceHelper.LogValidationBegin();
string[] inputValidationResults = MacroStabilityInwardsInputValidator.Validate(calculation.InputParameters, normativeAssessmentLevel).ToArray();
if (inputValidationResults.Length > 0)
{
CalculationServiceHelper.LogMessagesAsError(inputValidationResults);
CalculationServiceHelper.LogValidationEnd();
return(false);
}
IEnumerable <MacroStabilityInwardsKernelMessage> waternetExtremeKernelMessages;
IEnumerable <MacroStabilityInwardsKernelMessage> waternetDailyKernelMessages;
try
{
waternetExtremeKernelMessages = ValidateWaternet(() => WaternetCalculationService.ValidateExtreme(
calculation.InputParameters, generalInput, GetEffectiveAssessmentLevel(calculation.InputParameters, normativeAssessmentLevel)),
Resources.MacroStabilityInwardsCalculationService_Validate_Waternet_extreme_validation_started);
waternetDailyKernelMessages = ValidateWaternet(() => WaternetCalculationService.ValidateDaily(calculation.InputParameters, generalInput),
Resources.MacroStabilityInwardsCalculationService_Validate_Waternet_daily_validation_started);
}
catch (WaternetCalculationException e)
{
HandleExceptionOnValidation(e);
return(false);
}
IEnumerable <MacroStabilityInwardsKernelMessage> kernelMessages = Enumerable.Empty <MacroStabilityInwardsKernelMessage>();
if (!waternetExtremeKernelMessages.Any() && !waternetDailyKernelMessages.Any())
{
IUpliftVanCalculator calculator = GetCalculator(calculation, generalInput, normativeAssessmentLevel);
try
{
kernelMessages = calculator.Validate().ToArray();
}
catch (UpliftVanCalculatorException e)
{
HandleExceptionOnValidation(e);
return(false);
}
LogKernelMessages(kernelMessages);
}
CalculationServiceHelper.LogValidationEnd();
return(kernelMessages.Concat(waternetDailyKernelMessages)
.Concat(waternetExtremeKernelMessages)
.All(r => r.Type != MacroStabilityInwardsKernelMessageType.Error));
}
/// <summary>
/// Performs a macro stability inwards calculation based on the supplied <see cref="MacroStabilityInwardsCalculation"/>
/// and sets <see cref="MacroStabilityInwardsCalculation.Output"/> based on the result if the calculation was successful.
/// Error and status information is logged during the execution of the operation.
/// </summary>
/// <param name="calculation">The <see cref="MacroStabilityInwardsCalculation"/> to base the input for the calculation upon.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="normativeAssessmentLevel">The normative assessment level to use in case the manual assessment level is not applicable.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="UpliftVanCalculatorException">Thrown when an error (both expected or unexpected) occurred during the calculation.</exception>
/// <remarks>Consider calling <see cref="Validate"/> first to see if calculation is possible.</remarks>
public static void Calculate(MacroStabilityInwardsCalculation calculation, GeneralMacroStabilityInwardsInput generalInput, RoundedDouble normativeAssessmentLevel)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
UpliftVanCalculatorResult macroStabilityInwardsResult;
CalculationServiceHelper.LogCalculationBegin();
try
{
IUpliftVanCalculator calculator = GetCalculator(calculation, generalInput, normativeAssessmentLevel);
macroStabilityInwardsResult = calculator.Calculate();
}
catch (UpliftVanCalculatorException e)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(Resources.MacroStabilityInwardsCalculationService_Calculate_Kernel_provides_messages);
foreach (MacroStabilityInwardsKernelMessage kernelMessage in e.KernelMessages)
{
stringBuilder.AppendLine(string.Format(Resources.MacroStabilityInwardsCalculationService_Calculate_LogMessageType_0_LogMessage_1, kernelMessage.Type, kernelMessage.Message));
}
CalculationServiceHelper.LogExceptionAsError($"{RiskeerCommonServiceResources.CalculationService_Calculate_unexpected_error} {stringBuilder}", e);
CalculationServiceHelper.LogCalculationEnd();
throw;
}
if (macroStabilityInwardsResult.CalculationMessages.Any(cm => cm.Type == MacroStabilityInwardsKernelMessageType.Error))
{
CalculationServiceHelper.LogMessagesAsError(new[]
{
CreateAggregatedLogMessage(Resources.MacroStabilityInwardsCalculationService_Calculate_Errors_in_MacroStabilityInwards_calculation, macroStabilityInwardsResult)
});
CalculationServiceHelper.LogCalculationEnd();
throw new UpliftVanCalculatorException();
}
if (macroStabilityInwardsResult.CalculationMessages.Any())
{
CalculationServiceHelper.LogMessagesAsWarning(new[]
{
CreateAggregatedLogMessage(Resources.MacroStabilityInwardsCalculationService_Calculate_Warnings_in_MacroStabilityInwards_calculation, macroStabilityInwardsResult)
});
}
calculation.Output = new MacroStabilityInwardsOutput(
MacroStabilityInwardsSlidingCurveConverter.Convert(macroStabilityInwardsResult.SlidingCurveResult),
MacroStabilityInwardsSlipPlaneUpliftVanConverter.Convert(macroStabilityInwardsResult.CalculationGridResult),
new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = macroStabilityInwardsResult.FactorOfStability,
ForbiddenZonesXEntryMin = macroStabilityInwardsResult.ForbiddenZonesXEntryMin,
ForbiddenZonesXEntryMax = macroStabilityInwardsResult.ForbiddenZonesXEntryMax
});
CalculationServiceHelper.LogCalculationEnd();
}
