public void AssembleFailureMechanismSection_WithValidInputAndProbabilityDefined_InputCorrectlySentToKernel(
FailureMechanismSectionAssemblyInput input)
{
// Setup
var random = new Random(21);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
CategoriesList <InterpretationCategory> interpretationCategories = CreateInterpretationCategories();
categoryLimitsKernel.InterpretationCategoryLimits = interpretationCategories;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
var sectionProbability = new Probability(random.NextDouble(0.0, 0.01));
failureMechanismSectionAssemblyKernel.SectionProbability = sectionProbability;
failureMechanismSectionAssemblyKernel.CategoryOutput = EInterpretationCategory.Zero;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
calculator.AssembleFailureMechanismSection(input);
// Assert
AssessmentSection assessmentSection = categoryLimitsKernel.AssessmentSection;
ProbabilityAssert.AreEqual(input.MaximumAllowableFloodingProbability, assessmentSection.MaximumAllowableFloodingProbability);
ProbabilityAssert.AreEqual(input.SignalFloodingProbability, assessmentSection.SignalFloodingProbability);
Assert.AreSame(interpretationCategories, failureMechanismSectionAssemblyKernel.Categories);
Assert.AreEqual(input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, failureMechanismSectionAssemblyKernel.RefinementNecessary);
Assert.AreEqual(input.InitialSectionProbability, failureMechanismSectionAssemblyKernel.ProbabilityInitialMechanismSection);
Assert.AreEqual(input.RefinedSectionProbability, failureMechanismSectionAssemblyKernel.RefinedProbabilitySection);
Assert.AreEqual(sectionProbability, failureMechanismSectionAssemblyKernel.SectionProbabilityInput);
}
}
public void AssembleAssessmentSection_WithValidInput_InputCorrectlySetToKernel()
{
// Setup
var random = new Random(21);
double signalFloodingProbability = random.NextDouble();
double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3;
int nrOfProbabilities = random.Next(1, 10);
IEnumerable <double> failureMechanismProbabilities = Enumerable.Repeat(random.NextDouble(), nrOfProbabilities)
.ToArray();
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
var assessmentSectionCategories = new CategoriesList <AssessmentSectionCategory>(new[]
{
new AssessmentSectionCategory(random.NextEnumValue <EAssessmentGrade>(), new Probability(0), new Probability(1))
});
AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
categoryLimitsKernel.AssessmentSectionCategoryLimits = assessmentSectionCategories;
AssessmentSectionAssemblyKernelStub assessmentSectionAssemblyKernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
var assemblyProbability = new Probability(random.NextDouble());
assessmentSectionAssemblyKernel.AssemblyProbability = assemblyProbability;
assessmentSectionAssemblyKernel.AssemblyGroup = random.NextEnumValue <EAssessmentGrade>();
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
calculator.AssembleAssessmentSection(failureMechanismProbabilities, maximumAllowableFloodingProbability, signalFloodingProbability);
// Assert
Assert.IsTrue(categoryLimitsKernel.Calculated);
ProbabilityAssert.AreEqual(maximumAllowableFloodingProbability, categoryLimitsKernel.AssessmentSection.MaximumAllowableFloodingProbability);
ProbabilityAssert.AreEqual(signalFloodingProbability, categoryLimitsKernel.AssessmentSection.SignalFloodingProbability);
Assert.IsTrue(assessmentSectionAssemblyKernel.ProbabilityCalculated);
Assert.IsTrue(assessmentSectionAssemblyKernel.AssemblyGroupCalculated);
Assert.IsFalse(assessmentSectionAssemblyKernel.PartialAssembly);
Assert.AreSame(assessmentSectionCategories, assessmentSectionAssemblyKernel.Categories);
IEnumerable <Probability> actualProbabilitiesInput = assessmentSectionAssemblyKernel.FailureMechanismProbabilities;
Assert.AreEqual(nrOfProbabilities, actualProbabilitiesInput.Count());
for (var i = 0; i < nrOfProbabilities; i++)
{
ProbabilityAssert.AreEqual(failureMechanismProbabilities.ElementAt(i),
actualProbabilitiesInput.ElementAt(i));
}
Assert.AreEqual(assemblyProbability, assessmentSectionAssemblyKernel.AssemblyProbabilityInput);
}
}
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 CalculateFailureMechanismSectionAssemblyGroupBoundaries_WithValidInput_InputCorrectlySentToKernel()
{
// Setup
const double maximumAllowableFloodingProbability = 0.001;
const double signalFloodingProbability = 0.0001;
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
categoryLimitsKernel.InterpretationCategoryLimits = CreateInterpretationCategories();
var calculator = new FailureMechanismSectionAssemblyGroupBoundariesCalculator(factory);
// Call
calculator.CalculateFailureMechanismSectionAssemblyGroupBoundaries(signalFloodingProbability, maximumAllowableFloodingProbability);
// Assert
AssessmentSection assessmentSection = categoryLimitsKernel.AssessmentSection;
ProbabilityAssert.AreEqual(maximumAllowableFloodingProbability, assessmentSection.MaximumAllowableFloodingProbability);
ProbabilityAssert.AreEqual(signalFloodingProbability, assessmentSection.SignalFloodingProbability);
}
}
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);
}
}
}
public void Assemble_WithValidOutput_ReturnsExpectedOutput(bool applyLengthEffect, AssemblyMethod expectedAssemblyMethod)
{
// Setup
var random = new Random(21);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel;
var output = new FailureMechanismAssemblyResult(new Probability(random.NextDouble()), EFailureMechanismAssemblyMethod.Correlated);
kernel.ProbabilityResult = output;
var calculator = new FailureMechanismAssemblyCalculator(factory);
// Call
FailureMechanismAssemblyResultWrapper assemblyResultWrapper = calculator.Assemble(random.NextDouble(), Enumerable.Empty <RiskeerFailureMechanismSectionAssemblyResult>(),
applyLengthEffect);
// Assert
Assert.IsTrue(kernel.Calculated);
ProbabilityAssert.AreEqual(assemblyResultWrapper.AssemblyResult, output.Probability);
Assert.AreEqual(assemblyResultWrapper.AssemblyMethod, expectedAssemblyMethod);
}
}
