Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs
===================================================================
diff -u -r2977 -r2978
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs	(.../PlLinesToWaternetConverterTests.cs)	(revision 2977)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs	(.../PlLinesToWaternetConverterTests.cs)	(revision 2978)
@@ -258,7 +258,7 @@
         }
 
         [Test]
-        public void ConvertPlLineToWaternet_ValidPLLinesAndSoilProfile2DWithContinuousInBetweenAquiferLayer_ReturnsExpectedWaternet()
+        public void ConvertPlLineToWaternet_ValidPLLinesAndSoilProfile2DWithContinuousInBetweenAquiferLayerConsistOfTwoParts_ReturnsExpectedWaternet()
         {
             // Setup
             var random = new Random(21);
@@ -272,6 +272,115 @@
             var bottomLeftUpperLayer = new Point2D(leftCoordinate, -10);
             SoilLayer2D soilLayer = CreateSoilLayer2D(topLeftUpperLayer, topRightUpperLayer, bottomRightUpperLayer, bottomLeftUpperLayer);
 
+            var topRightInBetweenAquiferLayerLeft = new Point2D(rightCoordinate / 2, -10);
+            var bottomRightInBetweenAquiferLayerLeft = new Point2D(rightCoordinate / 2, -20);
+            var bottomLeftInBetweenAquiferLayerLeft = new Point2D(leftCoordinate, -20);
+            SoilLayer2D soilLayerAquiferInBetweenLeft = CreateSoilLayer2D(bottomLeftUpperLayer, topRightInBetweenAquiferLayerLeft, bottomRightInBetweenAquiferLayerLeft, bottomLeftInBetweenAquiferLayerLeft);
+            soilLayerAquiferInBetweenLeft.IsAquifer = true;
+
+            var topRightInBetweenAquiferLayerRight = new Point2D(rightCoordinate, -10);
+            var bottomRightInBetweenAquiferLayerRight = new Point2D(rightCoordinate, -20);
+            SoilLayer2D soilLayerAquiferInBetweenRight = CreateSoilLayer2D(topRightInBetweenAquiferLayerLeft, topRightInBetweenAquiferLayerRight, bottomRightInBetweenAquiferLayerRight, bottomLeftInBetweenAquiferLayerLeft);
+            soilLayerAquiferInBetweenRight.IsAquifer = true;
+
+            var topRightInBetweenLayer = new Point2D(rightCoordinate, -20);
+            var bottomRightInBetweenLayer = new Point2D(rightCoordinate, -25);
+            var bottomLeftInBetweenLayer = new Point2D(leftCoordinate, -25);
+            SoilLayer2D soilLayerInBetween = CreateSoilLayer2D(bottomLeftInBetweenAquiferLayerLeft, topRightInBetweenLayer, bottomRightInBetweenLayer, bottomLeftInBetweenLayer);
+
+            var topRightBottomAquiferLayer = new Point2D(rightCoordinate, -25);
+            var bottomRightBottomAquiferLayer = new Point2D(rightCoordinate, -30);
+            var bottomLeftBottomAquiferLayer = new Point2D(leftCoordinate, -30);
+            SoilLayer2D soilLayerAquiferBottom = CreateSoilLayer2D(bottomLeftInBetweenLayer, topRightBottomAquiferLayer, bottomRightBottomAquiferLayer, bottomLeftBottomAquiferLayer);
+            soilLayerAquiferBottom.IsAquifer = true;
+
+            var soilProfile = new SoilProfile2D
+            {
+                Geometry = new GeometryData
+                {
+                    Left = leftCoordinate,
+                    Right = rightCoordinate,
+                    Bottom = -20
+                }
+            };
+            soilProfile.Surfaces.Add(soilLayer);
+            soilProfile.Surfaces.Add(soilLayerAquiferInBetweenLeft);
+            soilProfile.Surfaces.Add(soilLayerAquiferInBetweenRight);
+            soilProfile.Surfaces.Add(soilLayerInBetween);
+            soilProfile.Surfaces.Add(soilLayerAquiferBottom);
+
+            var plLines = new PlLines();
+            PlLine plLine = plLines.Lines[PlLineType.Pl1];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -5));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -5));
+
+            plLine = plLines.Lines[PlLineType.Pl2];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -6));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -6));
+
+            plLine = plLines.Lines[PlLineType.Pl3];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -7));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -7));
+
+            plLine = plLines.Lines[PlLineType.Pl4];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -8));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -8));
+
+            // Call
+            Waternet waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile, penetrationLength);
+
+            // Assert
+            AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.Points);
+
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            AssertGeometry(plLines.Lines[PlLineType.Pl2].Points, waternet.HeadLineList[0].Points);
+            AssertGeometry(plLines.Lines[PlLineType.Pl3].Points, waternet.HeadLineList[1].Points);
+            AssertGeometry(plLines.Lines[PlLineType.Pl4].Points, waternet.HeadLineList[2].Points);
+
+            Assert.AreEqual(3, waternet.WaternetLineList.Count);
+
+            var expectedBottomAquiferCoordinates = new []
+            {
+                new GeometryPoint(leftCoordinate, -25), 
+                new GeometryPoint(rightCoordinate / 2, -25), 
+                new GeometryPoint(rightCoordinate, -25), 
+            };
+
+            WaternetLine pl2WaternetLine = waternet.WaternetLineList[0];
+            Assert.AreSame(waternet.HeadLineList[0], pl2WaternetLine.HeadLine);
+            var offSetAquiferCoordinates = expectedBottomAquiferCoordinates.Select(aquiferCoordinate => new GeometryPoint(aquiferCoordinate.X, aquiferCoordinate.Z + penetrationLength))
+                .ToArray();
+            AssertGeometry(offSetAquiferCoordinates, pl2WaternetLine.Points);
+
+            WaternetLine pl3WaternetLine = waternet.WaternetLineList[1];
+            Assert.AreSame(waternet.HeadLineList[1], pl3WaternetLine.HeadLine);
+            AssertGeometry(expectedBottomAquiferCoordinates, pl3WaternetLine.Points);
+
+            WaternetLine pl4WaternetLine = waternet.WaternetLineList[2];
+            Assert.AreSame(waternet.HeadLineList[2], pl4WaternetLine.HeadLine);
+            AssertGeometry(new[]
+            {
+                new GeometryPoint(leftCoordinate, -10), 
+                new GeometryPoint(rightCoordinate / 2, -10),
+                new GeometryPoint(rightCoordinate, -10)
+            }, pl4WaternetLine.Points);
+        }
+
+        [Test]
+        public void ConvertPlLineToWaternet_ValidPLLinesAndSoilProfile2DWithContinuousInBetweenAquiferLayerConsistOfOnePart_ReturnsExpectedWaternet()
+        {
+            // Setup
+            var random = new Random(21);
+            double leftCoordinate = random.NextDouble();
+            double rightCoordinate = leftCoordinate + 1;
+            double penetrationLength = random.NextDouble();
+
+            var topLeftUpperLayer = new Point2D(leftCoordinate, 0);
+            var topRightUpperLayer = new Point2D(rightCoordinate, 0);
+            var bottomRightUpperLayer = new Point2D(rightCoordinate, -10);
+            var bottomLeftUpperLayer = new Point2D(leftCoordinate, -10);
+            SoilLayer2D soilLayer = CreateSoilLayer2D(topLeftUpperLayer, topRightUpperLayer, bottomRightUpperLayer, bottomLeftUpperLayer);
+
             var topRightInBetweenAquiferLayer = new Point2D(rightCoordinate, -10);
             var bottomRightInBetweenAquiferLayer = new Point2D(rightCoordinate, -20);
             var bottomLeftInBetweenAquiferLayer = new Point2D(leftCoordinate, -20);
@@ -333,10 +442,10 @@
 
             Assert.AreEqual(3, waternet.WaternetLineList.Count);
 
-            var expectedBottomAquiferCoordinates = new []
+            var expectedBottomAquiferCoordinates = new[]
             {
-                new GeometryPoint(leftCoordinate, -25), 
-                new GeometryPoint(rightCoordinate, -25) 
+                new GeometryPoint(leftCoordinate, -25),
+                new GeometryPoint(rightCoordinate, -25)
             };
 
             WaternetLine pl2WaternetLine = waternet.WaternetLineList[0];
@@ -353,12 +462,268 @@
             Assert.AreSame(waternet.HeadLineList[2], pl4WaternetLine.HeadLine);
             AssertGeometry(new[]
             {
-                new GeometryPoint(leftCoordinate, -10), 
+                new GeometryPoint(leftCoordinate, -10),
                 new GeometryPoint(rightCoordinate, -10)
             }, pl4WaternetLine.Points);
         }
 
         [Test]
