private static bool LogAnyErrors(ProbabilisticPipingCalculation calculation,
PipingFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
string[] messages = ValidateHydraulicBoundaryDatabase(assessmentSection).ToArray();
if (messages.Length == 0)
{
messages = ValidateFailureMechanismHasSections(failureMechanism).ToArray();
}
if (messages.Length == 0)
{
messages = ValidateInput(calculation.InputParameters, failureMechanism.GeneralInput).ToArray();
}
if (messages.Length == 0)
{
messages = ValidateCalculationInMultipleSections(calculation, failureMechanism).ToArray();
}
if (messages.Length > 0)
{
CalculationServiceHelper.LogMessagesAsError(messages);
return(true);
}
return(false);
}
/// <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="ProbabilisticPipingCalculation"/> for which to validate the values.</param>
/// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/> for which to validate the values.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> for which to validate the values.</param>
/// <returns><c>true</c> if <paramref name="calculation"/> has no validation errors; <c>false</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static bool Validate(ProbabilisticPipingCalculation calculation,
PipingFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
CalculationServiceHelper.LogValidationBegin();
LogAnyWarnings(calculation);
bool hasErrors = LogAnyErrors(calculation, failureMechanism, assessmentSection);
CalculationServiceHelper.LogValidationEnd();
return(!hasErrors);
}
public void ShouldCalculate_Always_ReturnsExpectedValue(ProbabilisticPipingCalculation calculation, bool expectedShouldCalculate)
{
// Call
bool shouldCalculate = calculation.ShouldCalculate;
// Assert
Assert.AreEqual(expectedShouldCalculate, shouldCalculate);
}
/// <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 Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
ProbabilisticPipingCalculation original = CreateRandomCalculationWithoutOutput();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
}
private static IEnumerable <string> ValidateCalculationInMultipleSections(ProbabilisticPipingCalculation calculation, PipingFailureMechanism failureMechanism)
{
int numberOfSections = failureMechanism
.Sections
.Count(section => calculation.IsSurfaceLineIntersectionWithReferenceLineInSection(Math2D.ConvertPointsToLineSegments(section.Points)));
if (numberOfSections > 1)
{
yield return(Resources.ProbabilisticPipingCalculationService_ValidateCalculationInMultipleSections_Cannot_determine_section_for_calculation);
}
}
/// <summary>
/// Performs a section specific calculation.
/// </summary>
/// <param name="calculation">The calculation containing the input for the section specific calculation.</param>
/// <param name="generalInput">The general piping calculation input parameters.</param>
/// <param name="sectionLength">The length of the section.</param>
/// <param name="hydraulicBoundaryDatabaseFilePath">The path which points to the hydraulic boundary database file.</param>
/// <param name="usePreprocessor">Indicator whether to use the preprocessor in the calculation.</param>
/// <returns>A <see cref="PartialProbabilisticFaultTreePipingOutput"/>.</returns>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs while performing the calculation.</exception>
private IPartialProbabilisticPipingOutput CalculateSectionSpecific(ProbabilisticPipingCalculation calculation, GeneralPipingInput generalInput,
double sectionLength, string hydraulicBoundaryDatabaseFilePath, bool usePreprocessor)
{
NotifyProgress(string.Format(Resources.ProbabilisticPipingCalculationService_Calculate_Executing_calculation_of_type_0,
Resources.ProbabilisticPipingCalculationService_SectionSpecific),
2, numberOfCalculators);
PipingCalculationInput sectionSpecificCalculationInput = CreateInput(
calculation, generalInput, sectionLength,
hydraulicBoundaryDatabaseFilePath, usePreprocessor);
PerformCalculation(() => sectionSpecificCalculator.Calculate(sectionSpecificCalculationInput),
() => sectionSpecificCalculator.LastErrorFileContent,
() => sectionSpecificCalculator.OutputDirectory,
calculation.Name,
Resources.ProbabilisticPipingCalculationService_SectionSpecific);
LogNormalDistribution thicknessCoverageLayer = DerivedPipingInput.GetThicknessCoverageLayer(calculation.InputParameters);
GeneralResult <TopLevelFaultTreeIllustrationPoint> faultTreeGeneralResult = null;
GeneralResult <TopLevelSubMechanismIllustrationPoint> subMechanismGeneralResult = null;
if (calculation.InputParameters.ShouldSectionSpecificIllustrationPointsBeCalculated)
{
try
{
if (double.IsNaN(thicknessCoverageLayer.Mean))
{
subMechanismGeneralResult = ConvertSubMechanismIllustrationPointsResult(
sectionSpecificCalculator.IllustrationPointsResult,
sectionSpecificCalculator.IllustrationPointsParserErrorMessage);
}
else
{
faultTreeGeneralResult = ConvertFaultTreeIllustrationPointsResult(
sectionSpecificCalculator.IllustrationPointsResult,
sectionSpecificCalculator.IllustrationPointsParserErrorMessage);
}
}
catch (ArgumentException e)
{
log.WarnFormat(Resources.ProbabilisticPipingCalculationService_Calculate_Error_in_reading_illustrationPoints_for_CalculationName_0_CalculationType_1_with_ErrorMessage_2,
calculation.Name, Resources.ProbabilisticPipingCalculationService_SectionSpecific, e.Message);
}
}
return(double.IsNaN(thicknessCoverageLayer.Mean)
? (IPartialProbabilisticPipingOutput) new PartialProbabilisticSubMechanismPipingOutput(
sectionSpecificCalculator.ExceedanceProbabilityBeta,
subMechanismGeneralResult)
: new PartialProbabilisticFaultTreePipingOutput(
sectionSpecificCalculator.ExceedanceProbabilityBeta,
faultTreeGeneralResult));
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
ProbabilisticPipingCalculation original = CreateRandomCalculationWithoutOutput();
original.Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
}
private static void AssertProbabilisticPipingCalculationActivity(Activity activity,
ProbabilisticPipingCalculation calculation,
HydraulicBoundaryLocation hydraulicBoundaryLocation)
{
var profileSpecificCalculator = new TestPipingCalculator();
var sectionSpecificCalculator = new TestPipingCalculator();
var mocks = new MockRepository();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null))
.IgnoreArguments()
.Return(profileSpecificCalculator)
.Repeat.Once();
calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null))
.IgnoreArguments()
.Return(sectionSpecificCalculator)
.Repeat.Once();
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
PipingCalculationInput[] profileSpecificInputs = profileSpecificCalculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, profileSpecificInputs.Length);
Assert.AreEqual(hydraulicBoundaryLocation.Id, profileSpecificInputs[0].HydraulicBoundaryLocationId);
Assert.AreEqual(DerivedPipingInput.GetSeepageLength(calculation.InputParameters).Mean,
profileSpecificInputs[0].Variables.First(v => v.VariableId == 48).Parameter1);
PipingCalculationInput[] sectionSpecificInputs = sectionSpecificCalculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, sectionSpecificInputs.Length);
Assert.AreEqual(hydraulicBoundaryLocation.Id, sectionSpecificInputs[0].HydraulicBoundaryLocationId);
Assert.AreEqual(DerivedPipingInput.GetSeepageLength(calculation.InputParameters).Mean,
sectionSpecificInputs[0].Variables.First(v => v.VariableId == 48).Parameter1);
}
mocks.VerifyAll();
}
/// <summary>
/// Creates a new instance of <see cref="ProbabilisticPipingCalculationActivity"/>.
/// </summary>
/// <param name="calculation">The <see cref="ProbabilisticPipingCalculation"/> to perform.</param>
/// <param name="failureMechanism">The failure mechanism the calculation belongs to.</param>
/// <param name="assessmentSection">The assessment section the calculation belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public ProbabilisticPipingCalculationActivity(ProbabilisticPipingCalculation calculation,
PipingFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(calculation)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
this.calculation = calculation;
this.failureMechanism = failureMechanism;
this.assessmentSection = assessmentSection;
Description = string.Format(RiskeerCommonServiceResources.Perform_calculation_with_name_0_, calculation.Name);
service = new ProbabilisticPipingCalculationService();
service.OnProgressChanged += UpdateProgressText;
}
/// <summary>
/// Creates a <see cref="CalculatableActivity"/> based on the given <paramref name="calculation"/>.
/// </summary>
/// <param name="calculation">The calculation to create an activity for.</param>
/// <param name="failureMechanism">The failure mechanism the <paramref name="calculation"/> belongs to.</param>
/// <param name="assessmentSection">The assessment section the <paramref name="calculation"/> belongs to.</param>
/// <returns>A <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static CalculatableActivity CreateProbabilisticPipingCalculationActivity(ProbabilisticPipingCalculation calculation,
PipingFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(new ProbabilisticPipingCalculationActivity(calculation, failureMechanism, assessmentSection));
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(ProbabilisticPipingCalculation original, ProbabilisticPipingCalculation clone)
{
CommonCloneAssert.AreClones(original, clone);
CoreCloneAssert.AreObjectClones(original.InputParameters, clone.InputParameters, AreClones);
CoreCloneAssert.AreObjectClones(original.Output, clone.Output, AreClones);
}
private static void LogAnyWarnings(ProbabilisticPipingCalculation calculation)
{
CalculationServiceHelper.LogMessagesAsWarning(PipingCalculationValidationHelper.GetValidationWarnings(calculation.InputParameters).ToArray());
}
private static PipingCalculationInput CreateInput(ProbabilisticPipingCalculation calculation, GeneralPipingInput generalInput,
double sectionLength, string hydraulicBoundaryDatabaseFilePath, bool usePreprocessor)
{
ProbabilisticPipingInput pipingInput = calculation.InputParameters;
LogNormalDistribution thicknessCoverageLayer = DerivedPipingInput.GetThicknessCoverageLayer(pipingInput);
VariationCoefficientLogNormalDistribution seepageLength = DerivedPipingInput.GetSeepageLength(pipingInput);
LogNormalDistribution thicknessAquiferLayer = DerivedPipingInput.GetThicknessAquiferLayer(pipingInput);
VariationCoefficientLogNormalDistribution darcyPermeability = DerivedPipingInput.GetDarcyPermeability(pipingInput);
VariationCoefficientLogNormalDistribution diameterD70 = DerivedPipingInput.GetDiameterD70(pipingInput);
PipingCalculationInput input;
if (double.IsNaN(thicknessCoverageLayer.Mean))
{
input = new PipingCalculationInput(
pipingInput.HydraulicBoundaryLocation.Id,
sectionLength,
pipingInput.PhreaticLevelExit.Mean, pipingInput.PhreaticLevelExit.StandardDeviation,
generalInput.WaterVolumetricWeight,
generalInput.UpliftModelFactor.Mean, generalInput.UpliftModelFactor.StandardDeviation,
pipingInput.DampingFactorExit.Mean, pipingInput.DampingFactorExit.StandardDeviation,
seepageLength.Mean, seepageLength.CoefficientOfVariation,
thicknessAquiferLayer.Mean, thicknessAquiferLayer.StandardDeviation,
generalInput.SandParticlesVolumicWeight,
generalInput.SellmeijerModelFactor.Mean, generalInput.SellmeijerModelFactor.StandardDeviation,
generalInput.BeddingAngle,
generalInput.WhitesDragCoefficient,
generalInput.WaterKinematicViscosity,
darcyPermeability.Mean, darcyPermeability.CoefficientOfVariation,
diameterD70.Mean, diameterD70.CoefficientOfVariation,
generalInput.Gravity,
generalInput.CriticalHeaveGradient.Mean, generalInput.CriticalHeaveGradient.StandardDeviation);
}
else
{
LogNormalDistribution effectiveThicknessCoverageLayer = DerivedPipingInput.GetEffectiveThicknessCoverageLayer(pipingInput, generalInput);
LogNormalDistribution saturatedVolumicWeightOfCoverageLayer = DerivedPipingInput.GetSaturatedVolumicWeightOfCoverageLayer(pipingInput);
input = new PipingCalculationInput(
pipingInput.HydraulicBoundaryLocation.Id,
sectionLength,
pipingInput.PhreaticLevelExit.Mean, pipingInput.PhreaticLevelExit.StandardDeviation,
generalInput.WaterVolumetricWeight,
effectiveThicknessCoverageLayer.Mean, effectiveThicknessCoverageLayer.StandardDeviation,
saturatedVolumicWeightOfCoverageLayer.Mean, saturatedVolumicWeightOfCoverageLayer.StandardDeviation,
saturatedVolumicWeightOfCoverageLayer.Shift,
generalInput.UpliftModelFactor.Mean, generalInput.UpliftModelFactor.StandardDeviation,
pipingInput.DampingFactorExit.Mean, pipingInput.DampingFactorExit.StandardDeviation,
seepageLength.Mean, seepageLength.CoefficientOfVariation,
thicknessAquiferLayer.Mean, thicknessAquiferLayer.StandardDeviation,
generalInput.SandParticlesVolumicWeight,
generalInput.SellmeijerModelFactor.Mean, generalInput.SellmeijerModelFactor.StandardDeviation,
generalInput.BeddingAngle,
generalInput.WhitesDragCoefficient,
generalInput.WaterKinematicViscosity,
darcyPermeability.Mean, darcyPermeability.CoefficientOfVariation,
diameterD70.Mean, diameterD70.CoefficientOfVariation,
generalInput.Gravity,
generalInput.CriticalHeaveGradient.Mean, generalInput.CriticalHeaveGradient.StandardDeviation);
}
HydraRingSettingsDatabaseHelper.AssignSettingsFromDatabase(input, hydraulicBoundaryDatabaseFilePath, usePreprocessor);
return(input);
}
