Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -rec2c838182ed237b3abd753347a861857129331b -r47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53
--- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs)	(revision ec2c838182ed237b3abd753347a861857129331b)
+++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs)	(revision 47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53)
@@ -20,12 +20,14 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
 using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.FailurePath;
 
 namespace Riskeer.GrassCoverErosionInwards.Data
 {
@@ -71,5 +73,39 @@
                 new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(sectionResult, calculationScenarios),
                 failureMechanism.GeneralInput.ApplyLengthEffectInSection, 1.0);
         }
+
+        /// <summary>
+        /// Assembles the failure mechanism based on its input arguments.
+        /// </summary>
+        /// <param name="failureMechanism">The <see cref="GrassCoverErosionInwardsFailureMechanism"/> to assemble.</param>
+        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the <paramref name="failureMechanism"/>
+        /// belongs to.</param>
+        /// <returns>A <see cref="double"/> representing the assembly result.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any argument is <c>null</c>.</exception>
+        /// <exception cref="AssemblyException">Thrown when the failure mechanism could not be assembled.</exception>
+        public static double AssembleFailureMechanism(GrassCoverErosionInwardsFailureMechanism failureMechanism,
+                                                      IAssessmentSection assessmentSection)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            Func<double> performAssemblyFunc = () =>
+            {
+                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
+                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
+                                    .ToArray();
+
+                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.GeneralInput.N,
+                                                                                      sectionAssemblyResults);
+            };
+            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs
===================================================================
diff -u -r562b41f8cf13ba3d6a29919c6841c3ad8c1c8df1 -r47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53
--- Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision 562b41f8cf13ba3d6a29919c6841c3ad8c1c8df1)
+++ Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs	(.../GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision 47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53)
@@ -33,6 +33,7 @@
 using Riskeer.Common.Data.Contribution;
 using Riskeer.Common.Data.Exceptions;
 using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.FailurePath;
 using Riskeer.Common.Data.TestUtil;
 using Riskeer.Common.Primitives;
 
@@ -41,6 +42,8 @@
     [TestFixture]
     public class GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest
     {
+        #region AssembleSection
+
         [Test]
         public void AssembleSection_SectionResultNull_ThrowsArgumentNullException()
         {
@@ -197,5 +200,136 @@
                 Assert.AreEqual(innerException.Message, exception.Message);
             }
         }
+
+        #endregion
+
+        [Test]
+        public void AssembleFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(null, assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
+
+            // Call
+            void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
+        {
+            // Setup
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
+            {
+                AssemblyResult =
+                {
+                    ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic
+                }
+            };
+            failureMechanism.SetSections(new[]
+            {
+                FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+            }, "APath");
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+
+                // Call
+                GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                double expectedN = failureMechanism.GeneralInput.N;
+                Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN);
+                Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
+            }
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
+        {
+            // Setup
+            var random = new Random(21);
+            double assemblyOutput = random.NextDouble();
+
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
+            {
+                AssemblyResult =
+                {
+                    ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic
+                }
+            };
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+                calculator.AssemblyResult = assemblyOutput;
+
+                // Call
+                double result = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                Assert.AreEqual(assemblyOutput, result);
+            }
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
+        {
+            // Setup
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
+            {
+                AssemblyResult =
+                {
+                    ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic
+                }
+            };
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+                calculator.ThrowExceptionOnCalculate = true;
+
+                // Call
+                void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                var exception = Assert.Throws<AssemblyException>(Call);
+                Exception innerException = exception.InnerException;
+                Assert.IsInstanceOf<FailureMechanismAssemblyCalculatorException>(innerException);
+                Assert.AreEqual(innerException.Message, exception.Message);
+            }
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs
===================================================================
diff -u -r450fdfb2f034723cf74dc02d58cc1d9248f414a4 -r47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53
--- Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision 450fdfb2f034723cf74dc02d58cc1d9248f414a4)
+++ Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs)	(revision 47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53)
@@ -20,12 +20,14 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssemblyTool;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
 using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.FailurePath;
 using Riskeer.Common.Data.Probability;
 
 namespace Riskeer.MacroStabilityInwards.Data
