Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.Designer.cs
===================================================================
diff -u -r2041 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 2041)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 2050)
@@ -425,6 +425,24 @@
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to No pl-lines object defined.
+        /// </summary>
+        internal static string PlLinesToWaternetConverter_NoPlLinesDefined {
+            get {
+                return ResourceManager.GetString("PlLinesToWaternetConverter_NoPlLinesDefined", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to No 1D soil profile defined.
+        /// </summary>
+        internal static string PlLinesToWaternetConverter_NoSoilProfile1dDefined {
+            get {
+                return ResourceManager.GetString("PlLinesToWaternetConverter_NoSoilProfile1dDefined", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to Adapting the slope of the dike failed. Probably the slope is too steep or too shallow..
         /// </summary>
         internal static string SlopeErrorNoIntersection {
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.nl-NL.resx
===================================================================
diff -u -r2041 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.nl-NL.resx	(.../Resources.nl-NL.resx)	(revision 2041)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.nl-NL.resx	(.../Resources.nl-NL.resx)	(revision 2050)
@@ -297,4 +297,10 @@
   <data name="DesignCalculatorNoSoilProfilesAvailableForLocation" xml:space="preserve">
     <value>Geen ondergrond profielen beschikbaar voor locatie '{0}'</value>
   </data>
+  <data name="PlLinesToWaternetConverter_NoPlLinesDefined" xml:space="preserve">
+    <value>Geen object voor pn-lijnen gedefinieerd</value>
+  </data>
+  <data name="PlLinesToWaternetConverter_NoSoilProfile1dDefined" xml:space="preserve">
+    <value>Geen 1D ondergrond profiel gedefinieerd</value>
+  </data>
 </root>
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/DamMacroStabilityTestHelper.cs
===================================================================
diff -u -r1970 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/DamMacroStabilityTestHelper.cs	(.../DamMacroStabilityTestHelper.cs)	(revision 1970)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/DamMacroStabilityTestHelper.cs	(.../DamMacroStabilityTestHelper.cs)	(revision 2050)
@@ -224,5 +224,35 @@
             return soilProfile2D;
         }
 
+        /// <summary>
+        /// Creates a 1D soil profile for the tests.
+        /// </summary>
+        /// <returns></returns>
+        public static SoilProfile1D CreateSoilProfile1D()
+        {
+            SoilProfile1D soilProfile1D = new SoilProfile1D();
+            soilProfile1D.BottomLevel = -10;
+
+            var layer = new SoilLayer1D
+            {
+                Name = "Layer 1",
+                Soil = new Soil("OA", 17.70, 17.70)
+            };
+            layer.TopLevel = 1;
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+
+            layer = new SoilLayer1D
+            {
+                Name = "Layer 2",
+                Soil = new Soil("LM", 18.00, 18.00)
+            };
+            layer.TopLevel = -10;
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+
+            return soilProfile1D;
+        }
+
     }
 }
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj
===================================================================
diff -u -r2044 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj	(.../Deltares.DamEngine.Calculators.Tests.csproj)	(revision 2044)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj	(.../Deltares.DamEngine.Calculators.Tests.csproj)	(revision 2050)
@@ -87,6 +87,7 @@
     <Compile Include="KernelWrappers\Common\UpliftHelperTests.cs" />
     <Compile Include="KernelWrappers\MacroStabilityCommon\ConversionHelperTests.cs" />
     <Compile Include="KernelWrappers\MacroStabilityCommon\MacroStabilityIoTests.cs" />
+    <Compile Include="KernelWrappers\MacroStabilityCommon\PlLinesToWaternetConverterTests.cs" />
     <Compile Include="KernelWrappers\MacroStabilityInwards\MacroStabilityInwardsKernelWrapperTests.cs" />
     <Compile Include="KernelWrappers\WtiPipingSellmeijerRevised\WtiPipingSellmeijerRevisedKernelWrapperTests.cs" />
     <Compile Include="RegionalAssessment\Evaluator\AquitardEvaluatorTests.cs" />
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs
===================================================================
diff -u
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs	(revision 0)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs	(revision 2050)
@@ -0,0 +1,295 @@
+using System.Data;
+using Deltares.DamEngine.Data.General;
+using Deltares.DamEngine.Data.General.PlLines;
+using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon;
+using Deltares.DamEngine.Data.Geotechnics;
+using NUnit.Framework;
+
+namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon
+{
+    public class PlLinesToWaternetConverterTests
+    {
+        [Test]
+        public void TestConvertPlLinesToWaternet()
+        {
+            const double cDif = 0.0001;
+            var plLines = CreatePlLinesForTest();
+
+            var soilProfile1D = CreateSoilProfile1DForTest();
+            Assert.AreEqual(-2.111, soilProfile1D.InBetweenAquiferLayer.TopLevel, cDif);
+            Assert.AreEqual(-6.111, soilProfile1D.BottomAquiferLayer.TopLevel, cDif);
+
+            const double penetrationLength = 2.1;
+            const double left = 0;
+            const double right = 100;
+            var waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, left, right);
+
+            // Pl 1 is only the phreatic line, a headline or waternetline does not have to be created
+            // Pl 2 gets waternetline to level of BottomAquiferLayer.TopLevel + penetrationLength
+            // Pl 3 gets waternetline to level of InBetweenAquiferLayer.TopLevel
+            // Pl 4 gets waternetline to level of BottomAquiferLayer.TopLevel
+
+            // ex[ected phreatic line from pl 1
+            Assert.AreEqual(3, waternet.PhreaticLine.Points.Count);
+            Assert.AreEqual(0, waternet.PhreaticLine.Points[0].X, cDif);
+            Assert.AreEqual(0, waternet.PhreaticLine.Points[0].Z, cDif);
+            Assert.AreEqual(50, waternet.PhreaticLine.Points[1].X, cDif);
+            Assert.AreEqual(1, waternet.PhreaticLine.Points[1].Z, cDif);
+            Assert.AreEqual(100, waternet.PhreaticLine.Points[2].X, cDif);
+            Assert.AreEqual(1, waternet.PhreaticLine.Points[2].Z, cDif);
+            // expected head lines from pl 2, 3 and 4
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            Assert.AreEqual(2, waternet.HeadLineList[0].Points.Count);
+            Assert.AreEqual(3, waternet.HeadLineList[1].Points.Count);
+            Assert.AreEqual(2, waternet.HeadLineList[2].Points.Count);
+            // check the points of first head line that represents pl 2
+            Assert.AreEqual(0, waternet.HeadLineList[0].Points[0].X, cDif);
+            Assert.AreEqual(0, waternet.HeadLineList[0].Points[0].Z, cDif);
+            Assert.AreEqual(100, waternet.HeadLineList[0].Points[1].X, cDif);
+            Assert.AreEqual(-1, waternet.HeadLineList[0].Points[1].Z, cDif);
+            // expected waternet lines from pl 2, 3 and 4
+            Assert.AreEqual(3, waternet.WaternetLineList.Count);
+            // expected waternet line 0 is connected to pl2 with level -6.111 + 2.1 = -4.011
+            Assert.AreEqual(waternet.HeadLineList[0], waternet.WaternetLineList[0].HeadLine);
+            Assert.AreEqual(0, waternet.WaternetLineList[0].Points[0].X, cDif);
+            Assert.AreEqual(-4.011, waternet.WaternetLineList[0].Points[0].Z, cDif);
+            Assert.AreEqual(100, waternet.WaternetLineList[0].Points[1].X, cDif);
+            Assert.AreEqual(-4.011, waternet.WaternetLineList[0].Points[1].Z, cDif);
+            // expected waternet line 1 is connected to pl3 with level -2.111
+            Assert.AreEqual(waternet.HeadLineList[1], waternet.WaternetLineList[1].HeadLine);
+            Assert.AreEqual(-2.111, waternet.WaternetLineList[1].Points[0].Z, cDif);
+            // expected waternet line 2 is connected to pl4 with level -6.111
+            Assert.AreEqual(waternet.HeadLineList[2], waternet.WaternetLineList[2].HeadLine);
+            Assert.AreEqual(-6.111, waternet.WaternetLineList[2].Points[0].Z, cDif);
+        }
+
+        [Test]
+        public void TestConvertPlLinesToWaternetWhenNoHeadLinesExpected()
+        {
+            var plLines = CreatePlLinesForTest();
+            var soilProfile1D = CreateSoilProfile1DForTest();
+            var waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, 0, 0, 0);
+            // head lines
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            Assert.AreEqual(2, waternet.HeadLineList[0].Points.Count);
+            Assert.AreEqual(3, waternet.HeadLineList[1].Points.Count);
+            Assert.AreEqual(2, waternet.HeadLineList[2].Points.Count);
+            // phreatic line
+            Assert.AreEqual(3, waternet.PhreaticLine.Points.Count);
+
+            // check that no headline are added when Pl2, Pl3 or Pl4 does not exist or has no points
+            plLines.Lines[PlLineType.Pl3] = null;
+            plLines.Lines[PlLineType.Pl4].Points.Clear();
+            waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, 0, 0, 0);
+            // head lines
+            Assert.AreEqual(1, waternet.HeadLineList.Count);
+            Assert.AreEqual(2, waternet.HeadLineList[0].Points.Count);
+            // phreatic line
+            Assert.AreEqual(3, waternet.PhreaticLine.Points.Count);
+        }
+
+        [Test]
+        public void TestConvertPlLinesToWaternetWhenNoWaternetLinesExpected()
+        {
+            const double cDif = 0.0001;
+            var plLines = CreatePlLinesForTest();
+            var soilProfile1D = CreateSoilProfile1DForTest();
+            const double penetrationLength = 2.1;
+            var waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, 0, 0);
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            Assert.AreEqual(3, waternet.WaternetLineList.Count);
+
+            // check that no waternetlines are added for pl3 when InBetweenAquiferLayer is null
+            soilProfile1D = CreateSoilProfile1DWith1AquiferForTest();
+            waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, 0, 0);
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            Assert.AreEqual(2, waternet.WaternetLineList.Count);
+            // expected waternet line 0 is connected to pl2 with level -6.111 + 2.1 = -4.011
+            Assert.AreEqual(waternet.HeadLineList[0], waternet.WaternetLineList[0].HeadLine);
+            Assert.AreEqual(-4.011, waternet.WaternetLineList[0].Points[0].Z, cDif);
+            // expected waternet line 1 is connected to pl4 with level -6.111
+            Assert.AreEqual(waternet.HeadLineList[2], waternet.WaternetLineList[1].HeadLine);
+            Assert.AreEqual(-6.111, waternet.WaternetLineList[1].Points[0].Z, cDif);
+
+            // check that no waternetlines are added for pl2, pl3 and pl4 when BottomAquiferLayer is null
+            soilProfile1D = CreateSoilProfile1DWithoutAquifersForTest();
+            waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, 0, 0);
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            Assert.AreEqual(0, waternet.WaternetLineList.Count);
+        }
+
+        [Test]
+        public void TestConvertLevelToWaternetLine()
+        {
+            const double cDif = 0.0001;
+
+            const double level = 1.234;
+            const double left = -50.111;
+            const double right = 50.123;
+            var waternetLine = PlLinesToWaternetConverter.ConvertLevelToWaternetLine(level, left, right);
+
+            Assert.AreEqual(2, waternetLine.Points.Count);
+            Assert.AreEqual(-50.111, waternetLine.Points[0].X, cDif);
+            Assert.AreEqual(1.234, waternetLine.Points[0].Z, cDif);
+            Assert.AreEqual(50.123, waternetLine.Points[1].X, cDif);
+            Assert.AreEqual(1.234, waternetLine.Points[1].Z, cDif);
+        }
+        
+        [Test]
+        public void TestConvertPlLineToHeadLine()
+        {
+            const double cDif = 0.0001;
+
+            var plLines = new PlLines();
+            Assert.AreEqual(4, plLines.PlLineCount);
+            var plLine = plLines.Lines[PlLineType.Pl2];
+            plLine.Points.Add(new PlLinePoint(-1.234, 4.321));
+            plLine.Points.Add(new PlLinePoint(100, 1));
+            var headLine = PlLinesToWaternetConverter.ConvertPlLineToHeadLine(plLine);
+
+            Assert.AreEqual(2, headLine.Points.Count);
+            Assert.AreEqual(-1.234, headLine.Points[0].X, cDif);
+            Assert.AreEqual(4.321, headLine.Points[0].Z, cDif);
+            Assert.AreEqual(100, headLine.Points[1].X, cDif);
+            Assert.AreEqual(1, headLine.Points[1].Z, cDif);
+        }
+
+        [Test]
+        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen 1D ondergrond profiel gedefinieerd")]
+        [SetUICulture("nl-NL")]
+        public void TestLanguageNLThrowsExceptionWhenSoilProfile1DIsNull()
+        {
+            var plLines = new PlLines();
+            PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, null, 0, 0, 0);
+        }
+
+        [Test]
+        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen object voor pn-lijnen gedefinieerd")]
+        [SetUICulture("nl-NL")]
+        public void TestLanguageNLThrowsExceptionWhenPlLinesIsNull()
+        {
+            var soilProfile1D = new SoilProfile1D();
+            PlLinesToWaternetConverter.ConvertPlLineToWaternet(null, soilProfile1D, 0, 0, 0);
+        }
+
+        private PlLines CreatePlLinesForTest()
+        {
+            var plLines = new PlLines();
+            // pl 1 is phreatic line
+            var plLine = plLines.Lines[PlLineType.Pl1];
+            plLine.IsPhreatic = true;
+            plLine.Points.Add(new PlLinePoint(0, 0));
+            plLine.Points.Add(new PlLinePoint(50, 1));
+            plLine.Points.Add(new PlLinePoint(100, 1));
+            // pl 2 first equal to point of pl 1
+            plLine = plLines.Lines[PlLineType.Pl2];
+            plLine.Points.Add(new PlLinePoint(0, 0));
+            plLine.Points.Add(new PlLinePoint(100, -1));
+            // pl 3 
+            plLine = plLines.Lines[PlLineType.Pl3];
+            plLine.Points.Add(new PlLinePoint(0, 1));
+            plLine.Points.Add(new PlLinePoint(50, 0));
+            plLine.Points.Add(new PlLinePoint(100, -1));
+            // pl 4 
+            plLine = plLines.Lines[PlLineType.Pl4];
+            plLine.Points.Add(new PlLinePoint(0, -5));
+            plLine.Points.Add(new PlLinePoint(100, -5));
+
+            return plLines;
+        }
+
+        private SoilProfile1D CreateSoilProfile1DForTest()
+        {
+            var soilProfile1D = new SoilProfile1D();
+            soilProfile1D.BottomLevel = -30.0;
+
+            SoilLayer1D layer = new SoilLayer1D();
+            layer.Name = "L1a";
+            layer.TopLevel = 1.212;
+            layer.IsAquifer = true; // aquifer at top
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L1b";
+            layer.TopLevel = 1.212;
+            layer.IsAquifer = false;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L2a";
+            layer.TopLevel = -2.111; // top of in-between aquifer 
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L2b";
+            layer.TopLevel = -2.151;
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L3";
+            layer.TopLevel = -3.373;
+            layer.IsAquifer = false;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L4";
+            layer.TopLevel = -4.151;
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L5";
+            layer.TopLevel = -5.373;
+            layer.IsAquifer = false;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L6a";
+            layer.TopLevel = -6.111; // top of bottom aquifer
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L6b";
+            layer.TopLevel = -6.151;
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L7";
+            layer.TopLevel = -7.373;
+            layer.IsAquifer = false;
+            soilProfile1D.Layers.Add(layer);
+
+            return soilProfile1D;
+        }
+
+        private SoilProfile1D CreateSoilProfile1DWith1AquiferForTest()
+        {
+            var soilProfile1D = new SoilProfile1D();
+            soilProfile1D.BottomLevel = -30.0;
+
+            SoilLayer1D layer = new SoilLayer1D();
+            layer = new SoilLayer1D();
+            layer.Name = "L1b";
+            layer.TopLevel = 1.212;
+            layer.IsAquifer = false;
+            soilProfile1D.Layers.Add(layer);
+            layer = new SoilLayer1D();
+            layer.Name = "L6a";
+            layer.TopLevel = -6.111; // top of bottom aquifer
+            layer.IsAquifer = true;
+            soilProfile1D.Layers.Add(layer);
+
+            return soilProfile1D;
+        }
+
+        private SoilProfile1D CreateSoilProfile1DWithoutAquifersForTest()
+        {
+            var soilProfile1D = new SoilProfile1D();
+            soilProfile1D.BottomLevel = -30.0;
+
+            SoilLayer1D layer = new SoilLayer1D();
+            layer = new SoilLayer1D();
+            layer.Name = "L1b";
+            layer.TopLevel = 1.212;
+            layer.IsAquifer = false;
+            soilProfile1D.Layers.Add(layer);
+
+            return soilProfile1D;
+        }
+    }
+}
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs
===================================================================
diff -u
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs	(revision 0)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs	(revision 2050)
@@ -0,0 +1,135 @@
+using System.Data;
+using Deltares.DamEngine.Calculators.Properties;
+using Deltares.DamEngine.Data.General;
+using Deltares.DamEngine.Data.General.PlLines;
+using Deltares.DamEngine.Data.Geometry;
+using Deltares.DamEngine.Data.Geotechnics;
+
+namespace Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon
+{
+    public static class PlLinesToWaternetConverter
+    {
+        /// <summary>
+        /// Converts the pl lines to a waternet.
+        /// </summary>
+        /// <param name="plLines">The pl lines.</param>
+        /// <param name="soilProfile1D">The 1D soil profile.</param>
+        /// <param name="penetrationLength">Length of the penetration.</param>
+        /// <param name="xLeft">Left side of the 2D profile.</param>
+        /// <param name="xRight">Right side of the 2D profile.</param>
+        /// <returns></returns>
+        public static Waternet ConvertPlLineToWaternet(PlLines plLines, SoilProfile1D soilProfile1D, double penetrationLength, double xLeft, double xRight)
+        {
+            ThrowWhenPlLinesIsNull(plLines);
+            ThrowWhenSoilProfile1DIsNull(soilProfile1D);
+            var waternet = new Waternet
+            {
+                IsGenerated = false,
+            };
+
+            var plLine1 = plLines.Lines[PlLineType.Pl1];
+            waternet.PhreaticLine = new PhreaticLine();
+            foreach (var plLinePoint in plLine1.Points)
+            {
+                waternet.PhreaticLine.Points.Add(plLinePoint);
+            }
+
+            var plLine = plLines.Lines[PlLineType.Pl2];
+            var headLine = ConvertPlLineToHeadLine(plLine);
+            if (headLine != null)
+            {
+                waternet.HeadLineList.Add(headLine);
+                if (soilProfile1D.BottomAquiferLayer != null)
+                {
+                    var level = soilProfile1D.BottomAquiferLayer.TopLevel + penetrationLength;
+                    var waternetLine = ConvertLevelToWaternetLine(level, xLeft, xRight);
+                    waternetLine.HeadLine = headLine;
+                    waternet.WaternetLineList.Add(waternetLine);
+                }
+            }
+
+            plLine = plLines.Lines[PlLineType.Pl3];
+            headLine = ConvertPlLineToHeadLine(plLine);
+            if (headLine != null)
+            {
+                waternet.HeadLineList.Add(headLine);
+                if (soilProfile1D.InBetweenAquiferLayer != null)
+                {
+                    var level = soilProfile1D.InBetweenAquiferLayer.TopLevel;
+                    var waternetLine = ConvertLevelToWaternetLine(level, xLeft, xRight);
+                    waternetLine.HeadLine = headLine;
+                    waternet.WaternetLineList.Add(waternetLine);
+                }
+            }
+
+            plLine = plLines.Lines[PlLineType.Pl4];
+            headLine = ConvertPlLineToHeadLine(plLine);
+            if (headLine != null)
+            {
+                waternet.HeadLineList.Add(headLine);
+                if (soilProfile1D.BottomAquiferLayer != null)
+                {
+                    var level = soilProfile1D.BottomAquiferLayer.TopLevel;
+                    var waternetLine = ConvertLevelToWaternetLine(level, xLeft, xRight);
+                    waternetLine.HeadLine = headLine;
+                    waternet.WaternetLineList.Add(waternetLine);
+                }
+            }
+
+            return waternet;
+        }
+
+        internal static HeadLine ConvertPlLineToHeadLine(PlLine plLine)
+        {
+            HeadLine headLine = null;
+            if (plLine != null)
+            {
+                if (plLine.Points.Count > 0)
+                {
+                    headLine = new HeadLine();
+                    foreach (var plLinePoint in plLine.Points)
+                    {
+                        headLine.Points.Add(plLinePoint);
+                    }
+                }
+            }
+            return headLine;
+        }
+
+        internal static WaternetLine ConvertLevelToWaternetLine(double level, double xLeft, double xRight)
+        {
+            WaternetLine waternetLine = new WaternetLine();
+            waternetLine.Points.Add(new GeometryPoint(xLeft, level));
+            waternetLine.Points.Add(new GeometryPoint(xRight, level));
+            return waternetLine;
+        }
+
+        /// <summary>
+        /// Throws when the 1D soil profile is not assigned.
+        /// </summary>
+        /// <param name="soilProfile1D">The 1D soil profile.</param>
+        /// <exception cref="NoNullAllowedException"></exception>
+        public static void ThrowWhenSoilProfile1DIsNull(SoilProfile1D soilProfile1D)
+        {
+            if (soilProfile1D == null)
+            {
+                throw new NoNullAllowedException(Resources.PlLinesToWaternetConverter_NoSoilProfile1dDefined);
+            }
+        }
+
+        /// <summary>
+        /// Throws when the pl lines object is not assigned.
+        /// </summary>
+        /// <param name="plLines">The pl lines.</param>
+        /// <exception cref="NoNullAllowedException"></exception>
+        public static void ThrowWhenPlLinesIsNull(PlLines plLines)
+        {
+            if (plLines == null)
+            {
+                throw new NoNullAllowedException(Resources.PlLinesToWaternetConverter_NoPlLinesDefined);
+            }
+        }
+
+
+    }
+}
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.resx
===================================================================
diff -u -r2041 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.resx	(.../Resources.resx)	(revision 2041)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.resx	(.../Resources.resx)	(revision 2050)
@@ -300,4 +300,10 @@
   <data name="DesignCalculatorNoSoilProfilesAvailableForLocation" xml:space="preserve">
     <value>No soil profiles available for location '{0}'</value>
   </data>
