Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs
===================================================================
diff -u -rbe7bc76ff670773f4c8ea10b943a0f3ac792efbf -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs	(.../AssessmentSectionAssemblyFactory.cs)	(revision be7bc76ff670773f4c8ea10b943a0f3ac792efbf)
+++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs	(.../AssessmentSectionAssemblyFactory.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -121,7 +121,7 @@
                     CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, failureMechanismsToAssemble.Keys),
                     assessmentSection.ReferenceLine.Length);
 
-                return CombinedFailureMechanismSectionAssemblyResultFactory.Create(output.AssemblyResults, failureMechanismsToAssemble, assessmentSection);
+                return CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanismsToAssemble, assessmentSection);
             }
             catch (AssessmentSectionAssemblyCalculatorException e)
             {
Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResult.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResult.cs	(.../CombinedFailureMechanismSectionAssemblyResult.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResult.cs	(.../CombinedFailureMechanismSectionAssemblyResult.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -37,12 +37,21 @@
         /// <param name="sectionEnd">The end of the section from the beginning of the reference line
         /// in meters.</param>
         /// <param name="totalResult">The total result of the section.</param>
+        /// <param name="commonSectionAssemblyMethod">The <see cref="AssemblyMethod"/>
+        /// that is used to get the common sections.</param>
+        /// <param name="failureMechanismResultsAssemblyMethod">The <see cref="AssemblyMethod"/>
+        /// that is used to assemble the failure mechanism results.</param>
+        /// <param name="combinedSectionResultAssemblyMethod">The <see cref="AssemblyMethod"/>
+        /// that is used to assemble the combined section results.</param>
         /// <param name="properties">The container of the properties for the
         /// <see cref="CombinedFailureMechanismSectionAssemblyResult"/>.</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="properties"/>
         /// is <c>null</c>.</exception>
         public CombinedFailureMechanismSectionAssemblyResult(double sectionStart, double sectionEnd,
                                                              FailureMechanismSectionAssemblyGroup totalResult,
+                                                             AssemblyMethod commonSectionAssemblyMethod,
+                                                             AssemblyMethod failureMechanismResultsAssemblyMethod,
+                                                             AssemblyMethod combinedSectionResultAssemblyMethod,
                                                              ConstructionProperties properties)
         {
             if (properties == null)
@@ -69,6 +78,10 @@
             DuneErosion = properties.DuneErosion;
             SpecificFailureMechanisms = properties.SpecificFailureMechanisms;
             TotalResult = totalResult;
+
+            CommonSectionAssemblyMethod = commonSectionAssemblyMethod;
+            FailureMechanismResultsAssemblyMethod = failureMechanismResultsAssemblyMethod;
+            CombinedSectionResultAssemblyMethod = combinedSectionResultAssemblyMethod;
         }
 
         /// <summary>
@@ -169,6 +182,21 @@
         public FailureMechanismSectionAssemblyGroup TotalResult { get; }
 
         /// <summary>
+        /// Gets the <see cref="AssemblyMethod"/> that is used to get the common sections.
+        /// </summary> 
+        public AssemblyMethod CommonSectionAssemblyMethod { get; }
+
+        /// <summary>
+        /// Gets the <see cref="AssemblyMethod"/> that is used to assemble the failure mechanism results.
+        /// </summary>
+        public AssemblyMethod FailureMechanismResultsAssemblyMethod { get; }
+
+        /// <summary>
+        /// Gets the <see cref="AssemblyMethod"/> that is used to assemble the combined section results.
+        /// </summary>
+        public AssemblyMethod CombinedSectionResultAssemblyMethod { get; }
+
+        /// <summary>
         /// Container for properties for constructing a <see cref="CombinedFailureMechanismSectionAssemblyResult"/>.
         /// </summary>s
         public class ConstructionProperties
Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResultFactory.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResultFactory.cs	(.../CombinedFailureMechanismSectionAssemblyResultFactory.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResultFactory.cs	(.../CombinedFailureMechanismSectionAssemblyResultFactory.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -41,7 +41,7 @@
         /// <param name="assessmentSection">The assessment section to use while creating the results.</param>
         /// <returns>A collection of <see cref="CombinedFailureMechanismSectionAssemblyResult"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        public static IEnumerable<CombinedFailureMechanismSectionAssemblyResult> Create(IEnumerable<CombinedFailureMechanismSectionAssembly> output,
+        public static IEnumerable<CombinedFailureMechanismSectionAssemblyResult> Create(CombinedFailureMechanismSectionAssemblyResultWrapper output,
                                                                                         IDictionary<IFailureMechanism, int> failureMechanisms,
                                                                                         AssessmentSection assessmentSection)
         {
@@ -60,11 +60,15 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
-            return output.Select(assembly => new CombinedFailureMechanismSectionAssemblyResult(assembly.Section.SectionStart,
-                                                                                               assembly.Section.SectionEnd,
-                                                                                               assembly.Section.FailureMechanismSectionAssemblyGroup,
-                                                                                               CreateFailureMechanismResults(assembly.FailureMechanismSectionAssemblyGroupResults,
-                                                                                                                             failureMechanisms, assessmentSection)))
+            return output.AssemblyResults.Select(assembly => new CombinedFailureMechanismSectionAssemblyResult(
+                                                     assembly.Section.SectionStart,
+                                                     assembly.Section.SectionEnd,
+                                                     assembly.Section.FailureMechanismSectionAssemblyGroup,
+                                                     output.CommonSectionAssemblyMethod,
+                                                     output.FailureMechanismResultsAssemblyMethod,
+                                                     output.CombinedSectionResultAssemblyMethod,
+                                                     CreateFailureMechanismResults(assembly.FailureMechanismSectionAssemblyGroupResults,
+                                                                                   failureMechanisms, assessmentSection)))
                          .ToArray();
         }
 
Index: Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs
===================================================================
diff -u -rbe7bc76ff670773f4c8ea10b943a0f3ac792efbf -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs	(.../AssessmentSectionAssemblyFactoryTest.cs)	(revision be7bc76ff670773f4c8ea10b943a0f3ac792efbf)
+++ Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs	(.../AssessmentSectionAssemblyFactoryTest.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -239,7 +239,7 @@
                                                                                         })
                                                                                         .ToDictionary(x => x.FailureMechanism, x => x.Index);
                 CombinedFailureMechanismSectionAssemblyResult[] expectedOutput = CombinedFailureMechanismSectionAssemblyResultFactory.Create(
-                    calculator.CombinedFailureMechanismSectionAssemblyOutput.AssemblyResults, failureMechanisms, assessmentSection).ToArray();
+                    calculator.CombinedFailureMechanismSectionAssemblyOutput, failureMechanisms, assessmentSection).ToArray();
 
                 Assert.AreEqual(expectedOutput.Length, output.Length);
                 for (var i = 0; i < expectedOutput.Length; i++)
@@ -263,6 +263,10 @@
                     Assert.AreEqual(expectedOutput[i].StabilityPointStructures, output[i].StabilityPointStructures);
                     Assert.AreEqual(expectedOutput[i].DuneErosion, output[i].DuneErosion);
                     CollectionAssert.AreEqual(expectedOutput[i].SpecificFailureMechanisms, output[i].SpecificFailureMechanisms);
+
+                    Assert.AreEqual(expectedOutput[i].CommonSectionAssemblyMethod, output[i].CommonSectionAssemblyMethod);
+                    Assert.AreEqual(expectedOutput[i].FailureMechanismResultsAssemblyMethod, output[i].FailureMechanismResultsAssemblyMethod);
+                    Assert.AreEqual(expectedOutput[i].CombinedSectionResultAssemblyMethod, output[i].CombinedSectionResultAssemblyMethod);
                 }
             }
         }
