public void CreateForResultWithProfileAndSectionProbabilities_WithValidResult_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
double profileProbability = random.NextDouble(0.0001, 0.001);
double sectionProbability = random.NextDouble(0.0, 0.01);
EInterpretationCategory category = random.NextEnumValue(new[]
{
EInterpretationCategory.III,
EInterpretationCategory.II,
EInterpretationCategory.I,
EInterpretationCategory.Zero,
EInterpretationCategory.IMin,
EInterpretationCategory.IIMin,
EInterpretationCategory.IIIMin
});
var result = new ResultWithProfileAndSectionProbabilities(
new Probability(profileProbability), new Probability(sectionProbability));
// Call
FailureMechanismSectionAssemblyResult createdAssemblyResult = FailureMechanismSectionAssemblyResultCreator.Create(result, category);
// Assert
Assert.AreEqual(profileProbability, createdAssemblyResult.ProfileProbability);
Assert.AreEqual(sectionProbability, createdAssemblyResult.SectionProbability);
Assert.AreEqual(result.LengthEffectFactor, createdAssemblyResult.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(category),
createdAssemblyResult.FailureMechanismSectionAssemblyGroup);
}
/// <summary>
/// Converts a <see cref="ResultWithProfileAndSectionProbabilities"/> combined with a <see cref="EInterpretationCategory"/>
/// into a <see cref="FailureMechanismSectionAssemblyResult"/>.
/// </summary>
/// <param name="result">The <see cref="ResultWithProfileAndSectionProbabilities"/> to convert.</param>
/// <param name="category">The <see cref="EInterpretationCategory"/> to convert.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResult"/> based on <paramref name="result"/>
/// and <paramref name="category"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="category"/>
/// is an invalid value.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="category"/>
/// is a valid value, but unsupported.</exception>
public static FailureMechanismSectionAssemblyResult Create(ResultWithProfileAndSectionProbabilities result,
EInterpretationCategory category)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
return(new FailureMechanismSectionAssemblyResult(
result.ProbabilityProfile, result.ProbabilitySection, result.LengthEffectFactor,
FailureMechanismSectionAssemblyGroupConverter.ConvertTo(category)));
}
public void CreateResultWithProfileAndSectionProbabilities_WithValidResult_ReturnsExpectedFailureMechanismSectionAssemblyResult()
{
// Setup
var random = new Random(21);
var result = new FailureMechanismSectionAssemblyResult(
random.NextDouble(0.001, 0.01), random.NextDouble(0.01, 0.1), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
// Call
ResultWithProfileAndSectionProbabilities createdResult = FailureMechanismAssemblyCalculatorInputCreator.CreateResultWithProfileAndSectionProbabilities(result);
// Assert
ProbabilityAssert.AreEqual(result.ProfileProbability, createdResult.ProbabilityProfile);
ProbabilityAssert.AreEqual(result.SectionProbability, createdResult.ProbabilitySection);
}
public void AssembleFailureMechanismSectionWithLengthEffect_InputWithProbabilityDefinedKernelWithCompleteOutput_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
var input = new FailureMechanismSectionWithProfileProbabilityAssemblyInput(
0.001, 0.0001, true, true, random.NextDouble(), random.NextDouble(),
FailureMechanismSectionResultFurtherAnalysisType.Executed,
random.NextDouble(), 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 kernelResult = new ResultWithProfileAndSectionProbabilities(
new Probability(random.NextDouble(0.0001, 0.001)),
new Probability(random.NextDouble(0.001, 0.01)));
failureMechanismSectionAssemblyKernel.ProfileAndSectionProbabilities = kernelResult;
failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput;
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((double)kernelResult.ProbabilityProfile, result.ProfileProbability);
Assert.AreEqual((double)kernelResult.ProbabilitySection, result.SectionProbability);
Assert.AreEqual(kernelResult.LengthEffectFactor, result.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(categoryOutput),
result.FailureMechanismSectionAssemblyGroup);
Assert.AreEqual(AssemblyMethod.BOI0A2, resultWrapper.ProbabilityMethod);
Assert.AreEqual(AssemblyMethod.BOI0B1, resultWrapper.AssemblyGroupMethod);
}
}
public FailureMechanismSectionAssemblyResultWrapper AssembleFailureMechanismSection(FailureMechanismSectionWithProfileProbabilityAssemblyInput input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
try
{
IAssessmentResultsTranslator kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
if (!IsProbabilityDefined(input))
{
return(AssembleWithUndefinedProbabilities(input, kernel));
}
ResultWithProfileAndSectionProbabilities output = kernel.DetermineRepresentativeProbabilitiesBoi0A2(
input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary,
AssemblyCalculatorInputCreator.CreateProbability(input.InitialProfileProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.RefinedProfileProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability));
EInterpretationCategory interpretationCategory = AssembleInterpretationCategory(input, kernel, output.ProbabilitySection);
return(new FailureMechanismSectionAssemblyResultWrapper(
FailureMechanismSectionAssemblyResultCreator.Create(output, interpretationCategory),
AssemblyMethod.BOI0A2, AssemblyMethod.BOI0B1));
}
catch (AssemblyException e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e);
}
catch (Exception e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e);
}
}
public void Assemble_WithValidInputAndApplyLengthEffectTrue_SendsCorrectInputToKernel()
{
// Setup
var random = new Random(21);
double failureMechanismN = random.NextDouble();
RiskeerFailureMechanismSectionAssemblyResult[] sectionAssemblyResults =
{
CreateSectionAssemblyResult(random.Next()),
CreateSectionAssemblyResult(random.Next())
};
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel;
kernel.ProbabilityResult = new FailureMechanismAssemblyResult(new Probability(random.NextDouble()), EFailureMechanismAssemblyMethod.Correlated);
var calculator = new FailureMechanismAssemblyCalculator(factory);
// Call
calculator.Assemble(failureMechanismN, sectionAssemblyResults, true);
// Assert
Assert.AreEqual(failureMechanismN, kernel.LenghtEffectFactor);
Assert.IsFalse(kernel.PartialAssembly);
Assert.AreEqual(sectionAssemblyResults.Length, kernel.FailureMechanismSectionAssemblyResults.Count());
for (var i = 0; i < sectionAssemblyResults.Length; i++)
{
RiskeerFailureMechanismSectionAssemblyResult expected = sectionAssemblyResults.ElementAt(i);
ResultWithProfileAndSectionProbabilities actual = kernel.FailureMechanismSectionAssemblyResults.ElementAt(i);
ProbabilityAssert.AreEqual(expected.ProfileProbability, actual.ProbabilityProfile);
ProbabilityAssert.AreEqual(expected.SectionProbability, actual.ProbabilitySection);
}
}
}
