Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs
===================================================================
diff -u -r3893 -r4000
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs	(.../SurfaceLine2.cs)	(revision 3893)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs	(.../SurfaceLine2.cs)	(revision 4000)
@@ -46,25 +46,14 @@
         {
             geometry = new GeometryPointString();
             characteristicPoints = new CharacteristicPointSet
-                {
-                    GeometryMustContainPoint = true
-                };
+            {
+                GeometryMustContainPoint = true
+            };
             LandwardDirection = LandwardDirection.PositiveX;
             Name = LocalizationManager.GetTranslatedText(this, "DefaultNameSurfaceLine2");
         }
 
         /// <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>
@@ -104,6 +93,17 @@
         public LandwardDirection LandwardDirection { get; set; }
 
         /// <summary>
+        /// Deep clone the object.
+        /// </summary>
+        /// <returns></returns>
+        public SurfaceLine2 FullDeepClone()
+        {
+            var surfaceLine2 = new SurfaceLine2();
+            surfaceLine2.SetValuesFromOtherSurfaceLine(this, true);
+            return surfaceLine2;
+        }
+
+        /// <summary>
         /// Define a new characteristic point on the surface line with the given characteristic 
         /// point annotation.
         /// </summary>
@@ -114,21 +114,20 @@
             if (annotations == null || annotations.Length == 0)
             {
                 CharacteristicPoints.Add(new CharacteristicPoint
-                    {
-                        GeometryPoint = geometryPoint,
-                        CharacteristicPointType = CharacteristicPointType.None
-                    });
+                {
+                    GeometryPoint = geometryPoint,
+                    CharacteristicPointType = CharacteristicPointType.None
+                });
             }
             else
             {
-                foreach (var type in annotations)
+                foreach (CharacteristicPointType type in annotations)
                 {
-
                     CharacteristicPoints.Add(new CharacteristicPoint
-                        {
-                            GeometryPoint = geometryPoint,
-                            CharacteristicPointType = type
-                        });
+                    {
+                        GeometryPoint = geometryPoint,
+                        CharacteristicPointType = type
+                    });
                 }
             }
         }
@@ -142,8 +141,8 @@
         /// <param name="annotations">The annotations for geometryPoint with x, z/>.</param>
         public void AddCharacteristicPoint(double x, double z, params CharacteristicPointType[] annotations)
         {
-            GeometryPoint geometryPoint = new GeometryPoint(x, z);
-            AddCharacteristicPoint(geometryPoint, annotations);            
+            var geometryPoint = new GeometryPoint(x, z);
+            AddCharacteristicPoint(geometryPoint, annotations);
         }
 
         /// <summary>
@@ -166,39 +165,6 @@
         }
 
         /// <summary>
-        /// Gets the points orderd by x.
-        /// </summary>
-        /// <value>
-        /// The points orderd by x.
-        /// </value>
-        private IEnumerable<GeometryPoint> PointsOrderedByX
-        {
-            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>
@@ -214,7 +180,7 @@
 
             return from point in PointsOrderedByX
                    where TestIncluding(point, startX, endX)
-                   orderby point.X ascending
+                   orderby point.X
                    select point;
         }
 
@@ -229,6 +195,15 @@
         }
 
         /// <summary>
+        /// Copy all characteristic point related data from another <see cref="SurfaceLine2"/>.
+        /// </summary>
+        /// <param name="source">Data source</param>
+        public void Assign(SurfaceLine2 source)
+        {
+            SetValuesFromOtherSurfaceLine(source);
+        }
+
+        /// <summary>
         /// Returns a <see cref="System.String" /> that represents this instance.
         /// </summary>
         /// <returns>
@@ -249,19 +224,44 @@
             {
                 return CharacteristicPoints.Geometry.GetGeometryBounds();
             }
+
             return null;
         }
 
         /// <summary>
-        /// Copy all characteristic point related data from another <see cref="SurfaceLine2"/>.
+        /// Gets the points orderd by x.
         /// </summary>
