Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.IO.TestUtil/ExportableFailureMechanismSectionTestHelper.cs
===================================================================
diff -u -rf56c6e3627abb4f2399032992d4793089f86d419 -rd41d466b016e29fb8e52680f61a8cb744be378ce
--- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.IO.TestUtil/ExportableFailureMechanismSectionTestHelper.cs	(.../ExportableFailureMechanismSectionTestHelper.cs)	(revision f56c6e3627abb4f2399032992d4793089f86d419)
+++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.IO.TestUtil/ExportableFailureMechanismSectionTestHelper.cs	(.../ExportableFailureMechanismSectionTestHelper.cs)	(revision d41d466b016e29fb8e52680f61a8cb744be378ce)
@@ -43,7 +43,8 @@
         /// <list type="bullet">
         /// <item>The number of sections between <paramref name="expectedSections"/> and <paramref name="actualSections"/>
         /// do not match. </item>
-        /// <item>The geometry of any the sections are not equal.</item>
+        /// <item>The geometry of the sections are not equal.</item>
+        /// <item>The id does not contain the expected value.</item>
         /// </list></exception>
         public static void AssertExportableFailureMechanismSections(IEnumerable<FailureMechanismSection> expectedSections,
                                                                     IEnumerable<ExportableFailureMechanismSection> actualSections)
@@ -56,6 +57,8 @@
             {
                 FailureMechanismSection expectedSection = expectedSections.ElementAt(i);
                 ExportableFailureMechanismSection actualSection = actualSections.ElementAt(i);
+                
+                Assert.AreEqual($"Bv.{i}", actualSection.Id);
 
                 double expectedEndDistance = expectedStartDistance + Math2D.Length(expectedSection.Points);
 
Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r48cf7bc97178507b34018066b407c85f7f47d3a5 -rd41d466b016e29fb8e52680f61a8cb744be378ce
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 48cf7bc97178507b34018066b407c85f7f47d3a5)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision d41d466b016e29fb8e52680f61a8cb744be378ce)
@@ -85,7 +85,7 @@
                                                    assessmentSection.ReferenceLine.Points,
                                                    CreateExportableFailureMechanismSectionCollections(idGenerator, registry, assessmentSection),
                                                    CreateExportableAssessmentSectionAssemblyResult(idGenerator, assessmentSection),
-                                                   CreateExportableFailureMechanisms(idGenerator, assessmentSection),
+                                                   CreateExportableFailureMechanisms(idGenerator, registry, assessmentSection),
                                                    CreateExportableCombinedSectionAssemblyCollection(assessmentSection));
         }
 
@@ -149,73 +149,75 @@
         /// for failure mechanisms that are in assembly based on <paramref name="assessmentSection"/>.
         /// </summary>
         /// <param name="idGenerator">The generator to generate ids for the exportable components.</param>
+        /// <param name="registry">The <see cref="ExportableModelRegistry"/> to keep track of the created items.</param>
         /// <param name="assessmentSection">The assessment section to create a collection of
         /// <see cref="ExportableFailureMechanism"/> with probability for.</param>
         /// <returns>A collection of <see cref="ExportableFailureMechanism"/> based on failure
         /// mechanisms that are in assembly.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created for <paramref name="assessmentSection"/>.</exception>
