Index: dam clients/DamUI/trunk/src/Dam/Data/DamEngineIo/FillXmlInputFromDamUi.cs
===================================================================
diff -u -r560 -r568
--- dam clients/DamUI/trunk/src/Dam/Data/DamEngineIo/FillXmlInputFromDamUi.cs	(.../FillXmlInputFromDamUi.cs)	(revision 560)
+++ dam clients/DamUI/trunk/src/Dam/Data/DamEngineIo/FillXmlInputFromDamUi.cs	(.../FillXmlInputFromDamUi.cs)	(revision 568)
@@ -50,6 +50,12 @@
             TransferSurfaceLines(dike.SurfaceLines2, input.SurfaceLines);
             input.Soils = new DamEngine.Io.XmlInput.Soil[dike.SoilList.Soils.Count];
             TransferSoils(dike.SoilList.Soils, input.Soils);
+            if (dike.SoilProfiles != null)
+            {
+                var profilesCount = dike.SoilProfiles.Count;
+                input.SoilProfiles1D = new DamEngine.Io.XmlInput.SoilProfile1D[profilesCount];
+                TransferSoilProfiles1D(dike.SoilProfiles, input.SoilProfiles1D);
+            }
             return input;
         }
 
@@ -216,5 +222,39 @@
                 inputLocations[i] = inputLocation;
             }
         }
+        private static void TransferSoilProfiles1D(IList<Deltares.Geotechnics.Soils.SoilProfile1D> dikeSoilProfiles, DamEngine.Io.XmlInput.SoilProfile1D[] inputSoilProfiles1D)
+        {
+            var profilesCount = dikeSoilProfiles.Count;
+            for (int i = 0; i < profilesCount; i++)
+            {
+                var soilProfile1D = dikeSoilProfiles[i];
+                var inputSoilProfile1D = new DamEngine.Io.XmlInput.SoilProfile1D
+                {
+                    Name = soilProfile1D.Name,
+                    BottomLevel = soilProfile1D.BottomLevel,
+                    Layers = new SoilProfile1DLayer[soilProfile1D.LayerCount]
+                };
+                AddLayers1D(soilProfile1D, inputSoilProfile1D);
+                inputSoilProfiles1D[i] = inputSoilProfile1D;
+            }
+        }
+
+        private static void AddLayers1D(Deltares.Geotechnics.Soils.SoilProfile1D soilProfile1D, DamEngine.Io.XmlInput.SoilProfile1D inputSoilProfile1D)
+        {
+            for (int i = 0; i < soilProfile1D.LayerCount; i++)
+            {
+                var layer = soilProfile1D.Layers[i];
+                var inputLayer = new SoilProfile1DLayer
+                {
+                    Name = layer.Name,
+                    SoilName = layer.Soil.Name,
+                    TopLevel = layer.TopLevel,
+                    IsAquifer = layer.IsAquifer,
+                    WaterpressureInterpolationModel = ConversionHelper.ConvertToInputWaterpressureInterpolationModel(
+                        layer.WaterpressureInterpolationModel)
+                };
+                inputSoilProfile1D.Layers[i] = inputLayer;
+            }
+        }
     }
 }
Index: dam clients/DamUI/trunk/src/Dam/Data/DamEngineIo/ConversionHelper.cs
===================================================================
diff -u -r560 -r568
--- dam clients/DamUI/trunk/src/Dam/Data/DamEngineIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 560)
+++ dam clients/DamUI/trunk/src/Dam/Data/DamEngineIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 568)
@@ -21,8 +21,9 @@
 
 using System.Collections.Generic;
 using Deltares.DamEngine.Io.XmlInput;
-using Deltares.Geotechnics.SurfaceLines;
+using Deltares.Geotechnics.Soils;
 using Deltares.Standard;
+using CharacteristicPointType = Deltares.Geotechnics.SurfaceLines.CharacteristicPointType;
 
 namespace Deltares.Dam.Data.DamEngineIo
 {
@@ -264,5 +265,99 @@
                                                };
             return translationTable[calculationResult];
         }