Index: Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs	(.../CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs	(.../CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -57,8 +57,10 @@
 
             // Call
             void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create(
-                Enumerable.Empty<CombinedFailureMechanismSectionAssembly>(), null,
-                new AssessmentSection(random.NextEnumValue<AssessmentSectionComposition>()));
+                new CombinedFailureMechanismSectionAssemblyResultWrapper(
+                    Enumerable.Empty<CombinedFailureMechanismSectionAssembly>(),
+                    AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1),
+                null, new AssessmentSection(random.NextEnumValue<AssessmentSectionComposition>()));
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -70,7 +72,9 @@
         {
             // Call
             void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create(
-                Enumerable.Empty<CombinedFailureMechanismSectionAssembly>(),
+                new CombinedFailureMechanismSectionAssemblyResultWrapper(
+                    Enumerable.Empty<CombinedFailureMechanismSectionAssembly>(),
+                    AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1),
                 new Dictionary<IFailureMechanism, int>(), null);
 
             // Assert
@@ -97,43 +101,48 @@
 
             var section1 = new CombinedAssemblyFailureMechanismSection(0, 5, random.NextEnumValue<FailureMechanismSectionAssemblyGroup>());
             var section2 = new CombinedAssemblyFailureMechanismSection(5, 11, random.NextEnumValue<FailureMechanismSectionAssemblyGroup>());
-            var output = new[]
-            {
-                new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)),
-                new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random))
-            };
+            var output = new CombinedFailureMechanismSectionAssemblyResultWrapper(
+                new[]
+                {
+                    new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)),
+                    new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random))
+                }, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
 
             // Call
             CombinedFailureMechanismSectionAssemblyResult[] results = CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanisms, assessmentSection).ToArray();
 
             // Assert