-        private static IEnumerable<ExportableFailureMechanism> CreateExportableFailureMechanisms(IdentifierGenerator idGenerator, AssessmentSection assessmentSection)
+        private static IEnumerable<ExportableFailureMechanism> CreateExportableFailureMechanisms(
+            IdentifierGenerator idGenerator, ExportableModelRegistry registry, AssessmentSection assessmentSection)
         {
             var exportableFailureMechanisms = new List<ExportableFailureMechanism>();
 
             AddGenericFailureMechanismWhenInAssembly<PipingFailureMechanism, AdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.Piping, assessmentSection, PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.Piping, assessmentSection, PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 PipingFailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<GrassCoverErosionInwardsFailureMechanism, AdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.GrassCoverErosionInwards, assessmentSection, GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.GrassCoverErosionInwards, assessmentSection, GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<MacroStabilityInwardsFailureMechanism, AdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.MacroStabilityInwards, assessmentSection, MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.MacroStabilityInwards, assessmentSection, MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.Microstability, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.Microstability, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 FailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<StabilityStoneCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.StabilityStoneCover, assessmentSection, StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.StabilityStoneCover, assessmentSection, StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<WaveImpactAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.WaveImpactAsphaltCover, assessmentSection, WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.WaveImpactAsphaltCover, assessmentSection, WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.WaterPressureAsphaltCover, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.WaterPressureAsphaltCover, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 FailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<GrassCoverErosionOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.GrassCoverErosionOutwards, assessmentSection, GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.GrassCoverErosionOutwards, assessmentSection, GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.GrassCoverSlipOffOutwards, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.GrassCoverSlipOffOutwards, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 FailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.GrassCoverSlipOffInwards, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.GrassCoverSlipOffInwards, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 FailureMechanismAssemblyFactory.AssembleSection);
 
             AddGenericFailureMechanismWhenInAssembly<HeightStructuresFailureMechanism, AdoptableFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.HeightStructures, assessmentSection, HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.HeightStructures, assessmentSection, HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 StructuresFailureMechanismAssemblyFactory.AssembleSection<HeightStructuresInput>);
 
             AddGenericFailureMechanismWhenInAssembly<ClosingStructuresFailureMechanism, AdoptableFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.ClosingStructures, assessmentSection, ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.ClosingStructures, assessmentSection, ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 StructuresFailureMechanismAssemblyFactory.AssembleSection<ClosingStructuresInput>);
 
             AddGenericFailureMechanismWhenInAssembly<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.PipingStructure, assessmentSection, PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.PipingStructure, assessmentSection, PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 (sr, fm, ass) => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, ass));
 
             AddGenericFailureMechanismWhenInAssembly<StabilityPointStructuresFailureMechanism, AdoptableFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.StabilityPointStructures, assessmentSection, StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.StabilityPointStructures, assessmentSection, StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 StructuresFailureMechanismAssemblyFactory.AssembleSection<StabilityPointStructuresInput>);
 
             AddGenericFailureMechanismWhenInAssembly<DuneErosionFailureMechanism, NonAdoptableFailureMechanismSectionResult>(
-                idGenerator, exportableFailureMechanisms, assessmentSection.DuneErosion, assessmentSection, DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                idGenerator, registry, exportableFailureMechanisms, assessmentSection.DuneErosion, assessmentSection, DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 (sr, fm, ass) => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, ass));
 
             foreach (SpecificFailureMechanism specificFailureMechanism in assessmentSection.SpecificFailureMechanisms)
@@ -224,7 +226,7 @@
                 {
                     exportableFailureMechanisms.Add(
                         ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
-                            idGenerator, specificFailureMechanism, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                            idGenerator, registry, specificFailureMechanism, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
                             FailureMechanismAssemblyFactory.AssembleSection));
                 }
             }
@@ -233,7 +235,8 @@
         }
 
         private static void AddGenericFailureMechanismWhenInAssembly<TFailureMechanism, TSectionResult>(
-            IdentifierGenerator idGenerator, List<ExportableFailureMechanism> exportableFailureMechanisms, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
+            IdentifierGenerator idGenerator, ExportableModelRegistry registry, List<ExportableFailureMechanism> exportableFailureMechanisms, 
+            TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
             Func<TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
             Func<TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
             where TFailureMechanism : IFailureMechanism<TSectionResult>
@@ -243,7 +246,7 @@
             {
                 exportableFailureMechanisms.Add(
                     ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism(
-                        idGenerator, failureMechanism, assessmentSection, assembleFailureMechanismFunc, assembleFailureMechanismSectionFunc));
+                        idGenerator, registry, failureMechanism, assessmentSection, assembleFailureMechanismFunc, assembleFailureMechanismSectionFunc));
             }
         }
 
Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs
===================================================================
diff -u -rd45c4d685f147e9ef02db77b8085ce59edf92d08 -rd41d466b016e29fb8e52680f61a8cb744be378ce
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision d45c4d685f147e9ef02db77b8085ce59edf92d08)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision d41d466b016e29fb8e52680f61a8cb744be378ce)
@@ -42,6 +42,7 @@
         /// with assembly results based on the input parameters.
         /// </summary>
         /// <param name="idGenerator">The generator to generate ids for the exportable components.</param>
+        /// <param name="registry">The <see cref="ExportableModelRegistry"/> to keep track of the created items.</param>
         /// <param name="failureMechanism">The failure mechanism to create an <see cref="ExportableFailureMechanism"/> for.</param>
         /// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
         /// <param name="assembleFailureMechanismFunc">The <see cref="Func{T1,T2,TResult}"/> to perform