+  <data name="PlLinesToWaternetConverter_NoSoilProfile1dDefined" xml:space="preserve">
+    <value>No 1D soil profile defined</value>
+  </data>
+  <data name="PlLinesToWaternetConverter_NoPlLinesDefined" xml:space="preserve">
+    <value>No pl-lines object defined</value>
+  </data>
 </root>
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityInwards/MacroStabilityInwardsKernelWrapperTests.cs
===================================================================
diff -u -r2038 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityInwards/MacroStabilityInwardsKernelWrapperTests.cs	(.../MacroStabilityInwardsKernelWrapperTests.cs)	(revision 2038)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityInwards/MacroStabilityInwardsKernelWrapperTests.cs	(.../MacroStabilityInwardsKernelWrapperTests.cs)	(revision 2050)
@@ -362,6 +362,8 @@
             subSoilScenario.SoilProfile2D = DamMacroStabilityTestHelper.CreateSoilProfile2D();
             subSoilScenario.SegmentFailureMechanismType = FailureMechanismSystemType.StabilityInside;
 
+            subSoilScenario.SoilProfile1D = DamMacroStabilityTestHelper.CreateSoilProfile1D();
+
             var damKernelInput = new DamKernelInput();
             damKernelInput.Location = location;
             damKernelInput.SubSoilScenario = subSoilScenario;
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj
===================================================================
diff -u -r2044 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj	(.../Deltares.DamEngine.Calculators.csproj)	(revision 2044)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj	(.../Deltares.DamEngine.Calculators.csproj)	(revision 2050)
@@ -103,6 +103,7 @@
     <Compile Include="KernelWrappers\MacroStabilityCommon\MacroStabilityIo\FillDamEngineFromWti.cs" />
     <Compile Include="KernelWrappers\MacroStabilityCommon\MacroStabilityIo\FillWtiKernelData.cs" />
     <Compile Include="KernelWrappers\MacroStabilityCommon\TrafficLoad.cs" />
