Index: DamEngine/trunk/src/Deltares.DamEngine.Data/General/Gauges/GaugePLLine.cs
===================================================================
diff -u -r1117 -r1118
--- DamEngine/trunk/src/Deltares.DamEngine.Data/General/Gauges/GaugePLLine.cs	(.../GaugePLLine.cs)	(revision 1117)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/General/Gauges/GaugePLLine.cs	(.../GaugePLLine.cs)	(revision 1118)
@@ -57,14 +57,14 @@
         public GaugePlLine(PlLineType plLineType)
             : this()
         {
-            this.PLLineType = plLineType;
+            this.PlLineType = plLineType;
         }
 
-        public PlLineType PLLineType { get; set; }
+        public PlLineType PlLineType { get; set; }
 
         public override string ToString()
         {
-            string result = String.Format("{0} | ", this.PLLineType.ToString());
+            string result = String.Format("{0} | ", this.PlLineType.ToString());
             foreach (GaugePlLinePoint point in this.Points)
                 result += point.ToString() + ", ";
 
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftCalculator.cs
===================================================================
diff -u -r877 -r1118
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftCalculator.cs	(.../UpliftCalculator.cs)	(revision 877)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftCalculator.cs	(.../UpliftCalculator.cs)	(revision 1118)
@@ -130,7 +130,7 @@
         /// </summary>
         /// <param name="upliftFactor"></param>
         /// <returns></returns>
-        public double CalculateHeadOfPLLine(double upliftFactor)
+        public double CalculateHeadOfPlLine(double upliftFactor)
         {
             ThrowWhenSoilProfileIsNull();
 
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PlLinesCreator.cs
===================================================================
diff -u -r1117 -r1118
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PlLinesCreator.cs	(.../PlLinesCreator.cs)	(revision 1117)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PlLinesCreator.cs	(.../PlLinesCreator.cs)	(revision 1118)
@@ -248,23 +248,23 @@
                                        ((SoilProfileType == SoilProfileType.ProfileType2D) && (SoilProfile2D == null || DikeEmbankmentMaterial == null));
             if (hasNoGeometry1DData && hasNoGeometry2DData)
             {
-                throw new PlLinesCreatorException("PLLinesCreator contains not enough soil geometry information (SoilProfile1D, FullStiFileName, dikeEmbankmentMaterial or soilBase)");
+                throw new PlLinesCreatorException("PlLinesCreator contains not enough soil geometry information (SoilProfile1D, FullStiFileName, dikeEmbankmentMaterial or soilBase)");
             }
         }
 
         /// <summary>
         /// Create PL2 (is pl line for penetration)
         /// </summary>
         /// <returns></returns>
-        private PlLine CreatePLLine2ByExpertKnowledge(double penetrationLength, double? headInPLLine2)
+        private PlLine CreatePlLine2ByExpertKnowledge(double penetrationLength, double? headInPlLine2)
         {
             PlLine plLine = null;
 
             if (penetrationLength < 0.0)
             {
                 throw new PlLinesCreatorException("Negative penetration length.");
             }
-            if ((penetrationLength.AlmostEquals(0.0)) || (headInPLLine2 == null))
+            if ((penetrationLength.AlmostEquals(0.0)) || (headInPlLine2 == null))
             {
                 // No penetration, or no Head Pl2 defined, so empty pl-line will be returned
                 plLine = new PlLine();
@@ -278,11 +278,11 @@
                 switch (SoilProfileType)
                 {
                     case SoilProfileType.ProfileType1D:
-                        plLine = CreatePlLine2ByExpertKnowledgeFor1DGeometry(penetrationLength, headInPLLine2);
+                        plLine = CreatePlLine2ByExpertKnowledgeFor1DGeometry(penetrationLength, headInPlLine2);
                         break;
                     case SoilProfileType.ProfileType2D:
                     case SoilProfileType.ProfileTypeStiFile:
-                        plLine = CreatePlLine2ByExpertKnowledgeFor2DGeometry(penetrationLength, headInPLLine2);
+                        plLine = CreatePlLine2ByExpertKnowledgeFor2DGeometry(penetrationLength, headInPlLine2);
                         break;
                 }
             }
@@ -294,30 +294,30 @@
         /// Create PL2 (is pl line for penetration) for 2d-geometry
         /// </summary>
         /// <param name="penetrationLength">Length of the penetration.</param>
-        /// <param name="headInPLLine2">The head in pl line2.</param>
+        /// <param name="headInPlLine2">The head in pl line2.</param>
         /// <returns></returns>
         /// <exception cref="PlLinesCreatorException">Head PL2 not defined</exception>
-        private PlLine CreatePlLine2ByExpertKnowledgeFor2DGeometry(double penetrationLength, double? headInPLLine2)
+        private PlLine CreatePlLine2ByExpertKnowledgeFor2DGeometry(double penetrationLength, double? headInPlLine2)
         {
-            if (headInPLLine2 == null)
+            if (headInPlLine2 == null)
             {
                 throw new PlLinesCreatorException("Head PL2 not defined");
             }
             PlLine plLine = new PlLine();
-            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.First().X, headInPLLine2.Value));
-            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.Last().X, headInPLLine2.Value));
+            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.First().X, headInPlLine2.Value));
+            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.Last().X, headInPlLine2.Value));
             return plLine;
         }
 
         /// <summary>
         /// Create PL2 (is pl line for penetration) for 1d-geometry
         /// </summary>
         /// <param name="penetrationLength"></param>
