Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs
===================================================================
diff -u -r4628 -r6086
--- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs	(.../SurfaceLine2Tests.cs)	(revision 4628)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs	(.../SurfaceLine2Tests.cs)	(revision 6086)
@@ -43,102 +43,101 @@
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
         Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
         // Note: resetting GeometryMustContainPoint to false after filling the surface line will erase all Characteristic Points.
         // So the actual code should NEVER reset the GeometryMustContainPoint for filled surface lines. 
         surfaceLine.CharacteristicPoints.GeometryMustContainPoint = false;
         Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(0));
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
-        surfaceLine.Geometry.SyncPoints();
         Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(0));
-        Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
     }
 
     [Test]
     public void TestDeepCloneWithGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
         Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
         // Note: resetting GeometryMustContainPoint to true after filling the surface line reset the Characteristic Points to be
         // equal to the amount of geometry points, keeping only one type, possibly making the surface line invalid.
         // So the actual code should NEVER reset the GeometryMustContainPoint for filled surface lines.
         surfaceLine.CharacteristicPoints.GeometryMustContainPoint = true;
-        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
         Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(9));
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
-        surfaceLine.Geometry.SyncPoints();
+        
         Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(9));
-        Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
     }
 
     [Test]
     public void TestDeepCloneWithoutSettingGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
         Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
-        surfaceLine.Geometry.SyncPoints();
+        
         Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
         var tolerance = 1e-8;
         surfaceLine = FillSurfaceLine2();
-        Assert.That(newSurfaceLine.CharacteristicPoints[0].X, Is.EqualTo(surfaceLine.CharacteristicPoints[0].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[0].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[0].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[0].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[1].X, Is.EqualTo(surfaceLine.CharacteristicPoints[1].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[1].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[1].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[1].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[2].X, Is.EqualTo(surfaceLine.CharacteristicPoints[2].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[2].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[2].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[2].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[3].X, Is.EqualTo(surfaceLine.CharacteristicPoints[3].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[3].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[3].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[3].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[4].X, Is.EqualTo(surfaceLine.CharacteristicPoints[4].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[4].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[4].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[4].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[5].X, Is.EqualTo(surfaceLine.CharacteristicPoints[5].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[5].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[5].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[5].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[6].X, Is.EqualTo(surfaceLine.CharacteristicPoints[6].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[6].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[6].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[6].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[7].X, Is.EqualTo(surfaceLine.CharacteristicPoints[7].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[7].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[7].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[7].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[8].X, Is.EqualTo(surfaceLine.CharacteristicPoints[8].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[8].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[8].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[8].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[9].X, Is.EqualTo(surfaceLine.CharacteristicPoints[9].X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[9].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.Z).Within(tolerance));
         Assert.That(newSurfaceLine.CharacteristicPoints[9].CharacteristicPointType,
                     Is.EqualTo(surfaceLine.CharacteristicPoints[9].CharacteristicPointType));
     }
 
     private static void ValidateSurfaceLine(SurfaceLine2 surfaceLine)
     {
         var tolerance = 0.001;
-        Assert.That(surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(2));
+        Assert.That(surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.Point.X - 13.0) < tolerance && Math.Abs(cp.Point.Z - 5.4) < tolerance), Is.EqualTo(2));
         // Because TrafficLoadOutside and DikeTopAtPolder are on the same location, 1 point less should be in the geometry
-        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
-        Assert.That(surfaceLine.Geometry.Points.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(1));
+        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        Assert.That(surfaceLine.Geometry.CalcPoints.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(1));
     }
 
     private SurfaceLine2 FillSurfaceLine2()
@@ -155,16 +154,14 @@
         AddPointToSurfaceLine(surfaceLine, 14.0, 4.52, CharacteristicPointType.TrafficLoadInside);
         AddPointToSurfaceLine(surfaceLine, 18.0, 1.0, CharacteristicPointType.DikeToeAtPolder);
         AddPointToSurfaceLine(surfaceLine, 24.0, 1.0, CharacteristicPointType.SurfaceLevelInside);
-        surfaceLine.Geometry.SyncCalcPoints();
         return surfaceLine;
     }
 
     private void AddPointToSurfaceLine(SurfaceLine2 surfaceLine, double xCoordinate, double zCoordinate, CharacteristicPointType characteristicPointType)
     {
-        var geometryPoint = new GeometryPoint
+        var geometryPoint = new Point2D()
         {
             X = xCoordinate,
-            Y = 0.0,
             Z = zCoordinate
         };
         surfaceLine.AddCharacteristicPoint(geometryPoint, characteristicPointType);