Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs
===================================================================
diff -u -r3ed87c53aea49ac019672432d88c97245129d8d6 -r3449f574e011603ca159ccef3d2164ed3c0fd4ff
--- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs	(.../AssessmentSectionAssemblyCalculator.cs)	(revision 3ed87c53aea49ac019672432d88c97245129d8d6)
+++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/AssessmentSectionAssemblyCalculator.cs	(.../AssessmentSectionAssemblyCalculator.cs)	(revision 3449f574e011603ca159ccef3d2164ed3c0fd4ff)
@@ -21,9 +21,12 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Assembly.Kernel.Exceptions;
 using Assembly.Kernel.Interfaces;
+using Assembly.Kernel.Model;
 using Assembly.Kernel.Model.AssessmentSection;
+using Assembly.Kernel.Model.Categories;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.AssemblyTool.KernelWrapper.Creators;
 using Riskeer.AssemblyTool.KernelWrapper.Kernels;
@@ -52,6 +55,39 @@
             this.factory = factory;
         }
 
+        public AssessmentSectionAssemblyResult AssembleAssessmentSection(IEnumerable<double> failureMechanismProbabilities,
+                                                                         double lowerLimitNorm,
+                                                                         double signalingNorm)
+        {
+            if (failureMechanismProbabilities == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismProbabilities));
+            }
+
+            try
+            {
+                ICategoryLimitsCalculator categoryLimitsKernel = factory.CreateAssemblyCategoriesKernel();
+                CategoriesList<AssessmentSectionCategory> categoryLimits = categoryLimitsKernel.CalculateAssessmentSectionCategoryLimitsWbi21(
+                    new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(signalingNorm),
+                                          AssemblyCalculatorInputCreator.CreateProbability(lowerLimitNorm)));
+
+                IAssessmentGradeAssembler assessmentSectionAssemblyKernel = factory.CreateAssessmentSectionAssemblyKernel();
+                IEnumerable<Probability> probabilities = failureMechanismProbabilities.Select(AssemblyCalculatorInputCreator.CreateProbability)
+                                                                                      .ToArray();
+
+                AssessmentSectionResult assemblyResult = assessmentSectionAssemblyKernel.AssembleAssessmentSectionWbi2B1(probabilities, categoryLimits, false);
+                return AssessmentSectionAssemblyResultCreator.CreateAssessmentSectionAssemblyResult(assemblyResult);
+            }
+            catch (AssemblyException e)
+            {
+                throw new AssessmentSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e);
+            }
+            catch (Exception e)
+            {
+                throw new AssessmentSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e);
+            }
+        }
+
         public IEnumerable<CombinedFailureMechanismSectionAssembly> AssembleCombinedFailureMechanismSections(
             IEnumerable<IEnumerable<CombinedAssemblyFailureMechanismSection>> input, double assessmentSectionLength)
         {
Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs
===================================================================
diff -u -r16957b4e56e4335c72a2d557736b0eee3f742199 -r3449f574e011603ca159ccef3d2164ed3c0fd4ff
--- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs	(.../AssessmentSectionAssemblyCalculatorTest.cs)	(revision 16957b4e56e4335c72a2d557736b0eee3f742199)
+++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs	(.../AssessmentSectionAssemblyCalculatorTest.cs)	(revision 3449f574e011603ca159ccef3d2164ed3c0fd4ff)
@@ -20,9 +20,11 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using Assembly.Kernel.Exceptions;
+using Assembly.Kernel.Model;
 using Assembly.Kernel.Model.AssessmentSection;
 using Assembly.Kernel.Model.Categories;
 using Assembly.Kernel.Model.FailureMechanismSections;
@@ -36,6 +38,7 @@
 using Riskeer.AssemblyTool.KernelWrapper.TestUtil;
 using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels;
 using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Assembly;
+using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Categories;
 
 namespace Riskeer.AssemblyTool.KernelWrapper.Test.Calculators.Assembly
 {
@@ -70,6 +73,184 @@
         }
 
         [Test]
+        public void AssembleAssessmentSection_FailureMechanismProbabilitiesNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var kernelFactory = mocks.Stub<IAssemblyToolKernelFactory>();
+            mocks.ReplayAll();
+
+            var random = new Random(21);
+            var calculator = new AssessmentSectionAssemblyCalculator(kernelFactory);
+
+            // Call
+            void Call() => calculator.AssembleAssessmentSection(null, random.NextDouble(), random.NextDouble());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("failureMechanismProbabilities", exception.ParamName);
+        }
+
+        [Test]
+        public void AssembleAssessmentSection_WithValidInput_InputCorrectlySetToKernel()
+        {
+            // Setup
+            var random = new Random(21);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = signalingNorm + 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 categoryLimits = new CategoriesList<AssessmentSectionCategory>(new[]
+                {
+                    new AssessmentSectionCategory(random.NextEnumValue<EAssessmentGrade>(), new Probability(0), new Probability(1))
+                });
+                AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
+                categoryLimitsKernel.AssessmentSectionCategoryLimits = categoryLimits;
+
+                AssessmentSectionAssemblyKernelStub assessmentSectionAssemblyKernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
+                assessmentSectionAssemblyKernel.AssessmentSectionAssemblyResult = new AssessmentSectionResult(new Probability(random.NextDouble()), random.NextEnumValue<EAssessmentGrade>());
+
+                var calculator = new AssessmentSectionAssemblyCalculator(factory);
+
+                // Call
+                calculator.AssembleAssessmentSection(failureMechanismProbabilities, lowerLimitNorm, signalingNorm);
+
+                // Assert
+                Assert.IsTrue(categoryLimitsKernel.Calculated);
+                ProbabilityAssert.AreEqual(lowerLimitNorm, categoryLimitsKernel.AssessmentSection.FailureProbabilityLowerLimit);
+                ProbabilityAssert.AreEqual(signalingNorm, categoryLimitsKernel.AssessmentSection.FailureProbabilitySignallingLimit);
+
+                Assert.IsTrue(assessmentSectionAssemblyKernel.Calculated);
+                Assert.IsFalse(assessmentSectionAssemblyKernel.PartialAssembly);
+                Assert.AreSame(categoryLimits, 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));
+                }
+            }
+        }
+
+        [Test]
+        public void AssembleAssessmentSection_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
+        {
+            // Setup
+            var random = new Random(21);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = signalingNorm + 1e-3;
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
+                var assemblyResult = new AssessmentSectionResult(new Probability(random.NextDouble()), random.NextEnumValue<EAssessmentGrade>());
+                kernel.AssessmentSectionAssemblyResult = assemblyResult;
+
+                var calculator = new AssessmentSectionAssemblyCalculator(factory);
+
+                // Call
+                AssessmentSectionAssemblyResult result = calculator.AssembleAssessmentSection(Enumerable.Empty<double>(), lowerLimitNorm, signalingNorm);
+
+                // Assert
+                Assert.AreEqual(assemblyResult.FailureProbability, result.Probability);
+                Assert.AreEqual(AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory(assemblyResult.Category),
+                                result.AssemblyCategoryGroup);
+            }
+        }
+
+        [Test]
+        public void AssembleAssessmentSection_KernelWithInvalidOutput_ThrowsAssessmentSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(21);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = signalingNorm + 1e-3;
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
+                var assemblyResult = new AssessmentSectionResult(new Probability(random.NextDouble()), (EAssessmentGrade) 99);
+                kernel.AssessmentSectionAssemblyResult = assemblyResult;
+
+                var calculator = new AssessmentSectionAssemblyCalculator(factory);
+
+                // Call
+                void Call() => calculator.AssembleAssessmentSection(Enumerable.Empty<double>(), lowerLimitNorm, signalingNorm);
+
+                // Assert
+                var exception = Assert.Throws<AssessmentSectionAssemblyCalculatorException>(Call);
+                Assert.IsInstanceOf<InvalidEnumArgumentException>(exception.InnerException);
+                Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message);
+            }
+        }
+
+        [Test]
+        public void AssembleAssessmentSection_KernelThrowsException_ThrowsAssessmentSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(21);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = signalingNorm + 1e-3;
+
+            using (new AssemblyToolKernelFactoryConfig())
+            {
+                var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+                AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
+                kernel.ThrowExceptionOnCalculate = true;
+
+                var calculator = new AssessmentSectionAssemblyCalculator(factory);
+
+                // Call
+                void Call() => calculator.AssembleAssessmentSection(Enumerable.Empty<double>(), lowerLimitNorm, signalingNorm);
+
+                // Assert
+                var exception = Assert.Throws<AssessmentSectionAssemblyCalculatorException>(Call);
+                Assert.IsInstanceOf<Exception>(exception.InnerException);
+                Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message);
+            }
+        }
+
+        [Test]
+        public void AssembleAssessmentSection_KernelThrowsAssemblyException_ThrowsAssessmentSectionAssemblyCalculatorException()
+        {
+            // Setup
+            var random = new Random(21);
+            double signalingNorm = random.NextDouble();
+            double lowerLimitNorm = signalingNorm + 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<double>(), lowerLimitNorm, signalingNorm);
+
+                // Assert
+                var exception = Assert.Throws<AssessmentSectionAssemblyCalculatorException>(Call);
+                Assert.IsInstanceOf<AssemblyException>(exception.InnerException);
+                Assert.AreEqual(AssemblyErrorMessageCreator.CreateErrorMessage(new[]
+                {
+                    new AssemblyErrorMessage(string.Empty, EAssemblyErrors.InvalidCategoryLimits)
+                }), exception.Message);
+            }
+        }
+
+        [Test]
         public void AssembleCombinedFailureMechanismSections_WithInvalidInput_ThrowsAssessmentSectionAssemblyCalculatorException()
         {
             // Setup