Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -r8e3a27cd0c9f5e4ffcb6c5e8e29442a127c042b0 -r5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1
--- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs)	(revision 8e3a27cd0c9f5e4ffcb6c5e8e29442a127c042b0)
+++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs)	(revision 5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1)
@@ -76,6 +76,7 @@
         /// </summary>
         /// <param name="failureMechanismSectionResult">The failure mechanism section result to
         /// assemble the detailed assembly for.</param>
+        /// <param name="calculationScenarios">The calculation scenarios belonging to this section.</param>
         /// <param name="failureMechanism">The failure mechanism this section belongs to.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> this section belongs to.</param>
         /// <returns>A <see cref="FailureMechanismSectionAssembly"/>.</returns>
@@ -84,6 +85,7 @@
         /// could not be created.</exception>
         public static FailureMechanismSectionAssembly AssembleDetailedAssessment(
             GrassCoverErosionInwardsFailureMechanismSectionResult failureMechanismSectionResult,
+            IEnumerable<GrassCoverErosionInwardsCalculationScenario> calculationScenarios,
             GrassCoverErosionInwardsFailureMechanism failureMechanism,
             IAssessmentSection assessmentSection)
         {
@@ -92,6 +94,11 @@
                 throw new ArgumentNullException(nameof(failureMechanismSectionResult));
             }
 
+            if (calculationScenarios == null)
+            {
+                throw new ArgumentNullException(nameof(calculationScenarios));
+            }
+
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
@@ -172,6 +179,7 @@
         /// </summary>
         /// <param name="failureMechanismSectionResult">The failure mechanism section result to
         /// combine the assemblies for.</param>
+        /// <param name="calculationScenarios">The calculation scenarios belonging to this section.</param>
         /// <param name="failureMechanism">The failure mechanism this section belongs to.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> this section belongs to.</param>
         /// <returns>A <see cref="FailureMechanismSectionAssembly"/>.</returns>
@@ -180,6 +188,7 @@
         /// could not be created.</exception>
         public static FailureMechanismSectionAssembly AssembleCombinedAssessment(
             GrassCoverErosionInwardsFailureMechanismSectionResult failureMechanismSectionResult,
+            IEnumerable<GrassCoverErosionInwardsCalculationScenario> calculationScenarios,
             GrassCoverErosionInwardsFailureMechanism failureMechanism,
             IAssessmentSection assessmentSection)
         {
@@ -188,6 +197,11 @@
                 throw new ArgumentNullException(nameof(failureMechanismSectionResult));
             }
 
+            if (calculationScenarios == null)
+            {
+                throw new ArgumentNullException(nameof(calculationScenarios));
+            }
+
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
@@ -213,7 +227,7 @@
 
                 return calculator.AssembleCombined(
                     simpleAssembly,
-                    AssembleDetailedAssessment(failureMechanismSectionResult, failureMechanism, assessmentSection),
+                    AssembleDetailedAssessment(failureMechanismSectionResult, calculationScenarios, failureMechanism, assessmentSection),
                     AssembleTailorMadeAssessment(failureMechanismSectionResult, failureMechanism, assessmentSection));
             }
             catch (FailureMechanismSectionAssemblyCalculatorException e)
@@ -333,6 +347,7 @@
             else
             {
                 sectionAssembly = AssembleCombinedAssessment(failureMechanismSectionResult,
+                                                             failureMechanism.Calculations.Cast<GrassCoverErosionInwardsCalculationScenario>(),
                                                              failureMechanism,
                                                              assessmentSection);
             }
Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Factories/GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs
===================================================================
diff -u -r1f76045f08612f7b8259c460771c7cdbdb5447a7 -r5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1
--- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Factories/GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs	(.../GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs)	(revision 1f76045f08612f7b8259c460771c7cdbdb5447a7)
+++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Factories/GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs	(.../GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs)	(revision 5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1)
@@ -21,6 +21,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Core.Components.Gis.Features;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Forms.Factories;
@@ -78,6 +79,7 @@
                 failureMechanism,
                 sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
                     sectionResult,
