Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs
===================================================================
diff -u -r5382 -r5391
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs	(.../PlLinesToWaternetConverterTests.cs)	(revision 5382)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs	(.../PlLinesToWaternetConverterTests.cs)	(revision 5391)
@@ -51,6 +51,40 @@
     private static readonly double middleXCoordinate = 0.5 * (leftCoordinate + rightCoordinate);
 
     [Test]
+    [TestCase(10, -5, 10, 10)]
+    [TestCase(10, 5, 10, 10.01)]
+    [TestCase(10, 5, 0.005, 10.0025)]
+    public void GivenALineWithVerticalPart_WhenCorrectingToAvoidUpwardsLine_ThenExpectedLineReturned(double xPoint2, double heightVerticalPart, double distancePoints3And4, double expectedXPoint3)
+    {
+        // Setup
+        IList<Point2D> points = new List<Point2D>();
+        points.Add(new Point2D(xPoint2 - 10, 0));
+        points.Add(new Point2D(xPoint2, 0));
+        points.Add(new Point2D(xPoint2, heightVerticalPart));
+        points.Add(new Point2D(xPoint2 + distancePoints3And4, heightVerticalPart));
+        points.Add(new Point2D(xPoint2 + distancePoints3And4 + 10, heightVerticalPart));
+        
+        // Call
+        PlLinesToWaternetConverter.AvoidUpwardsVerticalLine(points);
+        
+        // Assert
+        Assert.That(points, Has.Count.EqualTo(5));
+        Assert.Multiple(() =>
+        {
+            Assert.That(points[0].X, Is.EqualTo(xPoint2 - 10).Within(precision5Decimals));
+            Assert.That(points[0].Z, Is.EqualTo(0).Within(precision5Decimals));
+            Assert.That(points[1].X, Is.EqualTo(xPoint2).Within(precision5Decimals));
+            Assert.That(points[1].Z, Is.EqualTo(0).Within(precision5Decimals));
+            Assert.That(points[2].X, Is.EqualTo(expectedXPoint3).Within(precision5Decimals));
+            Assert.That(points[2].Z, Is.EqualTo(heightVerticalPart).Within(precision5Decimals));
+            Assert.That(points[3].X, Is.EqualTo(xPoint2 + distancePoints3And4).Within(precision5Decimals));
+            Assert.That(points[3].Z, Is.EqualTo(heightVerticalPart).Within(precision5Decimals));
+            Assert.That(points[4].X, Is.EqualTo(xPoint2 + distancePoints3And4 + 10).Within(precision5Decimals));
+            Assert.That(points[4].Z, Is.EqualTo(heightVerticalPart).Within(precision5Decimals));
+        });
+    }
+
+    [Test]
     public void GivenALine_WhenSplittingAtTwoPoints_ThenReturnsThreeNewLines()
     {
         // Setup
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs
===================================================================
diff -u -r5382 -r5391
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs	(.../PlLinesToWaternetConverter.cs)	(revision 5382)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs	(.../PlLinesToWaternetConverter.cs)	(revision 5391)
@@ -296,6 +296,7 @@
         line.SyncCalcPoints();
         LineHelper.RemoveDuplicatedPoints(line.CalcPoints, toleranceAlmostEqual);
         line.RemoveUnnecessaryPoints();
+        AvoidUpwardsVerticalLine(line.CalcPoints);
         line.SyncPoints();
 
         return line;
@@ -604,4 +605,29 @@
 
         return lines;
     }
+
+    /// <summary>
+    /// This correction is needed for the creation of the STIX file because a reference line containing a vertical part
+    /// is always drawn in downwards direction by D-Stability. 
+    /// </summary>
+    internal static void AvoidUpwardsVerticalLine(IList<Point2D> points)
+    {
+        for (var i = 0; i < points.Count - 2; i++)
+        {
+            if (Math.Abs(points[i].X - points[i + 1].X) < toleranceAlmostEqual && points[i].Z < points[i + 1].Z)
+            {
+                if (i < points.Count)
+                {
+                    if (points[i + 1].X + 0.01 < points[i + 2].X)
+                    {
+                        points[i + 1].X += 0.01;
+                    }
+                    else
+                    {
+                        points[i + 1].X = points[i + 2].X - (points[i + 2].X - points[i + 1].X) / 2;
+                    }
+                }
+            }
+        }
+    }
 }
\ No newline at end of file