+        public void ConvertPlLineToWaternet_ValidPLLinesAndSoilProfile2DWithContinuousInBetweenAquiferLayerRightLayerTopLevelInRangeLeftLayer_ReturnsExpectedWaternet()
+        {
+            // Setup
+            var random = new Random(21);
+            double leftCoordinate = random.NextDouble();
+            double rightCoordinate = leftCoordinate + 1;
+            double penetrationLength = random.NextDouble();
+
+            var topLeftUpperLayer = new Point2D(leftCoordinate, 0);
+            var topRightUpperLayer = new Point2D(rightCoordinate, 0);
+            var bottomRightUpperLayer = new Point2D(rightCoordinate, -10);
+            var bottomLeftUpperLayer = new Point2D(leftCoordinate, -10);
+            SoilLayer2D soilLayer = CreateSoilLayer2D(topLeftUpperLayer, topRightUpperLayer, bottomRightUpperLayer, bottomLeftUpperLayer);
+
+            var topRightInBetweenAquiferLayerLeft = new Point2D(rightCoordinate / 2, -10);
+            var bottomRightInBetweenAquiferLayerLeft = new Point2D(rightCoordinate / 2, -20);
+            var bottomLeftInBetweenAquiferLayerLeft = new Point2D(leftCoordinate, -20);
+            SoilLayer2D soilLayerAquiferInBetweenLeft = CreateSoilLayer2D(bottomLeftUpperLayer, topRightInBetweenAquiferLayerLeft, bottomRightInBetweenAquiferLayerLeft, bottomLeftInBetweenAquiferLayerLeft);
+            soilLayerAquiferInBetweenLeft.IsAquifer = true;
+
+            // Add a layer to fill the gap between the right aquiferlayer and the upper layer
+            var bottomRightGapLayer = new Point2D(rightCoordinate, -15);
+            var bottomLeftGapLayer = new Point2D(rightCoordinate / 2, -15);
+            SoilLayer2D soilLayerGap = CreateSoilLayer2D(topRightInBetweenAquiferLayerLeft, bottomRightUpperLayer, bottomRightGapLayer, bottomLeftGapLayer);
+
+            var bottomRightInBetweenAquiferLayerRight = new Point2D(rightCoordinate, -21);
+            var bottomLeftInBetweenAquiferLayerRight = new Point2D(rightCoordinate / 2, -21);
+            SoilLayer2D soilLayerAquiferInBetweenRight = CreateSoilLayer2D(bottomLeftGapLayer, bottomRightGapLayer, bottomRightInBetweenAquiferLayerRight, bottomLeftInBetweenAquiferLayerRight);
+            soilLayerAquiferInBetweenRight.IsAquifer = true;
+
+            var bottomRightInBetweenLayer = new Point2D(rightCoordinate, -25);
+            var bottomLeftInBetweenLayer = new Point2D(leftCoordinate, -25);
+            var soilLayerInBetween = new SoilLayer2D
+            {
+                GeometrySurface = new GeometrySurface
+                {
+                    OuterLoop = new GeometryLoop
+                    {
+                        CurveList =
+                        {
+                            new GeometryCurve(bottomLeftInBetweenAquiferLayerLeft, bottomRightInBetweenAquiferLayerLeft),
+                            new GeometryCurve(bottomRightInBetweenAquiferLayerLeft, bottomLeftInBetweenAquiferLayerRight),
+                            new GeometryCurve(bottomLeftInBetweenAquiferLayerRight, bottomRightInBetweenAquiferLayerRight),
+                            new GeometryCurve(bottomRightInBetweenAquiferLayerRight, bottomRightInBetweenLayer),
+                            new GeometryCurve(bottomRightInBetweenLayer, bottomLeftInBetweenLayer)
+                        }
+                    }
+                }
+            };
+
+            var topRightBottomAquiferLayer = new Point2D(rightCoordinate, -25);
+            var bottomRightBottomAquiferLayer = new Point2D(rightCoordinate, -30);
+            var bottomLeftBottomAquiferLayer = new Point2D(leftCoordinate, -30);
+            SoilLayer2D soilLayerAquiferBottom = CreateSoilLayer2D(bottomLeftInBetweenLayer, topRightBottomAquiferLayer, bottomRightBottomAquiferLayer, bottomLeftBottomAquiferLayer);
+            soilLayerAquiferBottom.IsAquifer = true;
+
+            var soilProfile = new SoilProfile2D
+            {
+                Geometry = new GeometryData
+                {
+                    Left = leftCoordinate,
+                    Right = rightCoordinate,
+                    Bottom = -20
+                }
+            };
+            soilProfile.Surfaces.Add(soilLayer);
+            soilProfile.Surfaces.Add(soilLayerAquiferInBetweenLeft);
+            soilProfile.Surfaces.Add(soilLayerGap);
+            soilProfile.Surfaces.Add(soilLayerAquiferInBetweenRight);
+            soilProfile.Surfaces.Add(soilLayerInBetween);
+            soilProfile.Surfaces.Add(soilLayerAquiferBottom);
+
+            var plLines = new PlLines();
+            PlLine plLine = plLines.Lines[PlLineType.Pl1];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -5));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -5));
+
+            plLine = plLines.Lines[PlLineType.Pl2];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -6));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -6));
+
+            plLine = plLines.Lines[PlLineType.Pl3];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -7));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -7));
+
+            plLine = plLines.Lines[PlLineType.Pl4];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -8));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -8));
+
+            // Call
+            Waternet waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile, penetrationLength);
+
+            // Assert
+            AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.Points);
+
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            AssertGeometry(plLines.Lines[PlLineType.Pl2].Points, waternet.HeadLineList[0].Points);
+            AssertGeometry(plLines.Lines[PlLineType.Pl3].Points, waternet.HeadLineList[1].Points);
+            AssertGeometry(plLines.Lines[PlLineType.Pl4].Points, waternet.HeadLineList[2].Points);
+
+            Assert.AreEqual(3, waternet.WaternetLineList.Count);
+
+            var expectedBottomAquiferCoordinates = new[]
+            {
+                new GeometryPoint(leftCoordinate, -25),
+                new GeometryPoint(rightCoordinate / 2, -25),
+                new GeometryPoint(rightCoordinate, -25)
+            };
+
+            WaternetLine pl2WaternetLine = waternet.WaternetLineList[0];
+            Assert.AreSame(waternet.HeadLineList[0], pl2WaternetLine.HeadLine);
+            var offSetAquiferCoordinates = expectedBottomAquiferCoordinates.Select(aquiferCoordinate => new GeometryPoint(aquiferCoordinate.X, aquiferCoordinate.Z + penetrationLength))
+                .ToArray();
+            AssertGeometry(offSetAquiferCoordinates, pl2WaternetLine.Points);
+
+            WaternetLine pl3WaternetLine = waternet.WaternetLineList[1];
+            Assert.AreSame(waternet.HeadLineList[1], pl3WaternetLine.HeadLine);
+            AssertGeometry(expectedBottomAquiferCoordinates, pl3WaternetLine.Points);
+
+            WaternetLine pl4WaternetLine = waternet.WaternetLineList[2];
+            Assert.AreSame(waternet.HeadLineList[2], pl4WaternetLine.HeadLine);
+            AssertGeometry(new[]
+            {
+                new GeometryPoint(leftCoordinate, -10),
+                new GeometryPoint(rightCoordinate / 2, -10),
+                new GeometryPoint(rightCoordinate, -15)
+            }, pl4WaternetLine.Points);
+        }
+
+        [Test]
+        public void ConvertPlLineToWaternet_ValidPLLinesAndSoilProfile2DWithContinuousInBetweenAquiferLayerRightLayerBottomLevelInRangeLeftLayer_ReturnsExpectedWaternet()
+        {
+            // Setup
+            var random = new Random(21);
+            double leftCoordinate = random.NextDouble();
+            double rightCoordinate = leftCoordinate + 1;
+            double penetrationLength = random.NextDouble();
+
+            var topLeftUpperLayer = new Point2D(leftCoordinate, 0);
+            var topRightUpperLayer = new Point2D(rightCoordinate, 0);
+            var bottomRightUpperLayer = new Point2D(rightCoordinate, -5);
+            var bottomIntermediateUpperUpperLayer = new Point2D(rightCoordinate / 2, -5);
+            var bottomIntermediateLowerUpperLayer = new Point2D(rightCoordinate / 2, -10);
+            var bottomLeftUpperLayer = new Point2D(leftCoordinate, -10);
+            var soilLayer = new SoilLayer2D
+            {
+                GeometrySurface = new GeometrySurface
+                {
+                    OuterLoop = new GeometryLoop
+                    {
+                        CurveList =
+                        {
+                            new GeometryCurve(topLeftUpperLayer, topRightUpperLayer),
+                            new GeometryCurve(topRightUpperLayer, bottomRightUpperLayer),
+                            new GeometryCurve(bottomRightUpperLayer, bottomIntermediateUpperUpperLayer),
+                            new GeometryCurve(bottomIntermediateUpperUpperLayer, bottomIntermediateLowerUpperLayer),
+                            new GeometryCurve(bottomIntermediateLowerUpperLayer, bottomLeftUpperLayer),
+                            new GeometryCurve(bottomLeftUpperLayer, topLeftUpperLayer)
+                        }
+                    }
+                }
+            };
+
+            var bottomRightInBetweenAquiferLayerLeft = new Point2D(rightCoordinate / 2, -20);
+            var bottomLeftInBetweenAquiferLayerLeft = new Point2D(leftCoordinate, -20);
+            SoilLayer2D soilLayerAquiferInBetweenLeft = CreateSoilLayer2D(bottomLeftUpperLayer, bottomIntermediateLowerUpperLayer, bottomRightInBetweenAquiferLayerLeft, bottomLeftInBetweenAquiferLayerLeft);
+            soilLayerAquiferInBetweenLeft.IsAquifer = true;
+
+            var bottomRightInBetweenAquiferLayerRight = new Point2D(rightCoordinate, -20);
+            var bottomLeftInBetweenAquiferLayerRight = new Point2D(rightCoordinate / 2, -20);
+            SoilLayer2D soilLayerAquiferInBetweenRight = CreateSoilLayer2D(bottomIntermediateUpperUpperLayer, bottomRightUpperLayer, bottomRightInBetweenAquiferLayerRight, bottomLeftInBetweenAquiferLayerRight);
+            soilLayerAquiferInBetweenRight.IsAquifer = true;
+
+            var bottomRightInBetweenLayer = new Point2D(rightCoordinate, -25);
+            var bottomLeftInBetweenLayer = new Point2D(leftCoordinate, -25);
+            SoilLayer2D soilLayerInBetween = CreateSoilLayer2D(bottomLeftInBetweenAquiferLayerLeft, bottomRightInBetweenAquiferLayerRight, bottomRightInBetweenLayer, bottomLeftInBetweenLayer);
+
+            var topRightBottomAquiferLayer = new Point2D(rightCoordinate, -25);
+            var bottomRightBottomAquiferLayer = new Point2D(rightCoordinate, -30);
+            var bottomLeftBottomAquiferLayer = new Point2D(leftCoordinate, -30);
+            SoilLayer2D soilLayerAquiferBottom = CreateSoilLayer2D(bottomLeftInBetweenLayer, topRightBottomAquiferLayer, bottomRightBottomAquiferLayer, bottomLeftBottomAquiferLayer);
+            soilLayerAquiferBottom.IsAquifer = true;
+
+            var soilProfile = new SoilProfile2D
+            {
+                Geometry = new GeometryData
+                {
+                    Left = leftCoordinate,
+                    Right = rightCoordinate,
+                    Bottom = -20
+                }
+            };
+            soilProfile.Surfaces.Add(soilLayer);
+            soilProfile.Surfaces.Add(soilLayerAquiferInBetweenLeft);
+            soilProfile.Surfaces.Add(soilLayerAquiferInBetweenRight);
+            soilProfile.Surfaces.Add(soilLayerInBetween);
+            soilProfile.Surfaces.Add(soilLayerAquiferBottom);
+
+            var plLines = new PlLines();
+            PlLine plLine = plLines.Lines[PlLineType.Pl1];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -5));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -5));
+
+            plLine = plLines.Lines[PlLineType.Pl2];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -6));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -6));
+
+            plLine = plLines.Lines[PlLineType.Pl3];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -7));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -7));
+
+            plLine = plLines.Lines[PlLineType.Pl4];
+            plLine.Points.Add(new PlLinePoint(leftCoordinate, -8));
+            plLine.Points.Add(new PlLinePoint(rightCoordinate, -8));
+
+            // Call
+            Waternet waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile, penetrationLength);
+
+            // Assert
+            AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.Points);
+
+            Assert.AreEqual(3, waternet.HeadLineList.Count);
+            AssertGeometry(plLines.Lines[PlLineType.Pl2].Points, waternet.HeadLineList[0].Points);
+            AssertGeometry(plLines.Lines[PlLineType.Pl3].Points, waternet.HeadLineList[1].Points);
+            AssertGeometry(plLines.Lines[PlLineType.Pl4].Points, waternet.HeadLineList[2].Points);
+
+            Assert.AreEqual(3, waternet.WaternetLineList.Count);
+
+            var expectedBottomAquiferCoordinates = new[]
+            {
+                new GeometryPoint(leftCoordinate, -25),
+                new GeometryPoint(rightCoordinate / 2, -25),
+                new GeometryPoint(rightCoordinate, -25)
+            };
+
+            WaternetLine pl2WaternetLine = waternet.WaternetLineList[0];
+            Assert.AreSame(waternet.HeadLineList[0], pl2WaternetLine.HeadLine);
+            var offSetAquiferCoordinates = expectedBottomAquiferCoordinates.Select(aquiferCoordinate => new GeometryPoint(aquiferCoordinate.X, aquiferCoordinate.Z + penetrationLength))
+                .ToArray();
+            AssertGeometry(offSetAquiferCoordinates, pl2WaternetLine.Points);
+
+            WaternetLine pl3WaternetLine = waternet.WaternetLineList[1];
+            Assert.AreSame(waternet.HeadLineList[1], pl3WaternetLine.HeadLine);
+            AssertGeometry(expectedBottomAquiferCoordinates, pl3WaternetLine.Points);
+
+            WaternetLine pl4WaternetLine = waternet.WaternetLineList[2];
+            Assert.AreSame(waternet.HeadLineList[2], pl4WaternetLine.HeadLine);
+            AssertGeometry(new[]
+            {
+                new GeometryPoint(leftCoordinate, -10),
+                new GeometryPoint(rightCoordinate / 2, -5),
+                new GeometryPoint(rightCoordinate, -5)
+            }, pl4WaternetLine.Points);
+        }
+
+        [Test]
         [TestCase(true, false)]
         [TestCase(false, true)]
         public void ConvertPlLineToWaternet_ValidPLLinesAndSoilProfile2DWithDiscontinuousInBetweenAquiferLayer_ReturnsExpectedWaternet(
@@ -395,8 +760,8 @@
 
             var topRightBottomAquiferLayer = new Point2D(rightCoordinate, -25);
             var bottomRightBottomAquiferLayer = new Point2D(rightCoordinate, -30);
-            var bottomleftBottomAquiferLayer = new Point2D(leftCoordinate, -30);
-            SoilLayer2D soilLayerAquiferBottom = CreateSoilLayer2D(bottomLeftInBetweenLayer, topRightBottomAquiferLayer, bottomRightBottomAquiferLayer, bottomleftBottomAquiferLayer);
+            var bottomLeftBottomAquiferLayer = new Point2D(leftCoordinate, -30);
+            SoilLayer2D soilLayerAquiferBottom = CreateSoilLayer2D(bottomLeftInBetweenLayer, topRightBottomAquiferLayer, bottomRightBottomAquiferLayer, bottomLeftBottomAquiferLayer);
             soilLayerAquiferBottom.IsAquifer = true;
 
             var soilProfile = new SoilProfile2D
@@ -461,8 +826,7 @@
             Assert.AreSame(waternet.HeadLineList[1], pl3WaternetLine.HeadLine);
             AssertGeometry(expectedBottomAquiferCoordinates, pl3WaternetLine.Points);
         }
