Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs =================================================================== diff -u -rb2b50ced8da8e297316fed0680bd2ec9db870a29 -re67d42398b880bc12fc7e2b7689213b2e0613e50 --- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs (.../AssessmentSectionAssemblyCalculator.cs) (revision b2b50ced8da8e297316fed0680bd2ec9db870a29) +++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs (.../AssessmentSectionAssemblyCalculator.cs) (revision e67d42398b880bc12fc7e2b7689213b2e0613e50) @@ -91,5 +91,53 @@ throw new AssessmentSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e); } } + + public AssessmentSectionAssemblyResultWrapper AssembleAssessmentSection(IEnumerable correlatedFailureMechanismProbabilities, + IEnumerable uncorrelatedFailureMechanismProbabilities, + double maximumAllowableFloodingProbability, + double signalFloodingProbability) + { + if (correlatedFailureMechanismProbabilities == null) + { + throw new ArgumentNullException(nameof(correlatedFailureMechanismProbabilities)); + } + + if (uncorrelatedFailureMechanismProbabilities == null) + { + throw new ArgumentNullException(nameof(uncorrelatedFailureMechanismProbabilities)); + } + + try + { + ICategoryLimitsCalculator categoryLimitsKernel = factory.CreateAssemblyGroupsKernel(); + CategoriesList assessmentSectionCategories = categoryLimitsKernel.CalculateAssessmentSectionCategoryLimitsBoi21( + new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(signalFloodingProbability), + AssemblyCalculatorInputCreator.CreateProbability(maximumAllowableFloodingProbability))); + + IAssessmentGradeAssembler assessmentSectionAssemblyKernel = factory.CreateAssessmentSectionAssemblyKernel(); + IEnumerable correlatedProbabilities = correlatedFailureMechanismProbabilities.Select(AssemblyCalculatorInputCreator.CreateProbability) + .ToArray(); + IEnumerable uncorrelatedProbabilities = uncorrelatedFailureMechanismProbabilities.Select(AssemblyCalculatorInputCreator.CreateProbability) + .ToArray(); + + Probability assemblyProbability = assessmentSectionAssemblyKernel.CalculateAssessmentSectionFailureProbabilityBoi2A2(correlatedProbabilities, + uncorrelatedProbabilities, + false); + EAssessmentGrade assemblyCategory = assessmentSectionAssemblyKernel.DetermineAssessmentGradeBoi2B1(assemblyProbability, assessmentSectionCategories); + + return new AssessmentSectionAssemblyResultWrapper( + new AssessmentSectionAssemblyResult(assemblyProbability, + AssessmentSectionAssemblyGroupCreator.CreateAssessmentSectionAssemblyGroup(assemblyCategory)), + AssemblyMethod.BOI2A2, AssemblyMethod.BOI2B1); + } + catch (AssemblyException e) + { + throw new AssessmentSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e); + } + catch (Exception e) + { + throw new AssessmentSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e); + } + } } } \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs =================================================================== diff -u -rb2b50ced8da8e297316fed0680bd2ec9db870a29 -re67d42398b880bc12fc7e2b7689213b2e0613e50 --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs (.../AssessmentSectionAssemblyCalculatorTest.cs) (revision b2b50ced8da8e297316fed0680bd2ec9db870a29) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs (.../AssessmentSectionAssemblyCalculatorTest.cs) (revision e67d42398b880bc12fc7e2b7689213b2e0613e50) @@ -97,8 +97,7 @@ double signalFloodingProbability = random.NextDouble(); double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3; - int nrOfProbabilities = random.Next(1, 10); - IEnumerable failureMechanismProbabilities = Enumerable.Repeat(random.NextDouble(), nrOfProbabilities) + IEnumerable failureMechanismProbabilities = Enumerable.Repeat(random.NextDouble(), random.Next(1, 10)) .ToArray(); using (new AssemblyToolKernelFactoryConfig()) @@ -132,13 +131,7 @@ Assert.IsFalse(assessmentSectionAssemblyKernel.PartialAssembly); Assert.AreSame(assessmentSectionCategories, assessmentSectionAssemblyKernel.Categories); - IEnumerable actualProbabilitiesInput = assessmentSectionAssemblyKernel.FailureMechanismProbabilities; - Assert.AreEqual(nrOfProbabilities, actualProbabilitiesInput.Count()); - for (var i = 0; i < nrOfProbabilities; i++) - { - ProbabilityAssert.AreEqual(failureMechanismProbabilities.ElementAt(i), - actualProbabilitiesInput.ElementAt(i)); - } + AssertProbabilitiesInput(failureMechanismProbabilities, assessmentSectionAssemblyKernel.FailureMechanismProbabilities); Assert.AreEqual(assemblyProbability, assessmentSectionAssemblyKernel.AssemblyProbabilityInput); } @@ -258,5 +251,198 @@ }), exception.Message); } } + + [Test] + public void AssembleAssessmentSectionWithCorrelatedFailureMechanismProbabilities_CorrelatedFailureMechanismProbabilitiesNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var kernelFactory = mocks.Stub(); + mocks.ReplayAll(); + + var random = new Random(21); + var calculator = new AssessmentSectionAssemblyCalculator(kernelFactory); + + // Call + void Call() => calculator.AssembleAssessmentSection(null, Enumerable.Empty(), random.NextDouble(), random.NextDouble()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("correlatedFailureMechanismProbabilities", exception.ParamName); + } + + [Test] + public void AssembleAssessmentSectionWithCorrelatedFailureMechanismProbabilities_UncorrelatedFailureMechanismProbabilitiesNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var kernelFactory = mocks.Stub(); + mocks.ReplayAll(); + + var random = new Random(21); + var calculator = new AssessmentSectionAssemblyCalculator(kernelFactory); + + // Call + void Call() => calculator.AssembleAssessmentSection(Enumerable.Empty(), null, random.NextDouble(), random.NextDouble()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("uncorrelatedFailureMechanismProbabilities", exception.ParamName); + } + + [Test] + public void AssembleAssessmentSectionWithCorrelatedFailureMechanismProbabilities_WithValidInput_InputCorrectlySetToKernel() + { + // Setup + var random = new Random(21); + double signalFloodingProbability = random.NextDouble(); + double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3; + + IEnumerable correlatedFailureMechanismProbabilities = Enumerable.Repeat(random.NextDouble(), random.Next(1, 10)) + .ToArray(); + + IEnumerable uncorrelatedFailureMechanismProbabilities = Enumerable.Repeat(random.NextDouble(), random.Next(1, 10)) + .ToArray(); + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + + var assessmentSectionCategories = new CategoriesList(new[] + { + new AssessmentSectionCategory(random.NextEnumValue(), 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(); + + var calculator = new AssessmentSectionAssemblyCalculator(factory); + + // Call + calculator.AssembleAssessmentSection(correlatedFailureMechanismProbabilities, uncorrelatedFailureMechanismProbabilities, + 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); + + AssertProbabilitiesInput(correlatedFailureMechanismProbabilities, assessmentSectionAssemblyKernel.CorrelatedFailureMechanismProbabilities); + AssertProbabilitiesInput(uncorrelatedFailureMechanismProbabilities, assessmentSectionAssemblyKernel.UncorrelatedFailureMechanismProbabilities); + + Assert.AreEqual(assemblyProbability, assessmentSectionAssemblyKernel.AssemblyProbabilityInput); + } + } + + [Test] + public void AssembleAssessmentSectionWithCorrelatedFailureMechanismProbabilities_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() + { + // Setup + var random = new Random(21); + double signalFloodingProbability = random.NextDouble(); + double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3; + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel; + var assemblyProbability = new Probability(random.NextDouble()); + var assemblyGroup = random.NextEnumValue(); + kernel.AssemblyProbability = assemblyProbability; + kernel.AssemblyGroup = assemblyGroup; + + var calculator = new AssessmentSectionAssemblyCalculator(factory); + + // Call + AssessmentSectionAssemblyResultWrapper resultWrapper = calculator.AssembleAssessmentSection( + Enumerable.Empty(), Enumerable.Empty(), maximumAllowableFloodingProbability, signalFloodingProbability); + + // Assert + AssessmentSectionAssemblyResult result = resultWrapper.AssemblyResult; + Assert.AreEqual(assemblyProbability, result.Probability); + Assert.AreEqual(AssessmentSectionAssemblyGroupCreator.CreateAssessmentSectionAssemblyGroup(assemblyGroup), + result.AssemblyGroup); + Assert.AreEqual(AssemblyMethod.BOI2A2, resultWrapper.ProbabilityMethod); + Assert.AreEqual(AssemblyMethod.BOI2B1, resultWrapper.AssemblyGroupMethod); + } + } + + [Test] + public void AssembleAssessmentSectionWithCorrelatedFailureMechanismProbabilities_KernelWithInvalidOutput_ThrowsAssessmentSectionAssemblyCalculatorException() + { + // Setup + var random = new Random(21); + double signalFloodingProbability = random.NextDouble(); + double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3; + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel; + kernel.AssemblyProbability = new Probability(random.NextDouble()); + kernel.AssemblyGroup = (EAssessmentGrade) 99; + + var calculator = new AssessmentSectionAssemblyCalculator(factory); + + // Call + void Call() => calculator.AssembleAssessmentSection( + Enumerable.Empty(), Enumerable.Empty(), maximumAllowableFloodingProbability, signalFloodingProbability); + + // Assert + var exception = Assert.Throws(Call); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message); + } + } + + [Test] + public void AssembleAssessmentSectionWithCorrelatedFailureMechanismProbabilities_KernelThrowsAssemblyException_ThrowsAssessmentSectionAssemblyCalculatorException() + { + // Setup + var random = new Random(21); + double signalFloodingProbability = random.NextDouble(); + double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3; + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel; + kernel.ThrowAssemblyExceptionOnCalculate = true; + + var calculator = new AssessmentSectionAssemblyCalculator(factory); + + // Call + void Call() => calculator.AssembleAssessmentSection( + Enumerable.Empty(), Enumerable.Empty(), maximumAllowableFloodingProbability, signalFloodingProbability); + + // Assert + var exception = Assert.Throws(Call); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreator.CreateErrorMessage(new[] + { + AssemblyErrorMessageTestHelper.Create(string.Empty, EAssemblyErrors.InvalidCategoryLimits) + }), exception.Message); + } + } + + private static void AssertProbabilitiesInput(IEnumerable expectedProbabilities, IEnumerable actualProbabilitiesInput) + { + int nrOfProbabilities = expectedProbabilities.Count(); + Assert.AreEqual(nrOfProbabilities, actualProbabilitiesInput.Count()); + for (var i = 0; i < nrOfProbabilities; i++) + { + ProbabilityAssert.AreEqual(expectedProbabilities.ElementAt(i), + actualProbabilitiesInput.ElementAt(i)); + } + } } } \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/AssessmentSectionAssemblyKernelStub.cs =================================================================== diff -u -rb2b50ced8da8e297316fed0680bd2ec9db870a29 -re67d42398b880bc12fc7e2b7689213b2e0613e50 --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/AssessmentSectionAssemblyKernelStub.cs (.../AssessmentSectionAssemblyKernelStub.cs) (revision b2b50ced8da8e297316fed0680bd2ec9db870a29) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/AssessmentSectionAssemblyKernelStub.cs (.../AssessmentSectionAssemblyKernelStub.cs) (revision e67d42398b880bc12fc7e2b7689213b2e0613e50) @@ -39,6 +39,16 @@ public IEnumerable FailureMechanismProbabilities { get; private set; } /// + /// Gets the collection of correlated used as an input parameter for assembly methods. + /// + public IEnumerable CorrelatedFailureMechanismProbabilities { get; private set; } + + /// + /// Gets the collection of uncorrelated used as an input parameter for assembly methods. + /// + public IEnumerable UncorrelatedFailureMechanismProbabilities { get; private set; } + + /// /// Gets the collection of assessment section categories. /// public CategoriesList Categories { get; private set; } @@ -102,7 +112,8 @@ ThrowException(); ProbabilityCalculated = true; - FailureMechanismProbabilities = correlatedFailureMechanismProbabilities; + CorrelatedFailureMechanismProbabilities = correlatedFailureMechanismProbabilities; + UncorrelatedFailureMechanismProbabilities = uncorrelatedFailureMechanismProbabilities; PartialAssembly = partialAssembly; return AssemblyProbability;