@@ -51,12 +52,10 @@
         /// <typeparam name="TFailureMechanism">The type of the failure mechanism.</typeparam>
         /// <typeparam name="TSectionResult">The type of the section result.</typeparam>
         /// <returns>An <see cref="ExportableFailureMechanism"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="idGenerator"/>, <paramref name="failureMechanism"/>,
-        /// <paramref name="assessmentSection"/>, <paramref name="assembleFailureMechanismFunc"/> or
-        /// <paramref name="assembleFailureMechanismSectionFunc"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableGenericFailureMechanism CreateExportableGenericFailureMechanism<TFailureMechanism, TSectionResult>(
-            IdentifierGenerator idGenerator, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
+            IdentifierGenerator idGenerator, ExportableModelRegistry registry, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
             Func<TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
             Func<TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
             where TFailureMechanism : IFailureMechanism<TSectionResult>
@@ -67,6 +66,11 @@
                 throw new ArgumentNullException(nameof(idGenerator));
             }
 
+            if (registry == null)
+            {
+                throw new ArgumentNullException(nameof(registry));
+            }
+
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
@@ -92,7 +96,8 @@
                                                          new ExportableFailureMechanismAssemblyResult(
                                                              assemblyResultWrapper.AssemblyResult,
                                                              ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyMethod)),
-                                                         CreateExportableFailureMechanismSectionResults(idGenerator, failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
+                                                         CreateExportableFailureMechanismSectionResults(idGenerator, registry,
+                                                                                                        failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
                                                          failureMechanism.Code);
         }
 
@@ -101,19 +106,18 @@
         /// with assembly results based on the input parameters.
         /// </summary>
         /// <param name="idGenerator">The generator to generate ids for the exportable components.</param>
+        /// <param name="registry">The <see cref="ExportableModelRegistry"/> to keep track of the created items.</param>
         /// <param name="failureMechanism">The failure mechanism to create an <see cref="ExportableFailureMechanism"/> for.</param>
         /// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
         /// <param name="assembleFailureMechanismFunc">The <see cref="Func{T1,T2,TResult}"/> to perform
         /// the failure mechanism assembly.</param>
         /// <param name="assembleFailureMechanismSectionFunc">The <see cref="Func{T1,T2,T3,TResult}"/>
         /// to perform the failure mechanism section assembly.</param>
         /// <returns>An <see cref="ExportableFailureMechanism"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="idGenerator"/>, <paramref name="failureMechanism"/>,
-        /// <paramref name="assessmentSection"/>, <paramref name="assembleFailureMechanismFunc"/> or
-        /// <paramref name="assembleFailureMechanismSectionFunc"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableSpecificFailureMechanism CreateExportableSpecificFailureMechanism(
-            IdentifierGenerator idGenerator, SpecificFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
+            IdentifierGenerator idGenerator, ExportableModelRegistry registry, SpecificFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
             Func<SpecificFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
             Func<NonAdoptableWithProfileProbabilityFailureMechanismSectionResult, SpecificFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
         {
@@ -122,6 +126,11 @@
                 throw new ArgumentNullException(nameof(idGenerator));
             }
 
+            if (registry == null)
+            {
+                throw new ArgumentNullException(nameof(registry));
+            }
+
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
@@ -147,7 +156,8 @@
                                                           new ExportableFailureMechanismAssemblyResult(
                                                               assemblyResultWrapper.AssemblyResult,
                                                               ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyMethod)),
-                                                          CreateExportableFailureMechanismSectionResults(idGenerator, failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
+                                                          CreateExportableFailureMechanismSectionResults(idGenerator, registry, failureMechanism,
+                                                                                                         assessmentSection, assembleFailureMechanismSectionFunc),
                                                           failureMechanism.Name);
         }
 
@@ -156,6 +166,7 @@
         /// with assembly results based on <paramref name="failureMechanism"/>.
         /// </summary>
         /// <param name="idGenerator">The generator to generate ids for the exportable components.</param>
+        /// <param name="registry">The <see cref="ExportableModelRegistry"/> to keep track of the created items.</param>
         /// <param name="failureMechanism">The failure mechanism to create a collection of
         /// <see cref="ExportableFailureMechanismSectionAssemblyResult"/> for.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> to use in the assembly.</param>
@@ -166,24 +177,23 @@
         /// <returns>A collection of <see cref="ExportableFailureMechanismSectionAssemblyResult"/>.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         private static IEnumerable<ExportableFailureMechanismSectionAssemblyResult> CreateExportableFailureMechanismSectionResults
