Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r38dc28e4feb88ad7d1f12b77d90d24de0bfa2663 -r4fb11605ba89dbc4704a2a50493e810f2aa95850
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 38dc28e4feb88ad7d1f12b77d90d24de0bfa2663)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 4fb11605ba89dbc4704a2a50493e810f2aa95850)
@@ -1,9 +1,13 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using Ringtoets.AssemblyTool.Data;
 using Ringtoets.Common.Data.Exceptions;
+using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Data.Assembly;
 using Ringtoets.Integration.IO.Assembly;
+using Ringtoets.Piping.Data;
 
 namespace Ringtoets.Integration.IO.Factories
 {
@@ -34,7 +38,7 @@
             return new ExportableAssessmentSection(assessmentSection.Name,
                                                    assessmentSection.ReferenceLine.Points,
                                                    CreateExportableAssessmentSectionAssemblyResult(assessmentSection),
-                                                   Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>(),
+                                                   CreateExportableFailureMechanismsWithProbability(assessmentSection),
                                                    Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>(),
                                                    new ExportableCombinedSectionAssemblyCollection(Enumerable.Empty<ExportableCombinedFailureMechanismSection>(),
                                                                                                    Enumerable.Empty<ExportableCombinedSectionAssembly>()));
@@ -54,5 +58,84 @@
             return new ExportableAssessmentSectionAssemblyResult(ExportableAssemblyMethod.WBI2C1,
                                                                  AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection));
         }
+
+        private static IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> CreateExportableFailureMechanismsWithProbability(AssessmentSection assessmentSection)
+        {
+            var exportableFailureMechanisms = new List<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            exportableFailureMechanisms.Add(CreateExportablePipingFailureMechanism(assessmentSection));
+
+            return exportableFailureMechanisms;
+        }
+
+        private static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> CreateExportablePipingFailureMechanism(AssessmentSection assessmentSection)
+        {
+            FailureMechanismAssembly failureMechanismAssembly = PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.Piping, assessmentSection);
+
+            Dictionary<PipingFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
+                assessmentSection.Piping
+                                 .SectionResults
+                                 .ToDictionary(s => s, sectionResult => CreateExportableFailureMechanismSection(sectionResult.Section));
+
+            return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
+                new ExportableFailureMechanismAssemblyResultWithProbability(ExportableAssemblyMethod.WBI1B1,
+                                                                            failureMechanismAssembly.Group,
+                                                                            failureMechanismAssembly.Probability),
+                failureMechanismSectionsLookup.Values,
+                CreateExportablePipingFailureMechanismSectionResults(failureMechanismSectionsLookup, assessmentSection),
+                ExportableFailureMechanismType.STPH,
+                ExportableFailureMechanismGroup.Group2);
+        }
+
+        private static IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> CreateExportablePipingFailureMechanismSectionResults(
+            Dictionary<PipingFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSections,
+            AssessmentSection assessmentSection)
+        {
+            PipingFailureMechanism pipingFailureMechanism = assessmentSection.Piping;
+            IEnumerable<PipingCalculationScenario> pipingCalculationScenarios = pipingFailureMechanism.Calculations.Cast<PipingCalculationScenario>();
+
+            var exportableResults = new List<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>();
+            foreach (KeyValuePair<PipingFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSections)
+            {
+                PipingFailureMechanismSectionResult failureMechanismSectionResult = failureMechanismSectionPair.Key;
+                FailureMechanismSectionAssembly simpleAssembly =
+                    PipingFailureMechanismAssemblyFactory.AssembleSimpleAssessment(failureMechanismSectionResult);
+
+                FailureMechanismSectionAssembly detailedAssembly =
+                    PipingFailureMechanismAssemblyFactory.AssembleDetailedAssessment(failureMechanismSectionResult,
+                                                                                     pipingCalculationScenarios,
+                                                                                     pipingFailureMechanism,
+                                                                                     assessmentSection);
+                FailureMechanismSectionAssembly tailorMadeAssembly =
+                    PipingFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(failureMechanismSectionResult,
+                                                                                       pipingFailureMechanism,
+                                                                                       assessmentSection);
+                FailureMechanismSectionAssembly combinedAssembly =
+                    PipingFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanismSectionResult,
+                                                                                     pipingCalculationScenarios,
+                                                                                     pipingFailureMechanism,
+                                                                                     assessmentSection);
+
+                exportableResults.Add(
+                    new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability(
+                        failureMechanismSectionPair.Value,
+                        CreateExportableSectionAssemblyResultWithProbability(simpleAssembly, ExportableAssemblyMethod.WBI0E1),
+                        CreateExportableSectionAssemblyResultWithProbability(detailedAssembly, ExportableAssemblyMethod.WBI0G5),
+                        CreateExportableSectionAssemblyResultWithProbability(tailorMadeAssembly, ExportableAssemblyMethod.WBI0T5),
+                        CreateExportableSectionAssemblyResultWithProbability(combinedAssembly, ExportableAssemblyMethod.WBI1B1)));
+            }
+
+            return exportableResults;
+        }
+
+        private static ExportableSectionAssemblyResultWithProbability CreateExportableSectionAssemblyResultWithProbability(FailureMechanismSectionAssembly assembly,
+                                                                                                                           ExportableAssemblyMethod exportableAssemblyMethod)
+        {
+            return new ExportableSectionAssemblyResultWithProbability(exportableAssemblyMethod, assembly.Group, assembly.Probability);
+        }
+
+        private static ExportableFailureMechanismSection CreateExportableFailureMechanismSection(FailureMechanismSection failureMechanismSection)
+        {
+            return new ExportableFailureMechanismSection(failureMechanismSection.Points, double.NaN, double.NaN);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj
===================================================================
diff -u -r38dc28e4feb88ad7d1f12b77d90d24de0bfa2663 -r4fb11605ba89dbc4704a2a50493e810f2aa95850
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 38dc28e4feb88ad7d1f12b77d90d24de0bfa2663)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 4fb11605ba89dbc4704a2a50493e810f2aa95850)
@@ -97,6 +97,11 @@
       <Name>Ringtoets.Common.Util</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Piping\src\Ringtoets.Piping.Data\Ringtoets.Piping.Data.csproj">
