Index: DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs
===================================================================
diff -u -r1571 -r1624
--- DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 1571)
+++ DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 1624)
@@ -621,5 +621,54 @@
         {
             Assert.AreEqual(inputTimeStepUnit, ConversionHelper.ConvertToInputTimeStepUnit(timeStepUnit));
         }
+        [TestCase(ConversionHelper.PlLineTypePl1, PLLineType.PL1)]
+        [TestCase(ConversionHelper.PlLineTypePl2, PLLineType.PL2)]
+        [TestCase(ConversionHelper.PlLineTypePl3, PLLineType.PL3)]
+        [TestCase(ConversionHelper.PlLineTypePl4, PLLineType.PL4)]
+        public void CanConvertToPlLineType(uint inputPlLineType, PLLineType plLineType)
+        {
+            Assert.AreEqual(plLineType, ConversionHelper.ConvertToPlLineType(inputPlLineType));
+        }
+
+        [TestCase(PLLineType.PL1, ConversionHelper.PlLineTypePl1)]
+        [TestCase(PLLineType.PL2, ConversionHelper.PlLineTypePl2)]
+        [TestCase(PLLineType.PL3, ConversionHelper.PlLineTypePl3)]
+        [TestCase(PLLineType.PL4, ConversionHelper.PlLineTypePl4)]
+        public void CanConvertToInputPlLineType(PLLineType plLineType, uint inputPlLineType)
+        {
+            Assert.AreEqual(inputPlLineType, ConversionHelper.ConvertToInputPlLineType(plLineType));
+        }
+
+        [TestCase(ConversionHelper.SensorTypePiezometricHead, SensorType.PiezometricHead)]
+        [TestCase(ConversionHelper.SensorTypeWaterLevel, SensorType.WaterLevel)]
+        [TestCase(ConversionHelper.SensorTypePolderLevel, SensorType.PolderLevel)]
+        public void CanConvertToSensorType(uint inputSensorType, SensorType sensorType)
+        {
+            Assert.AreEqual(sensorType, ConversionHelper.ConvertToSensorType(inputSensorType));
+        }
+
+        [TestCase(SensorType.PiezometricHead, ConversionHelper.SensorTypePiezometricHead)]
+        [TestCase(SensorType.WaterLevel, ConversionHelper.SensorTypeWaterLevel)]
+        [TestCase(SensorType.PolderLevel, ConversionHelper.SensorTypePolderLevel)]
+        public void CanConvertToInputSensorType(SensorType sensorType, uint inputSensorType)
+        {
+            Assert.AreEqual(inputSensorType, ConversionHelper.ConvertToInputSensorType(sensorType));
+        }
+
+        [TestCase(ConversionHelper.DataSourceTypeSensorsIgnore, DataSourceTypeSensors.Ignore)]
+        [TestCase(ConversionHelper.DataSourceTypeSensorsLocationData, DataSourceTypeSensors.LocationData)]
+        [TestCase(ConversionHelper.DataSourceTypeSensorsSensor, DataSourceTypeSensors.Sensor)]
+        public void CanConvertToSensorType(uint inputdataSourceTypeSensors, DataSourceTypeSensors dataSourceTypeSensors)
+        {
+            Assert.AreEqual(dataSourceTypeSensors, ConversionHelper.ConvertToDataSourceTypeSensors(inputdataSourceTypeSensors));
+        }
+
+        [TestCase(DataSourceTypeSensors.Ignore, ConversionHelper.DataSourceTypeSensorsIgnore)]
+        [TestCase(DataSourceTypeSensors.LocationData, ConversionHelper.DataSourceTypeSensorsLocationData)]
+        [TestCase(DataSourceTypeSensors.Sensor, ConversionHelper.DataSourceTypeSensorsSensor)]
+        public void CanConvertToInputSensorType(DataSourceTypeSensors dataSourceTypeSensors, uint inputdataSourceTypeSensors)
+        {
+            Assert.AreEqual(inputdataSourceTypeSensors, ConversionHelper.ConvertToInputDataSourceTypeSensors(dataSourceTypeSensors));
+        }
     }
 }
Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs
===================================================================
diff -u -r1594 -r1624
--- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 1594)
+++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 1624)
@@ -1192,5 +1192,127 @@
             };
             return translationTable[timeStepUnit];
         }