+
+        /// <summary>
+        /// Converts to waterpressure interpolation model.
+        /// </summary>
+        /// <param name="inputWaterpressureInterpolationModel">The input waterpressure interpolation model.</param>
+        /// <returns></returns>
+        public static WaterpressureInterpolationModel ConvertToWaterpressureInterpolationModel(int inputWaterpressureInterpolationModel)
+        {
+            var translationTable = new Dictionary<int, WaterpressureInterpolationModel>()
+                                               {
+                                                   {0, WaterpressureInterpolationModel.Automatic},
+                                                   {1, WaterpressureInterpolationModel.Hydrostatic}
+                                               };
+            return translationTable[inputWaterpressureInterpolationModel];
+        }
+
+        /// <summary>
+        /// Converts to input waterpressure interpolation model.
+        /// </summary>
+        /// <param name="waterpressureInterpolationModel">The waterpressure interpolation model.</param>
+        /// <returns></returns>
+        public static int ConvertToInputWaterpressureInterpolationModel(WaterpressureInterpolationModel waterpressureInterpolationModel)
+        {
+            var translationTable = new Dictionary<WaterpressureInterpolationModel, int>()
+                                               {
+                                                   {WaterpressureInterpolationModel.Automatic, 0},
+                                                   {WaterpressureInterpolationModel.Hydrostatic, 1}
+                                               };
+            return translationTable[waterpressureInterpolationModel];
+        }
+
+        /// <summary>
+        /// Converts the type of to input soil geometry.
+        /// </summary>
+        /// <param name="soilGeometryType">Type of the soil geometry.</param>
+        /// <returns></returns>
+        public static SegmentSoilGeometryProbabilitySoilGeometryType ConvertToInputSoilGeometryType(SoilGeometryType soilGeometryType)
+        {
+            var translationTable = new Dictionary<SoilGeometryType, SegmentSoilGeometryProbabilitySoilGeometryType>()
+                                               {
+                                                   {SoilGeometryType.SoilGeometry1D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D},
+                                                   {SoilGeometryType.SoilGeometry2D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D}
+                                               };
+            return translationTable[soilGeometryType];
+        }
+
+        /// <summary>
+        /// Converts the type of to soil geometry.
+        /// </summary>
+        /// <param name="soilGeometryType">Type of the soil geometry.</param>
+        /// <returns></returns>
+        public static SoilGeometryType ConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilGeometryType soilGeometryType)
+        {
+            var translationTable = new Dictionary<SegmentSoilGeometryProbabilitySoilGeometryType, SoilGeometryType>()
+                                               {
+                                                   {SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D, SoilGeometryType.SoilGeometry1D},
+                                                   {SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D, SoilGeometryType.SoilGeometry2D}
+                                               };
+            return translationTable[soilGeometryType];
+        }
+
+        /// <summary>
+        /// Converts the Dam failure mechanism type to the input failure mechanism type .
+        /// </summary>
+        /// <param name="segmentFailureMechanismType">Type of the segment failure mechanism.</param>
+        /// <returns></returns>
+        public static SegmentSoilGeometryProbabilityFailureMechanismSystemType ConvertToInputFailureMechanismSystemType(FailureMechanismSystemType segmentFailureMechanismType)
+        {
+            var translationTable = new Dictionary<FailureMechanismSystemType, SegmentSoilGeometryProbabilityFailureMechanismSystemType>()
+                                               {
+                                                   {FailureMechanismSystemType.StabilityInside, SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityInside},
+                                                   {FailureMechanismSystemType.StabilityOutside, SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityOutside},
+                                                   {FailureMechanismSystemType.Piping, SegmentSoilGeometryProbabilityFailureMechanismSystemType.Piping},
+                                                   {FailureMechanismSystemType.HorizontalBalance, SegmentSoilGeometryProbabilityFailureMechanismSystemType.HorizontalBalance}
+                                               };
+            return translationTable[segmentFailureMechanismType];
+        }
+
+        /// <summary>
+        /// Converts the input failure mechanism type to the Dam failure mechanism type .
+        /// </summary>
+        /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
+        /// <returns></returns>
+        public static FailureMechanismSystemType ConvertToFailureMechanismSystemType(SegmentSoilGeometryProbabilityFailureMechanismSystemType failureMechanismSystemType)
+        {
+            var translationTable = new Dictionary<SegmentSoilGeometryProbabilityFailureMechanismSystemType, FailureMechanismSystemType>()
+                                               {
+                                                   {SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityInside, FailureMechanismSystemType.StabilityInside},
+                                                   {SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityOutside, FailureMechanismSystemType.StabilityOutside},
+                                                   {SegmentSoilGeometryProbabilityFailureMechanismSystemType.Piping, FailureMechanismSystemType.Piping},
+                                                   {SegmentSoilGeometryProbabilityFailureMechanismSystemType.HorizontalBalance, FailureMechanismSystemType.HorizontalBalance}
+                                               };
+            return translationTable[failureMechanismSystemType];
+        }
     }
 }