-            <TFailureMechanism, TSectionResult>(IdentifierGenerator idGenerator, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
-                                                Func<TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
+            <TFailureMechanism, TSectionResult>(
+                IdentifierGenerator idGenerator, ExportableModelRegistry registry, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
+                Func<TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
             where TFailureMechanism : IFailureMechanism<TSectionResult>
             where TSectionResult : FailureMechanismSectionResult
         {
-            IDictionary<TSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
-                ExportableFailureMechanismSectionHelper.CreateFailureMechanismSectionResultLookup(failureMechanism.SectionResults);
-
             var exportableResults = new List<ExportableFailureMechanismSectionAssemblyResult>();
-            foreach (KeyValuePair<TSectionResult, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSectionsLookup)
+            foreach (TSectionResult sectionResult in failureMechanism.SectionResults)
             {
                 FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = assembleFailureMechanismSectionFunc(
-                    failureMechanismSectionPair.Key, failureMechanism, assessmentSection);
+                    sectionResult, failureMechanism, assessmentSection);
                 FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
 
                 exportableResults.Add(
                     new ExportableFailureMechanismSectionAssemblyResult(
-                        idGenerator.GetNewId("Fa"), failureMechanismSectionPair.Value, assemblyResult.SectionProbability, assemblyResult.FailureMechanismSectionAssemblyGroup,
+                        idGenerator.GetNewId(Resources.ExportableFailureMechanismSectionAssemblyResult_IdPrefix), registry.Get(sectionResult.Section),
+                        assemblyResult.SectionProbability, assemblyResult.FailureMechanismSectionAssemblyGroup,
                         ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyGroupMethod),
                         ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.ProbabilityMethod)));
             }
Index: Riskeer/Integration/src/Riskeer.Integration.IO/Properties/Resources.Designer.cs
===================================================================
diff -u -r234c67f206c92dde881cc2c15e2cb4299be50741 -rd41d466b016e29fb8e52680f61a8cb744be378ce
--- Riskeer/Integration/src/Riskeer.Integration.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 234c67f206c92dde881cc2c15e2cb4299be50741)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision d41d466b016e29fb8e52680f61a8cb744be378ce)
@@ -154,6 +154,15 @@
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to Fa.
+        /// </summary>
+        public static string ExportableFailureMechanismSectionAssemblyResult_IdPrefix {
+            get {
+                return ResourceManager.GetString("ExportableFailureMechanismSectionAssemblyResult_IdPrefix", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to Vi.
         /// </summary>
         public static string ExportableFailureMechanismSectionCollection_IdPrefix {
Index: Riskeer/Integration/src/Riskeer.Integration.IO/Properties/Resources.resx
===================================================================
diff -u -r234c67f206c92dde881cc2c15e2cb4299be50741 -rd41d466b016e29fb8e52680f61a8cb744be378ce
--- Riskeer/Integration/src/Riskeer.Integration.IO/Properties/Resources.resx	(.../Resources.resx)	(revision 234c67f206c92dde881cc2c15e2cb4299be50741)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Properties/Resources.resx	(.../Resources.resx)	(revision d41d466b016e29fb8e52680f61a8cb744be378ce)
@@ -230,4 +230,7 @@
   <data name="ExportableFailureMechanismSection_IdPrefix" xml:space="preserve">
     <value>Bv</value>
   </data>
+  <data name="ExportableFailureMechanismSectionAssemblyResult_IdPrefix" xml:space="preserve">
+    <value>Fa</value>
+  </data>
 </root>
\ No newline at end of file
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs
===================================================================
diff -u -r3fedb02f6284e45456911f5831bb399ecc85e307 -rd41d466b016e29fb8e52680f61a8cb744be378ce
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision 3fedb02f6284e45456911f5831bb399ecc85e307)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision d41d466b016e29fb8e52680f61a8cb744be378ce)
@@ -50,7 +50,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
-                null, new TestFailureMechanism(), assessmentSection, (fm, section) => null, (sr, fm, section) => null);
+                null, new ExportableModelRegistry(), new TestFailureMechanism(), assessmentSection, (fm, section) => null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -59,6 +59,24 @@
         }
 
         [Test]