+
+
+        /// <summary>
+        /// Constants for translating to Enums PlLineType
+        /// </summary>
+        public const uint PlLineTypePl1 = 1;
+        public const uint PlLineTypePl2 = 2;
+        public const uint PlLineTypePl3 = 3;
+        public const uint PlLineTypePl4 = 4;
+
+        /// <summary>
+        /// Converts the input plLineType to Dam plLineType.
+        /// </summary>
+        /// <param name="plLineType">Type of the pl line.</param>
+        /// <returns>plLineType</returns>
+        public static PLLineType ConvertToPlLineType(uint plLineType)
+        {
+            var translationTable = new Dictionary<uint, PLLineType>()
+            {
+                {PlLineTypePl1, PLLineType.PL1},
+                {PlLineTypePl2, PLLineType.PL2},
+                {PlLineTypePl3, PLLineType.PL3},
+                {PlLineTypePl4, PLLineType.PL4}
+            };
+            return translationTable[plLineType];
+        }
+
+        /// <summary>
+        /// Converts the Dam plLineType to input plLineType.
+        /// </summary>
+        /// <param name="plLineType">Type of the pl line.</param>
+        /// <returns>plLineType as integer</returns>
+        public static uint ConvertToInputPlLineType(PLLineType plLineType)
+        {
+            var translationTable = new Dictionary<PLLineType, uint>()
+            {
+                {PLLineType.PL1, PlLineTypePl1},
+                {PLLineType.PL2, PlLineTypePl2},
+                {PLLineType.PL3, PlLineTypePl3},
+                {PLLineType.PL4, PlLineTypePl4}
+            };
+            return translationTable[plLineType];
+        }
+
+        /// <summary>
+        /// Constants for translating to Enums SensorType
+        /// </summary>
+        public const uint SensorTypePiezometricHead = 0;
+        public const uint SensorTypeWaterLevel = 1;
+        public const uint SensorTypePolderLevel = 2;
+
+        /// <summary>
+        /// Converts the Dam sensorType to input sensorType.
+        /// </summary>
+        /// <param name="sensorType">Type of the sensor.</param>
+        /// <returns>sensorType</returns>
+        public static SensorType ConvertToSensorType(uint sensorType)
+        {
+            var translationTable = new Dictionary<uint, SensorType>()
+            {
+                {SensorTypePiezometricHead, SensorType.PiezometricHead},
+                {SensorTypePolderLevel, SensorType.PolderLevel},
+                {SensorTypeWaterLevel, SensorType.WaterLevel}
+            };
+            return translationTable[sensorType];
+        }
+
+        /// <summary>
+        /// Converts the Dam sensorType to input sensorType.
+        /// </summary>
+        /// <param name="sensorType">Type of the sensor.</param>
+        /// <returns>sensorType as integer</returns>
+        public static uint ConvertToInputSensorType(SensorType sensorType)
+        {
+            var translationTable = new Dictionary<SensorType, uint>()
+            {
+                {SensorType.PiezometricHead, SensorTypePiezometricHead},
+                {SensorType.PolderLevel, SensorTypePolderLevel},
+                {SensorType.WaterLevel, SensorTypeWaterLevel}
+            };
+            return translationTable[sensorType];
+        }
+
+        public const uint DataSourceTypeSensorsIgnore = 0;
+        public const uint DataSourceTypeSensorsLocationData = 1;
+        public const uint DataSourceTypeSensorsSensor = 2;
+
+        /// <summary>
+        /// Converts the Dam DataSourceType to input DataSourceTypeSensors.
+        /// </summary>
+        /// <param name="dataSourceTypeSensors">The data source type sensors.</param>
+        /// <returns>
+        /// DataSourceTypeSensors
+        /// </returns>
+        public static DataSourceTypeSensors ConvertToDataSourceTypeSensors(uint dataSourceTypeSensors)
+        {
+            var translationTable = new Dictionary<uint, DataSourceTypeSensors>()
+            {
+                {DataSourceTypeSensorsIgnore, DataSourceTypeSensors.Ignore},
+                {DataSourceTypeSensorsLocationData, DataSourceTypeSensors.LocationData},
+                {DataSourceTypeSensorsSensor, DataSourceTypeSensors.Sensor}
+            };
+            return translationTable[dataSourceTypeSensors];
+        }
+
+        /// <summary>
+        /// Converts the Dam DataSourceType to input DataSourceType.
+        /// </summary>
+        /// <param name="dataSourceTypeSensors">The data source type sensors.</param>
+        /// <returns>
+        /// DataSourceType as integer
+        /// </returns>
+        public static uint ConvertToInputDataSourceTypeSensors(DataSourceTypeSensors dataSourceTypeSensors)
+        {
+            var translationTable = new Dictionary<DataSourceTypeSensors, uint>()
+            {
+                {DataSourceTypeSensors.Ignore, DataSourceTypeSensorsIgnore},
+                {DataSourceTypeSensors.LocationData, DataSourceTypeSensorsLocationData},
+                {DataSourceTypeSensors.Sensor, DataSourceTypeSensorsSensor}
+            };
+            return translationTable[dataSourceTypeSensors];
+        }
     }
 }