+                    failureMechanism.Calculations.Cast<GrassCoverErosionInwardsCalculationScenario>(),
                     failureMechanism,
                     assessmentSection));
         }
@@ -133,6 +135,7 @@
                 failureMechanism,
                 sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
                     sectionResult,
+                    failureMechanism.Calculations.Cast<GrassCoverErosionInwardsCalculationScenario>(),
                     failureMechanism,
                     assessmentSection));
         }
Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Views/GrassCoverErosionInwardsFailureMechanismSectionResultRow.cs
===================================================================
diff -u -re9800d75c970440a6e650e8ccf21d6bc50827c4d -r5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1
--- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Views/GrassCoverErosionInwardsFailureMechanismSectionResultRow.cs	(.../GrassCoverErosionInwardsFailureMechanismSectionResultRow.cs)	(revision e9800d75c970440a6e650e8ccf21d6bc50827c4d)
+++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Views/GrassCoverErosionInwardsFailureMechanismSectionResultRow.cs	(.../GrassCoverErosionInwardsFailureMechanismSectionResultRow.cs)	(revision 5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1)
@@ -373,6 +373,7 @@
             {
                 detailedAssemblyCategoryGroup = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
                     SectionResult,
+                    calculationScenarios,
                     failureMechanism,
                     assessmentSection).Group;
             }
@@ -406,6 +407,7 @@
                 FailureMechanismSectionAssembly combinedAssembly =
                     GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
                         SectionResult,
+                        calculationScenarios,
                         failureMechanism,
                         assessmentSection);
 
Index: Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs
===================================================================
diff -u -r8e3a27cd0c9f5e4ffcb6c5e8e29442a127c042b0 -r5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1
--- Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision 8e3a27cd0c9f5e4ffcb6c5e8e29442a127c042b0)
+++ Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision 5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1)
@@ -58,10 +58,10 @@
         public void AssembleSimpleAssessment_FailureMechanismSectionResultNull_ThrowsArgumentNullException()
         {
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(null);
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(null);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanismSectionResult", exception.ParamName);
         }
 
@@ -125,10 +125,10 @@
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
-                TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult);
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult);
 
                 // Assert
-                var exception = Assert.Throws<AssemblyException>(call);
+                var exception = Assert.Throws<AssemblyException>(Call);
                 Exception innerException = exception.InnerException;
                 Assert.IsInstanceOf<FailureMechanismSectionAssemblyCalculatorException>(innerException);
                 Assert.AreEqual(innerException.Message, exception.Message);
@@ -148,13 +148,12 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
-                null,
-                new GrassCoverErosionInwardsFailureMechanism(),
-                assessmentSection);
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
+                null, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                new GrassCoverErosionInwardsFailureMechanism(), assessmentSection);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanismSectionResult", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -167,29 +166,31 @@
             var assessmentSection = mocks.Stub<IAssessmentSection>();
             mocks.ReplayAll();
 
+            var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
+
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
-                new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                null,
-                assessmentSection);
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
+                sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(), null, assessmentSection);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
             mocks.VerifyAll();
         }
 
         [Test]
         public void AssembleDetailedAssessment_AssessmentSectionNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
+
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
-                new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                new GrassCoverErosionInwardsFailureMechanism(),
-                null);
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
+                sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                new GrassCoverErosionInwardsFailureMechanism(), null);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("assessmentSection", exception.ParamName);
         }
 
@@ -215,9 +216,8 @@
 
                 // Call
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection);
+                    sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                    failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(sectionResult.GetDetailedAssessmentProbability(failureMechanism, assessmentSection),
@@ -248,9 +248,8 @@
                 // Call
                 FailureMechanismSectionAssembly actualOutput =
                     GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
-                        sectionResult,
-                        failureMechanism,
-                        assessmentSection);
+                        sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                        failureMechanism, assessmentSection);
 
                 // Assert
                 FailureMechanismSectionAssembly calculatorOutput = calculator.DetailedAssessmentAssemblyOutput;