-            Assert.AreEqual(output.Length, results.Length);
-            for (var i = 0; i < output.Length; i++)
+            Assert.AreEqual(output.AssemblyResults.Count(), results.Length);
+            for (var i = 0; i < output.AssemblyResults.Count(); i++)
             {
-                Assert.AreEqual(output[i].Section.SectionStart, results[i].SectionStart);
-                Assert.AreEqual(output[i].Section.SectionEnd, results[i].SectionEnd);
-                Assert.AreEqual(output[i].Section.FailureMechanismSectionAssemblyGroup, results[i].TotalResult);
-
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Piping]), results[i].Piping);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionInwards]), results[i].GrassCoverErosionInwards);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.MacroStabilityInwards]), results[i].MacroStabilityInwards);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Microstability]), results[i].Microstability);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityStoneCover]), results[i].StabilityStoneCover);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaveImpactAsphaltCover]), results[i].WaveImpactAsphaltCover);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaterPressureAsphaltCover]), results[i].WaterPressureAsphaltCover);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionOutwards]), results[i].GrassCoverErosionOutwards);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffOutwards]), results[i].GrassCoverSlipOffOutwards);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffInwards]), results[i].GrassCoverSlipOffInwards);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.HeightStructures]), results[i].HeightStructures);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.ClosingStructures]), results[i].ClosingStructures);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.PipingStructure]), results[i].PipingStructure);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityPointStructures]), results[i].StabilityPointStructures);
-                Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.DuneErosion]), results[i].DuneErosion);
+                CombinedFailureMechanismSectionAssembly assemblyResult = output.AssemblyResults.ElementAt(i);
+                Assert.AreEqual(assemblyResult.Section.SectionStart, results[i].SectionStart);
+                Assert.AreEqual(assemblyResult.Section.SectionEnd, results[i].SectionEnd);
+                Assert.AreEqual(assemblyResult.Section.FailureMechanismSectionAssemblyGroup, results[i].TotalResult);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Piping]), results[i].Piping);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionInwards]), results[i].GrassCoverErosionInwards);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.MacroStabilityInwards]), results[i].MacroStabilityInwards);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Microstability]), results[i].Microstability);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityStoneCover]), results[i].StabilityStoneCover);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaveImpactAsphaltCover]), results[i].WaveImpactAsphaltCover);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaterPressureAsphaltCover]), results[i].WaterPressureAsphaltCover);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionOutwards]), results[i].GrassCoverErosionOutwards);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffOutwards]), results[i].GrassCoverSlipOffOutwards);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffInwards]), results[i].GrassCoverSlipOffInwards);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.HeightStructures]), results[i].HeightStructures);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.ClosingStructures]), results[i].ClosingStructures);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.PipingStructure]), results[i].PipingStructure);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityPointStructures]), results[i].StabilityPointStructures);
+                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.DuneErosion]), results[i].DuneErosion);
                 Assert.AreEqual(assessmentSection.SpecificFailureMechanisms.Count, results[i].SpecificFailureMechanisms.Length);
                 foreach (SpecificFailureMechanism specificFailureMechanism in assessmentSection.SpecificFailureMechanisms)
                 {
-                    Assert.AreEqual(output[i].FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[specificFailureMechanism]), results[i].SpecificFailureMechanisms.Single());
+                    Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[specificFailureMechanism]), results[i].SpecificFailureMechanisms.Single());
                 }
+
+                Assert.AreEqual(output.CommonSectionAssemblyMethod, results[i].CommonSectionAssemblyMethod);
+                Assert.AreEqual(output.FailureMechanismResultsAssemblyMethod, results[i].FailureMechanismResultsAssemblyMethod);
+                Assert.AreEqual(output.CombinedSectionResultAssemblyMethod, results[i].CombinedSectionResultAssemblyMethod);
             }
         }
 
@@ -155,23 +164,25 @@
                                                                                     .ToDictionary(x => x.FailureMechanism, x => x.Index);
             var section1 = new CombinedAssemblyFailureMechanismSection(0, 5, random.NextEnumValue<FailureMechanismSectionAssemblyGroup>());
             var section2 = new CombinedAssemblyFailureMechanismSection(5, 11, random.NextEnumValue<FailureMechanismSectionAssemblyGroup>());
