Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/FillDamUiFromXmlInput.cs
===================================================================
diff -u -r2163 -r2197
--- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/FillDamUiFromXmlInput.cs	(.../FillDamUiFromXmlInput.cs)	(revision 2163)
+++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/FillDamUiFromXmlInput.cs	(.../FillDamUiFromXmlInput.cs)	(revision 2197)
@@ -579,9 +579,9 @@
                 var soilGeometryProbability = new SoilGeometryProbability();
                 var inputSoilGeometryProbability = inputSegment.SoilGeometryProbability[i];
                 soilGeometryProbability.Probability = inputSoilGeometryProbability.Probability;
-                if (inputSoilGeometryProbability.FailureMechanismSystemTypeSpecified)
+                if (inputSoilGeometryProbability.SegmentFailureMechanismTypeSpecified)
                 {
-                    soilGeometryProbability.SegmentFailureMechanismType = ConversionHelper.ConvertToFailureMechanismSystemType(inputSoilGeometryProbability.FailureMechanismSystemType);
+                    soilGeometryProbability.SegmentFailureMechanismType = ConversionHelper.ConvertToSegmentFailureMechanismType(inputSoilGeometryProbability.SegmentFailureMechanismType);
                 }
                 else
                 {
Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs
===================================================================
diff -u -r2135 -r2197
--- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 2135)
+++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 2197)
@@ -20,11 +20,13 @@
 // All rights reserved.
 
 using System.Collections.Generic;
+using System.Configuration;
 using Deltares.DamEngine.Io.XmlInput;
 using Deltares.DamEngine.Io.XmlOutput;
 using Deltares.Geotechnics;
 using Deltares.Geotechnics.Soils;
 using Deltares.Standard;
+using Deltares.Standard.Extensions;
 using Deltares.Standard.Logging;
 using CharacteristicPointType = Deltares.Geotechnics.SurfaceLines.CharacteristicPointType;
 
@@ -341,11 +343,13 @@
             return translationTable[soilProfileType];
         }
 
+        /// <summary>The enumerated constants for input failure mechanism stability inside</summary>
         public const int InputFailureMechanismStabilityInside = 0;
         public const int InputFailureMechanismStabilityOutside = 1;
         public const int InputFailureMechanismPiping = 2;
         public const int InputFailureMechanismHorizontalBalance = 3;
-        
+        public const int InputFailureMechanismFlowSlide = 4;
+
         /// <summary>
         /// Converts the Dam failure mechanism type to the input failure mechanism type .
         /// </summary>
@@ -358,7 +362,8 @@
                                                    {FailureMechanismSystemType.StabilityInside, InputFailureMechanismStabilityInside},
                                                    {FailureMechanismSystemType.StabilityOutside, InputFailureMechanismStabilityOutside},
                                                    {FailureMechanismSystemType.Piping, InputFailureMechanismPiping},
-                                                   {FailureMechanismSystemType.HorizontalBalance, InputFailureMechanismHorizontalBalance}
+                                                   {FailureMechanismSystemType.HorizontalBalance, InputFailureMechanismHorizontalBalance},
+                                                   {FailureMechanismSystemType.FlowSlide, InputFailureMechanismFlowSlide}
                                                };
             return translationTable[segmentFailureMechanismType];
         }
@@ -375,10 +380,55 @@
                                                    {InputFailureMechanismStabilityInside, FailureMechanismSystemType.StabilityInside},
                                                    {InputFailureMechanismStabilityOutside, FailureMechanismSystemType.StabilityOutside},
                                                    {InputFailureMechanismPiping, FailureMechanismSystemType.Piping},
-                                                   {InputFailureMechanismHorizontalBalance, FailureMechanismSystemType.HorizontalBalance}
+                                                   {InputFailureMechanismHorizontalBalance, FailureMechanismSystemType.HorizontalBalance},
+                                                   {InputFailureMechanismFlowSlide, FailureMechanismSystemType.FlowSlide},
                                                };
             return translationTable[failureMechanismSystemType];
         }