+      <Project>{CE994CC9-6F6A-48AC-B4BE-02C30A21F4DB}</Project>
+      <Name>Ringtoets.Piping.Data</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
       <Project>{11F1F874-45AF-43E4-8AE5-15A5C9593E28}</Project>
       <Name>Ringtoets.Integration.Data</Name>
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs
===================================================================
diff -u -r38dc28e4feb88ad7d1f12b77d90d24de0bfa2663 -r4fb11605ba89dbc4704a2a50493e810f2aa95850
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 38dc28e4feb88ad7d1f12b77d90d24de0bfa2663)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 4fb11605ba89dbc4704a2a50493e810f2aa95850)
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Core.Common.Base.Geometry;
 using Core.Common.TestUtil;
 using NUnit.Framework;
@@ -8,6 +10,8 @@
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.IO.Assembly;
 using Ringtoets.Integration.IO.Factories;
@@ -48,11 +52,14 @@
                 ReferenceLine = referenceLine
             };
 
+            AddFailureMechanismSections(assessmentSection.Piping);
+
             using (new AssemblyToolCalculatorFactoryConfig())
             {
                 var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
-                AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
-                calculator.AssembleAssessmentSectionCategoryGroupOutput = random.NextEnumValue<AssessmentSectionAssemblyCategoryGroup>();
+                AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator;
+                FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
 
                 // Call
                 ExportableAssessmentSection exportableAssessmentSection = ExportableAssessmentSectionFactory.CreateExportableAssessmentSection(assessmentSection);
@@ -62,12 +69,26 @@
                 CollectionAssert.AreEqual(referenceLine.Points, exportableAssessmentSection.Geometry);
 
                 ExportableAssessmentSectionAssemblyResult exportableAssessmentSectionAssemblyResult = exportableAssessmentSection.AssessmentSectionAssembly;
-                Assert.AreEqual(calculator.AssembleAssessmentSectionCategoryGroupOutput, exportableAssessmentSectionAssemblyResult.AssemblyCategory);
+                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleAssessmentSectionCategoryGroupOutput, exportableAssessmentSectionAssemblyResult.AssemblyCategory);
                 Assert.AreEqual(ExportableAssemblyMethod.WBI2C1, exportableAssessmentSectionAssemblyResult.AssemblyMethod);
 
