private EInterpretationCategory AssembleInterpretationCategory(FailureMechanismSectionAssemblyInput input, IAssessmentResultsTranslator kernel, Probability probability)
{
ICategoryLimitsCalculator assemblyGroupsKernel = factory.CreateAssemblyGroupsKernel();
CategoriesList <InterpretationCategory> interpretationCategories = assemblyGroupsKernel.CalculateInterpretationCategoryLimitsBoi01(
new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(input.SignalFloodingProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.MaximumAllowableFloodingProbability)));
return(kernel.DetermineInterpretationCategoryFromFailureMechanismSectionProbabilityBoi0B1(
probability, interpretationCategories));
}
private static bool IsProbabilityDefined(FailureMechanismSectionAssemblyInput input)
{
if (!input.IsRelevant)
{
return(false);
}
return(input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.NotNecessary &&
input.HasProbabilitySpecified ||
input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.Executed);
}
public FailureMechanismSectionAssemblyResultWrapper AssembleFailureMechanismSection(FailureMechanismSectionAssemblyInput input)
{
if (ThrowExceptionOnCalculate)
{
throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception());
}
FailureMechanismSectionAssemblyInput = input;
return(FailureMechanismSectionAssemblyResultOutput ??
(FailureMechanismSectionAssemblyResultOutput =
new FailureMechanismSectionAssemblyResultWrapper(
new FailureMechanismSectionAssemblyResult(0.01, 0.1, 10, FailureMechanismSectionAssemblyGroup.I),
AssemblyMethod.BOI0A1, AssemblyMethod.BOI0B1)));
}
/// <summary>
/// Performs the assembly based on the <see cref="FailureMechanismSectionAssemblyInput"/>.
/// </summary>
/// <param name="input">The input to use in the assembly.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
/// <exception cref="AssemblyException">Thrown when the section could not be successfully assembled.</exception>
private static FailureMechanismSectionAssemblyResultWrapper PerformAssembly(FailureMechanismSectionAssemblyInput input)
{
IFailureMechanismSectionAssemblyCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateFailureMechanismSectionAssemblyCalculator(
AssemblyToolKernelFactory.Instance);
try
{
return(input is FailureMechanismSectionWithProfileProbabilityAssemblyInput probabilityAssemblyInput
? calculator.AssembleFailureMechanismSection(probabilityAssemblyInput)
: calculator.AssembleFailureMechanismSection(input));
}
catch (FailureMechanismSectionAssemblyCalculatorException e)
{
throw new AssemblyException(e.Message, e);
}
}
public void AssembleSectionAdoptableSectionWithoutProfileProbability_WithInput_ReturnsExpectedOutput(
AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified)
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
double manualSectionProbability = random.NextDouble();
double calculatedSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedSectionProbability = refinedSectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, () => calculatedSectionProbability);
// Assert
FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(isRelevant, calculatorInput.IsRelevant);
Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified);
double expectedInitialSectionProbability = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType)
? calculatedSectionProbability
: manualSectionProbability;
Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
private static EAnalysisState GetAnalysisStatus(FailureMechanismSectionAssemblyInput input)
{
if (!input.IsRelevant)
{
return(EAnalysisState.NotRelevant);
}
if (input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.NotNecessary)
{
return(!input.HasProbabilitySpecified
? EAnalysisState.NoProbabilityEstimationNecessary
: EAnalysisState.ProbabilityEstimated);
}
return(input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.Necessary
? EAnalysisState.ProbabilityEstimationNecessary
: EAnalysisState.ProbabilityEstimated);
}
public void AssembleSection_WithInput_SetsInputOnCalculator()
{
// Setup
var random = new Random(21);
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section)
{
IsRelevant = random.NextBoolean(),
InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual,
ManualInitialFailureMechanismResultProfileProbability = random.NextDouble(),
FurtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(),
ProbabilityRefinementType = ProbabilityRefinementType.Both,
RefinedSectionProbability = random.NextDouble()
};
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, assessmentSection);
// Assert
FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(sectionResult.IsRelevant, calculatorInput.IsRelevant);
Assert.IsTrue(calculatorInput.HasProbabilitySpecified);
Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(sectionResult.FurtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(sectionResult.RefinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
/// <summary>
/// Assembles a failure mechanism section result based on the input arguments.
/// </summary>
/// <param name="sectionResult">The section result to assemble for.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> to assemble with.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when the section could not be successfully assembled.</exception>
public static FailureMechanismSectionAssemblyResultWrapper AssembleSection(
NonAdoptableFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
FailureMechanismSectionAssemblyInput input = CreateInput(
assessmentSection, sectionResult.IsRelevant, sectionResult.ManualInitialFailureMechanismResultSectionProbability,
sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified);
return(PerformAssembly(input));
}
public void AssembleFailureMechanismSection_InputWithProbabilityDefinedKernelWithCompleteOutput_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
var input = new FailureMechanismSectionAssemblyInput(
0.001, 0.0001, true, true, random.NextDouble(),
FailureMechanismSectionResultFurtherAnalysisType.Executed, random.NextDouble());
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
categoryLimitsKernel.InterpretationCategoryLimits = CreateInterpretationCategories();
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
var categoryOutput = random.NextEnumValue <EInterpretationCategory>();
var sectionProbability = new Probability(random.NextDouble(0.0, 0.01));
failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput;
failureMechanismSectionAssemblyKernel.SectionProbability = sectionProbability;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
FailureMechanismSectionAssemblyResultWrapper resultWrapper = calculator.AssembleFailureMechanismSection(input);
// Assert
Assert.IsTrue(categoryLimitsKernel.Calculated);
Assert.IsTrue(failureMechanismSectionAssemblyKernel.Calculated);
FailureMechanismSectionAssemblyResult result = resultWrapper.AssemblyResult;
Assert.AreEqual(sectionProbability, result.ProfileProbability);
Assert.AreEqual(sectionProbability, result.SectionProbability);
Assert.AreEqual(1.0, result.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(categoryOutput),
result.FailureMechanismSectionAssemblyGroup);
Assert.AreEqual(AssemblyMethod.BOI0A1, resultWrapper.ProbabilityMethod);
Assert.AreEqual(AssemblyMethod.BOI0B1, resultWrapper.AssemblyGroupMethod);
}
}
public void AssembleFailureMechanismSection_WithValidInputAndNoProbabilityDefined_InputCorrectlySentToKernel(
FailureMechanismSectionAssemblyInput input, EAnalysisState expectedAnalysisState)
{
// Setup
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
var random = new Random(21);
var categoryOutput = random.NextEnumValue <EInterpretationCategory>();
failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput;
failureMechanismSectionAssemblyKernel.SectionProbability = new Probability(random.NextDouble());
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
calculator.AssembleFailureMechanismSection(input);
// Assert
Assert.AreEqual(expectedAnalysisState, failureMechanismSectionAssemblyKernel.AnalysisState);
Assert.AreEqual(categoryOutput, failureMechanismSectionAssemblyKernel.CategoryInput);
}
}
public void AssembleFailureMechanismSection_KernelThrowsException_ThrowsFailureMechanismSectionAssemblyCalculatorException()
{
// Setup
FailureMechanismSectionAssemblyInput input = CreateFailureMechanismSectionAssemblyInput();
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
failureMechanismSectionAssemblyKernel.ThrowExceptionOnCalculate = true;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
void Call() => calculator.AssembleFailureMechanismSection(input);
// Assert
var exception = Assert.Throws <FailureMechanismSectionAssemblyCalculatorException>(Call);
Assert.IsInstanceOf <Exception>(exception.InnerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message);
Assert.IsFalse(failureMechanismSectionAssemblyKernel.Calculated);
}
}
public FailureMechanismSectionAssemblyResultWrapper AssembleFailureMechanismSection(FailureMechanismSectionAssemblyInput input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
try
{
IAssessmentResultsTranslator kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
if (!IsProbabilityDefined(input))
{
return(AssembleWithUndefinedProbabilities(input, kernel));
}
Probability sectionProbability = kernel.DetermineRepresentativeProbabilityBoi0A1(
input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary,
AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability));
EInterpretationCategory interpretationCategory = AssembleInterpretationCategory(input, kernel, sectionProbability);
return(new FailureMechanismSectionAssemblyResultWrapper(
FailureMechanismSectionAssemblyResultCreator.Create(sectionProbability, interpretationCategory),
AssemblyMethod.BOI0A1, AssemblyMethod.BOI0B1));
}
catch (AssemblyException e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e);
}
catch (Exception e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e);
}
}
private static FailureMechanismSectionAssemblyResultWrapper AssembleWithUndefinedProbabilities(FailureMechanismSectionAssemblyInput input, IAssessmentResultsTranslator kernel)
{
EInterpretationCategory interpretationCategory = kernel.DetermineInterpretationCategoryWithoutProbabilityEstimationBoi0C1(GetAnalysisStatus(input));
Probability sectionProbability = kernel.TranslateInterpretationCategoryToProbabilityBoi0C2(interpretationCategory);
return(new FailureMechanismSectionAssemblyResultWrapper(
FailureMechanismSectionAssemblyResultCreator.Create(sectionProbability, interpretationCategory),
AssemblyMethod.BOI0C2, AssemblyMethod.BOI0C1));
}