-        /// <param name="headInPLLine2"></param>
+        /// <param name="headInPlLine2"></param>
         /// <returns></returns>
-        private PlLine CreatePlLine2ByExpertKnowledgeFor1DGeometry(double penetrationLength, double? headInPLLine2)
+        private PlLine CreatePlLine2ByExpertKnowledgeFor1DGeometry(double penetrationLength, double? headInPlLine2)
         {
-            if (headInPLLine2 == null)
+            if (headInPlLine2 == null)
             {
                 throw new PlLinesCreatorException("Head PL2 not defined");
             }
@@ -343,8 +343,8 @@
 
                         if (separationLevel <= infiltrationLayers.First().TopLevel)
                         {
-                            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.First().X, headInPLLine2.Value));
-                            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.Last().X, headInPLLine2.Value));
+                            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.First().X, headInPlLine2.Value));
+                            plLine.Points.Add(new PlLinePoint(this.surfaceLine.Geometry.Points.Last().X, headInPlLine2.Value));
 
                             SoilLayer1D separationLayer = (from SoilLayer1D layer in infiltrationLayers
                                                            where layer.TopLevel >= separationLevel
@@ -386,29 +386,29 @@
         {
             if (this.surfaceLine == null)
             {
-                throw new PlLinesCreatorException("PLLinesCreator contains no surface line.");
+                throw new PlLinesCreatorException("PlLinesCreator contains no surface line.");
             }
         }
 
         /// <summary>
         /// Create PL3 (is phreatic level)
         /// </summary>
         /// <returns></returns>
-        private PlLine CreatePLLine3ByExpertKnowledge(double headValue, double dampingFactor, double slopeGradient)
+        private PlLine CreatePlLine3ByExpertKnowledge(double headValue, double dampingFactor, double slopeGradient)
         {
-            return CreatePLLine3Or4ByExpertKnowledge(headValue, dampingFactor, PlLineType.PL3, slopeGradient);
+            return CreatePlLine3Or4ByExpertKnowledge(headValue, dampingFactor, PlLineType.PL3, slopeGradient);
         }
 
         /// <summary>
         /// Create PL4 (is phreatic level)
         /// </summary>
         /// <returns></returns>
-        private PlLine CreatePLLine4ByExpertKnowledge(double headValue, double dampingFactor, double slopeGradient)
+        private PlLine CreatePlLine4ByExpertKnowledge(double headValue, double dampingFactor, double slopeGradient)
         {
-            return CreatePLLine3Or4ByExpertKnowledge(headValue, dampingFactor, PlLineType.PL4, slopeGradient);
+            return CreatePlLine3Or4ByExpertKnowledge(headValue, dampingFactor, PlLineType.PL4, slopeGradient);
         }
 
-        private PlLine CreatePLLine3Or4ByExpertKnowledge(double headValue, double dampingFactor, PlLineType plLineType, double slopeGradient)
+        private PlLine CreatePlLine3Or4ByExpertKnowledge(double headValue, double dampingFactor, PlLineType plLineType, double slopeGradient)
         {
             // Offset to solve issue MWDAM-557
             const double offset = 0.01;
@@ -461,7 +461,7 @@
 
         /// <summary>
         ///  Continue PLline to the end with a slope of slopegradient
-        ///  If PLLine is lower then polderlevel, continue with polderlevel
+        ///  If PlLine is lower then polderlevel, continue with polderlevel
         /// </summary>
         /// <param name="slopeGradient">The slope gradient.</param>
         /// <param name="plLine">The pl line.</param>
@@ -624,7 +624,7 @@
         /// <param name="plLine">The pl line.</param>
         /// <param name="x">The x coordinate.</param>
         /// <returns></returns>
-        private int FindIndexOfPointInPLLineWithXCoordinate(PlLine plLine, double x)
+        private int FindIndexOfPointInPlLineWithXCoordinate(PlLine plLine, double x)
         {
             for (int pointIndex = plLine.Points.Count - 1; pointIndex > 0; pointIndex--)
             {
@@ -728,10 +728,10 @@
             };
             GeometryPoint startSurfacePoint = this.surfaceLine.GetDikeToeInward();
 
-            int indexOfFixedPlPoint = FindIndexOfPointInPLLineWithXCoordinate(plLine, this.surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).X);
+            int indexOfFixedPlPoint = FindIndexOfPointInPlLineWithXCoordinate(plLine, this.surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).X);
             if (indexOfFixedPlPoint < 0)
             {
-                throw new PlLinesCreatorException("Could not find fixed point for PLLine");
+                throw new PlLinesCreatorException("Could not find fixed point for PlLine");
             }
 
             // Adjust PL3/4 for all surface points from toe of dike to end of profile to, so no uplift will occur in that surface point
@@ -765,21 +765,21 @@
                     double upliftFactor = upliftCalculator.CalculateUpliftFactor(headOfPlLine);
                     if (upliftFactor <= cUpliftFactorEquilibrium)
                     {
-                        // Adjust headOfPLLine so there is equilibrium
+                        // Adjust headOfPlLine so there is equilibrium
                         bool hasNoCoverLayer = surfacePoint.Z <= aquiferTopLayer;
                         if (hasNoCoverLayer)
                         {
                             headOfPlLine = this.waterLevelPolder;
                         }
                         else
                         {
-                            headOfPlLine = Math.Max(upliftCalculator.CalculateHeadOfPLLine(cUpliftFactorEquilibrium),
+                            headOfPlLine = Math.Max(upliftCalculator.CalculateHeadOfPlLine(cUpliftFactorEquilibrium),
                                 this.waterLevelPolder);
                         }
                         if (headOfPlLine < lastAdjustedHeadOfPlLine)
                         {
                             var plPoint = new PlLinePoint(surfacePoint.X, headOfPlLine);
-                            // Remove all points of PLLine after fixed point
+                            // Remove all points of PlLine after fixed point
                             RemoveAllPointsOfPlLineAfterIndex(plLine, indexOfFixedPlPoint);
                             plLine.Points.Add(plPoint);
                             if (!isRemoveAllPlPointsBackToDikeToeAtRiver)
@@ -818,8 +818,8 @@
                         double upliftFactor = upliftCalculator.CalculateUpliftFactor(headOfPlLine);
                         if (upliftFactor <= cUpliftFactorEquilibrium)
                         {
-                            // Adjust headOfPLLine so there is equilibrium
-                            headOfPlLine = Math.Max(upliftCalculator.CalculateHeadOfPLLine(cUpliftFactorEquilibrium), this.waterLevelPolder);
+                            // Adjust headOfPlLine so there is equilibrium
+                            headOfPlLine = Math.Max(upliftCalculator.CalculateHeadOfPlLine(cUpliftFactorEquilibrium), this.waterLevelPolder);
                             double currentHead = plLine.ZFromX(surfacePoint.X);
                             if (headOfPlLine < currentHead)
                             {
@@ -921,7 +921,7 @@
         /// </summary>
         /// <param name="plLine"></param>
         /// <param name="genericLine"></param>
-        void CopyPointsInPLLine(ref PlLine plLine, GeometryPointString genericLine)
+        void CopyPointsInPlLine(ref PlLine plLine, GeometryPointString genericLine)
         {
             plLine.Points.Clear();
             foreach (GeometryPoint point in genericLine.Points)
@@ -935,7 +935,7 @@
         /// </summary>
         /// <param name="location"></param>
         /// <returns></returns>
-        private PlLines CreateAllPLLinesWithExpertKnowledge(Location location)
+        private PlLines CreateAllPlLinesWithExpertKnowledge(Location location)
         {
             PlLines plLines = new PlLines();
             foreach (PlLineType plLineType in Enum.GetValues(typeof(PlLineType)))
@@ -944,7 +944,7 @@
                 if ((plLineType == PlLineType.PL1) && isPL1LineDefinedForLocation)
                 {
                     PlLine plLine = plLines.Lines[plLineType];
-                    CopyPointsInPLLine(ref plLine, location.LocalXZPL1Line);
+                    CopyPointsInPlLine(ref plLine, location.LocalXZPL1Line);
                 }
                 else
                 {
@@ -1320,17 +1320,17 @@
         /// </summary>
         /// <param name="location"></param>
         /// <returns></returns>
-        private PlLines CreateAllPLLinesWithGaugesWithFallbackToExpertKnowledgeRRD(Location location)
+        private PlLines CreateAllPlLinesWithGaugesWithFallbackToExpertKnowledgeRrd(Location location)
         {
             var plLines = new PlLines();
 
             foreach (PlLineType plLineType in Enum.GetValues(typeof(PlLineType)))
             {
-                GaugePlLine gaugePLLine = (this.GaugePlLines != null) ? (this.GaugePlLines.FirstOrDefault(x => x.PLLineType == plLineType)) : null;
-                if (gaugePLLine != null && location != null)
+                GaugePlLine gaugePlLine = (this.GaugePlLines != null) ? (this.GaugePlLines.FirstOrDefault(x => x.PlLineType == plLineType)) : null;
+                if (gaugePlLine != null && location != null)
                 {
                     Boolean isUseWaterLevel = ((plLineType == PlLineType.PL1) || (plLineType == PlLineType.PL2));
-                    plLines.Lines[plLineType] = CreatePLLineFromGauges(gaugePLLine, this.Gauges, location, isUseWaterLevel);
+                    plLines.Lines[plLineType] = CreatePlLineFromGauges(gaugePlLine, this.Gauges, location, isUseWaterLevel);
                 }
                 else
                     plLines.Lines[plLineType] = CreatePlLineByExpertKnowledge(plLineType, location.DamType, location.SlopeDampingPiezometricHeightPolderSide);
@@ -1345,7 +1345,7 @@
         }
 
         /// <summary>
-        /// Create all PLLines
+        /// Create all PlLines
         /// </summary>
         /// <returns></returns>
         public PlLines CreateAllPlLines(Location location)
@@ -1355,9 +1355,9 @@
             switch (modelParametersForPlLines.PlLineCreationMethod)
             {
                 case PlLineCreationMethod.ExpertKnowledgeLinearInDike:
-                case PlLineCreationMethod.ExpertKnowledgeRRD: plLines = CreateAllPLLinesWithExpertKnowledge(location);
+                case PlLineCreationMethod.ExpertKnowledgeRRD: plLines = CreateAllPlLinesWithExpertKnowledge(location);
                     break;
-                case PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD: plLines = CreateAllPLLinesWithGaugesWithFallbackToExpertKnowledgeRRD(location);
+                case PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD: plLines = CreateAllPlLinesWithGaugesWithFallbackToExpertKnowledgeRrd(location);
                     break;
             }
 
@@ -1370,7 +1370,7 @@
 
             if (!plLines.Lines[PlLineType.PL1].IsXAscending())
             {
-                throw new PlLinesCreatorException("PLLine 1 not an X-ascending polyline");
+                throw new PlLinesCreatorException("PlLine 1 not an X-ascending polyline");
             }
 
             return plLines;
@@ -1388,16 +1388,16 @@
             switch (plLineType)
             {
                 case PlLineType.PL1:
-                    plLine = this.CreatePLLine1ByExpertKnowledge();
+                    plLine = this.CreatePlLine1ByExpertKnowledge();
                     break;
                 case PlLineType.PL2:
-                    plLine = this.CreatePLLine2ByExpertKnowledge(this.ModelParametersForPlLines.PenetrationLength, this.HeadInPlLine2);
+                    plLine = this.CreatePlLine2ByExpertKnowledge(this.ModelParametersForPlLines.PenetrationLength, this.HeadInPlLine2);
                     break;
                 case PlLineType.PL3:
-                    plLine = this.CreatePLLine3ByExpertKnowledge(HeadPL3TakingInAccountHydraulicShortcut, this.ModelParametersForPlLines.DampingFactorPL3, slopeGradient);
+                    plLine = this.CreatePlLine3ByExpertKnowledge(HeadPL3TakingInAccountHydraulicShortcut, this.ModelParametersForPlLines.DampingFactorPL3, slopeGradient);
                     break;
                 case PlLineType.PL4:
-                    plLine = this.CreatePLLine4ByExpertKnowledge(GetHeadPL4TakingInAccountHydraulicShortcut(damType), this.ModelParametersForPlLines.DampingFactorPL4, slopeGradient);
+                    plLine = this.CreatePlLine4ByExpertKnowledge(GetHeadPL4TakingInAccountHydraulicShortcut(damType), this.ModelParametersForPlLines.DampingFactorPL4, slopeGradient);
                     break;
             }
 
@@ -1419,59 +1419,59 @@
         /// <summary>
         /// 
         /// </summary>
-        /// <param name="gaugePLLine"></param>
+        /// <param name="gaugePlLine"></param>
         /// <param name="gauges"></param>
         /// <param name="location"></param>
         /// <returns></returns>
-        private PlLine CreatePLLineFromGauges(GaugePlLine gaugePLLine, IEnumerable<Gauge> gauges, Location location, Boolean useWaterLevel)
+        private PlLine CreatePlLineFromGauges(GaugePlLine gaugePlLine, IEnumerable<Gauge> gauges, Location location, Boolean useWaterLevel)
         {
             PlLine plLine = new PlLine();
 
             double? gaugeWaterLevelRiver = null;
             double? leftMostXAtRiverLevel = null;
 
             int pointIndex = 0;
-            foreach (GaugePlLinePoint gaugePLLinePoint in gaugePLLine.Points)
+            foreach (GaugePlLinePoint gaugePlLinePoint in gaugePlLine.Points)
             {
 
-                double? localX = gaugePLLinePoint.X;
-                double? localZ = gaugePLLinePoint.Z;
+                double? localX = gaugePlLinePoint.X;
+                double? localZ = gaugePlLinePoint.Z;
 
                 if (gauges != null)
                 {
-                    if (gaugePLLinePoint.GaugeIDX != null && gaugePLLinePoint.GaugeIDX != "")
+                    if (gaugePlLinePoint.GaugeIDX != null && gaugePlLinePoint.GaugeIDX != "")
                     {
-                        Gauge gauge = (gauges.Where(x => x.Name == gaugePLLinePoint.GaugeIDX && x.Location == location)).FirstOrDefault();
+                        Gauge gauge = (gauges.Where(x => x.Name == gaugePlLinePoint.GaugeIDX && x.Location == location)).FirstOrDefault();
                         if (gauge != null)
                             localX = gauge.LocalX;
                         else
                         {
                             throw new PlLinesCreatorException(String.Format("Gauge PL line {0} refers to an unknown gauge named '{1}' at X coordinate #{2}.",
-                                                                            gaugePLLine.PLLineType.ToString(), gaugePLLinePoint.GaugeIDX, pointIndex));
+                                                                            gaugePlLine.PlLineType.ToString(), gaugePlLinePoint.GaugeIDX, pointIndex));
                         }
                     }
-                    if (gaugePLLinePoint.GaugeIDZ != null && gaugePLLinePoint.GaugeIDZ != "")
+                    if (gaugePlLinePoint.GaugeIDZ != null && gaugePlLinePoint.GaugeIDZ != "")
                     {
-                        Gauge gauge = (gauges.Where(x => x.Name == gaugePLLinePoint.GaugeIDZ && x.Location == location)).FirstOrDefault();
+                        Gauge gauge = (gauges.Where(x => x.Name == gaugePlLinePoint.GaugeIDZ && x.Location == location)).FirstOrDefault();
                         if (gauge != null)
                         {
                             if ((!gauge.Value.HasValue) || (gauge.Value == GaugeMissVal))
                                 throw new PlLinesCreatorException(String.Format("Value of gauge {0} at location {1} in gauge PL line of type {2} is undefined.",
-                                                                                gauge.Name, location.Name, gaugePLLine.PLLineType.ToString()));
+                                                                                gauge.Name, location.Name, gaugePlLine.PlLineType.ToString()));
                             localZ = gauge.Value;
                         }
                         else
                         {
                             throw new PlLinesCreatorException(String.Format("Gauge PL line {0} refers to an unknown gauge named '{1}' at Z coordinate #{2}.",
-                                                                            gaugePLLine.PLLineType.ToString(), gaugePLLinePoint.GaugeIDZ, pointIndex));
+                                                                            gaugePlLine.PlLineType.ToString(), gaugePlLinePoint.GaugeIDZ, pointIndex));
                         }
                     }
                 }
 
                 if (!localX.HasValue)
-                    throw new PlLinesCreatorException(String.Format("Gauge PL line {0}'s X coordinate #{1} is undefined.", gaugePLLine.PLLineType.ToString(), pointIndex));
+                    throw new PlLinesCreatorException(String.Format("Gauge PL line {0}'s X coordinate #{1} is undefined.", gaugePlLine.PlLineType.ToString(), pointIndex));
                 else if (!localZ.HasValue)
-                    throw new PlLinesCreatorException(String.Format("Gauge PL line {0}'s value #{1} is undefined.", gaugePLLine.PLLineType.ToString(), pointIndex));
+                    throw new PlLinesCreatorException(String.Format("Gauge PL line {0}'s value #{1} is undefined.", gaugePlLine.PlLineType.ToString(), pointIndex));
                 else
                 {
                     if (!leftMostXAtRiverLevel.HasValue || localX > leftMostXAtRiverLevel)
@@ -1553,7 +1553,7 @@
             switch (modelParametersForPlLines.PlLineCreationMethod)
             {
                 case PlLineCreationMethod.ExpertKnowledgeLinearInDike:
-                    const double cPLLineOffsetBelowSurface = 0.1;
+                    const double cPlLineOffsetBelowSurface = 0.1;
                     PlLinePoint intersectionHighWaterLevelWithDike = DetermineIntersectionBetweenWaterLevelAndDike(highWaterLevel);
                     if (intersectionLowWaterLevelWithDike == null)
                     {
@@ -1563,14 +1563,14 @@
                     // At this point both intersectionHighWaterLevelWithDike and intersectionLowWaterLevelWithDike are <> null
                     // or else an exception would have been thrown
                     PlLinePoint pointBelowHighLevel = new PlLinePoint(intersectionHighWaterLevelWithDike.X,
-                        intersectionHighWaterLevelWithDike.Z - cPLLineOffsetBelowSurface);
+                        intersectionHighWaterLevelWithDike.Z - cPlLineOffsetBelowSurface);
 
                     //Add points below surface of dike talud riverside
                     foreach (GeometryPoint point in SurfaceLine.Geometry.Points.Where(
                         point => point.X > intersectionLowWaterLevelWithDike.X &&
                         point.X < intersectionHighWaterLevelWithDike.X))
                     {
-                        phreaticLine.Points.Add(new PlLinePoint(point.X, point.Z - cPLLineOffsetBelowSurface));
+                        phreaticLine.Points.Add(new PlLinePoint(point.X, point.Z - cPlLineOffsetBelowSurface));
                     }
 
                     // Add last point (below high riverlevel/dike section
@@ -1585,7 +1585,7 @@
                     {
                         //if (!surfaceLine.IsNonWaterRetainingObjectPoint(point))
                         //{
-                            phreaticLine.Points.Add(new PlLinePoint(point.X, point.Z - cPLLineOffsetBelowSurface));
+                            phreaticLine.Points.Add(new PlLinePoint(point.X, point.Z - cPlLineOffsetBelowSurface));
                         //}
                     }
 
@@ -1971,12 +1971,12 @@
                                 // by the fact that the waterlevel is higher than DikeToeAtPolder
                                 if (intersectPoint.Z > waterLevelPolder + cOffsetPhreaticLineBelowSurface)
                                 {
-                                    var newPLLinePoint = new PlLinePoint(intersectPoint.X,
+                                    var newPlLinePoint = new PlLinePoint(intersectPoint.X,
                                         intersectPoint.Z - cOffsetPhreaticLineBelowSurface);
                                     // Only add new point if it is more to the right than the first point of the phreatic line segment when
-                                    if (newPLLinePoint.X > phreaticLineSegment.BeginPoint.X)
+                                    if (newPlLinePoint.X > phreaticLineSegment.BeginPoint.X)
                                     {
-                                        phreaticLine.Points.Insert(phreaticPointIndex + 1, newPLLinePoint);
+                                        phreaticLine.Points.Insert(phreaticPointIndex + 1, newPlLinePoint);
                                         if (SurfaceLine.Geometry.Points[surfacePointIndex + 1].X.IsNearEqual(intersectPoint.X))
                                         {
                                             // phreatic point and surfaceline point are postioned above each other, so replace the phreatic point with the intersect point
@@ -1987,21 +1987,21 @@
                                         }
                                         else
                                         {
-                                            var newNextPLLinePoint =
+                                            var newNextPlLinePoint =
                                                 new PlLinePoint(SurfaceLine.Geometry.Points[surfacePointIndex + 1].X,
                                                     SurfaceLine.Geometry.Points[surfacePointIndex + 1].Z -
                                                     cOffsetPhreaticLineBelowSurface);
-                                            if (newNextPLLinePoint.X <= phreaticLine.Points[phreaticPointIndex + 2].X)
+                                            if (newNextPlLinePoint.X <= phreaticLine.Points[phreaticPointIndex + 2].X)
                                             {
-                                                if (newNextPLLinePoint.X.IsNearEqual(phreaticLine.Points[phreaticPointIndex + 2].X))
+                                                if (newNextPlLinePoint.X.IsNearEqual(phreaticLine.Points[phreaticPointIndex + 2].X))
                                                 {
                                                     // If phreatic point already exist on this x-coordinate just replace it with the new point
-                                                    phreaticLine.Points[phreaticPointIndex + 2] = newNextPLLinePoint;
+                                                    phreaticLine.Points[phreaticPointIndex + 2] = newNextPlLinePoint;
                                                 }
                                                 else
                                                 {
                                                     phreaticLine.Points.Insert(phreaticPointIndex + 2,
-                                                        newNextPLLinePoint);
+                                                        newNextPlLinePoint);
                                                 }
                                             }
                                         }
@@ -2016,7 +2016,7 @@
                 if (foundIntersect == false)
                     StopIteration = true;
                 if (iterationCount > cMaxIterations)
-                    throw new PlLinesCreatorException("PLLinesCreator.ValidatePhreaticBelowDike() cannot succeed");
+                    throw new PlLinesCreatorException("PlLinesCreator.ValidatePhreaticBelowDike() cannot succeed");
             }
         }
 
@@ -2025,7 +2025,7 @@
         /// </summary>
         /// <returns></returns>
         /// 
-        private PlLine CreatePLLine1ByExpertKnowledge()
+        private PlLine CreatePlLine1ByExpertKnowledge()
         {
             ValidateSurfaceLine();