-        /// <param name="source">Data source</param>
-        public void Assign(SurfaceLine2 source)
+        /// <value>
+        /// The points orderd by x.
+        /// </value>
+        private IEnumerable<GeometryPoint> PointsOrderedByX
         {
-            SetValuesFromOtherSurfaceLine(source);
+            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>
         /// Sets the values from another surface line.
         /// </summary>
         /// <param name="source">The source.</param>
@@ -278,17 +278,17 @@
             CharacteristicPoints.GeometryMustContainPoint = source.CharacteristicPoints.GeometryMustContainPoint;
             Geometry = cloneGeometry ? source.Geometry.Clone() : source.Geometry;
 
-            var geometryAnnotations = GetCharacteristicAnnotationsInSource(source, cloneGeometry);
+            Dictionary<GeometryPoint, CharacteristicPointType[]> geometryAnnotations = GetCharacteristicAnnotationsInSource(source, cloneGeometry);
 
             // Reconstruct annotation state from dictionary:
             if (CharacteristicPoints.GeometryMustContainPoint)
             {
-                foreach (var annotation in geometryAnnotations)
+                foreach (KeyValuePair<GeometryPoint, CharacteristicPointType[]> annotation in geometryAnnotations)
                 {
-                    for (int i = 0; i < annotation.Value.Length; i++)
+                    for (var i = 0; i < annotation.Value.Length; i++)
                     {
-                        var index = -1;
-                        for (int j = 0; j < CharacteristicPoints.Count; j++)
+                        int index = -1;
+                        for (var j = 0; j < CharacteristicPoints.Count; j++)
                         {
                             if (ReferenceEquals(CharacteristicPoints[j].GeometryPoint, annotation.Key))
                             {
@@ -315,9 +315,9 @@
             }
             else
             {
-                foreach (var annotation in geometryAnnotations)
+                foreach (KeyValuePair<GeometryPoint, CharacteristicPointType[]> annotation in geometryAnnotations)
                 {
-                    AddCharacteristicPoint((GeometryPoint)annotation.Key.Clone(), annotation.Value);
+                    AddCharacteristicPoint((GeometryPoint) annotation.Key.Clone(), annotation.Value);
                 }
             }
         }
@@ -353,14 +353,15 @@
         private Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustContainPoints(SurfaceLine2 source, bool cloneGeometry)
         {
             var geometryAnnotations = new Dictionary<GeometryPoint, CharacteristicPointType[]>();
-            for (int i = 0; i < source.Geometry.Count; i++)
+            for (var i = 0; i < source.Geometry.Count; i++)
             {
-                var annotationsForPoint = source.GetCharacteristicPoints(source.Geometry.Points[i]).Where(cpt => cpt != CharacteristicPointType.None).ToArray();
+                CharacteristicPointType[] annotationsForPoint = source.GetCharacteristicPoints(source.Geometry.Points[i]).Where(cpt => cpt != CharacteristicPointType.None).ToArray();
                 if (annotationsForPoint.Length > 0)
                 {
                     geometryAnnotations[Geometry.Points[i]] = annotationsForPoint;
                 }
             }
+
             return geometryAnnotations;
         }
 
@@ -374,16 +375,16 @@
         private static Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustNotContainPoints(SurfaceLine2 source)
         {
             var geometryAnnotations = new Dictionary<GeometryPoint, CharacteristicPointType[]>();
-            foreach (var characteristicPoint in source.CharacteristicPoints)
+            foreach (CharacteristicPoint characteristicPoint in source.CharacteristicPoints)
             {
                 if (!geometryAnnotations.ContainsKey(characteristicPoint.GeometryPoint))
                 {
                     geometryAnnotations[characteristicPoint.GeometryPoint] =
                         source.GetCharacteristicPoints(characteristicPoint.GeometryPoint).ToArray();
                 }
             }
+
             return geometryAnnotations;
         }
-
     }
 }
\ No newline at end of file