+
+        /// <summary>The enumerated constants for input segment failure mechanism stability inside</summary>
+        public const int InputSegmentFailureMechanismAll = 0;
+        public const int InputSegmentFailureMechanismStability = 1;
+        public const int InputSegmentFailureMechanismPiping = 2;
+        public const int InputSegmentFailureMechanismLiquefaction = 3;
+
+        /// <summary>
+        /// Converts the Dam segment failure mechanism type to the input segment failure mechanism type .
+        /// </summary>
+        /// <param name="segmentFailureMechanismType">Type of the segment failure mechanism.</param>
+        /// <returns></returns>
+        public static int ConvertToInputSegmentFailureMechanismType(FailureMechanismSystemType segmentFailureMechanismType)
+        {
+            var translationTable = new Dictionary<FailureMechanismSystemType, int>()
+                                               {
+                                                   {FailureMechanismSystemType.StabilityInside, InputSegmentFailureMechanismStability},
+                                                   {FailureMechanismSystemType.StabilityOutside, InputSegmentFailureMechanismStability},
+                                                   {FailureMechanismSystemType.Piping, InputSegmentFailureMechanismPiping},
+                                                   {FailureMechanismSystemType.FlowSlide, InputSegmentFailureMechanismLiquefaction},
+                                                   {FailureMechanismSystemType.HorizontalBalance, InputSegmentFailureMechanismStability}
+                                               };
+            return translationTable[segmentFailureMechanismType];
+        }
+
+        /// <summary>
+        /// Converts the input segment failure mechanism type to the Dam segment failure mechanism type .
+        /// </summary>
+        /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
+        /// <returns></returns>
+        public static FailureMechanismSystemType ConvertToSegmentFailureMechanismType(int failureMechanismSystemType)
+        {
+            if (failureMechanismSystemType == InputSegmentFailureMechanismAll)
+            {
+                throw new ConversionException(typeof(FailureMechanismSystemType), failureMechanismSystemType);
+            }
+            var translationTable = new Dictionary<int, FailureMechanismSystemType>()
+                                               {
+                                                   {InputSegmentFailureMechanismStability, FailureMechanismSystemType.StabilityInside},
+                                                   {InputSegmentFailureMechanismPiping, FailureMechanismSystemType.Piping},
+                                                   {InputSegmentFailureMechanismLiquefaction, FailureMechanismSystemType.FlowSlide},
+                                               };
+            return translationTable[failureMechanismSystemType];
+        }
         
         /// <summary>
         /// Converts the Dam piping model to the input piping model.
Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/FillXmlInputFromDamUi.cs
===================================================================
diff -u -r2168 -r2197
--- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/FillXmlInputFromDamUi.cs	(.../FillXmlInputFromDamUi.cs)	(revision 2168)
+++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/FillXmlInputFromDamUi.cs	(.../FillXmlInputFromDamUi.cs)	(revision 2197)
@@ -779,12 +779,12 @@
                     inputSoilGeometryProbability.Probability = soilGeometryProbability.Probability;
                     if (soilGeometryProbability.SegmentFailureMechanismType.HasValue)
                     {
-                        inputSoilGeometryProbability.FailureMechanismSystemType = ConversionHelper.ConvertToInputFailureMechanismSystemType(soilGeometryProbability.SegmentFailureMechanismType.Value);
-                        inputSoilGeometryProbability.FailureMechanismSystemTypeSpecified = true;
+                        inputSoilGeometryProbability.SegmentFailureMechanismType = ConversionHelper.ConvertToInputSegmentFailureMechanismType(soilGeometryProbability.SegmentFailureMechanismType.Value);
+                        inputSoilGeometryProbability.SegmentFailureMechanismTypeSpecified = true;
                     }
                     else
                     {
-                        inputSoilGeometryProbability.FailureMechanismSystemTypeSpecified = false;
+                        inputSoilGeometryProbability.SegmentFailureMechanismTypeSpecified = false;
                     }
 
                     switch (soilGeometryProbability.SoilProfileType)
Index: DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs
===================================================================
diff -u -r2135 -r2197
--- DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 2135)
+++ DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 2197)
@@ -27,6 +27,7 @@
 using Deltares.Geotechnics.Soils;
 using Deltares.Geotechnics.SurfaceLines;
 using Deltares.Standard;
+using Deltares.Standard.Extensions;
 using Deltares.Standard.Logging;
 using NUnit.Framework;
 
@@ -198,26 +199,55 @@
         }
 
         [Test]