+    <Compile Include="KernelWrappers\MacroStabilityCommon\PlLinesToWaternetConverter.cs" />
     <Compile Include="KernelWrappers\MacroStabilityCommon\UpliftVanCalculationGrid.cs" />
     <Compile Include="KernelWrappers\MacroStabilityInwards\MacroStabilityInput.cs" />
     <Compile Include="KernelWrappers\MacroStabilityInwards\MacroStabilityInwardsKernelWrapper.cs" />
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityInwards/MacroStabilityInwardsKernelWrapper.cs
===================================================================
diff -u -r2038 -r2050
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityInwards/MacroStabilityInwardsKernelWrapper.cs	(.../MacroStabilityInwardsKernelWrapper.cs)	(revision 2038)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityInwards/MacroStabilityInwardsKernelWrapper.cs	(.../MacroStabilityInwardsKernelWrapper.cs)	(revision 2050)
@@ -27,13 +27,15 @@
 using Deltares.DamEngine.Calculators.KernelWrappers.Common;
 using Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStabilityCommon;
 using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces;
+using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon;
 using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo;
 using Deltares.DamEngine.Calculators.Properties;
 using Deltares.DamEngine.Data.Design;
 using Deltares.DamEngine.Data.General;
 using Deltares.DamEngine.Data.General.Results;
 using Deltares.DamEngine.Data.Geotechnics;
 using Deltares.DamEngine.Data.Standard.Calculation;
