Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs
===================================================================
diff -u -r877 -r955
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs	(.../SurfaceLine2.cs)	(revision 877)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs	(.../SurfaceLine2.cs)	(revision 955)
@@ -23,6 +23,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Deltares.DamEngine.Data.Geometry;
+using Deltares.DamEngine.Data.Standard;
 using Deltares.DamEngine.Data.Standard.Language;
 using Deltares.DamEngine.Data.Standard.Validation;
 
@@ -52,6 +53,17 @@
         }
 
         /// <summary>
+        /// Deep clone the object.
+        /// </summary>
+        /// <returns></returns>
+        public SurfaceLine2 FullDeepClone()
+        {
+            SurfaceLine2 surfaceLine2 = new SurfaceLine2();
+            surfaceLine2.SetValuesFromOtherSurfaceLine(this, true);
+            return surfaceLine2;
+        }
+
+        /// <summary>
         /// The geometrical description of the surface line.
         /// </summary>
         /// <remarks>Aggregation relationship.</remarks>
@@ -153,6 +165,59 @@
         }
 
         /// <summary>
+        /// Gets the points orderd by x.
+        /// </summary>
+        /// <value>
+        /// The points orderd by x.
+        /// </value>
+        private IEnumerable<GeometryPoint> PointsOrderdByX
+        {
+            get
+            {
+                return Geometry.Points.OrderBy(p => p.X);
+            }
+        }
+
+        /// <summary>
+        /// Tests if the given point is between the given start X and end X.
+        /// </summary>
+        /// <param name="point">The point.</param>
+        /// <param name="startX">The start x.</param>
+        /// <param name="endX">The end x.</param>
+        /// <returns><c>true</c> if the given point is between the given start X and end X, otherwise <c>false</c></returns>
+        private bool TestIncluding(GeometryPoint point, double startX, double endX)
+        {
+            if (point == null)
+            {
+                return false;
+            }
+
+            double x = point.X;
+            return (x >= startX || x.AlmostEquals(startX, GeometryPoint.Precision))
+                   && (x < endX || x.AlmostEquals(endX, GeometryPoint.Precision));
+        }
+
+        /// <summary>
+        /// Gets the point segment including given start x and end x.
+        /// </summary>
+        /// <param name="startX">The start x.</param>
+        /// <param name="endX">The end x.</param>
+        /// <returns>collection of points between start X and end X (inlcuding those)</returns>
+        /// <exception cref="System.ArgumentException">End value is smaller then the start value</exception>
+        public virtual IEnumerable<GeometryPoint> GetPointSegmentIncluding(double startX, double endX)
+        {
+            if (endX < startX)
+            {
+                throw new ArgumentException("End value is smaller then the start value");
+            }
+
+            return from point in PointsOrderdByX
+                   where TestIncluding(point, startX, endX)
+                   orderby point.X ascending
+                   select point;
+        }
+
+        /// <summary>
         /// Validates this surfaceline.
         /// </summary>
         /// <returns>All validation messages.</returns>
@@ -318,5 +383,6 @@
             }
             return geometryAnnotations;
         }
+
     }
 }
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs
===================================================================
diff -u -r951 -r955
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs	(.../SurfaceLine2Extensions.cs)	(revision 951)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs	(.../SurfaceLine2Extensions.cs)	(revision 955)
@@ -474,6 +474,19 @@
         }
 
         /// <summary>
+        /// Determines the tan slope inside.
+        /// </summary>
+        /// <returns>tan slope inside</returns>
+        public static double TanSlopeInside(this SurfaceLine2 line)
+        {
+            GeometryPoint dikeToeInward = line.GetDikeToeInward();
+            GeometryPoint dikeTopAtPolder = line.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            return (dikeTopAtPolder.Z - dikeToeInward.Z) /
+                   (dikeToeInward.X - dikeTopAtPolder.X);
+        }
+
+
+        /// <summary>
         /// Create a horizontal line from a given starting X coordinate and ending at the
         /// X coordinate of <see cref="CharacteristicPointType.SurfaceLevelInside"/> defined
         /// in the surfaceline.
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/General/LocationJob.cs
===================================================================
diff -u -r877 -r955
--- DamEngine/trunk/src/Deltares.DamEngine.Data/General/LocationJob.cs	(.../LocationJob.cs)	(revision 877)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/General/LocationJob.cs	(.../LocationJob.cs)	(revision 955)
@@ -44,9 +44,6 @@
         private LocationResult locationResult = new LocationResult();
 
         private static ScenarioType currentScenarioType = ScenarioType.Scenario01;