-        [TestCase(0, FailureMechanismSystemType.StabilityInside)]
-        [TestCase(1, FailureMechanismSystemType.StabilityOutside)]
-        [TestCase(2, FailureMechanismSystemType.Piping)]
-        [TestCase(3, FailureMechanismSystemType.HorizontalBalance)]
+        [TestCase(FailureMechanismSystemType.StabilityInside, ConversionHelper.InputFailureMechanismStabilityInside)]
+        [TestCase(FailureMechanismSystemType.StabilityOutside, ConversionHelper.InputFailureMechanismStabilityOutside)]
+        [TestCase(FailureMechanismSystemType.Piping, ConversionHelper.InputFailureMechanismPiping)]
+        [TestCase(FailureMechanismSystemType.HorizontalBalance, ConversionHelper.InputFailureMechanismHorizontalBalance)]
+        [TestCase(FailureMechanismSystemType.FlowSlide, ConversionHelper.InputFailureMechanismFlowSlide)]
         public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, int inputFailureMechanismSystemType)
         {
             Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType));
         }
 
         [Test]
-        [TestCase(FailureMechanismSystemType.StabilityInside, 0)]
-        [TestCase(FailureMechanismSystemType.StabilityOutside, 1)]
-        [TestCase(FailureMechanismSystemType.Piping,2)]
-        [TestCase(FailureMechanismSystemType.HorizontalBalance, 3)]
+        [TestCase(ConversionHelper.InputFailureMechanismStabilityInside, FailureMechanismSystemType.StabilityInside)]
+        [TestCase(ConversionHelper.InputFailureMechanismStabilityOutside, FailureMechanismSystemType.StabilityOutside)]
+        [TestCase(ConversionHelper.InputFailureMechanismPiping, FailureMechanismSystemType.Piping)]
+        [TestCase(ConversionHelper.InputFailureMechanismHorizontalBalance, FailureMechanismSystemType.HorizontalBalance)]
+        [TestCase(ConversionHelper.InputFailureMechanismFlowSlide, FailureMechanismSystemType.FlowSlide)]
         public void CanConvertToFailureMechanismSystemType(int inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
         {
             Assert.AreEqual(failureMechanismSystemType, ConversionHelper.ConvertToFailureMechanismSystemType(inputFailureMechanismSystemType));
         }
 
         [Test]
+        [TestCase(FailureMechanismSystemType.StabilityInside, ConversionHelper.InputSegmentFailureMechanismStability)]
+        [TestCase(FailureMechanismSystemType.StabilityOutside, ConversionHelper.InputSegmentFailureMechanismStability)]
+        [TestCase(FailureMechanismSystemType.Piping, ConversionHelper.InputSegmentFailureMechanismPiping)]
+        [TestCase(FailureMechanismSystemType.HorizontalBalance, ConversionHelper.InputSegmentFailureMechanismStability)]
+        [TestCase(FailureMechanismSystemType.FlowSlide, ConversionHelper.InputSegmentFailureMechanismLiquefaction)]
+        public void CanConvertToInputSegmentFailureMechanismType(FailureMechanismSystemType failureMechanismSystemType, int inputFailureMechanismSystemType)
+        {
+            Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputSegmentFailureMechanismType(failureMechanismSystemType));
+        }
+
+        [Test]
+        [TestCase(ConversionHelper.InputSegmentFailureMechanismStability, FailureMechanismSystemType.StabilityInside)]
+        [TestCase(ConversionHelper.InputSegmentFailureMechanismPiping, FailureMechanismSystemType.Piping)]
+        [TestCase(ConversionHelper.InputSegmentFailureMechanismLiquefaction, FailureMechanismSystemType.FlowSlide)]
+        public void CanConvertToSegmentFailureMechanismType(int inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
+        {
+            Assert.AreEqual(failureMechanismSystemType, ConversionHelper.ConvertToSegmentFailureMechanismType(inputFailureMechanismSystemType));
+        }
+
+        [TestCase(ConversionHelper.InputSegmentFailureMechanismAll)]
+        [ExpectedException(typeof(ConversionException), ExpectedMessage = "Couldn't convert '0' to type FailureMechanismSystemType")]
+        public void CannotConvertToSegmentFailureMechanismType(int inputFailureMechanismSystemType)
+        {
+            ConversionHelper.ConvertToSegmentFailureMechanismType(inputFailureMechanismSystemType);
+        }
+
+        [Test]
         [TestCase(InputAnalysisType.AdaptGeometry, AnalysisType.AdaptGeometry)]
         [TestCase(InputAnalysisType.NoAdaption, AnalysisType.NoAdaption)]
         public void CanConvertToInputAnalysisType(AnalysisType analysisType, InputAnalysisType inputAnalysisType)