-            var output = new[]
-            {
-                new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)),
-                new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random))
-            };
+            var output = new CombinedFailureMechanismSectionAssemblyResultWrapper(
+                new[]
+                {
+                    new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)),
+                    new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random))
+                }, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
 
             // Call
             CombinedFailureMechanismSectionAssemblyResult[] results = CombinedFailureMechanismSectionAssemblyResultFactory.Create(
                 output, new Dictionary<IFailureMechanism, int>(), assessmentSection).ToArray();
 
             // Assert
-            Assert.AreEqual(output.Length, results.Length);
-            for (var i = 0; i < output.Length; i++)
+            Assert.AreEqual(output.AssemblyResults.Count(), results.Length);
+            for (var i = 0; i < output.AssemblyResults.Count(); i++)
             {
-                Assert.AreEqual(output[i].Section.SectionStart, results[i].SectionStart);
-                Assert.AreEqual(output[i].Section.SectionEnd, results[i].SectionEnd);
-                Assert.AreEqual(output[i].Section.FailureMechanismSectionAssemblyGroup, results[i].TotalResult);
+                CombinedFailureMechanismSectionAssembly assemblyResults = output.AssemblyResults.ElementAt(i);
+                Assert.AreEqual(assemblyResults.Section.SectionStart, results[i].SectionStart);
+                Assert.AreEqual(assemblyResults.Section.SectionEnd, results[i].SectionEnd);
+                Assert.AreEqual(assemblyResults.Section.FailureMechanismSectionAssemblyGroup, results[i].TotalResult);
 
                 Assert.IsNull(results[i].Piping);
                 Assert.IsNull(results[i].GrassCoverErosionInwards);
Index: Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultTest.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultTest.cs	(.../CombinedFailureMechanismSectionAssemblyResultTest.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultTest.cs	(.../CombinedFailureMechanismSectionAssemblyResultTest.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -38,7 +38,9 @@
 
             // Call
             void Call() => new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(),
-                                                                             random.NextEnumValue<FailureMechanismSectionAssemblyGroup>(), null);
+                                                                             random.NextEnumValue<FailureMechanismSectionAssemblyGroup>(),
+                                                                             random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>(),
+                                                                             random.NextEnumValue<AssemblyMethod>(), null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -53,9 +55,13 @@
             double sectionStart = random.NextDouble();
             double sectionEnd = random.NextDouble();
             var totalResult = random.NextEnumValue<FailureMechanismSectionAssemblyGroup>();
+            var commonSectionAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
+            var failureMechanismResultsAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
+            var combinedSectionResultAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
 
             // Call
-            var result = new CombinedFailureMechanismSectionAssemblyResult(sectionStart, sectionEnd, totalResult,
+            var result = new CombinedFailureMechanismSectionAssemblyResult(sectionStart, sectionEnd, totalResult, commonSectionAssemblyMethod,
+                                                                           failureMechanismResultsAssemblyMethod, combinedSectionResultAssemblyMethod,
                                                                            new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties());
 
             // Assert
@@ -78,6 +84,10 @@
             Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.StabilityPointStructures);
             Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.DuneErosion);
             Assert.IsEmpty(result.SpecificFailureMechanisms);
+
+            Assert.AreEqual(result.CommonSectionAssemblyMethod, commonSectionAssemblyMethod);
+            Assert.AreEqual(result.FailureMechanismResultsAssemblyMethod, failureMechanismResultsAssemblyMethod);
+            Assert.AreEqual(result.CombinedSectionResultAssemblyMethod, combinedSectionResultAssemblyMethod);
         }
 
         [Test]
@@ -109,9 +119,13 @@
                 random.NextEnumValue<FailureMechanismSectionAssemblyGroup>(),
                 random.NextEnumValue<FailureMechanismSectionAssemblyGroup>()
             };
+            var commonSectionAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
+            var failureMechanismResultsAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
+            var combinedSectionResultAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
 
             // Call