+        public void CreateExportableGenericFailureMechanism_RegistryNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            void Call() => ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
+                new IdentifierGenerator(), null, new TestFailureMechanism(), assessmentSection, (fm, section) => null, (sr, fm, section) => null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("registry", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
         public void CreateExportableGenericFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
             // Setup
@@ -68,7 +86,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
-                new IdentifierGenerator(), null, assessmentSection, (fm, section) => null, (sr, fm, section) => null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), null, assessmentSection, (fm, section) => null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -81,7 +99,7 @@
         {
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
-                new IdentifierGenerator(), new TestFailureMechanism(), null, (fm, section) => null, (sr, fm, section) => null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), new TestFailureMechanism(), null, (fm, section) => null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -98,7 +116,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
-                new IdentifierGenerator(), new TestFailureMechanism(), assessmentSection, null, (sr, fm, section) => null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), new TestFailureMechanism(), assessmentSection, null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -116,7 +134,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
-                new IdentifierGenerator(), new TestFailureMechanism(), assessmentSection, (fm, section) => null, null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), new TestFailureMechanism(), assessmentSection, (fm, section) => null, null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -139,10 +157,13 @@
 
             var idGenerator = new IdentifierGenerator();
 
+            var registry = new ExportableModelRegistry();
+            RegisterFailureMechanismSections(registry, failureMechanism.Sections);
+
             // Call
             ExportableGenericFailureMechanism exportableFailureMechanism =
                 ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
-                    idGenerator, failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(probability, assemblyMethod),
+                    idGenerator, registry, failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(probability, assemblyMethod),
                     (sr, fm, section) => expectedSectionOutput);
 
             // Assert
@@ -171,7 +192,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
-                null, new SpecificFailureMechanism(), assessmentSection, (fm, section) => null, (sr, fm, section) => null);
+                null, new ExportableModelRegistry(), new SpecificFailureMechanism(), assessmentSection, (fm, section) => null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -180,6 +201,24 @@
         }
 
         [Test]
+        public void CreateExportableSpecificFailureMechanism_RegistryNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            void Call() => ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
+                new IdentifierGenerator(), null, new SpecificFailureMechanism(), assessmentSection, (fm, section) => null, (sr, fm, section) => null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("registry", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
         public void CreateExportableSpecificFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
             // Setup
@@ -189,7 +228,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
-                new IdentifierGenerator(), null, assessmentSection, (fm, section) => null, (sr, fm, section) => null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), null, assessmentSection, (fm, section) => null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -202,7 +241,7 @@
         {
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
-                new IdentifierGenerator(), new SpecificFailureMechanism(), null, (fm, section) => null, (sr, fm, section) => null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), new SpecificFailureMechanism(), null, (fm, section) => null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -219,7 +258,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
-                new IdentifierGenerator(), new SpecificFailureMechanism(), assessmentSection, null, (sr, fm, section) => null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), new SpecificFailureMechanism(), assessmentSection, null, (sr, fm, section) => null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -237,7 +276,7 @@
 
             // Call
             void Call() => ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
-                new IdentifierGenerator(), new SpecificFailureMechanism(), assessmentSection, (fm, section) => null, null);
+                new IdentifierGenerator(), new ExportableModelRegistry(), new SpecificFailureMechanism(), assessmentSection, (fm, section) => null, null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
@@ -259,11 +298,13 @@
             FailureMechanismSectionAssemblyResultWrapper expectedSectionOutput = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
 
             var idGenerator = new IdentifierGenerator();
+            var registry = new ExportableModelRegistry();
+            RegisterFailureMechanismSections(registry, failureMechanism.Sections);
 
             // Call
             ExportableSpecificFailureMechanism exportableFailureMechanism =
                 ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
-                    idGenerator, failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(probability, assemblyMethod),
+                    idGenerator, registry, failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(probability, assemblyMethod),
                     (sr, fm, section) => expectedSectionOutput);
 
             // Assert
@@ -281,5 +322,11 @@
             ExportableFailureMechanismSectionAssemblyResultTestHelper.AssertExportableFailureMechanismSectionResults(
                 expectedSectionOutput, exportableFailureMechanismSections, exportableFailureMechanism.SectionAssemblyResults);
         }
+
+        private static void RegisterFailureMechanismSections(ExportableModelRegistry registry, IEnumerable<FailureMechanismSection> failureMechanismSections)
+        {
+            ExportableFailureMechanismSectionCollectionFactory.CreateExportableFailureMechanismSectionCollection(
+                new IdentifierGenerator(), registry, failureMechanismSections);
+        }
     }
 }
\ No newline at end of file