@@ -278,13 +277,12 @@
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
-                TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection);
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(
+                    sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                    failureMechanism, assessmentSection);
 
                 // Assert
-                var exception = Assert.Throws<AssemblyException>(call);
+                var exception = Assert.Throws<AssemblyException>(Call);
                 Exception innerException = exception.InnerException;
                 Assert.IsInstanceOf<FailureMechanismSectionAssemblyCalculatorException>(innerException);
                 Assert.AreEqual(innerException.Message, exception.Message);
@@ -305,13 +303,11 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
-                null,
-                new GrassCoverErosionInwardsFailureMechanism(),
-                assessmentSection);
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
+                null, new GrassCoverErosionInwardsFailureMechanism(), assessmentSection);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanismSectionResult", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -325,13 +321,12 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
                 new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                null,
-                assessmentSection);
+                null, assessmentSection);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -340,13 +335,12 @@
         public void AssembleTailorMadeAssessment_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
                 new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                new GrassCoverErosionInwardsFailureMechanism(),
-                null);
+                new GrassCoverErosionInwardsFailureMechanism(), null);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("assessmentSection", exception.ParamName);
         }
 
@@ -369,9 +363,7 @@
 
                 // Call
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection);
+                    sectionResult, failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(sectionResult.TailorMadeAssessmentProbability, calculator.TailorMadeAssessmentProbabilityInput);
@@ -401,9 +393,7 @@
                 // Call
                 FailureMechanismSectionAssembly actualOutput =
                     GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
-                        sectionResult,
-                        failureMechanism,
-                        assessmentSection);
+                        sectionResult, failureMechanism, assessmentSection);
 
                 // Assert
                 FailureMechanismSectionAssembly calculatorOutput = calculator.TailorMadeAssessmentAssemblyOutput;
@@ -431,13 +421,11 @@
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
-                TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection);
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(
+                    sectionResult, failureMechanism, assessmentSection);
 
                 // Assert
-                var exception = Assert.Throws<AssemblyException>(call);
+                var exception = Assert.Throws<AssemblyException>(Call);
                 Exception innerException = exception.InnerException;
                 Assert.IsInstanceOf<FailureMechanismSectionAssemblyCalculatorException>(innerException);
                 Assert.AreEqual(innerException.Message, exception.Message);
@@ -458,13 +446,12 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
-                null,
-                new GrassCoverErosionInwardsFailureMechanism(),
-                assessmentSection);
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+                null, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(), 
+                new GrassCoverErosionInwardsFailureMechanism(), assessmentSection);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanismSectionResult", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -478,13 +465,12 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
                 new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                null,
-                assessmentSection);
+                Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(), null, assessmentSection);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -493,13 +479,12 @@
         public void AssembleCombinedAssessment_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
                 new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                new GrassCoverErosionInwardsFailureMechanism(),
-                null);
+                Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(), new GrassCoverErosionInwardsFailureMechanism(), null);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("assessmentSection", exception.ParamName);
         }
 
@@ -528,9 +513,8 @@
 
                 // Call
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection);
+                    sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                    failureMechanism, assessmentSection);
 
                 // Assert
                 AssemblyToolTestHelper.AssertAreEqual(calculator.SimpleAssessmentAssemblyOutput, calculator.CombinedSimpleAssemblyInput);
@@ -562,9 +546,8 @@
 
                 // Call
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection);
+                    sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                    failureMechanism, assessmentSection);
 
                 // Assert
                 AssemblyToolTestHelper.AssertAreEqual(calculator.SimpleAssessmentAssemblyOutput, calculator.CombinedSimpleAssemblyInput);
@@ -594,9 +577,8 @@
                 // Call
                 FailureMechanismSectionAssembly actualOutput =
                     GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
