Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SoilProfile2DTests.cs =================================================================== diff -u -r6108 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SoilProfile2DTests.cs (.../SoilProfile2DTests.cs) (revision 6108) +++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SoilProfile2DTests.cs (.../SoilProfile2DTests.cs) (revision 6245) @@ -86,22 +86,22 @@ Assert.That(soilProfile2D.Geometry.Points.First().X, Is.EqualTo(-7.77)); Assert.That(soilProfile2D.Geometry.Curves[0].HeadPoint.X, Is.EqualTo(-7.77)); Assert.That(soilProfile2D.Geometry.Curves[5].EndPoint.X, Is.EqualTo(-7.77)); - Assert.That(soilProfile2D.Geometry.Loops[0].CalcPoints[0].X, Is.EqualTo(-7.77)); - Assert.That(soilProfile2D.Geometry.Surfaces[0].OuterLoop.CalcPoints[0].X, Is.EqualTo(-7.77)); + Assert.That(soilProfile2D.Geometry.Loops[0].Points[0].X, Is.EqualTo(-7.77)); + Assert.That(soilProfile2D.Geometry.Surfaces[0].OuterLoop.Points[0].X, Is.EqualTo(-7.77)); Assert.That(soilProfile2D.Geometry.Surfaces[0].OuterLoop.CurveList[0].HeadPoint.X, Is.EqualTo(-7.77)); - Assert.That(soilProfile2D.Geometry.Curves[0].SurfaceAtRight.OuterLoop.CalcPoints[0].X, Is.EqualTo(-7.77)); - Assert.That(soilProfile2D.Surfaces[0].GeometrySurface.OuterLoop.CalcPoints[0].X, Is.EqualTo(-7.77)); + Assert.That(soilProfile2D.Geometry.Curves[0].SurfaceAtRight.OuterLoop.Points[0].X, Is.EqualTo(-7.77)); + Assert.That(soilProfile2D.Surfaces[0].GeometrySurface.OuterLoop.Points[0].X, Is.EqualTo(-7.77)); Assert.That(soilProfile2D.Surfaces[0].GeometrySurface.OuterLoop.CurveList[0].HeadPoint.X, Is.EqualTo(-7.77)); Assert.That(cloneSoilProfile2D.Geometry.Points.First().X, Is.EqualTo(-99.99)); Assert.That(cloneSoilProfile2D.Geometry.Curves[0].HeadPoint.X, Is.EqualTo(-99.99)); Assert.That(cloneSoilProfile2D.Geometry.Curves[5].EndPoint.X, Is.EqualTo(-99.99)); - Assert.That(cloneSoilProfile2D.Geometry.Loops[0].CalcPoints[0].X, Is.EqualTo(-99.99)); + Assert.That(cloneSoilProfile2D.Geometry.Loops[0].Points[0].X, Is.EqualTo(-99.99)); Assert.That(cloneSoilProfile2D.Geometry.Loops[0].CurveList[0].HeadPoint.X, Is.EqualTo(-99.99)); - Assert.That(cloneSoilProfile2D.Geometry.Surfaces[0].OuterLoop.CalcPoints[0].X, Is.EqualTo(-99.99)); + Assert.That(cloneSoilProfile2D.Geometry.Surfaces[0].OuterLoop.Points[0].X, Is.EqualTo(-99.99)); Assert.That(cloneSoilProfile2D.Geometry.Curves[0].SurfaceAtRight, Is.EqualTo(null)); Assert.That(cloneSoilProfile2D.Geometry.Curves[0].SurfaceAtLeft, Is.EqualTo(null)); - Assert.That(cloneSoilProfile2D.Surfaces[0].GeometrySurface.OuterLoop.CalcPoints[0].X, Is.EqualTo(-99.99)); + Assert.That(cloneSoilProfile2D.Surfaces[0].GeometrySurface.OuterLoop.Points[0].X, Is.EqualTo(-99.99)); Assert.That(cloneSoilProfile2D.Surfaces[0].GeometrySurface.OuterLoop.CurveList[0].HeadPoint.X, Is.EqualTo(-99.99)); }); } Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs =================================================================== diff -u -r6106 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs (.../SurfaceLine2Tests.cs) (revision 6106) +++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs (.../SurfaceLine2Tests.cs) (revision 6245) @@ -45,19 +45,19 @@ Assert.Multiple(() => { Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); - Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(surfaceLine.Geometry.Points, Has.Count.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, Is.Empty); SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone(); surfaceLine.CharacteristicPoints.Clear(); - surfaceLine.Geometry.CalcPoints.Clear(); + surfaceLine.Geometry.Points.Clear(); Assert.Multiple(() => { Assert.That(newSurfaceLine.CharacteristicPoints, Is.Empty); - Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(newSurfaceLine.Geometry.Points, Has.Count.EqualTo(9)); }); } @@ -68,24 +68,24 @@ Assert.Multiple(() => { Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); - Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(surfaceLine.Geometry.Points, Has.Count.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.Multiple(() => { - Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(surfaceLine.Geometry.Points, Has.Count.EqualTo(9)); Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(9)); }); SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone(); surfaceLine.CharacteristicPoints.Clear(); - surfaceLine.Geometry.CalcPoints.Clear(); + surfaceLine.Geometry.Points.Clear(); Assert.Multiple(() => { Assert.That(newSurfaceLine.CharacteristicPoints, Has.Count.EqualTo(9)); - Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(newSurfaceLine.Geometry.Points, Has.Count.EqualTo(9)); }); } @@ -96,15 +96,15 @@ Assert.Multiple(() => { Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); - Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(surfaceLine.Geometry.Points, Has.Count.EqualTo(9)); }); SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone(); surfaceLine.CharacteristicPoints.Clear(); - surfaceLine.Geometry.CalcPoints.Clear(); + surfaceLine.Geometry.Points.Clear(); Assert.Multiple(() => { Assert.That(newSurfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); - Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(newSurfaceLine.Geometry.Points, Has.Count.EqualTo(9)); }); var tolerance = 1e-8; surfaceLine = FillSurfaceLine2(); @@ -160,9 +160,9 @@ { 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.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(surfaceLine.Geometry.Points, Has.Count.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)); + Assert.That(surfaceLine.Geometry.Points.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(1)); } private SurfaceLine2 FillSurfaceLine2() Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/CharacteristicPointSet.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/CharacteristicPointSet.cs (.../CharacteristicPointSet.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/CharacteristicPointSet.cs (.../CharacteristicPointSet.cs) (revision 6245) @@ -146,7 +146,7 @@ { characteristicPoint.Point.Z = double.NaN; } - else if (!geometry.CalcPoints.Contains(characteristicPoint.Point)) + else if (!geometry.Points.Contains(characteristicPoint.Point)) { if (double.IsNaN(characteristicPoint.Point.X)) { @@ -174,7 +174,7 @@ return; } - foreach (Point2D point in geometry.CalcPoints) + foreach (Point2D point in geometry.Points) { Add(new CharacteristicPoint { @@ -190,7 +190,7 @@ // characteristic points should have their height updated: foreach (CharacteristicPoint characteristicPoint in annotations.ToArray()) { - if (geometry != null && geometry.CalcPoints.Contains(characteristicPoint.Point)) + if (geometry != null && geometry.Points.Contains(characteristicPoint.Point)) { Remove(characteristicPoint); } @@ -404,12 +404,12 @@ typeCache.Remove(item.CharacteristicPointType); bool removeGeometryPoint = GeometryMustContainPoint && Geometry != null && - Geometry.CalcPoints.Contains(item.Point) && + Geometry.Points.Contains(item.Point) && !annotations.Any(cp => ReferenceEquals(cp.Point, item.Point)); if (removeGeometryPoint) { - PerformCollectionRemoveWithEvents(Geometry.CalcPoints, item.Point); + PerformCollectionRemoveWithEvents(Geometry.Points, item.Point); } } @@ -434,7 +434,7 @@ if (GeometryMustContainPoint && Geometry != null) { - Geometry.CalcPoints.Clear(); + Geometry.Points.Clear(); } } @@ -486,14 +486,14 @@ Point2D itemAtIndex = index < annotations.Count ? annotations[index].Point : null; PerformListInsertWithEvents(annotations, item, index); - if (GeometryMustContainPoint && Geometry != null && !Geometry.CalcPoints.Contains(item.Point)) + if (GeometryMustContainPoint && Geometry != null && !Geometry.Points.Contains(item.Point)) { - int geometryIndex = Geometry.CalcPoints.Count; + int geometryIndex = Geometry.Points.Count; if (null != itemAtIndex) { - for (var i = 0; i < Geometry.CalcPoints.Count; i++) + for (var i = 0; i < Geometry.Points.Count; i++) { - if (ReferenceEquals(Geometry.CalcPoints[i], itemAtIndex)) + if (ReferenceEquals(Geometry.Points[i], itemAtIndex)) { geometryIndex = i; break; @@ -504,11 +504,11 @@ // Check if point at same position already exists and set that point to the existing point // Do this to avoid points in Surfaceline.Geometry with the same location var IsPointExist = false; - for (var i = 0; i < Geometry.CalcPoints.Count; i++) + for (var i = 0; i < Geometry.Points.Count; i++) { - if (Geometry.CalcPoints[i].LocationEquals(item.Point)) + if (Geometry.Points[i].LocationEquals(item.Point)) { - item.Point = Geometry.CalcPoints[i]; + item.Point = Geometry.Points[i]; IsPointExist = true; break; } @@ -517,7 +517,7 @@ if (!IsPointExist) { // Only add new point if no point on same location was found - PerformListInsertWithEvents(Geometry.CalcPoints, item.Point, geometryIndex); + PerformListInsertWithEvents(Geometry.Points, item.Point, geometryIndex); } } Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs =================================================================== diff -u -r6233 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs (.../GeometryData.cs) (revision 6233) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs (.../GeometryData.cs) (revision 6245) @@ -54,7 +54,7 @@ { get { - if (surfaceLine.CalcPoints.Count == 0 && Points.Count > 0) + if (surfaceLine.Points.Count == 0 && Points.Count > 0) { UpdateSurfaceLine(); } @@ -220,7 +220,7 @@ List bCurves = GetBoundaryCurves(); if (bCurves.Count == 0) { - surfaceLine.CalcPoints.Clear(); + surfaceLine.Points.Clear(); } List curvesCopy = GetCurvesCopy(bCurves); @@ -357,9 +357,9 @@ private static void ReplacePointsForLoop(GeometryData clonedGeometryData, GeometryLoop clonedLoop) { - for (int i = 0; i < clonedLoop.CalcPoints.Count; i++) + for (int i = 0; i < clonedLoop.Points.Count; i++) { - clonedLoop.CalcPoints[i] = clonedGeometryData.GetPointAtLocation(clonedLoop.CalcPoints[i]); + clonedLoop.Points[i] = clonedGeometryData.GetPointAtLocation(clonedLoop.Points[i]); } } @@ -468,8 +468,8 @@ var result = new GeometryPointString(); foreach (GeometryCurve curve in curveList) { - result.CalcPoints.Add(curve.EndPoint); - result.CalcPoints.Add(curve.HeadPoint); + result.Points.Add(curve.EndPoint); + result.Points.Add(curve.HeadPoint); } return result; @@ -495,7 +495,7 @@ /// private void CreateSurfaceLinePointString(List curves) { - surfaceLine.CalcPoints.Clear(); + surfaceLine.Points.Clear(); if (curves.Count == 0) { @@ -513,14 +513,14 @@ foreach (GeometryCurve curve in curves) { - if (!surfaceLine.CalcPoints.Contains(curve.HeadPoint)) + if (!surfaceLine.Points.Contains(curve.HeadPoint)) { - surfaceLine.CalcPoints.Add(curve.HeadPoint); + surfaceLine.Points.Add(curve.HeadPoint); } - if (!surfaceLine.CalcPoints.Contains(curve.EndPoint)) + if (!surfaceLine.Points.Contains(curve.EndPoint)) { - surfaceLine.CalcPoints.Add(curve.EndPoint); + surfaceLine.Points.Add(curve.EndPoint); } } Index: DamEngine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs =================================================================== diff -u -r6216 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs (.../FillDamFromXmlInput.cs) (revision 6216) +++ DamEngine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs (.../FillDamFromXmlInput.cs) (revision 6245) @@ -860,12 +860,12 @@ if (existingPoint == null) { geometry.Points.Add(point); - outputLoop.CalcPoints.Add(point); + outputLoop.Points.Add(point); return point; } else { - outputLoop.CalcPoints.Add(existingPoint); + outputLoop.Points.Add(existingPoint); return existingPoint; } } Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs =================================================================== diff -u -r6100 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs (.../PlLinesToWaternetConverterTests.cs) (revision 6100) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverterTests.cs (.../PlLinesToWaternetConverterTests.cs) (revision 6245) @@ -177,11 +177,11 @@ Assert.Multiple(() => { // phreatic line (PL 1) - Assert.That(waternet.PhreaticLine.CalcPoints, Has.Count.EqualTo(2)); - Assert.That(waternet.PhreaticLine.CalcPoints[0].X, Is.EqualTo(xLeft).Within(precision3Decimals)); - Assert.That(waternet.PhreaticLine.CalcPoints[0].Z, Is.EqualTo(pL1Level).Within(precision3Decimals)); - Assert.That(waternet.PhreaticLine.CalcPoints[1].X, Is.EqualTo(xRight).Within(precision3Decimals)); - Assert.That(waternet.PhreaticLine.CalcPoints[1].Z, Is.EqualTo(pL1Level).Within(precision3Decimals)); + Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2)); + Assert.That(waternet.PhreaticLine.Points[0].X, Is.EqualTo(xLeft).Within(precision3Decimals)); + Assert.That(waternet.PhreaticLine.Points[0].Z, Is.EqualTo(pL1Level).Within(precision3Decimals)); + Assert.That(waternet.PhreaticLine.Points[1].X, Is.EqualTo(xRight).Within(precision3Decimals)); + Assert.That(waternet.PhreaticLine.Points[1].Z, Is.EqualTo(pL1Level).Within(precision3Decimals)); WaternetLine waternetLinePl1 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line phreatic line"); // expected: waternet line connected to pl1 has level: @@ -190,13 +190,13 @@ // - for Hydrostatic type, -2.111 m + 1 mm (Pl1 is in layer 2 from 0 m to -2.111 m) // - for Full hydrostatic, -30 (the bottom of the geometry) - Assert.That(waternetLinePl1.HeadLine.CalcPoints, Is.EqualTo(waternet.PhreaticLine.CalcPoints)); + Assert.That(waternetLinePl1.HeadLine.Points, Is.EqualTo(waternet.PhreaticLine.Points)); Assert.That(waternetLinePl1.HeadLine.Name, Is.EqualTo(waternet.PhreaticLine.Name)); - Assert.That(waternetLinePl1.CalcPoints, Has.Count.EqualTo(2)); - Assert.That(waternetLinePl1.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl1.CalcPoints[0].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); - Assert.That(waternetLinePl1.CalcPoints[1].X, Is.EqualTo(100).Within(precision3Decimals)); - Assert.That(waternetLinePl1.CalcPoints[1].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl1.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points[0].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points[1].X, Is.EqualTo(100).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points[1].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); }); // PL 2 @@ -205,20 +205,20 @@ { Assert.Multiple(() => { - Assert.That(waternet.HeadLineList[0].CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternet.HeadLineList[0].Points, Has.Count.EqualTo(2)); Assert.That(waternet.HeadLineList[0].Name, Is.EqualTo("Head line 2 (PL 2)")); // check the points of first headline that represents pl 2 - Assert.That(waternet.HeadLineList[0].CalcPoints[0].X, Is.EqualTo(xLeft).Within(precision3Decimals)); - Assert.That(waternet.HeadLineList[0].CalcPoints[0].Z, Is.EqualTo(-6).Within(precision3Decimals)); - Assert.That(waternet.HeadLineList[0].CalcPoints[1].X, Is.EqualTo(xRight).Within(precision3Decimals)); - Assert.That(waternet.HeadLineList[0].CalcPoints[1].Z, Is.EqualTo(-6).Within(precision3Decimals)); + Assert.That(waternet.HeadLineList[0].Points[0].X, Is.EqualTo(xLeft).Within(precision3Decimals)); + Assert.That(waternet.HeadLineList[0].Points[0].Z, Is.EqualTo(-6).Within(precision3Decimals)); + Assert.That(waternet.HeadLineList[0].Points[1].X, Is.EqualTo(xRight).Within(precision3Decimals)); + Assert.That(waternet.HeadLineList[0].Points[1].Z, Is.EqualTo(-6).Within(precision3Decimals)); // expected: waternet line connected to pl2 has level -6.111 + 2.1 = -4.011 Assert.That(waternetLinePl2.HeadLine, Is.EqualTo(waternet.HeadLineList[0])); - Assert.That(waternetLinePl2.CalcPoints, Has.Count.EqualTo(2)); - Assert.That(waternetLinePl2.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl2.CalcPoints[0].Z, Is.EqualTo(-4.011).Within(precision3Decimals)); - Assert.That(waternetLinePl2.CalcPoints[1].X, Is.EqualTo(100).Within(precision3Decimals)); - Assert.That(waternetLinePl2.CalcPoints[1].Z, Is.EqualTo(-4.011).Within(precision3Decimals)); + Assert.That(waternetLinePl2.Points, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl2.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl2.Points[0].Z, Is.EqualTo(-4.011).Within(precision3Decimals)); + Assert.That(waternetLinePl2.Points[1].X, Is.EqualTo(100).Within(precision3Decimals)); + Assert.That(waternetLinePl2.Points[1].Z, Is.EqualTo(-4.011).Within(precision3Decimals)); }); } else @@ -239,45 +239,45 @@ { // expected: waternet line connected to pl3 has level -6.111 Assert.That(waternetLinePl3.HeadLine.Name, Is.EqualTo("Head line 3 (PL 3)")); - Assert.That(waternetLinePl3.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl3.Points, Has.Count.EqualTo(2)); }); Assert.Multiple(() => { - Assert.That(waternetLinePl3.CalcPoints[0].Z, Is.EqualTo(-6.111).Within(precision3Decimals)); + Assert.That(waternetLinePl3.Points[0].Z, Is.EqualTo(-6.111).Within(precision3Decimals)); // expected: highest waternet lines connected to pl4 have levels -2.111 and -3.373 Assert.That(waternetLinePl4TopInBetweenAquiferTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4TopInBetweenAquiferTop.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points, Has.Count.EqualTo(2)); Assert.That(waternetLinePl4TopInBetweenAquiferBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4TopInBetweenAquiferBottom.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points, Has.Count.EqualTo(2)); }); Assert.Multiple(() => { - Assert.That(waternetLinePl4TopInBetweenAquiferTop.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl4TopInBetweenAquiferTop.CalcPoints[0].Z, Is.EqualTo(-2.111).Within(precision3Decimals)); - Assert.That(waternetLinePl4TopInBetweenAquiferTop.CalcPoints[1].X, Is.EqualTo(100).Within(precision3Decimals)); - Assert.That(waternetLinePl4TopInBetweenAquiferTop.CalcPoints[1].Z, Is.EqualTo(-2.111).Within(precision3Decimals)); - Assert.That(waternetLinePl4TopInBetweenAquiferBottom.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl4TopInBetweenAquiferBottom.CalcPoints[0].Z, Is.EqualTo(-3.373).Within(precision3Decimals)); - Assert.That(waternetLinePl4TopInBetweenAquiferBottom.CalcPoints[1].X, Is.EqualTo(100).Within(precision3Decimals)); - Assert.That(waternetLinePl4TopInBetweenAquiferBottom.CalcPoints[1].Z, Is.EqualTo(-3.373).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[0].Z, Is.EqualTo(-2.111).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[1].X, Is.EqualTo(100).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[1].Z, Is.EqualTo(-2.111).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[0].Z, Is.EqualTo(-3.373).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[1].X, Is.EqualTo(100).Within(precision3Decimals)); + Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[1].Z, Is.EqualTo(-3.373).Within(precision3Decimals)); // expected: lowest waternet lines 4 connected to pl4 have levels -4.151 and -5.373 Assert.That(waternetLinePl4BottomInBetweenAquiferTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4BottomInBetweenAquiferTop.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points, Has.Count.EqualTo(2)); Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points, Has.Count.EqualTo(2)); }); Assert.Multiple(() => { - Assert.That(waternetLinePl4BottomInBetweenAquiferTop.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl4BottomInBetweenAquiferTop.CalcPoints[0].Z, Is.EqualTo(-4.151).Within(precision3Decimals)); - Assert.That(waternetLinePl4BottomInBetweenAquiferTop.CalcPoints[1].X, Is.EqualTo(100).Within(precision3Decimals)); - Assert.That(waternetLinePl4BottomInBetweenAquiferTop.CalcPoints[1].Z, Is.EqualTo(-4.151).Within(precision3Decimals)); - Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.CalcPoints[0].Z, Is.EqualTo(-5.373).Within(precision3Decimals)); - Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.CalcPoints[1].X, Is.EqualTo(100).Within(precision3Decimals)); - Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.CalcPoints[1].Z, Is.EqualTo(-5.373).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[0].Z, Is.EqualTo(-4.151).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[1].X, Is.EqualTo(100).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[1].Z, Is.EqualTo(-4.151).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[0].Z, Is.EqualTo(-5.373).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[1].X, Is.EqualTo(100).Within(precision3Decimals)); + Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[1].Z, Is.EqualTo(-5.373).Within(precision3Decimals)); }); } else @@ -313,13 +313,13 @@ Assert.Multiple(() => { WaternetLine waternetLinePl1 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line phreatic line"); - Assert.That(waternetLinePl1.HeadLine.CalcPoints, Is.EqualTo(waternet.PhreaticLine.CalcPoints)); + Assert.That(waternetLinePl1.HeadLine.Points, Is.EqualTo(waternet.PhreaticLine.Points)); Assert.That(waternetLinePl1.HeadLine.Name, Is.EqualTo(waternet.PhreaticLine.Name)); - Assert.That(waternetLinePl1.CalcPoints, Has.Count.EqualTo(2)); - Assert.That(waternetLinePl1.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl1.CalcPoints[0].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); - Assert.That(waternetLinePl1.CalcPoints[1].X, Is.EqualTo(100).Within(precision3Decimals)); - Assert.That(waternetLinePl1.CalcPoints[1].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl1.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points[0].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points[1].X, Is.EqualTo(100).Within(precision3Decimals)); + Assert.That(waternetLinePl1.Points[1].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals)); }); } } @@ -334,11 +334,11 @@ Assert.That(waternet.HeadLineList, Has.Count.EqualTo(3)); Assert.Multiple(() => { - Assert.That(waternet.HeadLineList[0].CalcPoints, Has.Count.EqualTo(2)); - Assert.That(waternet.HeadLineList[1].CalcPoints, Has.Count.EqualTo(2)); - Assert.That(waternet.HeadLineList[2].CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternet.HeadLineList[0].Points, Has.Count.EqualTo(2)); + Assert.That(waternet.HeadLineList[1].Points, Has.Count.EqualTo(2)); + Assert.That(waternet.HeadLineList[2].Points, Has.Count.EqualTo(2)); // phreatic line - Assert.That(waternet.PhreaticLine.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2)); }); // check that no headline are added when Pl2, Pl3 or Pl4 does not exist or has no points @@ -349,9 +349,9 @@ Assert.That(waternet.HeadLineList, Has.Count.EqualTo(1)); Assert.Multiple(() => { - Assert.That(waternet.HeadLineList[0].CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternet.HeadLineList[0].Points, Has.Count.EqualTo(2)); // phreatic line - Assert.That(waternet.PhreaticLine.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2)); }); } @@ -374,22 +374,22 @@ Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile, surfaceLine, penetrationZone, pressureType); // Assert - AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.CalcPoints); + AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.Points); Assert.That(waternet.HeadLineList, Has.Count.EqualTo(headlineCount)); var indexHeadlinePl3 = 0; var indexHeadlinePl4 = 1; if (pressureType == IntrusionVerticalWaterPressureType.SemiTimeDependent && penetrationZone > 0) { - AssertGeometry(plLines.Lines[PlLineType.Pl2].Points, waternet.HeadLineList[0].CalcPoints); + AssertGeometry(plLines.Lines[PlLineType.Pl2].Points, waternet.HeadLineList[0].Points); indexHeadlinePl3 += 1; indexHeadlinePl4 += 1; } if (pressureType != IntrusionVerticalWaterPressureType.FullHydroStatic) { - AssertGeometry(plLines.Lines[PlLineType.Pl3].Points, waternet.HeadLineList[indexHeadlinePl3].CalcPoints); - AssertGeometry(plLines.Lines[PlLineType.Pl4].Points, waternet.HeadLineList[indexHeadlinePl4].CalcPoints); + AssertGeometry(plLines.Lines[PlLineType.Pl3].Points, waternet.HeadLineList[indexHeadlinePl3].Points); + AssertGeometry(plLines.Lines[PlLineType.Pl4].Points, waternet.HeadLineList[indexHeadlinePl4].Points); } Assert.That(waternet.WaternetLineList, Has.Count.EqualTo(waternetLineCount)); @@ -401,7 +401,7 @@ new(leftCoordinate, levelWaternetPl1), new(rightCoordinate, levelWaternetPl1) ]; - AssertGeometry(expectedWaternetLine1, pl1WaternetLine.CalcPoints); + AssertGeometry(expectedWaternetLine1, pl1WaternetLine.Points); Point2D[] expectedBottomAquiferCoordinates = [ @@ -415,7 +415,7 @@ Assert.That(pl2WaternetLine.HeadLine, Is.SameAs(waternet.HeadLineList[0])); Point2D[] offSetAquiferCoordinates = expectedBottomAquiferCoordinates.Select(aquiferCoordinate => new Point2D(aquiferCoordinate.X, aquiferCoordinate.Z + penetrationLength)) .ToArray(); - AssertGeometry(offSetAquiferCoordinates, pl2WaternetLine.CalcPoints); + AssertGeometry(offSetAquiferCoordinates, pl2WaternetLine.Points); } else { @@ -426,35 +426,35 @@ { WaternetLine pl3WaternetLine = waternet.WaternetLineList.Find(w => w.HeadLine.Name == "Head line 3 (PL 3)"); Assert.That(pl3WaternetLine.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl3])); - AssertGeometry(expectedBottomAquiferCoordinates, pl3WaternetLine.CalcPoints); + AssertGeometry(expectedBottomAquiferCoordinates, pl3WaternetLine.Points); WaternetLine pl4WaternetLine1Top = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer top (1)"); Assert.That(pl4WaternetLine1Top.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4])); AssertGeometry([ new Point2D(leftCoordinate, 10), new Point2D(rightCoordinate, 10) - ], pl4WaternetLine1Top.CalcPoints); + ], pl4WaternetLine1Top.Points); WaternetLine pl4WaternetLineBottom = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer bottom (1)"); Assert.That(pl4WaternetLineBottom.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4])); AssertGeometry([ new Point2D(leftCoordinate, 0), new Point2D(rightCoordinate, 0) - ], pl4WaternetLineBottom.CalcPoints); + ], pl4WaternetLineBottom.Points); WaternetLine pl4WaternetLine2Top = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer top (2)"); Assert.That(pl4WaternetLine2Top.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4])); AssertGeometry([ new Point2D(leftCoordinate, -10), new Point2D(rightCoordinate, -10) - ], pl4WaternetLine2Top.CalcPoints); + ], pl4WaternetLine2Top.Points); WaternetLine pl4WaternetLine2Bottom = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer bottom (2)"); Assert.That(pl4WaternetLine2Bottom.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4])); AssertGeometry([ new Point2D(leftCoordinate, -20), new Point2D(rightCoordinate, -20) - ], pl4WaternetLine2Bottom.CalcPoints); + ], pl4WaternetLine2Bottom.Points); } } @@ -471,15 +471,15 @@ Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile, surfaceLine, 0, pressureType); // Assert - AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.CalcPoints); + AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.Points); WaternetLine pl1WaternetLine = waternet.WaternetLineList.Find(w => w.HeadLine.Name == waternet.PhreaticLine.Name); Assert.That(pl1WaternetLine.HeadLine.Name, Is.SameAs(waternet.PhreaticLine.Name)); Point2D[] expectedWaternetLine1 = [ new(leftCoordinate, expectedLevelWaternetPl1), new(rightCoordinate, expectedLevelWaternetPl1) ]; - AssertGeometry(expectedWaternetLine1, pl1WaternetLine.CalcPoints); + AssertGeometry(expectedWaternetLine1, pl1WaternetLine.Points); } /// @@ -575,13 +575,13 @@ const double right = 50.123; WaternetLine waternetLine = PlLinesToWaternetConverter.CreateWaternetLine(level, left, right); - Assert.That(waternetLine.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLine.Points, Has.Count.EqualTo(2)); Assert.Multiple(() => { - Assert.That(waternetLine.CalcPoints[0].X, Is.EqualTo(-50.111).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[0].Z, Is.EqualTo(1.234).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].X, Is.EqualTo(50.123).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].Z, Is.EqualTo(1.234).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].X, Is.EqualTo(-50.111).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].Z, Is.EqualTo(1.234).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].X, Is.EqualTo(50.123).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].Z, Is.EqualTo(1.234).Within(precision3Decimals)); }); } @@ -614,24 +614,24 @@ Assert.That(waternetLine, Has.Count.EqualTo(9)); Assert.Multiple(() => { - Assert.That(waternetLine.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[0].Z, Is.EqualTo(0.92).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].X, Is.EqualTo(10.14).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].Z, Is.EqualTo(0.95).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[2].X, Is.EqualTo(17.08).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[2].Z, Is.EqualTo(0.88).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[3].X, Is.EqualTo(19.45).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[3].Z, Is.EqualTo(0.81).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[4].X, Is.EqualTo(20.62).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[4].Z, Is.EqualTo(0.3).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[5].X, Is.EqualTo(21.84).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[5].Z, Is.EqualTo(-0.61).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[6].X, Is.EqualTo(23.08).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[6].Z, Is.EqualTo(-0.38).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[7].X, Is.EqualTo(24.61).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[7].Z, Is.EqualTo(0.63).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[8].X, Is.EqualTo(80.78).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[8].Z, Is.EqualTo(0.63).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].Z, Is.EqualTo(0.92).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].X, Is.EqualTo(10.14).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].Z, Is.EqualTo(0.95).Within(precision3Decimals)); + Assert.That(waternetLine.Points[2].X, Is.EqualTo(17.08).Within(precision3Decimals)); + Assert.That(waternetLine.Points[2].Z, Is.EqualTo(0.88).Within(precision3Decimals)); + Assert.That(waternetLine.Points[3].X, Is.EqualTo(19.45).Within(precision3Decimals)); + Assert.That(waternetLine.Points[3].Z, Is.EqualTo(0.81).Within(precision3Decimals)); + Assert.That(waternetLine.Points[4].X, Is.EqualTo(20.62).Within(precision3Decimals)); + Assert.That(waternetLine.Points[4].Z, Is.EqualTo(0.3).Within(precision3Decimals)); + Assert.That(waternetLine.Points[5].X, Is.EqualTo(21.84).Within(precision3Decimals)); + Assert.That(waternetLine.Points[5].Z, Is.EqualTo(-0.61).Within(precision3Decimals)); + Assert.That(waternetLine.Points[6].X, Is.EqualTo(23.08).Within(precision3Decimals)); + Assert.That(waternetLine.Points[6].Z, Is.EqualTo(-0.38).Within(precision3Decimals)); + Assert.That(waternetLine.Points[7].X, Is.EqualTo(24.61).Within(precision3Decimals)); + Assert.That(waternetLine.Points[7].Z, Is.EqualTo(0.63).Within(precision3Decimals)); + Assert.That(waternetLine.Points[8].X, Is.EqualTo(80.78).Within(precision3Decimals)); + Assert.That(waternetLine.Points[8].Z, Is.EqualTo(0.63).Within(precision3Decimals)); }); } @@ -708,8 +708,8 @@ soilProfile.Surfaces.Add(soilLayer9); soilProfile.Surfaces.Add(soilLayerBottom); soilProfile.Geometry.Surfaces.Add(new GeometrySurface()); - soilProfile.Geometry.SurfaceLine.CalcPoints.Add(new Point2D(leftCoordinate, 0)); - soilProfile.Geometry.SurfaceLine.CalcPoints.Add(new Point2D(rightCoordinate, 0)); + soilProfile.Geometry.SurfaceLine.Points.Add(new Point2D(leftCoordinate, 0)); + soilProfile.Geometry.SurfaceLine.Points.Add(new Point2D(rightCoordinate, 0)); PlLines plLines = CreateAllPlLines(pL1Level); @@ -720,10 +720,10 @@ Assert.That(waternetLine, Has.Count.EqualTo(2)); Assert.Multiple(() => { - Assert.That(waternetLine.CalcPoints[0].X, Is.EqualTo(leftCoordinate).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[0].Z, Is.EqualTo(expectedWaternetLineLevel).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].X, Is.EqualTo(rightCoordinate).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].Z, Is.EqualTo(expectedWaternetLineLevel).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].X, Is.EqualTo(leftCoordinate).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].Z, Is.EqualTo(expectedWaternetLineLevel).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].X, Is.EqualTo(rightCoordinate).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].Z, Is.EqualTo(expectedWaternetLineLevel).Within(precision3Decimals)); }); } @@ -781,18 +781,18 @@ Assert.That(waternetLine, Has.Count.EqualTo(6)); Assert.Multiple(() => { - Assert.That(waternetLine.CalcPoints[0].X, Is.EqualTo(xLeft).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[0].Z, Is.EqualTo(-10).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].X, Is.EqualTo(xPointF).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[1].Z, Is.EqualTo(-10).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[2].X, Is.EqualTo(xPointG).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[2].Z, Is.EqualTo(-12.5).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[3].X, Is.EqualTo(xPointH).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[3].Z, Is.EqualTo(-12.5).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[4].X, Is.EqualTo(xPointI).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[4].Z, Is.EqualTo(-10).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[5].X, Is.EqualTo(xRight).Within(precision3Decimals)); - Assert.That(waternetLine.CalcPoints[5].Z, Is.EqualTo(-10).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].X, Is.EqualTo(xLeft).Within(precision3Decimals)); + Assert.That(waternetLine.Points[0].Z, Is.EqualTo(-10).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].X, Is.EqualTo(xPointF).Within(precision3Decimals)); + Assert.That(waternetLine.Points[1].Z, Is.EqualTo(-10).Within(precision3Decimals)); + Assert.That(waternetLine.Points[2].X, Is.EqualTo(xPointG).Within(precision3Decimals)); + Assert.That(waternetLine.Points[2].Z, Is.EqualTo(-12.5).Within(precision3Decimals)); + Assert.That(waternetLine.Points[3].X, Is.EqualTo(xPointH).Within(precision3Decimals)); + Assert.That(waternetLine.Points[3].Z, Is.EqualTo(-12.5).Within(precision3Decimals)); + Assert.That(waternetLine.Points[4].X, Is.EqualTo(xPointI).Within(precision3Decimals)); + Assert.That(waternetLine.Points[4].Z, Is.EqualTo(-10).Within(precision3Decimals)); + Assert.That(waternetLine.Points[5].X, Is.EqualTo(xRight).Within(precision3Decimals)); + Assert.That(waternetLine.Points[5].Z, Is.EqualTo(-10).Within(precision3Decimals)); }); } @@ -840,11 +840,11 @@ Assert.Multiple(() => { - Assert.That(waternet.PhreaticLine.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2)); WaternetLine waternetLinePl1 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line phreatic line"); - Assert.That(waternetLinePl1.HeadLine.CalcPoints, Is.EqualTo(waternet.PhreaticLine.CalcPoints)); + Assert.That(waternetLinePl1.HeadLine.Points, Is.EqualTo(waternet.PhreaticLine.Points)); Assert.That(waternetLinePl1.HeadLine.Name, Is.EqualTo(waternet.PhreaticLine.Name)); - Assert.That(waternetLinePl1.CalcPoints, Has.Count.EqualTo(10)); + Assert.That(waternetLinePl1.Points, Has.Count.EqualTo(10)); }); // no PL 2 WaternetLine waternetLinePl2 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Penetration zone lower aquifer"); @@ -854,19 +854,19 @@ Assert.Multiple(() => { Assert.That(waternetLinePl3.HeadLine.Name, Is.EqualTo("Head line 3 (PL 3)")); - Assert.That(waternetLinePl3.CalcPoints, Has.Count.EqualTo(6)); - Assert.That(waternetLinePl3.CalcPoints[0].X, Is.EqualTo(0)); - Assert.That(waternetLinePl3.CalcPoints[0].Z, Is.EqualTo(-6)); - Assert.That(waternetLinePl3.CalcPoints[1].X, Is.EqualTo(59.25)); - Assert.That(waternetLinePl3.CalcPoints[1].Z, Is.EqualTo(-6)); - Assert.That(waternetLinePl3.CalcPoints[2].X, Is.EqualTo(59.5)); - Assert.That(waternetLinePl3.CalcPoints[2].Z, Is.EqualTo(-8)); - Assert.That(waternetLinePl3.CalcPoints[3].X, Is.EqualTo(61.5)); - Assert.That(waternetLinePl3.CalcPoints[3].Z, Is.EqualTo(-8)); - Assert.That(waternetLinePl3.CalcPoints[4].X, Is.EqualTo(61.75)); - Assert.That(waternetLinePl3.CalcPoints[4].Z, Is.EqualTo(-6)); - Assert.That(waternetLinePl3.CalcPoints[5].X, Is.EqualTo(75)); - Assert.That(waternetLinePl3.CalcPoints[5].Z, Is.EqualTo(-6)); + Assert.That(waternetLinePl3.Points, Has.Count.EqualTo(6)); + Assert.That(waternetLinePl3.Points[0].X, Is.EqualTo(0)); + Assert.That(waternetLinePl3.Points[0].Z, Is.EqualTo(-6)); + Assert.That(waternetLinePl3.Points[1].X, Is.EqualTo(59.25)); + Assert.That(waternetLinePl3.Points[1].Z, Is.EqualTo(-6)); + Assert.That(waternetLinePl3.Points[2].X, Is.EqualTo(59.5)); + Assert.That(waternetLinePl3.Points[2].Z, Is.EqualTo(-8)); + Assert.That(waternetLinePl3.Points[3].X, Is.EqualTo(61.5)); + Assert.That(waternetLinePl3.Points[3].Z, Is.EqualTo(-8)); + Assert.That(waternetLinePl3.Points[4].X, Is.EqualTo(61.75)); + Assert.That(waternetLinePl3.Points[4].Z, Is.EqualTo(-6)); + Assert.That(waternetLinePl3.Points[5].X, Is.EqualTo(75)); + Assert.That(waternetLinePl3.Points[5].Z, Is.EqualTo(-6)); }); // PL 4: 4 waternet lines expected at top and bottom and at both sides of the ditch // No waternet line expected for the in-between aquifer in the dike body @@ -877,40 +877,40 @@ Assert.Multiple(() => { Assert.That(waternetLinePl4LeftDitchTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4LeftDitchTop.CalcPoints, Has.Count.EqualTo(3)); + Assert.That(waternetLinePl4LeftDitchTop.Points, Has.Count.EqualTo(3)); Assert.That(waternetLinePl4LeftDitchBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4LeftDitchBottom.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl4LeftDitchBottom.Points, Has.Count.EqualTo(2)); Assert.That(waternetLinePl4RightDitchTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4RightDitchTop.CalcPoints, Has.Count.EqualTo(3)); + Assert.That(waternetLinePl4RightDitchTop.Points, Has.Count.EqualTo(3)); Assert.That(waternetLinePl4RightDitchBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)")); - Assert.That(waternetLinePl4RightDitchBottom.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(waternetLinePl4RightDitchBottom.Points, Has.Count.EqualTo(2)); }); Assert.Multiple(() => { - Assert.That(waternetLinePl4LeftDitchTop.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchTop.CalcPoints[0].Z, Is.EqualTo(-2).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchTop.CalcPoints[1].X, Is.EqualTo(58.75).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchTop.CalcPoints[1].Z, Is.EqualTo(-2).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchTop.CalcPoints[2].X, Is.EqualTo(59).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchTop.CalcPoints[2].Z, Is.EqualTo(-4).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchTop.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchTop.Points[0].Z, Is.EqualTo(-2).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchTop.Points[1].X, Is.EqualTo(58.75).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchTop.Points[1].Z, Is.EqualTo(-2).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchTop.Points[2].X, Is.EqualTo(59).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchTop.Points[2].Z, Is.EqualTo(-4).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchBottom.CalcPoints[0].X, Is.EqualTo(0).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchBottom.CalcPoints[0].Z, Is.EqualTo(-4).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchBottom.CalcPoints[1].X, Is.EqualTo(59).Within(precision3Decimals)); - Assert.That(waternetLinePl4LeftDitchBottom.CalcPoints[1].Z, Is.EqualTo(-4).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchBottom.Points[0].X, Is.EqualTo(0).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchBottom.Points[0].Z, Is.EqualTo(-4).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchBottom.Points[1].X, Is.EqualTo(59).Within(precision3Decimals)); + Assert.That(waternetLinePl4LeftDitchBottom.Points[1].Z, Is.EqualTo(-4).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchTop.CalcPoints[0].X, Is.EqualTo(62).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchTop.CalcPoints[0].Z, Is.EqualTo(-4).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchTop.CalcPoints[1].X, Is.EqualTo(62.25).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchTop.CalcPoints[1].Z, Is.EqualTo(-2).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchTop.CalcPoints[2].X, Is.EqualTo(75).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchTop.CalcPoints[2].Z, Is.EqualTo(-2).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchTop.Points[0].X, Is.EqualTo(62).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchTop.Points[0].Z, Is.EqualTo(-4).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchTop.Points[1].X, Is.EqualTo(62.25).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchTop.Points[1].Z, Is.EqualTo(-2).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchTop.Points[2].X, Is.EqualTo(75).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchTop.Points[2].Z, Is.EqualTo(-2).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchBottom.CalcPoints[0].X, Is.EqualTo(62).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchBottom.CalcPoints[0].Z, Is.EqualTo(-4).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchBottom.CalcPoints[1].X, Is.EqualTo(75).Within(precision3Decimals)); - Assert.That(waternetLinePl4RightDitchBottom.CalcPoints[1].Z, Is.EqualTo(-4).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchBottom.Points[0].X, Is.EqualTo(62).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchBottom.Points[0].Z, Is.EqualTo(-4).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchBottom.Points[1].X, Is.EqualTo(75).Within(precision3Decimals)); + Assert.That(waternetLinePl4RightDitchBottom.Points[1].Z, Is.EqualTo(-4).Within(precision3Decimals)); }); } Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperInput.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperInput.cs (.../FillEngineFromMacroStabilityWrapperInput.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperInput.cs (.../FillEngineFromMacroStabilityWrapperInput.cs) (revision 6245) @@ -228,7 +228,7 @@ Name = waternetLine.Name }; Point2D[] coordinates = waternetLine.Points.Select(p => new Point2D(p.X, p.Z)).ToArray(); - lineType.CalcPoints.AddRange(coordinates); + lineType.Points.AddRange(coordinates); return lineType; } Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Routines2D.cs =================================================================== diff -u -r5923 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Routines2D.cs (.../Routines2D.cs) (revision 5923) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Routines2D.cs (.../Routines2D.cs) (revision 6245) @@ -242,16 +242,16 @@ // add the last point at the end, cos the polygon must be closed, so the last node equals the first var pointAdded = false; - if (polygon.CalcPoints.Count > 0) + if (polygon.Points.Count > 0) { - if (!polygon.CalcPoints[0].LocationEquals(polygon.CalcPoints[polygon.CalcPoints.Count - 1])) + if (!polygon.Points[0].LocationEquals(polygon.Points[polygon.Points.Count - 1])) { - polygon.CalcPoints.Add(polygon.CalcPoints[0]); + polygon.Points.Add(polygon.Points[0]); pointAdded = true; } } - if (polygon.CalcPoints.Count > 2) + if (polygon.Points.Count > 2) { double deltaX = polygon[0].X - x; double deltaZ = polygon[0].Z - z; @@ -267,7 +267,7 @@ double som = 0; var index = 1; - while (index < polygon.CalcPoints.Count) + while (index < polygon.Points.Count) { if (polygon[index] != null) { @@ -524,7 +524,7 @@ { if (needed) { - polygon.CalcPoints.Remove(polygon.CalcPoints[polygon.CalcPoints.Count - 1]); + polygon.Points.Remove(polygon.Points[polygon.Points.Count - 1]); } } Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryLoopTests.cs =================================================================== diff -u -r6086 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryLoopTests.cs (.../GeometryLoopTests.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryLoopTests.cs (.../GeometryLoopTests.cs) (revision 6245) @@ -38,9 +38,9 @@ var loop = new GeometryLoop(); // assert - Assert.That(loop.Count, Is.EqualTo(loop.CalcPoints.Count)); + Assert.That(loop.Count, Is.EqualTo(loop.Points.Count)); Assert.That(loop.Name, Is.EqualTo(String.Empty)); - Assert.That(loop.CalcPoints, Is.Empty); + Assert.That(loop.Points, Is.Empty); //Assert.AreEqual(String.Empty, loop.PointsDescription); Assert.That(loop.CurveList, Is.Empty); @@ -348,7 +348,7 @@ lastPoint = newPoint; } - int pointCount = loop.CalcPoints.Count; + int pointCount = loop.Points.Count; Assert.That(pointCount, Is.EqualTo(curveCount == 0 ? 0 : curveCount + 1)); // call @@ -443,7 +443,7 @@ }); // call - List points = loop.CalcPoints; + List points = loop.Points; // assert Assert.That(points.Count, Is.EqualTo(7)); @@ -484,7 +484,7 @@ }); // call - List points = loop.CalcPoints; + List points = loop.Points; // assert Assert.That(points.Count, Is.EqualTo(8)); @@ -512,7 +512,7 @@ }); // call - List points = loop.CalcPoints; + List points = loop.Points; // assert Assert.That(points.Count, Is.EqualTo(3)); @@ -535,7 +535,7 @@ }); // call - List points = loop.CalcPoints; + List points = loop.Points; // assert Assert.That(points.Count, Is.EqualTo(3)); @@ -558,7 +558,7 @@ }); // call - List points = loop.CalcPoints; + List points = loop.Points; // assert Assert.That(points.Count, Is.EqualTo(3)); @@ -581,7 +581,7 @@ }); // call - List points = loop.CalcPoints; + List points = loop.Points; // assert Assert.That(points.Count, Is.EqualTo(3)); @@ -599,7 +599,7 @@ loop.CurveList.Add(curve); // call - List points = loop.CalcPoints; + List points = loop.Points; // assert Assert.That(points.Count, Is.EqualTo(2)); @@ -614,7 +614,7 @@ var loop = new GeometryLoop(); // call - IList points = loop.CalcPoints; + IList points = loop.Points; // assert Assert.That(points, Is.Empty); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/SurfaceLineAdapter.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/SurfaceLineAdapter.cs (.../SurfaceLineAdapter.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/SurfaceLineAdapter.cs (.../SurfaceLineAdapter.cs) (revision 6245) @@ -413,7 +413,7 @@ /// The candidate to test private static void ThrowWhenSurfaceLineDoesNotSatisfyToSpecification(SurfaceLine2 surfaceLine) { - ThrowWhenSurfaceLineHasNoOrLessThenFourPoints(surfaceLine.Geometry.CalcPoints); + ThrowWhenSurfaceLineHasNoOrLessThenFourPoints(surfaceLine.Geometry.Points); ThrowWhenSurfaceHasNoDike(surfaceLine); ThrowWhenSurfaceLineHasAShoulderInsideAndNoSurfaceLevel(surfaceLine, surfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.SurfaceLevelInside)); Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs (.../GeometryGenerator.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs (.../GeometryGenerator.cs) (revision 6245) @@ -862,7 +862,7 @@ int surfaceCount = geometryData.Surfaces.Count; GeometryLoop newLoop = newSurface.OuterLoop; int newPointCount = newLoop.CurveList.Count; - List newPolygon = newLoop.CalcPoints; + List newPolygon = newLoop.Points; newSurface.RemoveAllInnerLoops(); for (var index = 0; index < surfaceCount; index++) @@ -877,7 +877,7 @@ var isOnPointCount = 0; var hasOnPointCount = 0; GeometryLoop loop = geometryData.Surfaces[index].OuterLoop; - List polygon = loop.CalcPoints; + List polygon = loop.Points; int existingLoopPointCount = polygon.Count; // check if it is an inner loop Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs (.../SurfaceLine2Extensions.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs (.../SurfaceLine2Extensions.cs) (revision 6245) @@ -223,7 +223,7 @@ if (addPoint) { - line.Geometry.CalcPoints.Add(point); + line.Geometry.Points.Add(point); line.AddCharacteristicPoint(point, type ?? CharacteristicPointType.None); } else if (type.HasValue && !movedPointToMatch) @@ -575,7 +575,7 @@ { // Notify change such that CharacteristicPointSet instances observing this // geometry can update if required. - line.Geometry.CalcPoints.Remove(geometryPoint); + line.Geometry.Points.Remove(geometryPoint); } } } @@ -595,11 +595,11 @@ { if (isInclusiveRange) { - return line.Geometry.CalcPoints.Where(cp => (cp.X >= startX || cp.X.AlmostEquals(startX, GeometryPoint.Precision)) && + return line.Geometry.Points.Where(cp => (cp.X >= startX || cp.X.AlmostEquals(startX, GeometryPoint.Precision)) && (cp.X <= endX || cp.X.AlmostEquals(endX, GeometryPoint.Precision))); } - return line.Geometry.CalcPoints.Where(cp => cp.X > startX && cp.X < endX); + return line.Geometry.Points.Where(cp => cp.X > startX && cp.X < endX); } #region Private methods @@ -634,7 +634,7 @@ { ThrowWhenLevelAboveDike(line, waterlevelLine.BeginPoint.Z); - List list = line.Geometry.CalcPoints.Where(point => + List list = line.Geometry.Points.Where(point => point.X >= line.CharacteristicPoints.GetPoint2D(CharacteristicPointType.SurfaceLevelOutside).X && point.X <= line.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver).X).ToList(); Index: DamEngine/trunk/src/Deltares.DamEngine.Data/GeometryExport/GeometryExporter.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/GeometryExport/GeometryExporter.cs (.../GeometryExporter.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/GeometryExport/GeometryExporter.cs (.../GeometryExporter.cs) (revision 6245) @@ -124,8 +124,8 @@ using (var writer = new StreamWriter(fileName)) { // Export calc points - writer.WriteLine("[BEGIN CALC POINTS] " + surfaceLine.CalcPoints.Count); - foreach (Point2D calcPoint in surfaceLine.CalcPoints) + writer.WriteLine("[BEGIN CALC POINTS] " + surfaceLine.Points.Count); + foreach (Point2D calcPoint in surfaceLine.Points) { writer.WriteLine($"{calcPoint.X}, {calcPoint.Z}"); } Index: DamEngine/trunk/src/Deltares.DamEngine.Data/General/PlLines/Pl1Line.cs =================================================================== diff -u -r6106 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/General/PlLines/Pl1Line.cs (.../Pl1Line.cs) (revision 6106) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/General/PlLines/Pl1Line.cs (.../Pl1Line.cs) (revision 6245) @@ -27,12 +27,12 @@ { private void Assign(Pl1Line pl1Line) { - CalcPoints.Clear(); + Points.Clear(); - foreach (Point2D point in pl1Line.CalcPoints) + foreach (Point2D point in pl1Line.Points) { Point2D newPoint = point.Clone(); - CalcPoints.Add(newPoint); + Points.Add(newPoint); } } Index: DamEngine/trunk/src/Deltares.DamEngine.TestHelpers/Factories/FactoryForDamProjectData.cs =================================================================== diff -u -r6216 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.TestHelpers/Factories/FactoryForDamProjectData.cs (.../FactoryForDamProjectData.cs) (revision 6216) +++ DamEngine/trunk/src/Deltares.DamEngine.TestHelpers/Factories/FactoryForDamProjectData.cs (.../FactoryForDamProjectData.cs) (revision 6245) @@ -567,18 +567,18 @@ layer.GeometrySurface = new GeometrySurface(); var outerLoop = new GeometryLoop(); - outerLoop.CalcPoints.Add(point1); - outerLoop.CalcPoints.Add(point2); - outerLoop.CalcPoints.Add(point3); + outerLoop.Points.Add(point1); + outerLoop.Points.Add(point2); + outerLoop.Points.Add(point3); outerLoop.CurveList.Add(curve1); outerLoop.CurveList.Add(curve2); outerLoop.CurveList.Add(curve3); layer.GeometrySurface.OuterLoop = outerLoop; profile.Geometry.Loops.Add(outerLoop); var innerloop = new GeometryLoop(); - innerloop.CalcPoints.Add(point4); - innerloop.CalcPoints.Add(point5); - innerloop.CalcPoints.Add(point6); + innerloop.Points.Add(point4); + innerloop.Points.Add(point5); + innerloop.Points.Add(point6); innerloop.CurveList.Add(curve4); innerloop.CurveList.Add(curve5); innerloop.CurveList.Add(curve6); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/SoilProfileValidatorTests.cs =================================================================== diff -u -r6103 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/SoilProfileValidatorTests.cs (.../SoilProfileValidatorTests.cs) (revision 6103) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/SoilProfileValidatorTests.cs (.../SoilProfileValidatorTests.cs) (revision 6245) @@ -93,7 +93,7 @@ { SurfaceLine = new SurfaceLine2() }; - soilProfileValidator.SurfaceLine.Geometry.CalcPoints.Add(new Point2D(0, 0)); + soilProfileValidator.SurfaceLine.Geometry.Points.Add(new Point2D(0, 0)); Assert.That(() => soilProfileValidator.ValidateSoilProfileForPlLinesCreator(), Throws.InstanceOf().With.Message.EqualTo @@ -552,7 +552,7 @@ List relevantSurfaces = soilProfile.Geometry.Surfaces.Where(s => s.InnerLoops.Count == 1).ToList(); Assert.That(relevantSurfaces, Has.Count.EqualTo(1)); Assert.That(relevantSurfaces[0].OuterLoop.CurveList, Has.Count.EqualTo(14)); - Assert.That(relevantSurfaces[0].InnerLoops[0].CalcPoints, Has.Count.EqualTo(3)); + Assert.That(relevantSurfaces[0].InnerLoops[0].Points, Has.Count.EqualTo(3)); Assert.That(relevantSurfaces[0].InnerLoops[0].CurveList, Has.Count.EqualTo(3)); Assert.That(soilProfile.Surfaces.Where(s => s.IsAquifer).ToList(), Has.Count.EqualTo(2)); }); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs (.../PlLinesToWaternetConverter.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/PlLinesToWaternetConverter.cs (.../PlLinesToWaternetConverter.cs) (revision 6245) @@ -184,8 +184,8 @@ internal static WaternetLine CreateWaternetLine(double level, double xLeft, double xRight) { var waternetLine = new WaternetLine(); - waternetLine.CalcPoints.Add(new Point2D(xLeft, level)); - waternetLine.CalcPoints.Add(new Point2D(xRight, level)); + waternetLine.Points.Add(new Point2D(xLeft, level)); + waternetLine.Points.Add(new Point2D(xRight, level)); return waternetLine; } @@ -239,7 +239,7 @@ foreach (GeometryPointString topLine in inBetweenAquiferUpperCoordinates.Where(topLine => IsLineEndingInPolderSide(topLine, surfaceLine))) { count += 1; - WaternetLine waternetLineTop = CreateWaternetLine(topLine.CalcPoints); + WaternetLine waternetLineTop = CreateWaternetLine(topLine.Points); waternetLineTop.HeadLine = headLine; waternetLineTop.Name = waternetLine4TopName + " (" + count + ")"; waternet.WaternetLineList.Add(waternetLineTop); @@ -249,7 +249,7 @@ foreach (GeometryPointString bottomLine in inBetweenAquiferLowerCoordinates.Where(bottomLine => IsLineEndingInPolderSide(bottomLine, surfaceLine))) { count += 1; - WaternetLine waternetLineBottom = CreateWaternetLine(bottomLine.CalcPoints); + WaternetLine waternetLineBottom = CreateWaternetLine(bottomLine.Points); waternetLineBottom.HeadLine = headLine; waternetLineBottom.Name = waternetLine4BottomName + " (" + count + ")"; waternet.WaternetLineList.Add(waternetLineBottom); @@ -265,7 +265,7 @@ } var line = new TLineType(); - line.CalcPoints.AddRange(plLine.Points); + line.Points.AddRange(plLine.Points); line.Name = name; return line; } @@ -276,12 +276,12 @@ foreach (Point2D coordinate in coordinates) { var point = new Point2D(coordinate.X, coordinate.Z + zOffSet); - line.CalcPoints.Add(point); + line.Points.Add(point); } - LineHelper.RemoveDuplicatedPoints(line.CalcPoints, toleranceAlmostEqual); + LineHelper.RemoveDuplicatedPoints(line.Points, toleranceAlmostEqual); line.RemoveUnnecessaryPoints(); - AvoidUpwardsVerticalLine(line.CalcPoints); + AvoidUpwardsVerticalLine(line.Points); return line; } @@ -309,7 +309,7 @@ { case IntrusionVerticalWaterPressureType.Linear: { - List coordinates = surfaceLine.Geometry.CalcPoints.Select(point => new Point2D(point.X, point.Z)).ToList(); + List coordinates = surfaceLine.Geometry.Points.Select(point => new Point2D(point.X, point.Z)).ToList(); return CreateWaternetLine(coordinates); } case IntrusionVerticalWaterPressureType.HydroStatic: @@ -373,7 +373,7 @@ } case IntrusionVerticalWaterPressureType.Linear: { - List xCoordinates = soilProfile2D.Geometry.SurfaceLine.CalcPoints.Select(point => new Point2D(point.X, point.Z)).ToList(); + List xCoordinates = soilProfile2D.Geometry.SurfaceLine.Points.Select(point => new Point2D(point.X, point.Z)).ToList(); return CreateWaternetLine(xCoordinates); } case IntrusionVerticalWaterPressureType.FullHydroStatic: @@ -407,12 +407,12 @@ { GeometryLoop outerLoop = surface.GeometrySurface.OuterLoop; // Add the first point to get a closed GeometryPointString - outerLoop.CalcPoints.Add(new Point2D(outerLoop.CalcPoints[0].X, outerLoop.CalcPoints[0].Z)); + outerLoop.Points.Add(new Point2D(outerLoop.Points[0].X, outerLoop.Points[0].Z)); var plLineInPoint2D = new GeometryPointString(); foreach (PlLinePoint point in plLine.Points) { - plLineInPoint2D.CalcPoints.Add(new Point2D(point.X, point.Z)); + plLineInPoint2D.Points.Add(new Point2D(point.X, point.Z)); } List intersectionPoints = outerLoop.IntersectionXzPointsWithGeometryString(plLineInPoint2D); @@ -431,7 +431,7 @@ // The waternet line is the polyline formed with the lowest lines connected to each other. List lines = DivideCurvesIntoLines(curves); - IEnumerable allPoints = curves.SelectMany(curve => curve.CalcPoints); + IEnumerable allPoints = curves.SelectMany(curve => curve.Points); double[] xCoordinates = allPoints.Select(point => point.X).OrderBy(x => x).Distinct().ToArray(); List splitLines = SplitLinesAtXCoordinates(xCoordinates, lines); for (var i = 0; i < xCoordinates.Length - 1; i++) @@ -445,20 +445,20 @@ List relevantLinesAtXWithZBeginMax = relevantLinesAtX.FindAll(line => Math.Abs(line.BeginPoint.Z - minZBegin) < toleranceAlmostEqual); double minZEnd = relevantLinesAtXWithZBeginMax.Select(line => line.EndPoint.Z).Min(); Line relevantLine = relevantLinesAtXWithZBeginMax.Find(line => Math.Abs(line.EndPoint.Z - minZEnd) < toleranceAlmostEqual); - waternetLine.CalcPoints.Add(new Point2D(relevantLine.BeginPoint.X, relevantLine.BeginPoint.Z)); - waternetLine.CalcPoints.Add(new Point2D(relevantLine.EndPoint.X, relevantLine.EndPoint.Z)); + waternetLine.Points.Add(new Point2D(relevantLine.BeginPoint.X, relevantLine.BeginPoint.Z)); + waternetLine.Points.Add(new Point2D(relevantLine.EndPoint.X, relevantLine.EndPoint.Z)); } // Make sure the waternet line for PL 1 is not in the bottom aquifer. - foreach (Point2D waternetLinePoint in waternetLine.CalcPoints) + foreach (Point2D waternetLinePoint in waternetLine.Points) { double bottomAquiferLevel = soilProfile2D.GetSoilProfile1D(waternetLinePoint.X).BottomAquiferLayer.TopLevel; waternetLinePoint.Z = Math.Max(waternetLinePoint.Z, bottomAquiferLevel); } - LineHelper.RemoveDuplicatedPoints(waternetLine.CalcPoints, toleranceAlmostEqual); + LineHelper.RemoveDuplicatedPoints(waternetLine.Points, toleranceAlmostEqual); waternetLine.RemoveUnnecessaryPoints(); - AvoidUpwardsVerticalLine(waternetLine.CalcPoints); + AvoidUpwardsVerticalLine(waternetLine.Points); return waternetLine; } @@ -490,8 +490,8 @@ { foreach (Point2D waternetLine1Point in from waternetLineOther in waternet.WaternetLineList.FindAll(w => w.Name != waternetLine1Name) - from waternetLine1Point in waternetLine1.CalcPoints - where waternetLineOther.CalcPoints.Any(point => Math.Abs(point.Z - waternetLine1Point.Z) < toleranceAlmostEqual) + from waternetLine1Point in waternetLine1.Points + where waternetLineOther.Points.Any(point => Math.Abs(point.Z - waternetLine1Point.Z) < toleranceAlmostEqual) select waternetLine1Point) { waternetLine1Point.Z += minimumDistance; @@ -541,7 +541,7 @@ private static List DivideCurvesIntoLines(List curves) { var lines = new List(); - foreach (IList points in curves.Select(curve => curve.CalcPoints)) + foreach (IList points in curves.Select(curve => curve.Points)) { for (var i = 0; i < points.Count - 1; i++) { @@ -584,6 +584,6 @@ private static bool IsLineEndingInPolderSide(GeometryPointString line, SurfaceLine2 surfaceLine) { Point2D dikeToeAtPolder = surfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); - return dikeToeAtPolder.X.IsLessThan(line.CalcPoints.Last().X, toleranceAlmostEqual); + return dikeToeAtPolder.X.IsLessThan(line.Points.Last().X, toleranceAlmostEqual); } } \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometrySurface.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometrySurface.cs (.../GeometrySurface.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometrySurface.cs (.../GeometrySurface.cs) (revision 6245) @@ -180,7 +180,7 @@ var topPoints = new GeometryPointString(); - int currentIndex = OuterLoop.CalcPoints.IndexOf(startTopPoint); + int currentIndex = OuterLoop.Points.IndexOf(startTopPoint); FillTopOrBottomPoints(topPoints, endTopPoint, currentIndex); @@ -205,30 +205,30 @@ var bottomPoints = new GeometryPointString(); - int currentIndex = OuterLoop.CalcPoints.IndexOf(endBottomPoint); + int currentIndex = OuterLoop.Points.IndexOf(endBottomPoint); FillTopOrBottomPoints(bottomPoints, startBottomPoint, currentIndex); // As the curves are sorted clockwise, the bottom curves are always orientated from right to left // while this result of this method must be from left to right so reverse the curves - bottomPoints.CalcPoints.Reverse(); + bottomPoints.Points.Reverse(); return bottomPoints; } private void FillTopOrBottomPoints(GeometryPointString linePoints, Point2D endPoint, int currentIndex) { - while (!linePoints.CalcPoints.Contains(endPoint)) + while (!linePoints.Points.Contains(endPoint)) { - linePoints.CalcPoints.Add(OuterLoop.CalcPoints[currentIndex++]); - if (currentIndex >= OuterLoop.CalcPoints.Count) + linePoints.Points.Add(OuterLoop.Points[currentIndex++]); + if (currentIndex >= OuterLoop.Points.Count) { currentIndex = 0; } } - for (var i = 0; i < linePoints.CalcPoints.Count; i++) + for (var i = 0; i < linePoints.Points.Count; i++) { - linePoints.CalcPoints[i] = new Point2D(linePoints.CalcPoints[i].X, linePoints.CalcPoints[i].Z); + linePoints.Points[i] = new Point2D(linePoints.Points[i].X, linePoints.Points[i].Z); } } } \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Data/General/Location.cs =================================================================== diff -u -r6216 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/General/Location.cs (.../Location.cs) (revision 6216) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/General/Location.cs (.../Location.cs) (revision 6245) @@ -462,13 +462,13 @@ /// The adapted surface line. public void AlignBoundaryPointsOfPl1LineWithAdaptedSurfaceLine(SurfaceLine2 adaptedSurfaceLine) { - if ((LocalXzpl1Line != null) && (LocalXzpl1Line.CalcPoints.Count > 1)) + if ((LocalXzpl1Line != null) && (LocalXzpl1Line.Points.Count > 1)) { - Point2D lastPointPl1Line = LocalXzpl1Line.CalcPoints.Last(); - Point2D lastPointSurfaceLine = adaptedSurfaceLine.Geometry.CalcPoints.Last(); + Point2D lastPointPl1Line = LocalXzpl1Line.Points.Last(); + Point2D lastPointSurfaceLine = adaptedSurfaceLine.Geometry.Points.Last(); lastPointPl1Line.X = lastPointSurfaceLine.X; - Point2D firstPointPl1Line = LocalXzpl1Line.CalcPoints.First(); - Point2D firstPointSurfaceLine = adaptedSurfaceLine.Geometry.CalcPoints.First(); + Point2D firstPointPl1Line = LocalXzpl1Line.Points.First(); + Point2D firstPointSurfaceLine = adaptedSurfaceLine.Geometry.Points.First(); firstPointPl1Line.X = firstPointSurfaceLine.X; } } Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIoTests.cs =================================================================== diff -u -r6086 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIoTests.cs (.../MacroStabilityIoTests.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIoTests.cs (.../MacroStabilityIoTests.cs) (revision 6245) @@ -209,7 +209,7 @@ var random = new Random(seed); for (var i = 0; i < 10; i++) { - geometry.CalcPoints.Add(new Point2D(random.NextDouble(), random.NextDouble())); + geometry.Points.Add(new Point2D(random.NextDouble(), random.NextDouble())); } } @@ -334,9 +334,9 @@ { Assert.That(actualHeadLine.Name, Is.EqualTo(expectedHeadLine.Name)); - List expectedCalcPoints = expectedHeadLine.CalcPoints; + List expectedCalcPoints = expectedHeadLine.Points; int expectedNrOfCalcPoints = expectedCalcPoints.Count; - List actualCalcPoints = actualHeadLine.CalcPoints; + List actualCalcPoints = actualHeadLine.Points; Assert.That(actualCalcPoints, Has.Count.EqualTo(expectedNrOfCalcPoints)); for (var i = 0; i < expectedNrOfCalcPoints; i++) { Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs =================================================================== diff -u -r6106 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs (.../SurfaceLine2.cs) (revision 6106) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs (.../SurfaceLine2.cs) (revision 6245) @@ -238,7 +238,7 @@ { get { - return Geometry.CalcPoints.OrderBy(p => p.X); + return Geometry.Points.OrderBy(p => p.X); } } @@ -355,10 +355,10 @@ var geometryAnnotations = new Dictionary(); for (var i = 0; i < source.Geometry.Count; i++) { - CharacteristicPointType[] annotationsForPoint = source.GetCharacteristicPoints(source.Geometry.CalcPoints[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.CalcPoints[i]] = annotationsForPoint; + geometryAnnotations[Geometry.Points[i]] = annotationsForPoint; } } Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryPointStringTests.cs =================================================================== diff -u -r4925 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryPointStringTests.cs (.../GeometryPointStringTests.cs) (revision 4925) +++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryPointStringTests.cs (.../GeometryPointStringTests.cs) (revision 6245) @@ -33,66 +33,66 @@ var geometryPointString = new GeometryPointString(); // The polyline contains only 3 identical points => expected 1 point - geometryPointString.CalcPoints.Add(new Point2D(2, 3)); - geometryPointString.CalcPoints.Add(new Point2D(2, 3)); - geometryPointString.CalcPoints.Add(new Point2D(2, 3)); + geometryPointString.Points.Add(new Point2D(2, 3)); + geometryPointString.Points.Add(new Point2D(2, 3)); + geometryPointString.Points.Add(new Point2D(2, 3)); geometryPointString.RemoveUnnecessaryPoints(); - Assert.That(geometryPointString.CalcPoints, Has.Count.EqualTo(1)); + Assert.That(geometryPointString.Points, Has.Count.EqualTo(1)); Assert.Multiple(() => { - Assert.That(geometryPointString.CalcPoints[0].X, Is.EqualTo(2)); - Assert.That(geometryPointString.CalcPoints[0].Z, Is.EqualTo(3)); + Assert.That(geometryPointString.Points[0].X, Is.EqualTo(2)); + Assert.That(geometryPointString.Points[0].Z, Is.EqualTo(3)); }); // The polyline contains 1 straight line with 3 points => expected 2 points - geometryPointString.CalcPoints.Clear(); - geometryPointString.CalcPoints.Add(new Point2D(2, 3)); - geometryPointString.CalcPoints.Add(new Point2D(3, 3)); - geometryPointString.CalcPoints.Add(new Point2D(4, 3)); + geometryPointString.Points.Clear(); + geometryPointString.Points.Add(new Point2D(2, 3)); + geometryPointString.Points.Add(new Point2D(3, 3)); + geometryPointString.Points.Add(new Point2D(4, 3)); geometryPointString.RemoveUnnecessaryPoints(); - Assert.That(geometryPointString.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(geometryPointString.Points, Has.Count.EqualTo(2)); Assert.Multiple(() => { - Assert.That(geometryPointString.CalcPoints[0].X, Is.EqualTo(2)); - Assert.That(geometryPointString.CalcPoints[0].Z, Is.EqualTo(3)); - Assert.That(geometryPointString.CalcPoints[1].X, Is.EqualTo(4)); - Assert.That(geometryPointString.CalcPoints[1].Z, Is.EqualTo(3)); + Assert.That(geometryPointString.Points[0].X, Is.EqualTo(2)); + Assert.That(geometryPointString.Points[0].Z, Is.EqualTo(3)); + Assert.That(geometryPointString.Points[1].X, Is.EqualTo(4)); + Assert.That(geometryPointString.Points[1].Z, Is.EqualTo(3)); }); // The polyline contains 1 straight line with 5 points => expected 2 points - geometryPointString.CalcPoints.Clear(); - geometryPointString.CalcPoints.Add(new Point2D(2, 3)); - geometryPointString.CalcPoints.Add(new Point2D(3, 3)); - geometryPointString.CalcPoints.Add(new Point2D(4, 3)); - geometryPointString.CalcPoints.Add(new Point2D(5, 3)); - geometryPointString.CalcPoints.Add(new Point2D(6, 3)); + geometryPointString.Points.Clear(); + geometryPointString.Points.Add(new Point2D(2, 3)); + geometryPointString.Points.Add(new Point2D(3, 3)); + geometryPointString.Points.Add(new Point2D(4, 3)); + geometryPointString.Points.Add(new Point2D(5, 3)); + geometryPointString.Points.Add(new Point2D(6, 3)); geometryPointString.RemoveUnnecessaryPoints(); - Assert.That(geometryPointString.CalcPoints, Has.Count.EqualTo(2)); + Assert.That(geometryPointString.Points, Has.Count.EqualTo(2)); Assert.Multiple(() => { - Assert.That(geometryPointString.CalcPoints[0].X, Is.EqualTo(2)); - Assert.That(geometryPointString.CalcPoints[0].Z, Is.EqualTo(3)); - Assert.That(geometryPointString.CalcPoints[1].X, Is.EqualTo(6)); - Assert.That(geometryPointString.CalcPoints[1].Z, Is.EqualTo(3)); + Assert.That(geometryPointString.Points[0].X, Is.EqualTo(2)); + Assert.That(geometryPointString.Points[0].Z, Is.EqualTo(3)); + Assert.That(geometryPointString.Points[1].X, Is.EqualTo(6)); + Assert.That(geometryPointString.Points[1].Z, Is.EqualTo(3)); }); // The polyline contains 2 straight lines with 5 points => expected 3 points - geometryPointString.CalcPoints.Clear(); - geometryPointString.CalcPoints.Add(new Point2D(2, 3)); - geometryPointString.CalcPoints.Add(new Point2D(3, 4)); - geometryPointString.CalcPoints.Add(new Point2D(4, 5)); - geometryPointString.CalcPoints.Add(new Point2D(5, 4)); - geometryPointString.CalcPoints.Add(new Point2D(6, 3)); + geometryPointString.Points.Clear(); + geometryPointString.Points.Add(new Point2D(2, 3)); + geometryPointString.Points.Add(new Point2D(3, 4)); + geometryPointString.Points.Add(new Point2D(4, 5)); + geometryPointString.Points.Add(new Point2D(5, 4)); + geometryPointString.Points.Add(new Point2D(6, 3)); geometryPointString.RemoveUnnecessaryPoints(); - Assert.That(geometryPointString.CalcPoints, Has.Count.EqualTo(3)); + Assert.That(geometryPointString.Points, Has.Count.EqualTo(3)); Assert.Multiple(() => { - Assert.That(geometryPointString.CalcPoints[0].X, Is.EqualTo(2)); - Assert.That(geometryPointString.CalcPoints[0].Z, Is.EqualTo(3)); - Assert.That(geometryPointString.CalcPoints[1].X, Is.EqualTo(4)); - Assert.That(geometryPointString.CalcPoints[1].Z, Is.EqualTo(5)); - Assert.That(geometryPointString.CalcPoints[2].X, Is.EqualTo(6)); - Assert.That(geometryPointString.CalcPoints[2].Z, Is.EqualTo(3)); + Assert.That(geometryPointString.Points[0].X, Is.EqualTo(2)); + Assert.That(geometryPointString.Points[0].Z, Is.EqualTo(3)); + Assert.That(geometryPointString.Points[1].X, Is.EqualTo(4)); + Assert.That(geometryPointString.Points[1].Z, Is.EqualTo(5)); + Assert.That(geometryPointString.Points[2].X, Is.EqualTo(6)); + Assert.That(geometryPointString.Points[2].Z, Is.EqualTo(3)); }); } } \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Common/SoilProfile2DHelper.cs =================================================================== diff -u -r6126 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Common/SoilProfile2DHelper.cs (.../SoilProfile2DHelper.cs) (revision 6126) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Common/SoilProfile2DHelper.cs (.../SoilProfile2DHelper.cs) (revision 6245) @@ -254,9 +254,9 @@ foreach (GeometrySurface surface in soilProfile.Geometry.Surfaces) { var polygon = new GeometryLoop(); - foreach (Point2D point in surface.OuterLoop.CalcPoints) + foreach (Point2D point in surface.OuterLoop.Points) { - polygon.CalcPoints.Add(point); + polygon.Points.Add(point); } if (Routines2D.CheckIfPointIsInPolygon(polygon, xCoord, zCoord) == PointInPolygon.OutsidePolygon) @@ -366,10 +366,10 @@ { if (connectionType == PolyLineConnectionType.SamePoint) { - return currentPolyLine.CalcPoints.Last().LocationEquals(nextPolyLine.CalcPoints.First()); + return currentPolyLine.Points.Last().LocationEquals(nextPolyLine.Points.First()); } - bool isPolyLineUnique = polyLines.FindAll(p => p.CalcPoints.First().X.IsNearEqual(nextPolyLine.CalcPoints.First().X, toleranceAlmostEqual)).Count == 1; - return currentPolyLine.CalcPoints.Last().X.IsNearEqual(nextPolyLine.CalcPoints.First().X, toleranceAlmostEqual) && isPolyLineUnique; + bool isPolyLineUnique = polyLines.FindAll(p => p.Points.First().X.IsNearEqual(nextPolyLine.Points.First().X, toleranceAlmostEqual)).Count == 1; + return currentPolyLine.Points.Last().X.IsNearEqual(nextPolyLine.Points.First().X, toleranceAlmostEqual) && isPolyLineUnique; } @@ -393,7 +393,7 @@ continue; var currentPolyLine = new GeometryPointString(); - currentPolyLine.CalcPoints.AddRange(polyLine.CalcPoints); + currentPolyLine.Points.AddRange(polyLine.Points); usedPolyLines.Add(polyLine); bool isConnectionFound; @@ -418,7 +418,7 @@ if (CanPolyLinesBeConnected(connectionType, currentPolyLine, nextPolyLine, polyLines)) { - currentPolyLine.CalcPoints.AddRange(connectionType == PolyLineConnectionType.SamePoint ? nextPolyLine.CalcPoints.Skip(1) : nextPolyLine.CalcPoints); + currentPolyLine.Points.AddRange(connectionType == PolyLineConnectionType.SamePoint ? nextPolyLine.Points.Skip(1) : nextPolyLine.Points); usedPolyLines.Add(nextPolyLine); isConnectionFound = true; break; @@ -435,7 +435,7 @@ /// All the xCoordinates of the soil profile 2D. private static double[] DetermineAllXCoordinatesOfSoilProfile(SoilProfile2D soilProfile) { - IEnumerable points = soilProfile.Surfaces.SelectMany(surf => surf.GeometrySurface.OuterLoop.CalcPoints); + IEnumerable points = soilProfile.Surfaces.SelectMany(surf => surf.GeometrySurface.OuterLoop.Points); double[] xCoordinates = points.Select(point => point.X).OrderBy(x => x).Distinct().ToArray(); return xCoordinates; } Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryDataTests.cs =================================================================== diff -u -r6086 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryDataTests.cs (.../GeometryDataTests.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryDataTests.cs (.../GeometryDataTests.cs) (revision 6245) @@ -82,19 +82,19 @@ { GeometryData gData = CreateGeometrySurface2(); GeometryPointString line = gData.SurfaceLine; - Assert.That(line.CalcPoints.Count, Is.EqualTo(3)); - Assert.That(line.CalcPoints.OrderBy(p => p.X).First().X, Is.EqualTo(1.0)); - Assert.That(line.CalcPoints.OrderByDescending(p => p.X).First().X, Is.EqualTo(10.0)); + Assert.That(line.Points.Count, Is.EqualTo(3)); + Assert.That(line.Points.OrderBy(p => p.X).First().X, Is.EqualTo(1.0)); + Assert.That(line.Points.OrderByDescending(p => p.X).First().X, Is.EqualTo(10.0)); } [Test] public void GeometryDataTestSurfaceTwoHorLayers() { GeometryData gData = CreateGeometrySurface(); GeometryPointString line = gData.SurfaceLine; - Assert.That(line.CalcPoints.Count, Is.EqualTo(2)); - Assert.That(line.CalcPoints.OrderBy(p => p.X).First().X, Is.EqualTo(1.0)); - Assert.That(line.CalcPoints.OrderByDescending(p => p.X).First().X, Is.EqualTo(10.0)); + Assert.That(line.Points.Count, Is.EqualTo(2)); + Assert.That(line.Points.OrderBy(p => p.X).First().X, Is.EqualTo(1.0)); + Assert.That(line.Points.OrderByDescending(p => p.X).First().X, Is.EqualTo(10.0)); } [Test] @@ -187,7 +187,7 @@ Assert.That(geom.Surfaces[0].InnerLoops.Count, Is.EqualTo(0)); Assert.That(geom.Surfaces[0].OuterLoop.Count, Is.EqualTo(4)); Assert.That(geom.Surfaces[0].OuterLoop.CurveList.Count, Is.EqualTo(4)); - Assert.That(geom.Surfaces[0].OuterLoop.CalcPoints.Count, Is.EqualTo(4)); + Assert.That(geom.Surfaces[0].OuterLoop.Points.Count, Is.EqualTo(4)); Assert.That(geom.Surfaces[0].OuterLoop.HasArea(), Is.True); Assert.That(geom.Surfaces[0].OuterLoop.IsLoop(), Is.True); Assert.That(geom.Surfaces[0].OuterLoop.IsPointInLoopArea(new Point2D(25, 3)), Is.True); Index: DamEngine/trunk/src/Deltares.DamEngine.Data/GeometryExport/GeometryExporterHelper.cs =================================================================== diff -u -r5387 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/GeometryExport/GeometryExporterHelper.cs (.../GeometryExporterHelper.cs) (revision 5387) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/GeometryExport/GeometryExporterHelper.cs (.../GeometryExporterHelper.cs) (revision 6245) @@ -79,7 +79,7 @@ } return new PersistableSurfaceLine { - Points = surfaceLine.CalcPoints.Select(point => new PersistablePoint() + Points = surfaceLine.Points.Select(point => new PersistablePoint() { X = point.X, Z = point.Z Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftLocationDeterminator.cs =================================================================== diff -u -r6157 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftLocationDeterminator.cs (.../UpliftLocationDeterminator.cs) (revision 6157) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftLocationDeterminator.cs (.../UpliftLocationDeterminator.cs) (revision 6245) @@ -70,7 +70,7 @@ Point2D startSurfacePoint = SurfaceLine.GetDikeToeInward(); - IEnumerable relevantSurfacePointsList = from Point2D point in SurfaceLine.Geometry.CalcPoints + IEnumerable relevantSurfacePointsList = from Point2D point in SurfaceLine.Geometry.Points where point.X >= startSurfacePoint.X orderby point.X select point; @@ -183,7 +183,7 @@ ThrowIfNoSoilProfileDefined(); Point2D startSurfacePoint = SurfaceLine.GetDikeToeInward(); - IEnumerable relevantSurfacePointsList = from Point2D point in SurfaceLine.Geometry.CalcPoints + IEnumerable relevantSurfacePointsList = from Point2D point in SurfaceLine.Geometry.Points where point.X >= startSurfacePoint.X orderby point.X select point; Index: DamEngine/trunk/src/Deltares.DamEngine.TestHelpers/Factories/FactoryForSoilProfiles.cs =================================================================== diff -u -r6229 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.TestHelpers/Factories/FactoryForSoilProfiles.cs (.../FactoryForSoilProfiles.cs) (revision 6229) +++ DamEngine/trunk/src/Deltares.DamEngine.TestHelpers/Factories/FactoryForSoilProfiles.cs (.../FactoryForSoilProfiles.cs) (revision 6245) @@ -921,7 +921,7 @@ public static SurfaceLine2 CreateSurfaceLine(IEnumerable coordinates) { var surfaceLine = new SurfaceLine2(); - surfaceLine.Geometry.CalcPoints.AddRange(coordinates); + surfaceLine.Geometry.Points.AddRange(coordinates); return surfaceLine; } @@ -1481,9 +1481,9 @@ /// public static SurfaceLine2 CreateSurfaceLineForSoilProfile2D(SoilProfile2D soilProfile2D, PositionToSoilProfile2D positionToSoilProfile2D) { - Point2D geometryPoint = soilProfile2D.Geometry.SurfaceLine.CalcPoints.First(); + Point2D geometryPoint = soilProfile2D.Geometry.SurfaceLine.Points.First(); var leftPoint = new Point2D(geometryPoint.X, geometryPoint.Z); - geometryPoint = soilProfile2D.Geometry.SurfaceLine.CalcPoints.Last(); + geometryPoint = soilProfile2D.Geometry.SurfaceLine.Points.Last(); var rightPoint = new Point2D(geometryPoint.X, geometryPoint.Z); var middlePoint = new Point2D((leftPoint.X + rightPoint.X) / 2, (leftPoint.Z + rightPoint.Z) / 2); switch (positionToSoilProfile2D) Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PlLinesCreator.cs =================================================================== diff -u -r6157 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PlLinesCreator.cs (.../PlLinesCreator.cs) (revision 6157) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PlLinesCreator.cs (.../PlLinesCreator.cs) (revision 6245) @@ -331,8 +331,8 @@ } var plLine = new PlLine(); - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.First().X, headInPlLine2.Value)); - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.Last().X, headInPlLine2.Value)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.First().X, headInPlLine2.Value)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.Last().X, headInPlLine2.Value)); return plLine; } @@ -372,8 +372,8 @@ if (separationLevel <= infiltrationLayers.First().TopLevel) { - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.First().X, headInPlLine2.Value)); - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.Last().X, headInPlLine2.Value)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.First().X, headInPlLine2.Value)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.Last().X, headInPlLine2.Value)); } } } @@ -416,7 +416,7 @@ { double referenceLevel = HeadInPlLine2 ?? WaterLevelPolder; double headAtPolderDikeToe = headValue - Math.Max(0, dampingFactor * (headValue - referenceLevel)); - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.First().X, headValue)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.First().X, headValue)); plLine.Points.Add(new PlLinePoint(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtRiver).X, headValue)); if (IsSurfaceLineIntersectedByAquiferAtPolder(plLineType, out Point2D intersectionAquifer)) @@ -476,30 +476,30 @@ if (plLine.Points.Last().Z <= WaterLevelPolder) { // the PL line is already at WaterLevelPolder, so countinue it horizontally - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.Last().X, WaterLevelPolder)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.Last().X, WaterLevelPolder)); } else { - double lengthFromLastPlPointToEnd = Math.Abs(SurfaceLine.Geometry.CalcPoints.Last().X - plLine.Points.Last().X); + double lengthFromLastPlPointToEnd = Math.Abs(SurfaceLine.Geometry.Points.Last().X - plLine.Points.Last().X); double headAtLastPlPoint = plLine.Points.Last().Z; double headAtEnd = plLine.Points.Last().Z - slopeGradient * lengthFromLastPlPointToEnd; var waterLevelPolderLine = - new Line(new Point2D(SurfaceLine.Geometry.CalcPoints.First().X, WaterLevelPolder), - new Point2D(SurfaceLine.Geometry.CalcPoints.Last().X, WaterLevelPolder)); + new Line(new Point2D(SurfaceLine.Geometry.Points.First().X, WaterLevelPolder), + new Point2D(SurfaceLine.Geometry.Points.Last().X, WaterLevelPolder)); var slopeLine = new Line( new Point2D(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder).X, headAtLastPlPoint), - new Point2D(SurfaceLine.Geometry.CalcPoints.Last().X, headAtEnd)); + new Point2D(SurfaceLine.Geometry.Points.Last().X, headAtEnd)); if (waterLevelPolderLine.IntersectsZ(slopeLine, out Point2D intersectionPoint)) { plLine.Points.Add(new PlLinePoint(intersectionPoint.X, WaterLevelPolder)); - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.Last().X, WaterLevelPolder)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.Last().X, WaterLevelPolder)); } else { - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.Last().X, headAtEnd)); + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.Last().X, headAtEnd)); } } } @@ -723,7 +723,7 @@ } // 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 - IEnumerable relevantSurfacePointsList = from Point2D point in SurfaceLine.Geometry.CalcPoints + IEnumerable relevantSurfacePointsList = from Point2D point in SurfaceLine.Geometry.Points where point.X >= startSurfacePoint.X orderby point.X select point; @@ -792,7 +792,7 @@ { Point2D startPoint = SurfaceLine.GetDikeToeInward(); Point2D endPoint = SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DitchPolderSide); - IEnumerable recheckSurfacePointsList = from Point2D point in SurfaceLine.Geometry.CalcPoints + IEnumerable recheckSurfacePointsList = from Point2D point in SurfaceLine.Geometry.Points where point.X >= startPoint.X && point.X <= endPoint.X orderby point.X select point; @@ -909,7 +909,7 @@ void CopyPointsInPlLine(ref PlLine plLine, GeometryPointString genericLine) { plLine.Points.Clear(); - foreach (Point2D point in genericLine.CalcPoints) + foreach (Point2D point in genericLine.Points) { plLine.Points.Add(new PlLinePoint(point.X, point.Z)); } @@ -930,7 +930,7 @@ if (location != null) { bool isPl1LineDefinedForLocation = location.LocalXzpl1Line != null && - location.LocalXzpl1Line.CalcPoints.Count > 1; + location.LocalXzpl1Line.Points.Count > 1; if ((plLineType == PlLineType.Pl1) && isPl1LineDefinedForLocation) { PlLine plLine = plLines.Lines[plLineType]; @@ -1068,15 +1068,15 @@ else { // No intersection with dike; polder is flooded - leftMostXAtRiverLevel = SurfaceLine.Geometry.CalcPoints.Last().X; - plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints.Last().X, gaugeWaterLevelRiver.Value)); + leftMostXAtRiverLevel = SurfaceLine.Geometry.Points.Last().X; + plLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points.Last().X, gaugeWaterLevelRiver.Value)); } } } else { // In this case no intersection for this PlLine with the dike will be considered - leftMostXAtRiverLevel = SurfaceLine.Geometry.CalcPoints.First().X; + leftMostXAtRiverLevel = SurfaceLine.Geometry.Points.First().X; } } @@ -1085,8 +1085,8 @@ if (plLine.Points.Any()) { - plLine.Points.First().X = SurfaceLine.Geometry.CalcPoints.First().X; - plLine.Points.Last().X = SurfaceLine.Geometry.CalcPoints.Last().X; + plLine.Points.First().X = SurfaceLine.Geometry.Points.First().X; + plLine.Points.Last().X = SurfaceLine.Geometry.Points.Last().X; } return plLine; @@ -1119,7 +1119,7 @@ intersectionHighWaterLevelWithDike.Z - cPlLineOffsetBelowSurface); //Add points below surface of dike talud riverside - foreach (Point2D point in SurfaceLine.Geometry.CalcPoints.Where( + foreach (Point2D point in SurfaceLine.Geometry.Points.Where( point => point.X > intersectionLowWaterLevelWithDike.X && point.X < intersectionHighWaterLevelWithDike.X)) { @@ -1132,7 +1132,7 @@ break; case PlLineCreationMethod.ExpertKnowledgeRRD: //Add points below surface of dike talud riverside until toe of dike riverside - foreach (Point2D point in SurfaceLine.Geometry.CalcPoints.Where( + foreach (Point2D point in SurfaceLine.Geometry.Points.Where( point => point.X > intersectionLowWaterLevelWithDike.X && point.X <= pointDikeToeAtRiver.X)) { @@ -1242,7 +1242,7 @@ PlLinePoint intersectionPolderLevelWithDike = DetermineIntersectionBetweenPolderLevelAndDike(WaterLevelPolder); Point2D dikeToeAtPolderPoint = SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); - double maxXCoordinateSurface = SurfaceLine.Geometry.CalcPoints.Max(x => x.X); + double maxXCoordinateSurface = SurfaceLine.Geometry.Points.Max(x => x.X); if (ModelParametersForPlLines.PlLineCreationMethod != PlLineCreationMethod.ExpertKnowledgeLinearInDike) { // Points created below are points starting at shoulder point to the right @@ -1311,7 +1311,7 @@ // if there is a ditch, then adjust it. if (isDitchPresent) { - int surfacePointIndex = SurfaceLine.Geometry.CalcPoints.IndexOf(ditchDikeSidePoint); + int surfacePointIndex = SurfaceLine.Geometry.Points.IndexOf(ditchDikeSidePoint); AdjustForDitchAtPolderSide(phreaticLine, surfacePointIndex); } else @@ -1355,19 +1355,19 @@ { // Add phreatic point at offset below every surface line point as long as depth > polder level. Else determine the // proper position of the point at polder level (intersection) and stop. - int surfacePointIndex = SurfaceLine.Geometry.CalcPoints.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder)) + 1; + int surfacePointIndex = SurfaceLine.Geometry.Points.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder)) + 1; var intersected = false; - for (int i = surfacePointIndex; i < SurfaceLine.Geometry.CalcPoints.Count; i++) + for (int i = surfacePointIndex; i < SurfaceLine.Geometry.Points.Count; i++) { - double z = Math.Max(WaterLevelPolder, SurfaceLine.Geometry.CalcPoints[i].Z - PlLineOffsetBelowDikeToeAtPolder); - double x = SurfaceLine.Geometry.CalcPoints[i].X; - if (WaterLevelPolder > SurfaceLine.Geometry.CalcPoints[i].Z - PlLineOffsetBelowDikeToeAtPolder) + double z = Math.Max(WaterLevelPolder, SurfaceLine.Geometry.Points[i].Z - PlLineOffsetBelowDikeToeAtPolder); + double x = SurfaceLine.Geometry.Points[i].X; + if (WaterLevelPolder > SurfaceLine.Geometry.Points[i].Z - PlLineOffsetBelowDikeToeAtPolder) { // Determine intersection between would be phreatic segment and polderlevel. Add that as next point. - var waterLevelPolderLine = new Line(new Point2D(SurfaceLine.Geometry.CalcPoints.First().X, WaterLevelPolder), - new Point2D(SurfaceLine.Geometry.CalcPoints.Last().X, WaterLevelPolder)); + var waterLevelPolderLine = new Line(new Point2D(SurfaceLine.Geometry.Points.First().X, WaterLevelPolder), + new Point2D(SurfaceLine.Geometry.Points.Last().X, WaterLevelPolder)); var slopeLine = new Line(new Point2D(phreaticLine.Points[phreaticLine.Points.Count - 1].X, phreaticLine.Points[phreaticLine.Points.Count - 1].Z), - new Point2D(SurfaceLine.Geometry.CalcPoints[i].X, SurfaceLine.Geometry.CalcPoints[i].Z - PlLineOffsetBelowDikeToeAtPolder)); + new Point2D(SurfaceLine.Geometry.Points[i].X, SurfaceLine.Geometry.Points[i].Z - PlLineOffsetBelowDikeToeAtPolder)); Point2D intersectionPoint; if (waterLevelPolderLine.IntersectsZ(slopeLine, out intersectionPoint)) { @@ -1409,12 +1409,12 @@ Point2D pointDitchPolder = SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DitchPolderSide); if (pointDitchPolder != null) { - int indexatDitchPolder = SurfaceLine.Geometry.CalcPoints.IndexOf(pointDitchPolder); + int indexatDitchPolder = SurfaceLine.Geometry.Points.IndexOf(pointDitchPolder); var lineDitchPolderSide = new Line(); if (indexatDitchPolder > 1) { - lineDitchPolderSide.SetBeginAndEndPoints(new Point2D(SurfaceLine.Geometry.CalcPoints[indexatDitchPolder - 1].X, SurfaceLine.Geometry.CalcPoints[indexatDitchPolder - 1].Z), - new Point2D(SurfaceLine.Geometry.CalcPoints[indexatDitchPolder].X, SurfaceLine.Geometry.CalcPoints[indexatDitchPolder].Z)); + lineDitchPolderSide.SetBeginAndEndPoints(new Point2D(SurfaceLine.Geometry.Points[indexatDitchPolder - 1].X, SurfaceLine.Geometry.Points[indexatDitchPolder - 1].Z), + new Point2D(SurfaceLine.Geometry.Points[indexatDitchPolder].X, SurfaceLine.Geometry.Points[indexatDitchPolder].Z)); var intersectDitchPolderPhreatic = new Point2D(); if (LineHelper.DetermineStrictIntersectionPoint(lineDitchPolderSide, phreaticPolderPartialLine, ref intersectDitchPolderPhreatic)) @@ -1443,11 +1443,11 @@ /// private void AddIntersectionDitchDikeSegmentPolderLevelToPhreatic(PlLine phreaticLine, int surfacePointIndex, Line phreaticPolderPartialLine) { - if (surfacePointIndex + 1 < SurfaceLine.Geometry.CalcPoints.Count) + if (surfacePointIndex + 1 < SurfaceLine.Geometry.Points.Count) { var lineDitchDikeSide = new Line(); - lineDitchDikeSide.SetBeginAndEndPoints(new Point2D(SurfaceLine.Geometry.CalcPoints[surfacePointIndex].X, SurfaceLine.Geometry.CalcPoints[surfacePointIndex].Z), - new Point2D(SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].X, SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].Z)); + lineDitchDikeSide.SetBeginAndEndPoints(new Point2D(SurfaceLine.Geometry.Points[surfacePointIndex].X, SurfaceLine.Geometry.Points[surfacePointIndex].Z), + new Point2D(SurfaceLine.Geometry.Points[surfacePointIndex + 1].X, SurfaceLine.Geometry.Points[surfacePointIndex + 1].Z)); var intersectDitchDikePhreatic = new Point2D(); if (LineHelper.DetermineStrictIntersectionPoint(lineDitchDikeSide, phreaticPolderPartialLine, ref intersectDitchDikePhreatic)) @@ -1456,7 +1456,7 @@ } else { - phreaticLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.CalcPoints[surfacePointIndex].X, phreaticPolderPartialLine.EndPoint.Z)); + phreaticLine.Points.Add(new PlLinePoint(SurfaceLine.Geometry.Points[surfacePointIndex].X, phreaticPolderPartialLine.EndPoint.Z)); } } else @@ -1468,22 +1468,22 @@ private PlLinePoint DetermineIntersectionBetweenPolderLevelAndDike(double polderLevel) { var polderlevelLine = new Line(); - double startXCoordinate = SurfaceLine.Geometry.CalcPoints.OrderBy(p => p.X).First().X; + double startXCoordinate = SurfaceLine.Geometry.Points.OrderBy(p => p.X).First().X; Point2D pointEndOfprofile = SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.SurfaceLevelInside); polderlevelLine.SetBeginAndEndPoints(new Point2D(startXCoordinate, polderLevel), new Point2D(pointEndOfprofile.X, polderLevel)); ThrowWhenWaterLevelAboveDike(polderLevel, SurfaceLine); // Find intersection between dike top (riverside because that is taken as default DTH) and dike toe (polder side) with polder level. // Start at dike toe and work your way back to dike top. - int startPosition = SurfaceLine.Geometry.CalcPoints.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder)); - int endPosition = SurfaceLine.Geometry.CalcPoints.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver)); + int startPosition = SurfaceLine.Geometry.Points.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder)); + int endPosition = SurfaceLine.Geometry.Points.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver)); for (int surfacePointIndex = startPosition; surfacePointIndex > endPosition; surfacePointIndex--) { var surfaceLineSegment = new Line(); - surfaceLineSegment.SetBeginAndEndPoints(new Point2D(SurfaceLine.Geometry.CalcPoints[surfacePointIndex - 1].X, - SurfaceLine.Geometry.CalcPoints[surfacePointIndex - 1].Z), new Point2D(SurfaceLine.Geometry.CalcPoints[surfacePointIndex].X, - SurfaceLine.Geometry.CalcPoints[surfacePointIndex].Z)); + surfaceLineSegment.SetBeginAndEndPoints(new Point2D(SurfaceLine.Geometry.Points[surfacePointIndex - 1].X, + SurfaceLine.Geometry.Points[surfacePointIndex - 1].Z), new Point2D(SurfaceLine.Geometry.Points[surfacePointIndex].X, + SurfaceLine.Geometry.Points[surfacePointIndex].Z)); var intersectPoint = new Point2D(); if (LineHelper.DetermineStrictIntersectionPoint(surfaceLineSegment, polderlevelLine, ref intersectPoint)) { @@ -1503,12 +1503,12 @@ /// private void ValidatePhreaticBelowDike(PlLine phreaticLine) { - int startIndex = SurfaceLine.Geometry.CalcPoints.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver)); - int stopIndex = SurfaceLine.Geometry.CalcPoints.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder)); + int startIndex = SurfaceLine.Geometry.Points.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver)); + int stopIndex = SurfaceLine.Geometry.Points.IndexOf(SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder)); var stopIteration = false; // This code can go into an endless loop // Enter failsave to raise exception when this occurs - int cMaxIterations = Math.Max(100, phreaticLine.Points.Count * SurfaceLine.Geometry.CalcPoints.Count); + int cMaxIterations = Math.Max(100, phreaticLine.Points.Count * SurfaceLine.Geometry.Points.Count); var iterationCount = 0; while (!stopIteration) { @@ -1524,8 +1524,8 @@ { var surfaceLineSegment = new Line(); surfaceLineSegment.SetBeginAndEndPoints( - new Point2D(SurfaceLine.Geometry.CalcPoints[surfacePointIndex].X, SurfaceLine.Geometry.CalcPoints[surfacePointIndex].Z), - new Point2D(SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].X, SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].Z)); + new Point2D(SurfaceLine.Geometry.Points[surfacePointIndex].X, SurfaceLine.Geometry.Points[surfacePointIndex].Z), + new Point2D(SurfaceLine.Geometry.Points[surfacePointIndex + 1].X, SurfaceLine.Geometry.Points[surfacePointIndex + 1].Z)); var intersectGeoPoint = new Point2D(); var intersectPoint = new Point2D(); if (LineHelper.DetermineStrictIntersectionPoint(phreaticLineSegment, surfaceLineSegment, ref intersectGeoPoint)) @@ -1546,19 +1546,19 @@ if (newPlLinePoint.X > phreaticLineSegment.BeginPoint.X) { phreaticLine.Points.Insert(phreaticPointIndex + 1, newPlLinePoint); - if (SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].X.IsNearEqual(intersectPoint.X)) + 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 phreaticLine.Points[phreaticPointIndex + 2] = - new PlLinePoint(SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].X, - SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].Z - + new PlLinePoint(SurfaceLine.Geometry.Points[surfacePointIndex + 1].X, + SurfaceLine.Geometry.Points[surfacePointIndex + 1].Z - cOffsetPhreaticLineBelowSurface); } else { var newNextPlLinePoint = - new PlLinePoint(SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].X, - SurfaceLine.Geometry.CalcPoints[surfacePointIndex + 1].Z - + new PlLinePoint(SurfaceLine.Geometry.Points[surfacePointIndex + 1].X, + SurfaceLine.Geometry.Points[surfacePointIndex + 1].Z - cOffsetPhreaticLineBelowSurface); if (newNextPlLinePoint.X <= phreaticLine.Points[phreaticPointIndex + 2].X) { @@ -1607,7 +1607,7 @@ ThrowWhenWaterLevelPolderAboveDikeTopAtPolder(); //Create Phreatic line and add polderwater level - double startXCoordinate = SurfaceLine.Geometry.CalcPoints.OrderBy(p => p.X).First().X; + double startXCoordinate = SurfaceLine.Geometry.Points.OrderBy(p => p.X).First().X; var phreaticLine = new PlLine(); phreaticLine.IsPhreatic = true; @@ -1743,7 +1743,7 @@ SoilLayer1D aquifer = GetRelevantAquiferLayer(plLineType, relevantSoilProfile); if (aquifer != null) { - int indexStartSearch = SurfaceLine.Geometry.CalcPoints.FindIndex(p => p.X.IsNearEqual(xStartSearch, toleranceAlmostEquals)); + int indexStartSearch = SurfaceLine.Geometry.Points.FindIndex(p => p.X.IsNearEqual(xStartSearch, toleranceAlmostEquals)); double xIntersection = SurfaceLine.Geometry.GetXatZStartingAt(indexStartSearch, aquifer.TopLevel); if (!double.IsNaN(xIntersection)) { @@ -1776,10 +1776,10 @@ intersectionDitchPl1 = new Point2D(); bool isPl1AboveAquifer = CurrentPl1Line.Points.Last().Z.IsGreaterThanOrEqualTo(intersectionDitchAquifer.Z, toleranceAlmostEquals); Point2D dikeToeAtPolder = SurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); - double xStart = SurfaceLine.Geometry.CalcPoints.First(p => p.X.IsGreaterThanOrEqualTo(intersectionDitchAquifer.X, toleranceAlmostEquals)).X; - int indexStart = SurfaceLine.Geometry.CalcPoints.FindIndex(p => p.X.AlmostEquals(xStart, toleranceAlmostEquals)) - 1; - int indexDikeToeAtPolder = SurfaceLine.Geometry.CalcPoints.FindIndex(p => p.X.AlmostEquals(dikeToeAtPolder.X, toleranceAlmostEquals)); - int indexEnd = isPl1AboveAquifer ? indexDikeToeAtPolder : SurfaceLine.Geometry.CalcPoints.Count - 1; + double xStart = SurfaceLine.Geometry.Points.First(p => p.X.IsGreaterThanOrEqualTo(intersectionDitchAquifer.X, toleranceAlmostEquals)).X; + int indexStart = SurfaceLine.Geometry.Points.FindIndex(p => p.X.AlmostEquals(xStart, toleranceAlmostEquals)) - 1; + int indexDikeToeAtPolder = SurfaceLine.Geometry.Points.FindIndex(p => p.X.AlmostEquals(dikeToeAtPolder.X, toleranceAlmostEquals)); + int indexEnd = isPl1AboveAquifer ? indexDikeToeAtPolder : SurfaceLine.Geometry.Points.Count - 1; if ((isPl1AboveAquifer && indexStart < indexEnd) || (!isPl1AboveAquifer && indexStart > indexEnd)) { @@ -1789,8 +1789,8 @@ int index = indexStart; while (index != indexEnd) { - Point2D currentPoint = SurfaceLine.Geometry.CalcPoints[index]; - Point2D nextPoint = SurfaceLine.Geometry.CalcPoints[index + 1]; + Point2D currentPoint = SurfaceLine.Geometry.Points[index]; + Point2D nextPoint = SurfaceLine.Geometry.Points[index + 1]; var surfaceLineSegment = new Line(); surfaceLineSegment.SetBeginAndEndPoints(new Point2D(currentPoint.X, currentPoint.Z), new Point2D(nextPoint.X, nextPoint.Z)); var phreaticPolderPartialLine = new Line(); Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Validator.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Validator.cs (.../SurfaceLine2Validator.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Validator.cs (.../SurfaceLine2Validator.cs) (revision 6245) @@ -94,7 +94,7 @@ /// public static bool AreAllPointsXCoordinatesAscending(SurfaceLine2 line) { - return AreGeometryPointsXCoordinatesAscending(line.Geometry.CalcPoints); + return AreGeometryPointsXCoordinatesAscending(line.Geometry.Points); } /// @@ -135,7 +135,7 @@ private bool ArePointsAscending(SurfaceLine2 line) { - return AreGeometryPointsXCoordinatesAscending(line.Geometry.CalcPoints); + return AreGeometryPointsXCoordinatesAscending(line.Geometry.Points); } private static bool AreGeometryPointsXCoordinatesAscending(IList characteristicPoints) Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineShoulderAdapterTest.cs =================================================================== diff -u -r6086 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineShoulderAdapterTest.cs (.../SurfaceLineShoulderAdapterTest.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineShoulderAdapterTest.cs (.../SurfaceLineShoulderAdapterTest.cs) (revision 6245) @@ -643,15 +643,15 @@ double xSurfaceLevelInside = adaptedSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.SurfaceLevelInside).X; IEnumerable actualExtraPoints = adaptedSurfaceLine.GetPointSegmentIncluding(xToePolder, xSurfaceLevelInside); const int expectedNumberOfPoints = 9; - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(expectedNumberOfPoints)); + Assert.That(adaptedSurfaceLine.Geometry.Points.Count, Is.EqualTo(expectedNumberOfPoints)); const int expectedNumberOfExtraPoints = 3; Assert.That(actualExtraPoints.Count(), Is.EqualTo(expectedNumberOfExtraPoints)); Point2D actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.SurfaceLevelInside); double actualXValue = pointAtSurfaceLevelInside.X; Assert.That(actualPoint.X, Is.EqualTo(actualXValue).Within(pointCoordinateTolerance)); Assert.That(actualPoint.Z, Is.EqualTo(pointAtSurfaceLevelInside.Z).Within(pointCoordinateTolerance)); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Any(p => p.LocationEquals(extraPoint2)), Is.True); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Any(p => p.LocationEquals(extraPoint1)), Is.False); + Assert.That(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint2)), Is.True); + Assert.That(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint1)), Is.False); } [Test] @@ -681,8 +681,8 @@ Assert.That(surfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.ShoulderTopInside), Is.Null); var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0); SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(7)); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(8)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(7)); + Assert.That(adaptedSurfaceLine.Geometry.Points.Count, Is.EqualTo(8)); EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); } @@ -715,8 +715,8 @@ SlopeOfNewShoulder = 2 }; SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(12)); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(12)); + Assert.That(adaptedSurfaceLine.Geometry.Points.Count, Is.EqualTo(9)); EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); } @@ -852,8 +852,8 @@ var expectedDitchPolderSide = new Point2D(14.5, 0); actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DitchPolderSide); Assert.That(expectedDitchPolderSide.LocationEquals(actualPoint), Is.True); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(12)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9)); + Assert.That(adaptedSurfaceLine.Geometry.Points.Count, Is.EqualTo(12)); } [Test] @@ -950,8 +950,8 @@ var expectedDitchPolderSide = new Point2D(14.5, 0); actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DitchPolderSide); Assert.That(expectedDitchPolderSide.LocationEquals(actualPoint), Is.True); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(12)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9)); + Assert.That(adaptedSurfaceLine.Geometry.Points.Count, Is.EqualTo(12)); } [Test] @@ -1042,8 +1042,8 @@ var expectedDikeToePolder = new Point2D(6.5, 0); actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedDikeToePolder.LocationEquals(actualPoint), Is.True); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(10)); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(11)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(10)); + Assert.That(adaptedSurfaceLine.Geometry.Points.Count, Is.EqualTo(11)); } [Test] @@ -1152,8 +1152,8 @@ var expectedDitchPolderSide = new Point2D(18.5, 0); actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DitchPolderSide); Assert.That(expectedDitchPolderSide.LocationEquals(actualPoint), Is.True); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(11)); - Assert.That(adaptedSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(11)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(11)); + Assert.That(adaptedSurfaceLine.Geometry.Points.Count, Is.EqualTo(11)); } [Test] @@ -1242,7 +1242,7 @@ surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null); surfaceLine.EnsurePointOfType(apoint3.X, apoint3.Z, null); surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(12)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(12)); var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0) { SlopeOfNewShoulder = 2 Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryHelper.cs =================================================================== diff -u -r5564 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryHelper.cs (.../GeometryHelper.cs) (revision 5564) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryHelper.cs (.../GeometryHelper.cs) (revision 6245) @@ -249,7 +249,7 @@ List surfacesLeftOfLimits = new List(); foreach (GeometrySurface surface in geometry.Surfaces) { - foreach (Point2D point in (IEnumerable) surface.OuterLoop.CalcPoints) + foreach (Point2D point in (IEnumerable) surface.OuterLoop.Points) { if (point.X < atX - GeometryConstants.Tolerance) { @@ -266,7 +266,7 @@ List surfacesRightOfLimits = new List(); foreach (GeometrySurface surface in geometry.Surfaces) { - foreach (Point2D point in (IEnumerable) surface.OuterLoop.CalcPoints) + foreach (Point2D point in (IEnumerable) surface.OuterLoop.Points) { if (point.X > atX + GeometryConstants.Tolerance) { Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilProfile2DSurfaceLineHelper.cs =================================================================== diff -u -r6165 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilProfile2DSurfaceLineHelper.cs (.../SoilProfile2DSurfaceLineHelper.cs) (revision 6165) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilProfile2DSurfaceLineHelper.cs (.../SoilProfile2DSurfaceLineHelper.cs) (revision 6245) @@ -74,7 +74,7 @@ { if (soilProfile2D == null || soilProfile2D.Surfaces.Count == 0) return null; - if (surfaceLine == null || surfaceLine.CalcPoints.Count == 0) + if (surfaceLine == null || surfaceLine.Points.Count == 0) return null; SoilProfile2D clonedProfile = soilProfile2D.Clone(); @@ -111,7 +111,7 @@ public static bool IsSurfaceLineAboveBottomSoilProfile2D(SurfaceLine2 surfaceLine, SoilProfile2D soilProfile2D) { double bottom = soilProfile2D.Geometry.Bottom; - foreach (Point2D point in surfaceLine.Geometry.CalcPoints) + foreach (Point2D point in surfaceLine.Geometry.Points) { if (point.Z < bottom) { @@ -154,7 +154,7 @@ } resultGeometry.Rebox(); - if (surfaceLine == null || surfaceLine.CalcPoints.Count <= 2) + if (surfaceLine == null || surfaceLine.Points.Count <= 2) { return null; } @@ -200,7 +200,7 @@ { geometryData.NewlyEffectedCurves.Clear(); geometryData.NewlyEffectedPoints.Clear(); - IList points = surfaceLine.CalcPoints; + IList points = surfaceLine.Points; GeometryData geometry = geometryData; Point2D currentPoint1 = points[0].Clone(); var existingPoint1 = geometry.GetPointAtLocation(currentPoint1); @@ -268,7 +268,7 @@ private static void RemoveGeometryDataAboveSurfaceLine(GeometryPointString surfaceLine, ref GeometryData result) { - if (surfaceLine == null || surfaceLine.CalcPoints.Count <= 1) + if (surfaceLine == null || surfaceLine.Points.Count <= 1) return; foreach (GeometrySurface geometrySurface in result.Surfaces.ToArray()) { @@ -352,7 +352,7 @@ return false; } - return layer.GeometrySurface.OuterLoop.CalcPoints.All(point => !point.Z.IsLessThan(surfaceLine.GetZatX(point.X))); + return layer.GeometrySurface.OuterLoop.Points.All(point => !point.Z.IsLessThan(surfaceLine.GetZatX(point.X))); } private static void ReconstructPreConsolidations(ref SoilProfile2D result, SoilProfile2D clonedProfile) @@ -365,8 +365,8 @@ private static SoilLayer2D DetermineLayerIfSurfaceIsLeftOrRightOfOldSurfaces(GeometrySurface surface, List oldSurfaces) { - double[] xMin = surface.OuterLoop.CalcPoints.Select(p => p.X).OrderBy(x => x).Distinct().ToArray(); - double[] zMin = surface.OuterLoop.CalcPoints.Select(p => p.Z).OrderBy(z => z).Distinct().ToArray(); + double[] xMin = surface.OuterLoop.Points.Select(p => p.X).OrderBy(x => x).Distinct().ToArray(); + double[] zMin = surface.OuterLoop.Points.Select(p => p.Z).OrderBy(z => z).Distinct().ToArray(); var leftPoint = new Point2D { X = xMin[0] - 0.1, Index: DamEngine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs =================================================================== diff -u -r6231 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs (.../FillXmlInputFromDam.cs) (revision 6231) +++ DamEngine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs (.../FillXmlInputFromDam.cs) (revision 6245) @@ -726,27 +726,27 @@ }; GeometryLoop loop = layer.GeometrySurface.OuterLoop; - inputLayer.Surface.OuterLoop = new SoilProfile2DLayer2DSurfaceOuterPoint[loop.CalcPoints.Count]; - for (var j = 0; j < loop.CalcPoints.Count; j++) + inputLayer.Surface.OuterLoop = new SoilProfile2DLayer2DSurfaceOuterPoint[loop.Points.Count]; + for (var j = 0; j < loop.Points.Count; j++) { var point = new SoilProfile2DLayer2DSurfaceOuterPoint { - X = loop.CalcPoints[j].X, - Z = loop.CalcPoints[j].Z + X = loop.Points[j].X, + Z = loop.Points[j].Z }; inputLayer.Surface.OuterLoop[j] = point; } GeometryLoop innerloop = layer.GeometrySurface.InnerLoops.FirstOrDefault(); if (innerloop != null) { - inputLayer.Surface.Innerloop = new SoilProfile2DLayer2DSurfaceInnerPoint[innerloop.CalcPoints.Count]; - for (var j = 0; j < innerloop.CalcPoints.Count; j++) + inputLayer.Surface.Innerloop = new SoilProfile2DLayer2DSurfaceInnerPoint[innerloop.Points.Count]; + for (var j = 0; j < innerloop.Points.Count; j++) { var point = new SoilProfile2DLayer2DSurfaceInnerPoint { - X = innerloop.CalcPoints[j].X, - Z = innerloop.CalcPoints[j].Z + X = innerloop.Points[j].X, + Z = innerloop.Points[j].Z }; inputLayer.Surface.Innerloop[j] = point; } Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs (.../GeometryPointString.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs (.../GeometryPointString.cs) (revision 6245) @@ -81,9 +81,9 @@ private const double epsilon = GeometryConstants.Accuracy; /// - /// The calculate points as protected field (to be able to prevent recursive calls to CalcPoints) + /// The calculate points as protected field (to be able to prevent recursive calls to Points) /// - protected List calcPoints = new List(); + protected List points = new List(); /// /// Gets the at the specified index. @@ -98,18 +98,18 @@ { get { - return calcPoints[index]; + return points[index]; } } /// /// The calculate points (to be used in calculation instead of Points for better performance) /// - public virtual List CalcPoints + public virtual List Points { get { - return calcPoints; + return points; } } @@ -123,7 +123,7 @@ { get { - return calcPoints.Count; + return points.Count; } } @@ -135,10 +135,10 @@ { var clone = new GeometryPointString(); this.CloneProperties(clone); // excludes the points ! - clone.CalcPoints.Clear(); - foreach (Point2D point in CalcPoints) + clone.Points.Clear(); + foreach (Point2D point in Points) { - clone.CalcPoints.Add(new Point2D(point.X, point.Z)); + clone.Points.Add(new Point2D(point.X, point.Z)); } return clone; } @@ -148,7 +148,7 @@ /// public void RoundPointsCoordinates(double accuracy) { - foreach (Point2D point in CalcPoints) + foreach (Point2D point in Points) { point.X = RoundValue(point.X, accuracy); point.Z = RoundValue(point.Z, accuracy); @@ -157,53 +157,53 @@ /// /// Gets the minimum z. - /// Note: CalcPoints must be used instead of calcPoints as otherwise unclear behaviour of Linq spoils the result - /// Change back to calcPoints and Benchmark4_01l in the WaternetCreatorTests will fail! + /// Note: Points must be used instead of points as otherwise unclear behaviour of Linq spoils the result + /// Change back to points and Benchmark4_01l in the WaternetCreatorTests will fail! /// /// public double GetMinZ() { - return CalcPoints.Any() - ? CalcPoints.Min(p => p.Z) + return Points.Any() + ? Points.Min(p => p.Z) : double.NaN; } /// /// Gets the maximum z. - /// Note: CalcPoints must be used instead of calcPoints as otherwise unclear behaviour of Linq spoils the result - /// Change back to calcPoints and Benchmark4_01l in the WaternetCreatorTests will fail! + /// Note: Points must be used instead of points as otherwise unclear behaviour of Linq spoils the result + /// Change back to points and Benchmark4_01l in the WaternetCreatorTests will fail! /// /// public double GetMaxZ() { - return CalcPoints.Any() - ? CalcPoints.Max(p => p.Z) + return Points.Any() + ? Points.Max(p => p.Z) : double.NaN; } /// - /// The minimal X value among . - /// Note: CalcPoints must be used instead of calcPoints as otherwise unclear behaviour of Linq spoils the result - /// Change back to calcPoints and Benchmark4_01l in the WaternetCreatorTests will fail! + /// The minimal X value among . + /// Note: Points must be used instead of points as otherwise unclear behaviour of Linq spoils the result + /// Change back to points and Benchmark4_01l in the WaternetCreatorTests will fail! /// /// The minimal X value or in case there are no points. public double GetMinX() { - return CalcPoints.Any(p => !double.IsNaN(p.X)) - ? CalcPoints.Where(p => !double.IsNaN(p.X)).Min(p => p.X) + return Points.Any(p => !double.IsNaN(p.X)) + ? Points.Where(p => !double.IsNaN(p.X)).Min(p => p.X) : double.NaN; } /// /// Gets the maximum x. - /// Note: CalcPoints must be used instead of calcPoints as otherwise unclear behaviour of Linq spoils the result - /// Change back to calcPoints and Benchmark4_01l in the WaternetCreatorTests will fail! + /// Note: Points must be used instead of points as otherwise unclear behaviour of Linq spoils the result + /// Change back to points and Benchmark4_01l in the WaternetCreatorTests will fail! /// /// public double GetMaxX() { - return CalcPoints.Any(p => !double.IsNaN(p.X)) - ? CalcPoints.Where(p => !double.IsNaN(p.X)).Max(p => p.X) + return Points.Any(p => !double.IsNaN(p.X)) + ? Points.Where(p => !double.IsNaN(p.X)).Max(p => p.X) : double.NaN; } @@ -213,15 +213,15 @@ /// /// X coordinate /// - /// The z value determined by or - /// when is empty. + /// The z value determined by or + /// when is empty. /// /// /// Uses constant extrapolation and linear interpolation. /// public double GetZAtUnsortedX(double x) { - if (calcPoints.Count > 0) + if (points.Count > 0) { var verticalLineAtX = new Line(new Point2D { @@ -261,15 +261,15 @@ /// /// X coordinate /// - /// The z value determined by or - /// when is empty. + /// The z value determined by or + /// when is empty. /// /// /// Uses constant extrapolation and linear interpolation. /// public double GetZatX(double x) { - if (calcPoints.Any()) + if (points.Any()) { double zAtX; if (DoConstantExtrapolationXz(x, out zAtX)) @@ -278,10 +278,10 @@ } } - for (var i = 0; i < calcPoints.Count - 1; i++) + for (var i = 0; i < points.Count - 1; i++) { - Point2D current = calcPoints[i]; - Point2D next = calcPoints[i + 1]; + Point2D current = points[i]; + Point2D next = points[i + 1]; double leftOffset = x - current.X; double rightOffset = next.X - x; @@ -334,17 +334,17 @@ /// Finds the first intersection of the line with a given horizontal line. /// /// Start considering instances from - /// starting from this index. + /// starting from this index. /// The height level of the horizontal line. /// Optional: Discard intersections whose X value is less than or equal to this value. /// The first intersection point matching the criteria. /// public double GetXatZStartingAt(int start, double z, double xMin = double.MinValue) { - for (int i = start; i < calcPoints.Count - 1; i++) + for (int i = start; i < points.Count - 1; i++) { - Point2D current = calcPoints[i]; - Point2D next = calcPoints[i + 1]; + Point2D current = points[i]; + Point2D next = points[i + 1]; if (IsSegmentNotCrossingZ(z, current, next)) // Performance micro-optimization { @@ -368,7 +368,7 @@ /// public IEnumerable DeterminePointsAtX(double x) { - return from Point2D point in calcPoints + return from Point2D point in points where point.X.AlmostEquals(x, GeometryPoint.Precision) select point; } @@ -381,7 +381,7 @@ /// public Point2D DeterminePointAt(double x, double z) { - return calcPoints.FirstOrDefault( + return points.FirstOrDefault( point => point.X.AlmostEquals(x, GeometryPoint.Precision) && point.Z.AlmostEquals(z, GeometryPoint.Precision)); } @@ -434,27 +434,27 @@ /// public List IntersectionXzPointsWithGeometryString(GeometryPointString externalSurface) { - return IntersectionXzPointsWithGeometryPointList(externalSurface.CalcPoints); + return IntersectionXzPointsWithGeometryPointList(externalSurface.Points); } /// /// Sorts the points by x ascending (only to be used for Surface lines). /// public virtual void SortPointsByXAscending() { - calcPoints.Sort(); + points.Sort(); } /// /// Removes all double points at a location, if consecutive /// private void CondensePoints() { - for (int i = calcPoints.Count - 1; i > 0; i--) + for (int i = points.Count - 1; i > 0; i--) { - if (calcPoints[i].LocationEquals(calcPoints[i - 1])) + if (points[i].LocationEquals(points[i - 1])) { - calcPoints.RemoveAt(i); + points.RemoveAt(i); } } } @@ -468,15 +468,15 @@ CondensePoints(); - for (int i = calcPoints.Count - 2; i > 0; i--) + for (int i = points.Count - 2; i > 0; i--) { // if the slope of the line before the point is equal to the slope after the point, the point can be removed - double slopeBefore = (calcPoints[i].Z - calcPoints[i - 1].Z) / (calcPoints[i].X - calcPoints[i - 1].X); - double slopeAfter = (calcPoints[i + 1].Z - calcPoints[i].Z) / (calcPoints[i + 1].X - calcPoints[i].X); + double slopeBefore = (points[i].Z - points[i - 1].Z) / (points[i].X - points[i - 1].X); + double slopeAfter = (points[i + 1].Z - points[i].Z) / (points[i + 1].X - points[i].X); if (Routines2D.AreEqual(slopeBefore, slopeAfter, slopeTolerance)) { - calcPoints.RemoveAt(i); + points.RemoveAt(i); } } } @@ -500,7 +500,7 @@ /// public RelativeXzPosition GetPosition(GeometryLoop geometryLoop, ExtraPolationMode extraPolationMode = ExtraPolationMode.Beyond) { - foreach (Point2D point in geometryLoop.CalcPoints.Concat(DetermineLoopSegmentMiddlePoints(geometryLoop))) + foreach (Point2D point in geometryLoop.Points.Concat(DetermineLoopSegmentMiddlePoints(geometryLoop))) { RelativeXzPosition position = PositionXzOfPointRelatedToExtrapolatedLine(point, extraPolationMode); if (position == RelativeXzPosition.BeyondGeometricLine) @@ -523,10 +523,10 @@ /// public override GeometryBounds GetGeometryBounds() { - GeometryBounds bounds = CalcPoints[0].GetGeometryBounds(); - for (var i = 1; i < CalcPoints.Count; i++) + GeometryBounds bounds = Points[0].GetGeometryBounds(); + for (var i = 1; i < Points.Count; i++) { - Point2D point = CalcPoints[i]; + Point2D point = Points[i]; bounds.Left = Math.Min(bounds.Left, point.X); bounds.Right = Math.Max(bounds.Right, point.X); @@ -542,9 +542,9 @@ IList intersectionPointsWithLine = IntersectionPointsXzWithLineXz(line); // close the poly line - if (calcPoints.Count > 0) + if (points.Count > 0) { - DoIntersectAndAddToCollection(line, calcPoints[calcPoints.Count - 1], calcPoints[0], + DoIntersectAndAddToCollection(line, points[points.Count - 1], points[0], intersectionPointsWithLine, false); } @@ -559,7 +559,7 @@ private bool IsPointConsideredBeyondLine(Point2D point, ExtraPolationMode extraPolationMode) { - if (CalcPoints.Count == 0) + if (Points.Count == 0) { return true; } @@ -569,7 +569,7 @@ private bool IsPointOutsideRangeX(Point2D point) { - return point.X < CalcPoints[0].X || point.X > CalcPoints[checked(CalcPoints.Count - 1)].X; + return point.X < Points[0].X || point.X > Points[checked(Points.Count - 1)].X; } private RelativeXzPosition DeterminePositionWithRespectToExtrapolatedLine(Point2D point, @@ -590,13 +590,13 @@ double x = point.X; if (extraPolationMode == ExtraPolationMode.Horizontal) { - if (x < CalcPoints[0].X) + if (x < Points[0].X) { - x = CalcPoints[0].X; + x = Points[0].X; } - else if (x > CalcPoints[checked(CalcPoints.Count - 1)].X) + else if (x > Points[checked(Points.Count - 1)].X) { - x = CalcPoints[checked(CalcPoints.Count - 1)].X; + x = Points[checked(Points.Count - 1)].X; } } @@ -607,19 +607,19 @@ { var loopSegmentMiddlePoints = new List(); var index = 0; - while (index < checked(geometryLoop.CalcPoints.Count - 1)) + while (index < checked(geometryLoop.Points.Count - 1)) { - AddLoopSegmentMiddlePoint(geometryLoop.CalcPoints[index], geometryLoop.CalcPoints[checked(index + 1)], loopSegmentMiddlePoints); + AddLoopSegmentMiddlePoint(geometryLoop.Points[index], geometryLoop.Points[checked(index + 1)], loopSegmentMiddlePoints); checked { ++index; } } - if (geometryLoop.CalcPoints.Count > 2) + if (geometryLoop.Points.Count > 2) { - int last = geometryLoop.CalcPoints.Count - 1; - AddLoopSegmentMiddlePoint(geometryLoop.CalcPoints[0], geometryLoop.CalcPoints[last], loopSegmentMiddlePoints); + int last = geometryLoop.Points.Count - 1; + AddLoopSegmentMiddlePoint(geometryLoop.Points[0], geometryLoop.Points[last], loopSegmentMiddlePoints); } return loopSegmentMiddlePoints; @@ -646,16 +646,16 @@ /// True if extrapolation possible; false otherwise. private bool DoConstantExtrapolationXz(double x, out double z) { - if (calcPoints.Count > 0) + if (points.Count > 0) { - Point2D first = calcPoints[0]; + Point2D first = points[0]; if (x < first.X || Math.Abs(x - first.X) < epsilon) { z = first.Z; return true; } - Point2D last = calcPoints[calcPoints.Count - 1]; + Point2D last = points[points.Count - 1]; if (x > last.X) { z = last.Z; @@ -680,31 +680,31 @@ { var result = new List(); - if (calcPoints.Count == 1 && Math.Abs(calcPoints[0].X - x) < epsilon) + if (points.Count == 1 && Math.Abs(points[0].X - x) < epsilon) { - result.Add(calcPoints[0].Z); + result.Add(points[0].Z); return result; } - int pointsCount = calcPoints.Count - 1; + int pointsCount = points.Count - 1; if (asSurface) { - pointsCount = calcPoints.Count; + pointsCount = points.Count; } for (var i = 0; i < pointsCount; i++) { Point2D current; Point2D next; - if (i == calcPoints.Count - 1) + if (i == points.Count - 1) { - current = calcPoints[i]; - next = calcPoints[0]; + current = points[i]; + next = points[0]; } else { - current = calcPoints[i]; - next = calcPoints[i + 1]; + current = points[i]; + next = points[i + 1]; } double leftOffset = x - current.X; @@ -782,9 +782,9 @@ { var intersectionPointsWithLine = new List(); - for (var pointIndex = 0; pointIndex < calcPoints.Count - 1; pointIndex++) + for (var pointIndex = 0; pointIndex < points.Count - 1; pointIndex++) { - DoIntersectAndAddToCollection(line, calcPoints[pointIndex], calcPoints[pointIndex + 1], + DoIntersectAndAddToCollection(line, points[pointIndex], points[pointIndex + 1], intersectionPointsWithLine, allowDuplicates); } Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/LayerDetector.cs =================================================================== diff -u -r5251 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/LayerDetector.cs (.../LayerDetector.cs) (revision 5251) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/LayerDetector.cs (.../LayerDetector.cs) (revision 6245) @@ -84,7 +84,7 @@ { var tel = 0; var curve = new GeometryCurve(); - foreach (Point2D loopCalcPoint in loop.CalcPoints) + foreach (Point2D loopCalcPoint in loop.Points) { if (tel == 0) //(tel % 2 == 0) { Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityCommonHelperTests.cs =================================================================== diff -u -r6086 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityCommonHelperTests.cs (.../MacroStabilityCommonHelperTests.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityCommonHelperTests.cs (.../MacroStabilityCommonHelperTests.cs) (revision 6245) @@ -51,10 +51,10 @@ Assert.That(geometry.Left, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(geometry.Right, Is.EqualTo(75.0).Within(cTolerance)); Assert.That(geometry.Bottom, Is.EqualTo(-20.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().X, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().Z, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().X, Is.EqualTo(75.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().X, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().X, Is.EqualTo(75.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); }); } @@ -75,10 +75,10 @@ Assert.That(geometry.Left, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(geometry.Right, Is.EqualTo(75.0).Within(cTolerance)); Assert.That(geometry.Bottom, Is.EqualTo(-20.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().X, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().Z, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().X, Is.EqualTo(75.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().X, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().X, Is.EqualTo(75.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); }); } @@ -103,10 +103,10 @@ Assert.That(geometry.Left, Is.EqualTo(5.0).Within(cTolerance)); Assert.That(geometry.Right, Is.EqualTo(75.0).Within(cTolerance)); Assert.That(geometry.Bottom, Is.EqualTo(-20.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().X, Is.EqualTo(5.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().Z, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().X, Is.EqualTo(75.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().X, Is.EqualTo(5.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().X, Is.EqualTo(75.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); }); } @@ -156,10 +156,10 @@ Assert.That(geometry.Left, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(geometry.Right, Is.EqualTo(70.0).Within(cTolerance)); Assert.That(geometry.Bottom, Is.EqualTo(-20.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().X, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.First().Z, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().X, Is.EqualTo(70.0).Within(cTolerance)); - Assert.That(geometry.SurfaceLine.CalcPoints.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().X, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.First().Z, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().X, Is.EqualTo(70.0).Within(cTolerance)); + Assert.That(geometry.SurfaceLine.Points.Last().Z, Is.EqualTo(0.0).Within(cTolerance)); }); } Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SoilProfile2DSurfaceLineHelperTests.cs =================================================================== diff -u -r6230 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SoilProfile2DSurfaceLineHelperTests.cs (.../SoilProfile2DSurfaceLineHelperTests.cs) (revision 6230) +++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SoilProfile2DSurfaceLineHelperTests.cs (.../SoilProfile2DSurfaceLineHelperTests.cs) (revision 6245) @@ -164,9 +164,9 @@ private static SurfaceLine2 CreateSurfaceLineForSoilProfile2D(SoilProfile2D soilProfile2D, PositionToSoilProfile2D positionToSoilProfile2D) { - Point2D geometryPoint = soilProfile2D.Geometry.SurfaceLine.CalcPoints.First(); + Point2D geometryPoint = soilProfile2D.Geometry.SurfaceLine.Points.First(); var leftPoint = new Point2D(geometryPoint.X, geometryPoint.Z); - geometryPoint = soilProfile2D.Geometry.SurfaceLine.CalcPoints.Last(); + geometryPoint = soilProfile2D.Geometry.SurfaceLine.Points.Last(); var rightPoint = new Point2D(geometryPoint.X, geometryPoint.Z); var middlePoint = new Point2D((leftPoint.X + rightPoint.X) / 2, (leftPoint.Z + rightPoint.Z) / 2); switch (positionToSoilProfile2D) @@ -207,8 +207,8 @@ int indexLayer = -1; // Find a point within the expected soil layer - double[] xMin = expectedSoilLayer.GeometrySurface.OuterLoop.CalcPoints.Select(p => p.X).OrderBy(x => x).Distinct().ToArray(); - double[] zMin = expectedSoilLayer.GeometrySurface.OuterLoop.CalcPoints.Select(p => p.Z).OrderBy(z => z).Distinct().ToArray(); + double[] xMin = expectedSoilLayer.GeometrySurface.OuterLoop.Points.Select(p => p.X).OrderBy(x => x).Distinct().ToArray(); + double[] zMin = expectedSoilLayer.GeometrySurface.OuterLoop.Points.Select(p => p.Z).OrderBy(z => z).Distinct().ToArray(); var gravityPoint = new Point2D { X = xMin[0] + 2, @@ -229,24 +229,24 @@ Assert.Multiple(() => { Assert.That(soilProfile2D.Surfaces[indexLayer].SoilName, Is.EqualTo(expectedSoilLayer.SoilName)); - Assert.That(soilProfile2D.Geometry.Surfaces[indexLayer].OuterLoop.CalcPoints, Has.Count.EqualTo(expectedSoilLayer.GeometrySurface.OuterLoop.CalcPoints.Count)); + Assert.That(soilProfile2D.Geometry.Surfaces[indexLayer].OuterLoop.Points, Has.Count.EqualTo(expectedSoilLayer.GeometrySurface.OuterLoop.Points.Count)); Assert.That(soilProfile2D.Geometry.Surfaces[indexLayer].OuterLoop.CurveList, Has.Count.EqualTo(expectedSoilLayer.GeometrySurface.OuterLoop.CurveList.Count)); - Assert.That(soilProfile2D.Surfaces[indexLayer].GeometrySurface.OuterLoop.CalcPoints, Has.Count.EqualTo(expectedSoilLayer.GeometrySurface.OuterLoop.CalcPoints.Count)); + Assert.That(soilProfile2D.Surfaces[indexLayer].GeometrySurface.OuterLoop.Points, Has.Count.EqualTo(expectedSoilLayer.GeometrySurface.OuterLoop.Points.Count)); Assert.That(soilProfile2D.Surfaces[indexLayer].GeometrySurface.OuterLoop.CurveList, Has.Count.EqualTo(expectedSoilLayer.GeometrySurface.OuterLoop.CurveList.Count)); }); foreach (GeometryCurve curve in expectedSoilLayer.GeometrySurface.OuterLoop.CurveList) { Assert.That(IsCurvePresentInSoilLayer(soilProfile2D.Surfaces[indexLayer], curve), Is.True); } - foreach (Point2D point in expectedSoilLayer.GeometrySurface.OuterLoop.CalcPoints) + foreach (Point2D point in expectedSoilLayer.GeometrySurface.OuterLoop.Points) { Assert.That(IsPointPresentInSoilLayer(soilProfile2D.Surfaces[indexLayer], point), Is.True); } } private static bool IsPointPresentInSoilLayer(SoilLayer2D soilLayer, Point2D point) { - return soilLayer.GeometrySurface.OuterLoop.CalcPoints.Any(p => p.X.IsNearEqual(point.X) && p.Z.IsNearEqual(point.Z)); + return soilLayer.GeometrySurface.OuterLoop.Points.Any(p => p.X.IsNearEqual(point.X) && p.Z.IsNearEqual(point.Z)); } private static bool IsCurvePresentInSoilLayer(SoilLayer2D soilLayer, GeometryCurve curve) @@ -350,25 +350,25 @@ if (testCaseSurfaceLine.TestNumber == 6) { Assert.That(newSoilProfile2D, Is.Not.Null); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints, Has.Count.EqualTo(8)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points, Has.Count.EqualTo(8)); Assert.Multiple(() => { - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[0].X, Is.EqualTo(10)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[0].Z, Is.EqualTo(10)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[1].X, Is.EqualTo(30)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[1].Z, Is.EqualTo(12)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[2].X, Is.EqualTo(50)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[2].Z, Is.EqualTo(10)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[3].X, Is.EqualTo(60)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[3].Z, Is.EqualTo(9)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[4].X, Is.EqualTo(70)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[4].Z, Is.EqualTo(8)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[5].X, Is.EqualTo(90)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[5].Z, Is.EqualTo(10)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[6].X, Is.EqualTo(110)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[6].Z, Is.EqualTo(12)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[7].X, Is.EqualTo(130)); - Assert.That(newSoilProfile2D.Geometry.SurfaceLine.CalcPoints[7].Z, Is.EqualTo(10)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[0].X, Is.EqualTo(10)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[0].Z, Is.EqualTo(10)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[1].X, Is.EqualTo(30)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[1].Z, Is.EqualTo(12)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[2].X, Is.EqualTo(50)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[2].Z, Is.EqualTo(10)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[3].X, Is.EqualTo(60)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[3].Z, Is.EqualTo(9)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[4].X, Is.EqualTo(70)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[4].Z, Is.EqualTo(8)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[5].X, Is.EqualTo(90)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[5].Z, Is.EqualTo(10)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[6].X, Is.EqualTo(110)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[6].Z, Is.EqualTo(12)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[7].X, Is.EqualTo(130)); + Assert.That(newSoilProfile2D.Geometry.SurfaceLine.Points[7].Z, Is.EqualTo(10)); }); } } Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/Common/SoilProfile2DHelperTests.cs =================================================================== diff -u -r6086 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/Common/SoilProfile2DHelperTests.cs (.../SoilProfile2DHelperTests.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/Common/SoilProfile2DHelperTests.cs (.../SoilProfile2DHelperTests.cs) (revision 6245) @@ -217,8 +217,8 @@ new(leftCoordinate, -22), new(rightCoordinate, -22) ]; - AssertGeometry(topLevelInBetweenAquifer[0].CalcPoints, expectedTop); - AssertGeometry(bottomLevelInBetweenAquifer[0].CalcPoints, expectedBottom); + AssertGeometry(topLevelInBetweenAquifer[0].Points, expectedTop); + AssertGeometry(bottomLevelInBetweenAquifer[0].Points, expectedBottom); } /// @@ -278,8 +278,8 @@ new(leftCoordinate, -20), new(rightCoordinate, -20) ]; - AssertGeometry(topLevelInBetweenAquifer[0].CalcPoints, expectedTop); - AssertGeometry(bottomLevelInBetweenAquifer[0].CalcPoints, expectedBottom); + AssertGeometry(topLevelInBetweenAquifer[0].Points, expectedTop); + AssertGeometry(bottomLevelInBetweenAquifer[0].Points, expectedBottom); } /// @@ -378,8 +378,8 @@ new(middleXCoordinate, -21), new(rightCoordinate, -21) ]; - AssertGeometry(topLevelInBetweenAquifer[0].CalcPoints, expectedTop); - AssertGeometry(bottomLevelInBetweenAquifer[0].CalcPoints, expectedBottom); + AssertGeometry(topLevelInBetweenAquifer[0].Points, expectedTop); + AssertGeometry(bottomLevelInBetweenAquifer[0].Points, expectedBottom); } /// @@ -467,8 +467,8 @@ new(middleXCoordinate, -20), new(rightCoordinate, -20) ]; - AssertGeometry(topLevelInBetweenAquifer[0].CalcPoints, expectedTop); - AssertGeometry(bottomLevelInBetweenAquifer[0].CalcPoints, expectedBottom); + AssertGeometry(topLevelInBetweenAquifer[0].Points, expectedTop); + AssertGeometry(bottomLevelInBetweenAquifer[0].Points, expectedBottom); } /// @@ -575,8 +575,8 @@ new(middleXCoordinate, -17), new(rightCoordinate, -17) ]; - AssertGeometry(topLevelInBetweenAquifer[0].CalcPoints, expectedTop); - AssertGeometry(bottomLevelInBetweenAquifer[0].CalcPoints, expectedBottom); + AssertGeometry(topLevelInBetweenAquifer[0].Points, expectedTop); + AssertGeometry(bottomLevelInBetweenAquifer[0].Points, expectedBottom); } /// @@ -684,8 +684,8 @@ new(middleXCoordinate, -21), new(rightCoordinate, -21) ]; - AssertGeometry(topLevelInBetweenAquifer[0].CalcPoints, expectedTop); - AssertGeometry(bottomLevelInBetweenAquifer[0].CalcPoints, expectedBottom); + AssertGeometry(topLevelInBetweenAquifer[0].Points, expectedTop); + AssertGeometry(bottomLevelInBetweenAquifer[0].Points, expectedBottom); } /// @@ -766,8 +766,8 @@ new(pointC.X, pointC.Z), new(pointG.X, pointG.Z) ]; - AssertGeometry(topLevelInBetweenAquifer[0].CalcPoints, expectedTop); - AssertGeometry(bottomLevelInBetweenAquifer[0].CalcPoints, expectedBottom); + AssertGeometry(topLevelInBetweenAquifer[0].Points, expectedTop); + AssertGeometry(bottomLevelInBetweenAquifer[0].Points, expectedBottom); } /// @@ -965,23 +965,23 @@ { // Setup var polyLine1 = new GeometryPointString(); - polyLine1.CalcPoints.Add(new Point2D(-1, 2)); - polyLine1.CalcPoints.Add(new Point2D(3, 4)); - polyLine1.CalcPoints.Add(new Point2D(5, 6)); + polyLine1.Points.Add(new Point2D(-1, 2)); + polyLine1.Points.Add(new Point2D(3, 4)); + polyLine1.Points.Add(new Point2D(5, 6)); var polyLine2 = new GeometryPointString(); - polyLine2.CalcPoints.Add(new Point2D(5, 6)); - polyLine2.CalcPoints.Add(new Point2D(9, 1)); - polyLine2.CalcPoints.Add(new Point2D(15, 26)); + polyLine2.Points.Add(new Point2D(5, 6)); + polyLine2.Points.Add(new Point2D(9, 1)); + polyLine2.Points.Add(new Point2D(15, 26)); var polyLine3 = new GeometryPointString(); - polyLine3.CalcPoints.Add(new Point2D(3, 4)); - polyLine3.CalcPoints.Add(new Point2D(9, 5)); - polyLine3.CalcPoints.Add(new Point2D(6, 8)); + polyLine3.Points.Add(new Point2D(3, 4)); + polyLine3.Points.Add(new Point2D(9, 5)); + polyLine3.Points.Add(new Point2D(6, 8)); var polyLine4 = new GeometryPointString(); - polyLine4.CalcPoints.Add(new Point2D(15, 14)); - polyLine4.CalcPoints.Add(new Point2D(16, 14)); + polyLine4.Points.Add(new Point2D(15, 14)); + polyLine4.Points.Add(new Point2D(16, 14)); var polyLines = new List { @@ -998,22 +998,22 @@ Assert.Multiple(() => { Assert.That(connectedPolyLines, Has.Count.EqualTo(2)); - Assert.That(connectedPolyLines[0].CalcPoints, Has.Count.EqualTo(7)); - Assert.That(connectedPolyLines[1].CalcPoints, Has.Count.EqualTo(3)); - Assert.That(connectedPolyLines[0].CalcPoints[0].X, Is.EqualTo(-1)); - Assert.That(connectedPolyLines[0].CalcPoints[0].Z, Is.EqualTo(2)); - Assert.That(connectedPolyLines[0].CalcPoints[1].X, Is.EqualTo(3)); - Assert.That(connectedPolyLines[0].CalcPoints[1].Z, Is.EqualTo(4)); - Assert.That(connectedPolyLines[0].CalcPoints[2].X, Is.EqualTo(5)); - Assert.That(connectedPolyLines[0].CalcPoints[2].Z, Is.EqualTo(6)); - Assert.That(connectedPolyLines[0].CalcPoints[3].X, Is.EqualTo(9)); - Assert.That(connectedPolyLines[0].CalcPoints[3].Z, Is.EqualTo(1)); - Assert.That(connectedPolyLines[0].CalcPoints[4].X, Is.EqualTo(15)); - Assert.That(connectedPolyLines[0].CalcPoints[4].Z, Is.EqualTo(26)); - Assert.That(connectedPolyLines[0].CalcPoints[5].X, Is.EqualTo(15)); - Assert.That(connectedPolyLines[0].CalcPoints[5].Z, Is.EqualTo(14)); - Assert.That(connectedPolyLines[0].CalcPoints[6].X, Is.EqualTo(16)); - Assert.That(connectedPolyLines[0].CalcPoints[6].Z, Is.EqualTo(14)); + Assert.That(connectedPolyLines[0].Points, Has.Count.EqualTo(7)); + Assert.That(connectedPolyLines[1].Points, Has.Count.EqualTo(3)); + Assert.That(connectedPolyLines[0].Points[0].X, Is.EqualTo(-1)); + Assert.That(connectedPolyLines[0].Points[0].Z, Is.EqualTo(2)); + Assert.That(connectedPolyLines[0].Points[1].X, Is.EqualTo(3)); + Assert.That(connectedPolyLines[0].Points[1].Z, Is.EqualTo(4)); + Assert.That(connectedPolyLines[0].Points[2].X, Is.EqualTo(5)); + Assert.That(connectedPolyLines[0].Points[2].Z, Is.EqualTo(6)); + Assert.That(connectedPolyLines[0].Points[3].X, Is.EqualTo(9)); + Assert.That(connectedPolyLines[0].Points[3].Z, Is.EqualTo(1)); + Assert.That(connectedPolyLines[0].Points[4].X, Is.EqualTo(15)); + Assert.That(connectedPolyLines[0].Points[4].Z, Is.EqualTo(26)); + Assert.That(connectedPolyLines[0].Points[5].X, Is.EqualTo(15)); + Assert.That(connectedPolyLines[0].Points[5].Z, Is.EqualTo(14)); + Assert.That(connectedPolyLines[0].Points[6].X, Is.EqualTo(16)); + Assert.That(connectedPolyLines[0].Points[6].Z, Is.EqualTo(14)); }); } Index: DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/IssuesTests.cs =================================================================== diff -u -r6164 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/IssuesTests.cs (.../IssuesTests.cs) (revision 6164) +++ DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/IssuesTests.cs (.../IssuesTests.cs) (revision 6245) @@ -75,7 +75,7 @@ Assert.That(soilProfile2D.Geometry.Surfaces, Has.Count.EqualTo(surfaceCount)); Assert.That(soilProfile2D.Geometry.Curves, Has.Count.EqualTo(curveCount)); Assert.That(soilProfile2D.Geometry.Points, Has.Count.EqualTo(pointCount)); - Assert.That(soilProfile2D.Geometry.SurfaceLine.CalcPoints, Has.Count.EqualTo(surfaceLinePointCount)); + Assert.That(soilProfile2D.Geometry.SurfaceLine.Points, Has.Count.EqualTo(surfaceLinePointCount)); }); GeneralHelper.RunAfterInputValidation(engineInterface, true, outputName); int errorCount = GeneralHelper.DetermineNumberOfCalculationErrors(engineInterface.DamProjectData.CalculationMessages); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/SoilProfileValidator.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/SoilProfileValidator.cs (.../SoilProfileValidator.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/SoilProfileValidator.cs (.../SoilProfileValidator.cs) (revision 6245) @@ -171,7 +171,7 @@ + Resources.SoilProfileValidator_NoSurfaceLineDefined); } - if (SurfaceLine.Geometry.CalcPoints.Count < 2) + if (SurfaceLine.Geometry.Points.Count < 2) { throw new PlLinesCreatorException(Resources.SoilProfileValidator_General + Resources.SoilProfileValidator_AtLeastTwoSurfaceLinePoints); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineHeightAdapterTest.cs =================================================================== diff -u -r6086 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineHeightAdapterTest.cs (.../SurfaceLineHeightAdapterTest.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineHeightAdapterTest.cs (.../SurfaceLineHeightAdapterTest.cs) (revision 6245) @@ -100,7 +100,7 @@ { Point2D newPointAtToeRiver = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtRiver); Assert.That(newPointAtToeRiver.LocationEquals(pointAtToeRiver), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Any(p => p.LocationEquals(pointAtToeRiver)), Is.True); + Assert.That(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtToeRiver)), Is.True); } } @@ -240,7 +240,7 @@ surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside); var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location, 0); SurfaceLine2 newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Any(p => p.LocationEquals(pointAtTopRiver)), Is.False); + Assert.That(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtTopRiver)), Is.False); } [Test] @@ -333,7 +333,7 @@ surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside); var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location, 0); SurfaceLine2 newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Any(p => p.LocationEquals(pointAtTopPolder)), Is.False); + Assert.That(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtTopPolder)), Is.False); } [Test] @@ -477,11 +477,11 @@ SurfaceLine2 newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight); Assert.That(newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.ShoulderTopInside), Is.Null); Assert.That(newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.ShoulderBaseInside), Is.Null); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Any(p => p.LocationEquals(pointAtShoulderInsteek)), Is.False); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Any(p => p.LocationEquals(pointAtShoulderTop)), Is.False); + Assert.That(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtShoulderInsteek)), Is.False); + Assert.That(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtShoulderTop)), Is.False); Point2D newPointAtToePolder = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(newSurfaceLine.GetPointSegmentIncluding(pointAtTopRiver.X, newPointAtToePolder.X).Count(), Is.EqualTo(3)); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(5)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(5)); } [Test] @@ -776,10 +776,10 @@ var location = new Location(); const double cTolerance = 0.001; const double newDikeHeight = 4.0; - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(10)); + Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(10)); var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location, 0); SurfaceLine2 newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(6)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(6)); Assert.That(newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver).X, Is.EqualTo(7.3333).Within(cTolerance)); Assert.That(newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver).Z, Is.EqualTo(4.0000).Within(cTolerance)); Assert.That(newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtPolder).X, Is.EqualTo(9.3333).Within(cTolerance)); @@ -835,7 +835,7 @@ }; Point2D actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.ShoulderBaseInside); Assert.That(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(9)); } [Test] @@ -881,7 +881,7 @@ X = 3.8, Z = 1 }; - Point2D actualNewPoint = newSurfaceLine.Geometry.CalcPoints[4]; + Point2D actualNewPoint = newSurfaceLine.Geometry.Points[4]; Assert.That(expectedNewPoint.LocationEquals(actualNewPoint), Is.True); var expectedShoulderBaseInside = new Point2D { @@ -890,7 +890,7 @@ }; Point2D actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.ShoulderBaseInside); Assert.That(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(10)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(10)); } [Test] @@ -938,7 +938,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(5)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(5)); } [Test] @@ -986,7 +986,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(6)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(6)); } [Test] @@ -1048,7 +1048,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(7)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(7)); } [Test] @@ -1096,7 +1096,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(5)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(5)); } [Test] @@ -1142,7 +1142,7 @@ X = 6, Z = 0 }; - Point2D actualPoint = newSurfaceLine.Geometry.CalcPoints[3]; + Point2D actualPoint = newSurfaceLine.Geometry.Points[3]; Assert.That(expectedPoint.LocationEquals(actualPoint), Is.True); var expectedToeInside = new Point2D { @@ -1151,7 +1151,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(6)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(6)); } [Test] @@ -1199,7 +1199,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(6)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(6)); } [Test] @@ -1247,7 +1247,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(6)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(6)); } [Test] @@ -1297,14 +1297,14 @@ X = 3.5, Z = 1 }; - Point2D actualPoint = newSurfaceLine.Geometry.CalcPoints[4]; + Point2D actualPoint = newSurfaceLine.Geometry.Points[4]; Assert.That(expectedPoint.LocationEquals(actualPoint), Is.True); var expectedPoint2 = new Point2D { X = 4, Z = 1 }; - Point2D actualPoint2 = newSurfaceLine.Geometry.CalcPoints[5]; + Point2D actualPoint2 = newSurfaceLine.Geometry.Points[5]; Assert.That(expectedPoint2.LocationEquals(actualPoint2), Is.True); var expectedShoulderBaseInside = new Point2D { @@ -1320,7 +1320,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(10)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(10)); } [Test] @@ -1372,7 +1372,7 @@ }; Point2D actualToeInside = newSurfaceLine.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder); Assert.That(expectedToeInside.LocationEquals(actualToeInside), Is.True); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(6)); + Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(6)); } [Test] Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryLoop.cs =================================================================== diff -u -r6106 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryLoop.cs (.../GeometryLoop.cs) (revision 6106) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryLoop.cs (.../GeometryLoop.cs) (revision 6245) @@ -36,17 +36,17 @@ /// /// This property is not serialized. If you want to add point definitions, /// do so by adding/inserting a new element to . - public override List CalcPoints + public override List Points { get { //explicit use of protected field to prevent stack overflow due to recursive call - if (calcPoints.Count == 0) + if (points.Count == 0) { - calcPoints = PopulateLoopPointList(calcPoints); + points = PopulateLoopPointList(points); } - return calcPoints; + return points; } } @@ -113,7 +113,7 @@ /// Cannot determine if loop is clockwise if checked location forms a straight line with its neighboring vectors. public bool IsClockWise() { - Clockwise isClockWise = Routines2D.IsClockWise(CalcPoints); + Clockwise isClockWise = Routines2D.IsClockWise(Points); if (isClockWise == Clockwise.NotEnoughUniquePoints) { throw new NotEnoughUniquePointsException(); @@ -165,10 +165,10 @@ { GeometryPointString clonedGeometryPointString = base.Clone(); var clonedGeometryLoop = new GeometryLoop(); - clonedGeometryLoop.CalcPoints.AddRange(clonedGeometryPointString.CalcPoints); + clonedGeometryLoop.Points.AddRange(clonedGeometryPointString.Points); foreach (GeometryCurve curve in CurveList) { - clonedGeometryLoop.CurveList.Add(curve.Clone(clonedGeometryLoop.CalcPoints)); + clonedGeometryLoop.CurveList.Add(curve.Clone(clonedGeometryLoop.Points)); } return clonedGeometryLoop; @@ -229,11 +229,11 @@ private void RemoveDoubleClosingPointWhenNeeded() { - if (calcPoints.Count > 0) + if (points.Count > 0) { - if (calcPoints[0] == calcPoints[calcPoints.Count - 1]) + if (points[0] == points[points.Count - 1]) { - calcPoints.RemoveAt(calcPoints.Count - 1); + points.RemoveAt(points.Count - 1); } } } Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/DesignCalculatorShoulderPerPoint.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/DesignCalculatorShoulderPerPoint.cs (.../DesignCalculatorShoulderPerPoint.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesDesign/DesignCalculatorShoulderPerPoint.cs (.../DesignCalculatorShoulderPerPoint.cs) (revision 6245) @@ -82,7 +82,7 @@ Point2D startSurfacePoint = surfaceLine.GetDikeToeInward(); - IEnumerable relevantSurfacePointsList = from Point2D point in surfaceLine.Geometry.CalcPoints + IEnumerable relevantSurfacePointsList = from Point2D point in surfaceLine.Geometry.Points where point.X >= startSurfacePoint.X orderby point.X select point; Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilSurfaceProfile.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilSurfaceProfile.cs (.../SoilSurfaceProfile.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilSurfaceProfile.cs (.../SoilSurfaceProfile.cs) (revision 6245) @@ -133,7 +133,7 @@ || profile == null || profile.Layers.Count == 0 || surfaceLine.Geometry.GetMaxZ() < profile.BottomLevel - || surfaceLine.Geometry.CalcPoints.Count < 2) + || surfaceLine.Geometry.Points.Count < 2) { return; } @@ -255,7 +255,7 @@ /// be able to determine a surface from it. private static IEnumerable GetXCoordinates(IEnumerable soilLayers, SurfaceLine2 surfaceLine) { - var xCoordinates = new List(surfaceLine.Geometry.CalcPoints.Select(p => p.X)); + var xCoordinates = new List(surfaceLine.Geometry.Points.Select(p => p.X)); foreach (SoilLayer1D layer in soilLayers) { Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityWrapperInputFromEngine.cs =================================================================== diff -u -r6087 -r6245 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityWrapperInputFromEngine.cs (.../FillMacroStabilityWrapperInputFromEngine.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityWrapperInputFromEngine.cs (.../FillMacroStabilityWrapperInputFromEngine.cs) (revision 6245) @@ -355,7 +355,7 @@ var line = new TKernelLineType { Name = geometry.Name, - Points = geometry.CalcPoints.Select(p => new KernelPoint2D(p.X, p.Z)).ToList() + Points = geometry.Points.Select(p => new KernelPoint2D(p.X, p.Z)).ToList() }; return line;