-        private static string currentProfileName = "";
-        private static string currentScenarioName = "";
-        private static string currentCalculation = "";
         private static DateTime currentTime = DateTime.Today;
         private static DamProjectType damProjectType = DamProjectType.Operational;
         
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineHeightAdapterTest.cs
===================================================================
diff -u
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineHeightAdapterTest.cs	(revision 0)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineHeightAdapterTest.cs	(revision 955)
@@ -0,0 +1,1000 @@
+// Copyright (C) Stichting Deltares 2018. All rights reserved.
+//
+// This file is part of the Dam Engine.
+//
+// The Dam Engine is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System.Linq;
+using Deltares.DamEngine.Calculators.Dikes_Design;
+using Deltares.DamEngine.Data.General;
+using Deltares.DamEngine.Data.Geometry;
+using Deltares.DamEngine.Data.Geotechnics;
+using Deltares.DamEngine.Data.Standard.Validation;
+using Deltares.DamEngine.TestHelpers.Factories;
+using NUnit.Framework;
+
+namespace Deltares.DamEngine.Calculators.Tests.DikesDesign
+{
+    [TestFixture]
+    public class SurfaceLineHeightAdapterTest
+    {
+        [Test]
+        public void ConstructNewSurfaceLineReturnsANewSurfaceLine()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            {
+                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+                surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+                surfaceLine.EnsurePointOfType(2, 1, CharacteristicPointType.DikeTopAtPolder);
+                surfaceLine.EnsurePointOfType(3, 0, CharacteristicPointType.DikeToeAtPolder);
+                surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+                var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+                var constructNewSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(1);
+                {
+                    Assert.IsNotNull(constructNewSurfaceLine);
+                }
+            }
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineHasSamePointAtToeRiver()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            {
+                const double newDikeHeight = 6.0;
+                var pointAtToeRiver = new GeometryPoint { X = 17, Z = 0 };
+                var pointAtTopRiver = new GeometryPoint { X = 34.5, Z = 5 };
+                var pointAtTopPolder = new GeometryPoint { X = 35, Z = 5 };
+                var pointAtToePolder = new GeometryPoint { X = 36, Z = 0 };
+
+                surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtRiver);
+                surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+                surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+                surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+                surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+
+                var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+                var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+                {
+                    var newPointAtToeRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver);
+                    Assert.IsTrue(newPointAtToeRiver.LocationEquals(pointAtToeRiver));
+                    Assert.IsTrue(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtToeRiver)));
+                }
+            }
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineHasSameSlopeInside()
+        {
+            var line = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var surfaceLine = line;
+            var location = new Location();
+            const double cToleranceSlope = 0.0001;
+            const double newDikeHeight = 6.0;
+            var pointAtToeRiver = new GeometryPoint { X = 17, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 34.5, Z = 5 };
+            var pointAtTopPolder = new GeometryPoint { X = 35, Z = 5 };
+            var pointAtToePolder = new GeometryPoint { X = 36, Z = 0 };
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            double oldSlope = surfaceLine.TanSlopeInside();
+            double newSlope = newSurfaceLine.TanSlopeInside();
+            Assert.AreEqual(oldSlope, newSlope, cToleranceSlope);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineHasCorrectNewPointAtTopRiver()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
+            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            var expectedPoint = new GeometryPoint { X = 2, Z = 2 };
+            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineHasRemovedOldPointAtTopRiverCorrectly()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
+            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtTopRiver)));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithoutShoulderHasCorrectNewPointAtTopPolder()
+        {
+            var line = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var surfaceLine = line;
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
+            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            var expectedPoint = new GeometryPoint { X = 3, Z = 2 };
+            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithoutShoulderHasCorrectlyRemovedOldPointAtTopPolder()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
+            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtTopPolder)));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithoutShoulderHasCorrectNewPointAtToePolder()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 2, Z = 1 };
+            var pointAtTopPolder = new GeometryPoint { X = 3, Z = 1 };
+            var pointAtToePolder = new GeometryPoint { X = 7, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            var expectedPoint = new GeometryPoint { X = 13 };
+            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
+            double oldSlope = surfaceLine.TanSlopeInside();
+            double newSlope = newSurfaceLine.TanSlopeInside();
+            Assert.AreEqual(oldSlope, newSlope, 0.001);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtToePolder()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(2, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(3, 0.5, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(4, 0.5, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedPoint = new GeometryPoint() { X = 7, Z = 0 };  // 
+            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineHasRemovedShoulderPointsCorrectly()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 3.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
+            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 0.5 };
+            var pointAtShoulderTop = new GeometryPoint { X = 4, Z = 0.5 };
+            var pointAtToePolder = new GeometryPoint { X = 5, Z = 0 };
+            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.IsNull(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
+            Assert.IsNull(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
+            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtShoulderInsteek)));
+            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtShoulderTop)));
+            var newPointAtToePolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.AreEqual(3, newSurfaceLine.GetPointSegmentIncluding(pointAtTopRiver.X, newPointAtToePolder.X).Count());
+            Assert.AreEqual(5, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithLargeShoulderHaveSameToeAtPolder()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 1.5;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
+            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 0.5 };
+            var pointAtShoulderTop = new GeometryPoint { X = 5, Z = 0.5 };
+            var pointAtToePolder = new GeometryPoint { X = 6, Z = 0 };
+            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.IsTrue(pointAtToePolder.LocationEquals(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithLargeShoulderHaveSameTopAtShoulderInside()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 3.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 2 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 2 };
+            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 1 };
+            var pointAtShoulderTop = new GeometryPoint { X = 5, Z = 1 };
+            var pointAtToePolder = new GeometryPoint { X = 6, Z = 2 };
+            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.IsTrue(pointAtShoulderTop.LocationEquals(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside)));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithLargeShoulderShouldHaveACorrectIntersectionPoint()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 3.0;
+            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 2 };
+            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 2 };
+            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 1 };
+            var pointAtShoulderTop = new GeometryPoint { X = 5, Z = 1 };
+            var pointAtToePolder = new GeometryPoint { X = 6, Z = 0 };
+            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedPoint = new GeometryPoint { X = 4.5, Z = 1 };
+            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
+            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithSoulderAndDitchShouldNotCreateInvalidSurfaceLine()
+        {
+            var surfaceLine = FactoryForSurfaceLines.CreateRealisticSurfaceLineForHeightAdapter();
+            var location = new Location();
+            const double newDikeHeight = 19.2;
+            var validationError = surfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
+            if (validationError != null)
+            {
+                throw new SurfaceLineException(validationError.Text);
+            }
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            validationError = newSurfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
+            if (validationError != null)
+            {
+                throw new SurfaceLineException(validationError.Text);
+            }
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints1()
+        {
+            var surfaceLine = FactoryForSurfaceLines.CreateRealisticSurfaceLineForHeightAdapter();
+            var location = new Location();
+            const double cTolerance = 0.0000001;
+            const double newDikeHeight = 19.2;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z, cTolerance);
+            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z, cTolerance);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints2()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 1.2;
+            var pointDikeToeAtRiver = new GeometryPoint { X = 0, Z = 0 };
+            var pointDikeTopAtRiver = new GeometryPoint { X = 1, Z = 1 };
+            var pointTrafficLoadOutside = new GeometryPoint { X = 1.1, Z = 1 };
+            var pointTrafficLoadInside = new GeometryPoint { X = 1.9, Z = 1 };
+            var pointDikeTopAtPolder = new GeometryPoint { X = 2, Z = 1 };
+            var pointDikeToeAtPolder = new GeometryPoint { X = 3, Z = 0 };
+            surfaceLine.EnsurePointOfType(pointDikeToeAtRiver.X, pointDikeToeAtRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointDikeTopAtRiver.X, pointDikeTopAtRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
+            surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
+            surfaceLine.EnsurePointOfType(pointDikeTopAtPolder.X, pointDikeTopAtPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z);
+            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z);
+        }
+
+        /// <summary>
+        /// Create dike with skewed dike table and points between characteristic points
+        /// </summary>
+        /// <returns></returns>
+        private SurfaceLine2 CreateSurfaceLineWithSkwewedDikeTableAndInBetweenPoints()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints = { GeometryMustContainPoint = true },
+                Geometry = new GeometryPointString()
+            };
+            var point1 = new GeometryPoint { X = 0, Z = 0 };
+            var pointDikeToeAtRiver = new GeometryPoint { X = 2, Z = 0 };
+            var point2 = new GeometryPoint { X = 4, Z = 1 };
+            var pointDikeTopAtRiver = new GeometryPoint { X = 6, Z = 3 };
+            var point3 = new GeometryPoint { X = 7, Z = 3 };
+            var pointDikeTopAtPolder = new GeometryPoint { X = 8, Z = 3.5 };
+            var point4 = new GeometryPoint { X = 10, Z = 1.5 };
+            var pointDikeToeAtPolder = new GeometryPoint { X = 12, Z = 0.5 };
+            var point5 = new GeometryPoint { X = 13, Z = 0 };
+            var pointSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
+
+            surfaceLine.EnsurePointOfType(pointDikeToeAtRiver.X, pointDikeToeAtRiver.Z, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(pointDikeTopAtRiver.X, pointDikeTopAtRiver.Z, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(pointDikeTopAtPolder.X, pointDikeTopAtPolder.Z, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
+            surfaceLine.EnsurePoint(point1.X, point1.Z);
+            surfaceLine.EnsurePoint(point2.X, point2.Z);
+            surfaceLine.EnsurePoint(point3.X, point3.Z);
+            surfaceLine.EnsurePoint(point4.X, point4.Z);
+            surfaceLine.EnsurePoint(point5.X, point5.Z);
+            surfaceLine.SortPoints();
+            return surfaceLine;
+        }
+
+        /// <summary>
+        /// Test if dike with skewed dike table and points between characteristic points is constructed correctly with new height
+        /// </summary>
+        [Test]
+        public void CanAdaptSurfaceLineWithSkewedDikeTableAndInBetweenPoints()
+        {
+            SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkwewedDikeTableAndInBetweenPoints();
+            var location = new Location();
+            const double cTolerance = 0.001;
+            const double newDikeHeight = 4.0;
+            Assert.AreEqual(10, surfaceLine.Geometry.Points.Count);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
+            Assert.AreEqual(7.3333, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).X, cTolerance);
+            Assert.AreEqual(4.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).Z, cTolerance);
+            Assert.AreEqual(9.3333, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).X, cTolerance);
+            Assert.AreEqual(4.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, cTolerance);
+            Assert.AreEqual(14.6666, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X, cTolerance);
+            Assert.AreEqual(0.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z, cTolerance);
+            Assert.AreEqual(100.000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, cTolerance);
+            Assert.AreEqual(0.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).Z, cTolerance);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedTopExactOnOldTop()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeTopWidth = true;
+            location.NewDikeTopWidth = 1;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 3, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedShoulderBaseInside = new GeometryPoint() { X = 5, Z = 0 };
+            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
+            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
+            Assert.AreEqual(9, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedTopSmallerThanOldTop()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeTopWidth = true;
+            location.NewDikeTopWidth = 0.8;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 2.8, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedNewPoint = new GeometryPoint() { X = 3.8, Z = 1 };
+            var actualNewPoint = newSurfaceLine.Geometry.Points[4];
+            Assert.IsTrue(expectedNewPoint.LocationEquals(actualNewPoint));
+            var expectedShoulderBaseInside = new GeometryPoint() { X = 5, Z = 0 };
+            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
+            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
+            Assert.AreEqual(10, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedTopWiderThanOldTopBeyondShoulder()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeTopWidth = true;
+            location.NewDikeTopWidth = 3;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 5, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedToeInside = new GeometryPoint() { X = 8, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(5, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedTopWiderThanOldTopOnShoulderTopInside()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeTopWidth = true;
+            location.NewDikeTopWidth = 2;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 4, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedTopWiderThanOldTopIntersectingShoulder()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeTopWidth = true;
+            location.NewDikeTopWidth = 1.5;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 3.5, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedShoulderBaseInside = new GeometryPoint() { X = 5.5, Z = 0 };
+            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
+            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
+            var expectedShoulderTopInside = new GeometryPoint() { X = 6, Z = 0 };
+            var actualShoulderTopInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
+            Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualShoulderTopInside));
+            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(7, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedInsideSlope()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeSlopeInside = true;
+            location.NewDikeSlopeInside = 0.5;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 5, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedToeInside = new GeometryPoint() { X = 11, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(5, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedInsideSlopeEndingOnOldShoulderTop()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeSlopeInside = true;
+            location.NewDikeSlopeInside = 2;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 5, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedPoint = new GeometryPoint() { X = 6, Z = 0 };
+            var actualPoint = newSurfaceLine.Geometry.Points[3];
+            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
+            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedOutsideSlope2()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeSlopeOutside = true;
+            location.NewDikeSlopeOutside = 2;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 1.5, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 4.5, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedToeInside = new GeometryPoint() { X = 7.5, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedOutsideSlope05()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeSlopeOutside = true;
+            location.NewDikeSlopeOutside = 0.5;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 3, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 6, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedToeInside = new GeometryPoint() { X = 9, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedTopWidthAndOutsideSlopeAndInsideSlope()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeSlopeOutside = true;
+            location.NewDikeSlopeOutside = 2;
+            location.UseNewDikeSlopeInside = true;
+            location.NewDikeSlopeInside = 2;
+            location.UseNewDikeTopWidth = true;
+            location.NewDikeTopWidth = 1.5;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 1.5, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 3, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedPoint = new GeometryPoint() { X = 3.5, Z = 1 };
+            var actualPoint = newSurfaceLine.Geometry.Points[4];
+            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
+            var expectedPoint2 = new GeometryPoint() { X = 4, Z = 1 };
+            var actualPoint2 = newSurfaceLine.Geometry.Points[5];
+            Assert.IsTrue(expectedPoint2.LocationEquals(actualPoint2));
+            var expectedShoulderBaseInside = new GeometryPoint() { X = 5, Z = 0 };
+            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
+            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
+            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(10, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        public void AdaptedSurfaceLineWithNewDefinedTopWidthAndOutsideSlopeAndInsideSlope05()
+        {
+            var surfaceLine = new SurfaceLine2
+            {
+                CharacteristicPoints =
+                {
+                    GeometryMustContainPoint = true
+                },
+                Geometry = new GeometryPointString()
+            };
+            var location = new Location();
+            const double newDikeHeight = 2.0;
+            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
+            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
+            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
+            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
+            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
+            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
+            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
+            location.UseNewDikeSlopeOutside = true;
+            location.NewDikeSlopeOutside = 2;
+            location.UseNewDikeSlopeInside = true;
+            location.NewDikeSlopeInside = 0.5;
+            location.UseNewDikeTopWidth = true;
+            location.NewDikeTopWidth = 1.5;
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            var expectedNewTopRiver = new GeometryPoint() { X = 1.5, Z = 2 };
+            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
+            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
+            var expectedNewTopPolder = new GeometryPoint() { X = 3, Z = 2 };
+            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
+            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
+            var expectedToeInside = new GeometryPoint() { X = 9, Z = -1 };
+            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
+            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
+            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
+        }
+
+        [Test]
+        [ExpectedException(typeof(SurfaceLineAdapterException))]
+        public void HeightAdaptionThrowsExceptionIfSurfaceLIsNotLongEnough()
+        {
+            var surfaceLine = FactoryForSurfaceLines.CreateRealisticSurfaceLineForHeightAdapter();
+            var location = new Location();
+            const double newDikeHeight = 19.0;
+            var pointSurfaceLevelInside = new GeometryPoint { X = 40, Z = 12 }; // Set surfacelevelinside just beside ditch to force exception
+            surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
+            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
+            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
+            Assert.Null(newSurfaceLine);
+        }
+    }
+}	
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj
===================================================================
diff -u -r951 -r955
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj	(.../Deltares.DamEngine.Calculators.Tests.csproj)	(revision 951)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj	(.../Deltares.DamEngine.Calculators.Tests.csproj)	(revision 955)
@@ -46,6 +46,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="DikesDesign\SurfaceLineAdapterTest.cs" />
+    <Compile Include="DikesDesign\SurfaceLineHeightAdapterTest.cs" />
     <Compile Include="KernelWrappers\Common\DamPipingHelperTests.cs" />
     <Compile Include="KernelWrappers\Common\PlLinesHelperTests.cs" />
     <Compile Include="KernelWrappers\DamMacroStabilityCommon\DamMacroStabilityTestHelper.cs" />
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/SurfaceLineAdapter.cs
===================================================================
diff -u -r946 -r955
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/SurfaceLineAdapter.cs	(.../SurfaceLineAdapter.cs)	(revision 946)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/SurfaceLineAdapter.cs	(.../SurfaceLineAdapter.cs)	(revision 955)
@@ -74,8 +74,7 @@
         {
             ThrowWhenSurfaceLineIsNull(surfaceLine);
             ThrowWhenSurfaceLineDoesNotSatisfyToSpecification(surfaceLine);
-            this.surfaceLine = new SurfaceLine2();
-            surfaceLine.CloneProperties(this.surfaceLine);// ##Bka: replaced FullDeepClone(); by this (as todo says, has to be tested)// TODO: Do not do this! Give it the clone instead: GRASP Creator principle
+            this.surfaceLine = surfaceLine.FullDeepClone();
             this.Location = location;
             RetainTrafficLoad();
         }