-                        sectionResult,
-                        failureMechanism,
-                        assessmentSection);
+                        sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(),
+                        failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreSame(calculator.CombinedAssemblyOutput, actualOutput);
@@ -623,13 +605,12 @@
                 calculator.ThrowExceptionOnCalculateCombinedAssembly = true;
 
                 // Call
-                TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection);
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(
+                    sectionResult, Enumerable.Empty<GrassCoverErosionInwardsCalculationScenario>(), 
+                    failureMechanism, assessmentSection);
 
                 // Assert
-                var exception = Assert.Throws<AssemblyException>(call);
+                var exception = Assert.Throws<AssemblyException>(Call);
                 Exception innerException = exception.InnerException;
                 Assert.IsInstanceOf<FailureMechanismSectionAssemblyCalculatorException>(innerException);
                 Assert.AreEqual(innerException.Message, exception.Message);
@@ -650,14 +631,11 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                null,
-                new GrassCoverErosionInwardsFailureMechanism(),
-                assessmentSection,
-                new Random(39).NextBoolean());
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+                null, new GrassCoverErosionInwardsFailureMechanism(), assessmentSection, new Random(39).NextBoolean());
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanismSectionResult", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -671,14 +649,12 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                null,
-                assessmentSection,
-                new Random(39).NextBoolean());
+                null, assessmentSection, new Random(39).NextBoolean());
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -687,14 +663,12 @@
         public void GetSectionAssemblyCategoryGroup_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
                 new GrassCoverErosionInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()),
-                new GrassCoverErosionInwardsFailureMechanism(),
-                null,
-                new Random(39).NextBoolean());
+                new GrassCoverErosionInwardsFailureMechanism(), null, new Random(39).NextBoolean());
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("assessmentSection", exception.ParamName);
         }
 
@@ -716,10 +690,7 @@
 
                 // Call
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection,
-                    new Random(39).NextBoolean());
+                    sectionResult, failureMechanism, assessmentSection, new Random(39).NextBoolean());
 
                 // Assert
                 AssemblyToolTestHelper.AssertAreEqual(calculator.SimpleAssessmentAssemblyOutput, calculator.CombinedSimpleAssemblyInput);
@@ -755,10 +726,7 @@
 
                 // Call
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection,
-                    true);
+                    sectionResult, failureMechanism, assessmentSection, true);
 
                 // Assert
                 Assert.AreEqual(sectionResult.ManualAssemblyProbability, calculator.ManualAssemblyProbabilityInput);
@@ -794,10 +762,7 @@
 
                 // Call
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection,
-                    false);
+                    sectionResult, failureMechanism, assessmentSection, false);
 
                 // Assert
                 Assert.AreEqual(0.0, calculator.ManualAssemblyProbabilityInput);
@@ -825,10 +790,7 @@
 
                 // Call
                 FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection,
-                    new Random(39).NextBoolean());
+                    sectionResult, failureMechanism, assessmentSection, new Random(39).NextBoolean());
 
                 // Assert
                 Assert.AreEqual(calculator.CombinedAssemblyOutput.Group, categoryGroup);
@@ -859,10 +821,7 @@
 
                 // Call
                 FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection,
-                    true);
+                    sectionResult, failureMechanism, assessmentSection, true);
 
                 // Assert
                 Assert.AreEqual(calculator.ManualAssemblyAssemblyOutput.Group, categoryGroup);
@@ -893,10 +852,7 @@
 
                 // Call
                 FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection,
-                    false);
+                    sectionResult, failureMechanism, assessmentSection, false);
 
                 // Assert
                 Assert.AreEqual(calculator.CombinedAssemblyOutput.Group, categoryGroup);
@@ -934,14 +890,11 @@
                 }
 
                 // Call
-                TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
-                    sectionResult,
-                    failureMechanism,
-                    assessmentSection,
-                    useManualAssembly);
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+                    sectionResult, failureMechanism, assessmentSection, useManualAssembly);
 
                 // Assert