Index: dam clients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs
===================================================================
diff -u -r531 -r568
--- dam clients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 531)
+++ dam clients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 568)
@@ -27,6 +27,7 @@
 using Deltares.Dam.Data;
 using Deltares.Dam.Data.DamEngineIo;
 using Deltares.DamEngine.Io.XmlInput;
+using Deltares.Geotechnics.Soils;
 using Deltares.Geotechnics.SurfaceLines;
 using Deltares.Standard;
 using NUnit.Framework;
@@ -178,5 +179,49 @@
         {
             Assert.AreEqual(result, ConversionHelper.ConvertToCalculationResult(calculationResult));
         }
+
+        [Test]
+        [TestCase(0, WaterpressureInterpolationModel.Automatic)]
+        [TestCase(1, WaterpressureInterpolationModel.Hydrostatic)]
+        public void CanConvertToWaterpressureInterpolationModel(int inputInterpolationModel, WaterpressureInterpolationModel interpolationModel)
+        {
+            Assert.AreEqual(interpolationModel, ConversionHelper.ConvertToWaterpressureInterpolationModel(inputInterpolationModel));
+        }
+
+        [Test]
+        [TestCase(SoilGeometryType.SoilGeometry1D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D)]
+        [TestCase(SoilGeometryType.SoilGeometry2D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D)]
+        public void CanConvertToInputSoilGeometryType(SoilGeometryType soilGeometryType, SegmentSoilGeometryProbabilitySoilGeometryType inputSoilGeometryType)
+        {
+            Assert.AreEqual(inputSoilGeometryType, ConversionHelper.ConvertToInputSoilGeometryType(soilGeometryType));
+        }
+
+        [Test]
+        [TestCase(SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D, SoilGeometryType.SoilGeometry1D)]
+        [TestCase(SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D, SoilGeometryType.SoilGeometry2D)]
+        public void CanConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilGeometryType inputSoilGeometryType, SoilGeometryType soilGeometryType)
+        {
+            Assert.AreEqual(soilGeometryType, ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryType));
+        }
+
+        [Test]
+        [TestCase(SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityInside, FailureMechanismSystemType.StabilityInside)]
+        [TestCase(SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityOutside, FailureMechanismSystemType.StabilityOutside)]
+        [TestCase(SegmentSoilGeometryProbabilityFailureMechanismSystemType.Piping, FailureMechanismSystemType.Piping)]
+        [TestCase(SegmentSoilGeometryProbabilityFailureMechanismSystemType.HorizontalBalance, FailureMechanismSystemType.HorizontalBalance)]
+        public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, SegmentSoilGeometryProbabilityFailureMechanismSystemType inputFailureMechanismSystemType)
+        {
+            Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType));
+        }
+
+        [Test]
+        [TestCase(FailureMechanismSystemType.StabilityInside, SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityInside)]
+        [TestCase(FailureMechanismSystemType.StabilityOutside, SegmentSoilGeometryProbabilityFailureMechanismSystemType.StabilityOutside)]
+        [TestCase(FailureMechanismSystemType.Piping, SegmentSoilGeometryProbabilityFailureMechanismSystemType.Piping)]
+        [TestCase(FailureMechanismSystemType.HorizontalBalance, SegmentSoilGeometryProbabilityFailureMechanismSystemType.HorizontalBalance)]
+        public void CanConvertToFailureMechanismSystemType(SegmentSoilGeometryProbabilityFailureMechanismSystemType inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
+        {
+            Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType));
+        }
     }
 }