@@ -73,5 +75,39 @@
                 failureMechanism.GeneralInput.ApplyLengthEffectInSection,
                 failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(sectionResult.Section.Length));
         }
+
+        /// <summary>
+        /// Assembles the failure mechanism based on its input arguments.
+        /// </summary>
+        /// <param name="failureMechanism">The <see cref="MacroStabilityInwardsFailureMechanism"/> to assemble.</param>
+        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the <paramref name="failureMechanism"/>
+        /// belongs to.</param>
+        /// <returns>A <see cref="double"/> representing the assembly result.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any argument is <c>null</c>.</exception>
+        /// <exception cref="AssemblyException">Thrown when the failure mechanism could not be assembled.</exception>
+        public static double AssembleFailureMechanism(MacroStabilityInwardsFailureMechanism failureMechanism,
+                                                      IAssessmentSection assessmentSection)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            Func<double> performAssemblyFunc = () =>
+            {
+                IEnumerable<FailureMechanismSectionAssemblyResult> sectionAssemblyResults =
+                    failureMechanism.SectionResults.Select(sr => AssembleSection(sr, failureMechanism, assessmentSection))
+                                    .ToArray();
+
+                return FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length),
+                                                                                      sectionAssemblyResults);
+            };
+            return FailurePathAssemblyHelper.AssembleFailurePath(failureMechanism, performAssemblyFunc);
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs
===================================================================
diff -u -r450fdfb2f034723cf74dc02d58cc1d9248f414a4 -r47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53
--- Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision 450fdfb2f034723cf74dc02d58cc1d9248f414a4)
+++ Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs	(.../MacroStabilityInwardsFailureMechanismAssemblyFactoryTest.cs)	(revision 47ce3d9e30dba726a2621ec5cdf8cd4e18d79d53)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.Linq;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Rhino.Mocks;
@@ -32,6 +33,8 @@
 using Riskeer.Common.Data.Contribution;
 using Riskeer.Common.Data.Exceptions;
 using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.FailurePath;
+using Riskeer.Common.Data.Probability;
 using Riskeer.Common.Data.TestUtil;
 using Riskeer.Common.Primitives;
 
@@ -40,6 +43,8 @@
     [TestFixture]
     public class MacroStabilityInwardsFailureMechanismAssemblyFactoryTest
     {
+        #region AssembleSection
+
         [Test]
         public void AssembleSection_SectionResultNull_ThrowsArgumentNullException()
         {
@@ -196,5 +201,140 @@
                 Assert.AreEqual(innerException.Message, exception.Message);
             }
         }
+
+        #endregion
+
+        #region AssembleFailureMechanism
+
+        [Test]
+        public void AssembleFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            void Call() => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(null, assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism();
+
+            // Call
+            void Call() => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
+        {
+            // Setup
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism
+            {
+                AssemblyResult =
+                {
+                    ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic
+                }
+            };
+            failureMechanism.SetSections(new[]
+            {
+                FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+            }, "APath");
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+
+                // Call
+                MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                double expectedN = failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length);
+                Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN);
+                Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
+            }
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
+        {
+            // Setup
+            var random = new Random(21);
+            double assemblyOutput = random.NextDouble();
+
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism
+            {
+                AssemblyResult =
+                {
+                    ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic
+                }
+            };
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+                calculator.AssemblyResult = assemblyOutput;
+
+                // Call
+                double result = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                Assert.AreEqual(assemblyOutput, result);
+            }
+        }
+
+        [Test]
+        public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
+        {
+            // Setup
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism
+            {
+                AssemblyResult =
+                {
+                    ProbabilityResultType = FailurePathAssemblyProbabilityResultType.Automatic
+                }
+            };
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
+                calculator.ThrowExceptionOnCalculate = true;
+
+                // Call
+                void Call() => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                var exception = Assert.Throws<AssemblyException>(Call);
+                Exception innerException = exception.InnerException;
+                Assert.IsInstanceOf<FailureMechanismAssemblyCalculatorException>(innerException);
+                Assert.AreEqual(innerException.Message, exception.Message);
+            }
+        }
+
+        #endregion
     }
 }
\ No newline at end of file