-                CollectionAssert.IsEmpty(exportableAssessmentSection.FailureMechanismsWithProbability);
+                Assert.AreEqual(1, exportableAssessmentSection.FailureMechanismsWithProbability.Count());
+                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> piping = exportableAssessmentSection.FailureMechanismsWithProbability.First();
+                Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Group, piping.FailureMechanismAssembly.AssemblyCategory);
+                Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Probability, piping.FailureMechanismAssembly.Probability);
+                Assert.AreEqual(ExportableFailureMechanismType.STPH, piping.Code);
+                Assert.AreEqual(ExportableFailureMechanismGroup.Group2, piping.Group);
+
+                AssertExportableFailureMechanismSections(assessmentSection.Piping.Sections, piping.Sections);
+                AssertExportablePipingFailureMechanismSectionResults(failureMechanismSectionAssemblyCalculator.SimpleAssessmentAssemblyOutput,
+                                                                     failureMechanismSectionAssemblyCalculator.DetailedAssessmentAssemblyOutput,
+                                                                     failureMechanismSectionAssemblyCalculator.TailorMadeAssessmentAssemblyOutput,
+                                                                     failureMechanismSectionAssemblyCalculator.CombinedAssemblyOutput,
+                                                                     piping.Sections,
+                                                                     piping.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
+
                 CollectionAssert.IsEmpty(exportableAssessmentSection.FailureMechanismsWithoutProbability);
-                Assert.IsNotNull(exportableAssessmentSection.CombinedSectionAssemblyResults);   
+                Assert.IsNotNull(exportableAssessmentSection.CombinedSectionAssemblyResults);
             }
         }
 
@@ -84,7 +105,7 @@
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
-                var calculatorfactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
+                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
                 AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator;
                 calculator.ThrowExceptionOnCalculate = true;
 
@@ -95,5 +116,106 @@
                 Assert.Throws<AssemblyException>(call);
             }
         }