+using Deltares.MacroStability.Kernel;
 using Deltares.WTIStability.Calculation.Wrapper;
 using GeometryPoint = Deltares.DamEngine.Data.Geometry.GeometryPoint;
 using LogMessage = Deltares.DamEngine.Data.Standard.Logging.LogMessage;
@@ -82,11 +84,36 @@
                 try
                 {
                     // Determine whether there is uplift
-                    var upliftSituation = UpliftHelper.DetermineStabilityUplift(damKernelInput, false);
+                    UpliftSituation upliftSituation;
+                    const bool useRivelLevelLow = false;
+                    var plLines = UpliftHelper.DeterminePlLinesForStability(damKernelInput, useRivelLevelLow, out upliftSituation);
+                    upliftSituation.IsUplift = UpliftHelper.DetermineIsUplift(plLines, damKernelInput.Location, damKernelInput.SubSoilScenario);
                     macroStabilityOutput.UpliftSituation = upliftSituation;
                     if (upliftSituation.IsUplift)
                     {
                         // ToDo MWDAM-1356: Not clear yet what parts are required for input.
+                        var left = 0.0;// ToDo MWDAM-1356: first point of surfaceline
+                        var right = 100.0;// ToDo  MWDAM-1356: last point of surfaceline
+                        var penetrationLength = damKernelInput.Location.ModelParametersForPlLines.PenetrationLength;
+                        var waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, damKernelInput.SubSoilScenario.SoilProfile1D, 
+                            penetrationLength, left, right);
+
+                        FillWtiKernelData fillWtiKernelData = new FillWtiKernelData()
+                        {
+                            SoilList = damKernelInput.Location.SoilList,
+                            FailureMechanismParametersMStab = this.FailureMechanismParametersMStab,
+                            Location = damKernelInput.Location,
+                            // ToDo MWDAM-1373/1374: fill SoilProfile2D
+                            // SoilProfile2D = expectedSoilProfile2D,
+                            SurfaceLine2 = damKernelInput.Location.SurfaceLine,
+                            Waternet = waternet,
+                            // ToDo MWDAM-1399: add data for calculation grid Uplift Van
+                            // UpliftVanCalculationGrid = expectedUpliftVanCalculationGrid
+                        };
+                        
+                        // ToDo MWDAM-1356: following line is not working yet, first all necessary input must be declared
+                        //KernelModel expectedKernelModel = fillWtiKernelData.CreateKernelModel();
+
                         var xmlInput = CreateXmlInput(macroStabilityInput, FailureMechanismParametersMStab.EmbankmentDesignParameters);
                         return PrepareKernel(xmlInput);
                     }