-            var result = new CombinedFailureMechanismSectionAssemblyResult(sectionStart, sectionEnd, totalResult,
+            var result = new CombinedFailureMechanismSectionAssemblyResult(sectionStart, sectionEnd, totalResult, commonSectionAssemblyMethod,
+                                                                           failureMechanismResultsAssemblyMethod, combinedSectionResultAssemblyMethod,
                                                                            new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties
                                                                            {
                                                                                Piping = pipingResult,
@@ -152,6 +166,9 @@
             Assert.AreEqual(stabilityPointStructuresResult, result.StabilityPointStructures);
             Assert.AreEqual(duneErosionResult, result.DuneErosion);
             CollectionAssert.AreEqual(specificFailureMechanismResults, result.SpecificFailureMechanisms);
+            Assert.AreEqual(result.CommonSectionAssemblyMethod, commonSectionAssemblyMethod);
+            Assert.AreEqual(result.FailureMechanismResultsAssemblyMethod, failureMechanismResultsAssemblyMethod);
+            Assert.AreEqual(result.CombinedSectionResultAssemblyMethod, combinedSectionResultAssemblyMethod);
         }
 
         [Test]
@@ -168,9 +185,13 @@
                 null,
                 null
             };
+            var commonSectionAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
+            var failureMechanismResultsAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
+            var combinedSectionResultAssemblyMethod = random.NextEnumValue<AssemblyMethod>();
 
             // Call
-            var result = new CombinedFailureMechanismSectionAssemblyResult(sectionStart, sectionEnd, totalResult,
+            var result = new CombinedFailureMechanismSectionAssemblyResult(sectionStart, sectionEnd, totalResult, commonSectionAssemblyMethod,
+                                                                           failureMechanismResultsAssemblyMethod, combinedSectionResultAssemblyMethod,
                                                                            new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties
                                                                            {
                                                                                Piping = null,
@@ -215,6 +236,10 @@
             {
                 Assert.IsNull(specificFailureMechanismResult);
             }
+
+            Assert.AreEqual(result.CommonSectionAssemblyMethod, commonSectionAssemblyMethod);
+            Assert.AreEqual(result.FailureMechanismResultsAssemblyMethod, failureMechanismResultsAssemblyMethod);
+            Assert.AreEqual(result.CombinedSectionResultAssemblyMethod, combinedSectionResultAssemblyMethod);
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/CombinedFailureMechanismSectionAssemblyResultRowTest.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/CombinedFailureMechanismSectionAssemblyResultRowTest.cs	(.../CombinedFailureMechanismSectionAssemblyResultRowTest.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/CombinedFailureMechanismSectionAssemblyResultRowTest.cs	(.../CombinedFailureMechanismSectionAssemblyResultRowTest.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -140,9 +140,8 @@
             // Setup
             var random = new Random(21);
 
-            var result = new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(),
-                                                                           random.NextDouble(),
-                                                                           assemblyGroup,
+            var result = new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(), assemblyGroup, random.NextEnumValue<AssemblyMethod>(),
+                                                                           random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>(),
                                                                            new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties
                                                                            {
                                                                                Piping = assemblyGroup,
@@ -203,9 +202,9 @@
             // Setup
             var random = new Random(21);
 
-            var result = new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(),
-                                                                           random.NextDouble(),
-                                                                           FailureMechanismSectionAssemblyGroup.Gr,
+            var result = new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(), FailureMechanismSectionAssemblyGroup.Gr,
+                                                                           random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>(),
+                                                                           random.NextEnumValue<AssemblyMethod>(),
                                                                            new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties
                                                                            {
                                                                                Piping = null,
@@ -264,9 +263,8 @@
         private static CombinedFailureMechanismSectionAssemblyResult GetCombinedFailureMechanismSectionAssemblyResult(bool failureMechanismsInAssembly)
         {
             var random = new Random(21);
-            return new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(),
-                                                                     random.NextDouble(),
-                                                                     random.NextEnumValue<FailureMechanismSectionAssemblyGroup>(),
+            return new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyGroup>(),
+                                                                     random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>(),
                                                                      new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties
                                                                      {
                                                                          Piping = GetFailureMechanismSectionAssemblyGroup(failureMechanismsInAssembly, random),
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r3e75fc50ffdf533afc5985680446e00f32c38f8a
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs	(.../ExportableCombinedSectionAssemblyFactoryTest.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs	(.../ExportableCombinedSectionAssemblyFactoryTest.cs)	(revision 3e75fc50ffdf533afc5985680446e00f32c38f8a)
@@ -108,8 +108,8 @@
         {
             var random = new Random(seed);
 
-            return new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(),
-                                                                     random.NextEnumValue<FailureMechanismSectionAssemblyGroup>(),
+            return new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(), random.NextEnumValue<FailureMechanismSectionAssemblyGroup>(),
+                                                                     random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>(),
                                                                      new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties
                                                                      {
                                                                          Piping = GetAssemblyGroup(random, hasAssemblyGroupResults),