-                var exception = Assert.Throws<AssemblyException>(call);
+                var exception = Assert.Throws<AssemblyException>(Call);
                 Exception innerException = exception.InnerException;
                 Assert.IsInstanceOf<FailureMechanismSectionAssemblyCalculatorException>(innerException);
                 Assert.AreEqual(innerException.Message, exception.Message);
@@ -962,13 +915,11 @@
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
-                null,
-                assessmentSection,
-                new Random(39).NextBoolean());
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
+                null, assessmentSection, new Random(39).NextBoolean());
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
             mocks.VerifyAll();
         }
@@ -977,13 +928,11 @@
         public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Call
-            TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
-                new GrassCoverErosionInwardsFailureMechanism(),
-                null,
-                new Random(39).NextBoolean());
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
+                new GrassCoverErosionInwardsFailureMechanism(), null, new Random(39).NextBoolean());
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("assessmentSection", exception.ParamName);
         }
 
@@ -1158,13 +1107,11 @@
                 calculator.ThrowExceptionOnCalculate = true;
 
                 // Call
-                TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
-                    failureMechanism,
-                    assessmentSection,
-                    new Random(39).NextBoolean());
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
+                    failureMechanism, assessmentSection, new Random(39).NextBoolean());
 
                 // Assert
-                var exception = Assert.Throws<AssemblyException>(call);
+                var exception = Assert.Throws<AssemblyException>(Call);
                 Exception innerException = exception.InnerException;
                 Assert.IsInstanceOf<FailureMechanismAssemblyCalculatorException>(innerException);
                 Assert.AreEqual(innerException.Message, exception.Message);
@@ -1193,13 +1140,11 @@
                 calculator.ThrowExceptionOnCalculateCombinedAssembly = true;
 
                 // Call
-                TestDelegate call = () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
-                    failureMechanism,
-                    assessmentSection,
-                    new Random(39).NextBoolean());
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
+                    failureMechanism, assessmentSection, new Random(39).NextBoolean());
 
                 // Assert
-                var exception = Assert.Throws<AssemblyException>(call);
+                var exception = Assert.Throws<AssemblyException>(Call);
                 Exception innerException = exception.InnerException;
                 Assert.IsInstanceOf<AssemblyException>(innerException);
                 Assert.AreEqual("Voor een of meerdere vakken kan geen resultaat worden bepaald.", exception.Message);
Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs
===================================================================
diff -u -r86594ccd7329d320872573a1d066fe18959d3cea -r5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs)	(revision 86594ccd7329d320872573a1d066fe18959d3cea)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs)	(revision 5e5c2d499b8746b356f4c7ef7dac45bdfc0113e1)
@@ -21,6 +21,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
@@ -99,6 +100,8 @@
             IDictionary<GrassCoverErosionInwardsFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
                 ExportableFailureMechanismSectionHelper.CreateFailureMechanismSectionResultLookup(failureMechanism.SectionResults);
 
+            IEnumerable<GrassCoverErosionInwardsCalculationScenario> calculationScenarios = failureMechanism.Calculations.Cast<GrassCoverErosionInwardsCalculationScenario>();
+
             var exportableResults = new List<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>();
             foreach (KeyValuePair<GrassCoverErosionInwardsFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSectionsLookup)
             {
@@ -108,6 +111,7 @@
                     GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(failureMechanismSectionResult);
                 FailureMechanismSectionAssembly detailedAssembly =
                     GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(failureMechanismSectionResult,
+                                                                                                       calculationScenarios,
                                                                                                        failureMechanism,
                                                                                                        assessmentSection);
                 FailureMechanismSectionAssembly tailorMadeAssembly =
@@ -116,6 +120,7 @@
                                                                                                          assessmentSection);
                 FailureMechanismSectionAssembly combinedAssembly =
                     GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanismSectionResult,
+                                                                                                       calculationScenarios,
                                                                                                        failureMechanism,
                                                                                                        assessmentSection);