-
-
+        
         [Test]
         public void ConvertPlLineToWaternet_ValidPLLinesAndSoilProfile2DWithDiscontinuousBottomAquiferLayer_ReturnsExpectedWaternet()
         {
@@ -918,10 +1282,18 @@
             }).SetName("Right aquifer fully enveloped by left aquifer");
         }
 
+        /// <summary>
+        /// Creates a rectangular <see cref="SoilLayer2D"/>.
+        /// </summary>
+        /// <param name="topLeftCoordinate"></param>
+        /// <param name="topRightCoordinate"></param>
+        /// <param name="bottomRightCoordinate"></param>
+        /// <param name="bottomLeftCoordinate"></param>
+        /// <returns>A rectangular <see cref="SoilLayer2D"/>.</returns>
         private static SoilLayer2D CreateSoilLayer2D(Point2D topLeftCoordinate, 
             Point2D topRightCoordinate, Point2D bottomRightCoordinate, Point2D bottomLeftCoordinate)
         {
-            var soilLayer = new SoilLayer2D
+            return new SoilLayer2D
             {
                 GeometrySurface = new GeometrySurface
                 {
@@ -937,7 +1309,6 @@
                     }
                 }
             };
-            return soilLayer;
         }
 
         private static void AssertGeometry(IEnumerable<GeometryPoint> expectedPoints, IEnumerable<GeometryPoint> actualPoints)