+
+        private static void AssertExportableFailureMechanismSections(IEnumerable<FailureMechanismSection> expectedSections,
+                                                                     IEnumerable<ExportableFailureMechanismSection> actualSections)
+        {
+            int expectedNrOfSections = expectedSections.Count();
+            Assert.AreEqual(expectedNrOfSections, actualSections.Count());
+            for (var i = 0; i < expectedNrOfSections; i++)
+            {
+                FailureMechanismSection expectedSection = expectedSections.ElementAt(i);
+                ExportableFailureMechanismSection actualSection = actualSections.ElementAt(i);
+
+                AssertExportableFailureMechanismSection(expectedSection, actualSection);
+            }
+        }
+
+        private static void AssertExportableFailureMechanismSection(FailureMechanismSection expectedSection,
+                                                                    ExportableFailureMechanismSection actualSection)
+        {
+            Assert.IsNaN(actualSection.StartDistance);
+            Assert.IsNaN(actualSection.EndDistance);
+            CollectionAssert.AreEqual(expectedSection.Points, actualSection.Geometry);
+        }
+
+        private static void AssertExportablePipingFailureMechanismSectionResults(FailureMechanismSectionAssembly expectedSimpleAssembly,
+                                                                                 FailureMechanismSectionAssembly expectedDetailedAssembly,
+                                                                                 FailureMechanismSectionAssembly expectedTailorMadeAssembly,
+                                                                                 FailureMechanismSectionAssembly expectedCombinedAssembly,
+                                                                                 IEnumerable<ExportableFailureMechanismSection> sections,
+                                                                                 IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> results)
+        {
+            int expectedNrOfResults = sections.Count();
+            Assert.AreEqual(expectedNrOfResults, results.Count());
+
+            for (var i = 0; i < expectedNrOfResults; i++)
+            {
+                ExportableFailureMechanismSection section = sections.ElementAt(i);
+                ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability result = results.ElementAt(i);
+
+                AssertExportablePipingFailureMechanismSectionResult(expectedSimpleAssembly,
+                                                                    expectedDetailedAssembly,
+                                                                    expectedTailorMadeAssembly,
+                                                                    expectedCombinedAssembly,
+                                                                    section,
+                                                                    result);
+            }
+        }
+
+        private static void AssertExportablePipingFailureMechanismSectionResult(FailureMechanismSectionAssembly expectedSimpleAssembly,
+                                                                                FailureMechanismSectionAssembly expectedDetailedAssembly,
+                                                                                FailureMechanismSectionAssembly expectedTailorMadeAssembly,
+                                                                                FailureMechanismSectionAssembly expectedCombinedAssembly,
+                                                                                ExportableFailureMechanismSection expectedSection,
+                                                                                ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability actualResult)
+        {
+            Assert.AreSame(expectedSection, actualResult.FailureMechanismSection);
+
+            ExportableSectionAssemblyResultWithProbability actualSimpleAssembly = actualResult.SimpleAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI0E1, actualSimpleAssembly.AssemblyMethod);
+            Assert.AreEqual(expectedSimpleAssembly.Group, actualSimpleAssembly.AssemblyCategory);
+            Assert.AreEqual(expectedSimpleAssembly.Probability, actualSimpleAssembly.Probability);
+
+            ExportableSectionAssemblyResultWithProbability actualDetailedAssembly = actualResult.DetailedAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI0G5, actualDetailedAssembly.AssemblyMethod);
+            Assert.AreEqual(expectedDetailedAssembly.Group, actualDetailedAssembly.AssemblyCategory);
+            Assert.AreEqual(expectedDetailedAssembly.Probability, actualDetailedAssembly.Probability);
+
+            ExportableSectionAssemblyResultWithProbability actualTailorMadeAssembly = actualResult.TailorMadeAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI0T5, actualTailorMadeAssembly.AssemblyMethod);
+            Assert.AreEqual(expectedTailorMadeAssembly.Group, actualTailorMadeAssembly.AssemblyCategory);
+            Assert.AreEqual(expectedTailorMadeAssembly.Probability, actualTailorMadeAssembly.Probability);
+
+            ExportableSectionAssemblyResultWithProbability actualCombinedResult = actualResult.CombinedAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, actualCombinedResult.AssemblyMethod);
+            Assert.AreEqual(expectedCombinedAssembly.Group, actualCombinedResult.AssemblyCategory);
+            Assert.AreEqual(expectedCombinedAssembly.Probability, actualCombinedResult.Probability);
+        }
+
+        private static void AddFailureMechanismSections(IFailureMechanism failureMechanism)
+        {
+            const int numberOfSections = 3;
+
+            var startPoint = new Point2D(-1, -1);
+            var endPoint = new Point2D(15, 15);
+            double endPointStepsX = (endPoint.X - startPoint.X) / numberOfSections;
+            double endPointStepsY = (endPoint.Y - startPoint.Y) / numberOfSections;
+
+            var sections = new List<FailureMechanismSection>();
+            for (var i = 1; i <= numberOfSections; i++)
+            {
+                endPoint = new Point2D(startPoint.X + endPointStepsX, startPoint.Y + endPointStepsY);
+                sections.Add(new FailureMechanismSection(i.ToString(),
+                                                         new[]
+                                                         {
+                                                             startPoint,
+                                                             endPoint
+                                                         }));
+                startPoint = endPoint;
+            }
+
+            FailureMechanismTestHelper.SetSections(failureMechanism, sections);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj
===================================================================
diff -u -r38dc28e4feb88ad7d1f12b77d90d24de0bfa2663 -r4fb11605ba89dbc4704a2a50493e810f2aa95850
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 38dc28e4feb88ad7d1f12b77d90d24de0bfa2663)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 4fb11605ba89dbc4704a2a50493e810f2aa95850)
@@ -88,6 +88,10 @@
       <Project>{54DF6303-BF9A-4AE9-BE09-4AF50EF27412}</Project>
       <Name>Ringtoets.Common.Util.TestUtil</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Piping\src\Ringtoets.Piping.Data\Ringtoets.Piping.Data.csproj">
+      <Project>{ce994cc9-6f6a-48ac-b4be-02c30a21f4db}</Project>
+      <Name>Ringtoets.Piping.Data</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\src\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
       <Project>{11F1F874-45AF-43E4-8AE5-15A5C9593E28}</Project>
       <Name>Ringtoets.Integration.Data</Name>