Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/PlLinesCreatorTest.cs =================================================================== diff -u -r5169 -r5224 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/PlLinesCreatorTest.cs (.../PlLinesCreatorTest.cs) (revision 5169) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/PlLinesCreatorTest.cs (.../PlLinesCreatorTest.cs) (revision 5224) @@ -34,7 +34,7 @@ [TestFixture] public class PlLinesCreatorTest { - private readonly double Tolerance = 0.001; + private const double tolerance = 0.001; [SetUp] public void TestFixtureSetup() {} @@ -46,23 +46,30 @@ /// Test if PL1 created correctly if PolderLevel above toe at polder /// [Test] - public void CreatePL1WithPolderLevelHigherDikeToeAtPolder() + public void CreatePl1WithPolderLevelHigherDikeToeAtPolder() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(4)); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + }, + SurfaceLine = surfaceLineSimpleDike + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.0).Within(cTolerance)); @@ -71,12 +78,15 @@ Assert.That(plLine.Points[2].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); Assert.That(plLine.Points[3].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[3].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); + }); - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.5; // Default value - plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); + plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; + plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value + plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.5; // Default value + plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.0).Within(cTolerance)); @@ -89,7 +99,8 @@ Assert.That(plLine.Points[4].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[5].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); - } + }); + } /// @@ -99,22 +110,28 @@ public void CreatePL1WithPolderLevelBetweenShoulderBaseInsideAndShoulderTopInside() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineDikeWithSlopingShoulder = FactoryForSurfaceLines.CreateSurfacelineDikeWithSlopingShoulder(); + SurfaceLine2 surfaceLineDikeWithSlopingShoulder = FactoryForSurfaceLines.CreateSurfacelineDikeWithSlopingShoulder(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineDikeWithSlopingShoulder; - plLineCreator.WaterLevelPolder = 2.75; // CharacteristicPointType.ShoulderTopInside.Z = 2.5; CharacteristicPointType.ShoulderBaseInside.Z = 3.0); - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(7)); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + PlLineOffsetBelowDikeTopAtRiver = 0.5, // Default value + PlLineOffsetBelowDikeTopAtPolder = 1.0, + SurfaceLine = surfaceLineDikeWithSlopingShoulder, + WaterLevelPolder = 2.75 // CharacteristicPointType.ShoulderTopInside.Z = 2.5; CharacteristicPointType.ShoulderBaseInside.Z = 3.0); + }; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(7)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.0).Within(cTolerance)); @@ -123,13 +140,13 @@ Assert.That(plLine.Points[2].Z, Is.EqualTo(3.5).Within(cTolerance)); Assert.That(plLine.Points[3].X, Is.EqualTo(7.0).Within(cTolerance)); Assert.That(plLine.Points[3].Z, Is.EqualTo(3.0).Within(cTolerance)); - Assert.That(plLine.Points[4].X, Is.EqualTo(9.0).Within(cTolerance)); // This point has offset below surfacelevel of PlLineOffsetBelowShoulderBaseInside + Assert.That(plLine.Points[4].X, Is.EqualTo(9.0).Within(cTolerance)); // This point has offset below surface level of PlLineOffsetBelowShoulderBaseInside Assert.That(plLine.Points[4].Z, Is.EqualTo(2.9).Within(cTolerance)); - Assert.That(plLine.Points[5].X, Is.EqualTo(10.0).Within(cTolerance)); // This point and following points are raised to match polderlevel + Assert.That(plLine.Points[5].X, Is.EqualTo(10.0).Within(cTolerance)); // This point and following points are raised to match polder level Assert.That(plLine.Points[5].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); Assert.That(plLine.Points[6].X, Is.EqualTo(15).Within(cTolerance)); Assert.That(plLine.Points[6].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); - } + }); } /// @@ -139,23 +156,28 @@ public void CreatePL1WithPolderLevelHigherShoulderBaseInside() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineDikeWithSlopingShoulder = FactoryForSurfaceLines.CreateSurfacelineDikeWithSlopingShoulder(); + SurfaceLine2 surfaceLineDikeWithSlopingShoulder = FactoryForSurfaceLines.CreateSurfacelineDikeWithSlopingShoulder(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.5; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineDikeWithSlopingShoulder; + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.5, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + PlLineOffsetBelowDikeTopAtRiver = 0.5, // Default value + PlLineOffsetBelowDikeTopAtPolder = 1.0, + SurfaceLine = surfaceLineDikeWithSlopingShoulder, + WaterLevelPolder = 3.25 // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Lower than PlLineOffsetBelowDikeTopAtPolder + }; - plLineCreator.WaterLevelPolder = 3.25; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Lower than PlLineOffsetBelowDikeTopAtPolder - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.5).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.5).Within(cTolerance)); @@ -168,10 +190,13 @@ Assert.That(plLine.Points[4].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); Assert.That(plLine.Points[5].X, Is.EqualTo(15).Within(cTolerance)); Assert.That(plLine.Points[5].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); + }); - plLineCreator.WaterLevelPolder = 3.75; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Higher than PlLineOffsetBelowDikeTopAtPolder - plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); + plLineCreator.WaterLevelPolder = 3.75; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Higher than PlLineOffsetBelowDikeTopAtPolder + plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.5).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.5).Within(cTolerance)); @@ -184,10 +209,13 @@ Assert.That(plLine.Points[4].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); Assert.That(plLine.Points[5].X, Is.EqualTo(15).Within(cTolerance)); Assert.That(plLine.Points[5].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); + }); - plLineCreator.WaterLevelPolder = 4.25; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Higher than PlLineOffsetBelowDikeTopAtRiver - plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); + plLineCreator.WaterLevelPolder = 4.25; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Higher than PlLineOffsetBelowDikeTopAtRiver + plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.5).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.5).Within(cTolerance)); @@ -200,29 +228,31 @@ Assert.That(plLine.Points[4].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); Assert.That(plLine.Points[5].X, Is.EqualTo(15).Within(cTolerance)); Assert.That(plLine.Points[5].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); - } + }); } /// - /// Test if exception thrown if PolderLevel above top of dike + /// Test if exception is thrown if PolderLevel above top of dike /// [Test] public void ThrowsWhenPolderLevelHigherDikeTopAtPolder() { - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z + 0.1; - Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02), Throws.InstanceOf()); - } + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + }, + SurfaceLine = surfaceLineSimpleDike + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z + 0.1; + + Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02), Throws.InstanceOf()); } /// @@ -232,20 +262,27 @@ public void CreatePL1For1DGeometryWithExpertKnowledgeLinearInDike() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(4)); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + }, + SurfaceLine = surfaceLineSimpleDike + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.0).Within(cTolerance)); @@ -254,7 +291,7 @@ Assert.That(plLine.Points[2].Z, Is.EqualTo(0.9).Within(cTolerance)); Assert.That(plLine.Points[3].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[3].Z, Is.EqualTo(0.9).Within(cTolerance)); - } + }); } /// @@ -264,25 +301,32 @@ public void CreatePL1For1DGeometryWithExpertKnowledgeLinearInDikeWithShoulder() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + // Add shoulder; this should not affect the creation of the phreatic line + surfaceLineSimpleDike.EnsurePointOfType(8.0, 4.0, CharacteristicPointType.ShoulderBaseInside); + surfaceLineSimpleDike.EnsurePointOfType(9.0, 4.0, CharacteristicPointType.ShoulderTopInside); + surfaceLineSimpleDike.Geometry.SyncCalcPoints(); + surfaceLineSimpleDike.SortPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - // Add shoulder; this should not affect the creation of the phreatic line - plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 4.0, CharacteristicPointType.ShoulderBaseInside); - plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 4.0, CharacteristicPointType.ShoulderTopInside); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.SurfaceLine.SortPoints(); - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(4)); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + }, + SurfaceLine = surfaceLineSimpleDike + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.0).Within(cTolerance)); @@ -291,7 +335,7 @@ Assert.That(plLine.Points[2].Z, Is.EqualTo(0.9).Within(cTolerance)); Assert.That(plLine.Points[3].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[3].Z, Is.EqualTo(0.9).Within(cTolerance)); - } + }); } /// @@ -301,22 +345,28 @@ public void CreatePL1LowMidFor1DGeometryWithExpertKnowledgeLinearInDike() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelRiverLow = 3.0; // <===================== low waterlevel crossing dike - plLineCreator.IsUseLowWaterLevel = true; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(5)); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + WaterLevelRiverLow = 3.0, // <===================== low waterlevel crossing dike + IsUseLowWaterLevel = true, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + }, + SurfaceLine = surfaceLineSimpleDike + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(5)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(2.0).Within(cTolerance)); @@ -327,7 +377,7 @@ Assert.That(plLine.Points[3].Z, Is.EqualTo(0.9).Within(cTolerance)); Assert.That(plLine.Points[4].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); - } + }); } /// @@ -336,22 +386,24 @@ [Test] public void CreatePL1LowLowFor1DGeometryWithExpertKnowledgeLinearInDike() { - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelRiverLow = 1.0; // <===================== low waterlevel below surfacelevel - plLineCreator.IsUseLowWaterLevel = true; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; - Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02), Throws.TypeOf(typeof(SurfaceLineException)).With.Message.Contains("should be higher than dike toe at river side")); - } + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + WaterLevelRiverLow = 1.0, // <===== low water level below surface level + IsUseLowWaterLevel = true, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + }, + SurfaceLine = surfaceLineSimpleDike + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02), Throws.TypeOf(typeof(SurfaceLineException)).With.Message.Contains("should be higher than dike toe at river side")); } /// @@ -369,35 +421,38 @@ GeometryMustContainPoint = true } }; + surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePoint(1.5, 2.5); + surfaceLine.EnsurePoint(2.5, 3.0); + surfaceLine.EnsurePoint(3.0, 4.0); + surfaceLine.EnsurePointOfType(4.0, 5.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(7.0, 5.0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(), + WaterLevelRiverHigh = 4.0, + WaterLevelRiverLow = 3.0, // <===================== low waterlevel crossing dike + IsUseLowWaterLevel = true, + ModelParametersForPlLines = { - SurfaceLine = surfaceLine - }; - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelRiverLow = 3.0; // <===================== low waterlevel crossing dike - plLineCreator.IsUseLowWaterLevel = true; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); - plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); - plLineCreator.SurfaceLine.EnsurePoint(1.5, 2.5); - plLineCreator.SurfaceLine.EnsurePoint(2.5, 3.0); - plLineCreator.SurfaceLine.EnsurePoint(3.0, 4.0); - plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 5.0, CharacteristicPointType.DikeTopAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 5.0, CharacteristicPointType.DikeTopAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.WaterLevelPolder = - plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(5)); + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + } + }; + plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); + + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + Assert.That(plLine.Points, Has.Count.EqualTo(5)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(2.5).Within(cTolerance)); @@ -408,7 +463,7 @@ Assert.That(plLine.Points[3].Z, Is.EqualTo(0.9).Within(cTolerance)); Assert.That(plLine.Points[4].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); - } + }); } /// @@ -425,33 +480,34 @@ GeometryMustContainPoint = true } }; + surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePoint(1.5, 2.5); + surfaceLine.EnsurePoint(2.5, 3.0); + surfaceLine.EnsurePoint(3.0, 4.0); + surfaceLine.EnsurePointOfType(4.0, 5.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(7.0, 5.0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + WaterLevelRiverLow = 1.0, // <===================== low water level below surface level + IsUseLowWaterLevel = true, + ModelParametersForPlLines = { - SurfaceLine = surfaceLine - }; - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelRiverLow = 1.0; // <===================== low waterlevel below surfacelevel - plLineCreator.IsUseLowWaterLevel = true; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); - plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); - plLineCreator.SurfaceLine.EnsurePoint(1.5, 2.5); - plLineCreator.SurfaceLine.EnsurePoint(2.5, 3.0); - plLineCreator.SurfaceLine.EnsurePoint(3.0, 4.0); - plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 5.0, CharacteristicPointType.DikeTopAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 5.0, CharacteristicPointType.DikeTopAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; - Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02), Throws.TypeOf(typeof(SurfaceLineException)).With.Message.Contains("should be higher than dike toe at river side")); - } + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike + } + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02), Throws.TypeOf(typeof(SurfaceLineException)).With.Message.Contains("should be higher than dike toe at river side")); } /// @@ -461,20 +517,27 @@ public void CreatePL1For1DGeometryWithExpertKnowledgeRRD() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + SurfaceLine = surfaceLineSimpleDike + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(3.0).Within(cTolerance)); @@ -487,43 +550,51 @@ Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[5].Z, Is.EqualTo(0.9).Within(cTolerance)); - } + }); } /// /// Test if PL1 is created correctly with expert knowledge with complex profile when waterlevel of river equlas top of dike /// This could cause a problem in PlLinesCreator.ValidatePhreaticBelowDike /// [Test] - public void CreatePl1For1DGeometryWithExpertKnowledgeRrdIfRiverlevelEqualsTopOfDike() + public void CreatePl1For1DGeometryWithExpertKnowledgeRrdIfRiverLevelEqualsTopOfDike() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4, + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + SurfaceLine = surfaceLineSimpleDike + }; plLineCreator.WaterLevelRiverHigh = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).Z; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(plLine.Points[0].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh).Within(cTolerance)); - Assert.That(plLine.Points[1].X, Is.EqualTo(plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).X).Within(cTolerance)); - Assert.That(plLine.Points[1].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh).Within(cTolerance)); - Assert.That(plLine.Points[2].X, Is.EqualTo(4.0).Within(cTolerance)); - Assert.That(plLine.Points[2].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtRiver).Within(cTolerance)); - Assert.That(plLine.Points[3].X, Is.EqualTo(7.0).Within(cTolerance)); - Assert.That(plLine.Points[3].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtPolder).Within(cTolerance)); - Assert.That(plLine.Points[4].X, Is.EqualTo(10.0).Within(cTolerance)); - Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); - Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); - Assert.That(plLine.Points[5].Z, Is.EqualTo(0.9).Within(cTolerance)); + + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(plLine.Points[0].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh).Within(cTolerance)); + Assert.That(plLine.Points[1].X, Is.EqualTo(plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).X).Within(cTolerance)); + Assert.That(plLine.Points[1].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh).Within(cTolerance)); + Assert.That(plLine.Points[2].X, Is.EqualTo(4.0).Within(cTolerance)); + Assert.That(plLine.Points[2].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtRiver).Within(cTolerance)); + Assert.That(plLine.Points[3].X, Is.EqualTo(7.0).Within(cTolerance)); + Assert.That(plLine.Points[3].Z, Is.EqualTo(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtPolder).Within(cTolerance)); + Assert.That(plLine.Points[4].X, Is.EqualTo(10.0).Within(cTolerance)); + Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); + Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); + Assert.That(plLine.Points[5].Z, Is.EqualTo(0.9).Within(cTolerance)); + }); } } @@ -534,7 +605,7 @@ public void CreatePL1_WithPointBelowDikeTopAtPolderLowerPolderLevel_ReturnsPointAtPolderLevel() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { @@ -543,24 +614,27 @@ ModelParametersForPlLines = { PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD - } + }, + SurfaceLine = surfaceLineSimpleDike, + PlLineOffsetBelowDikeTopAtRiver = 0.5, + PlLineOffsetBelowDikeTopAtPolder = 3.0 }; - plLineCreator.SurfaceLine = surfacelineSimpleDike; - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 3.0; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(plLine.Points[0].Z, Is.EqualTo(2.5).Within(cTolerance)); - Assert.That(plLine.Points[2].X, Is.EqualTo(4).Within(cTolerance)); - Assert.That(plLine.Points[2].Z, Is.EqualTo(2.0).Within(cTolerance)); - Assert.That(plLine.Points[3].X, Is.EqualTo(7).Within(cTolerance)); - Assert.That(plLine.Points[3].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); - Assert.That(plLine.Points[4].X, Is.EqualTo(10).Within(cTolerance)); - Assert.That(plLine.Points[4].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); - Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); - Assert.That(plLine.Points[5].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(plLine.Points[0].Z, Is.EqualTo(2.5).Within(cTolerance)); + Assert.That(plLine.Points[2].X, Is.EqualTo(4).Within(cTolerance)); + Assert.That(plLine.Points[2].Z, Is.EqualTo(2.0).Within(cTolerance)); + Assert.That(plLine.Points[3].X, Is.EqualTo(7).Within(cTolerance)); + Assert.That(plLine.Points[3].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); + Assert.That(plLine.Points[4].X, Is.EqualTo(10).Within(cTolerance)); + Assert.That(plLine.Points[4].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); + Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); + Assert.That(plLine.Points[5].Z, Is.EqualTo(plLineCreator.WaterLevelPolder).Within(cTolerance)); + }); } } @@ -580,35 +654,37 @@ GeometryMustContainPoint = true } }; + surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), + WaterLevelRiverHigh = 3.0, + ModelParametersForPlLines = { - SurfaceLine = surfaceLine, - SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), - WaterLevelRiverHigh = 3.0, - ModelParametersForPlLines = - { - PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD - } - }; - plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); - plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); - plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); - plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; - plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; - plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; - plLineCreator.WaterLevelPolder = - plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(7)); + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + PlLineOffsetBelowDikeTopAtRiver = 0.5, + PlLineOffsetBelowDikeTopAtPolder = 1.0, + PlLineOffsetBelowShoulderBaseInside = 0.2, + PlLineOffsetBelowDikeToeAtPolder = 0.3 + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(7)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); Assert.That(plLine.Points[2].X, Is.EqualTo(4.0).Within(cTolerance)); @@ -621,7 +697,7 @@ Assert.That(plLine.Points[5].Z, Is.EqualTo(0.7).Within(cTolerance)); Assert.That(plLine.Points[6].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[6].Z, Is.EqualTo(0.7).Within(cTolerance)); - } + }); } [Test] @@ -636,37 +712,40 @@ GeometryMustContainPoint = true } }; + surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePoint(11.0, 0.5); + surfaceLine.EnsurePoint(12.0, 0.4); + surfaceLine.EnsurePointOfType(13.0, 0.3, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), + WaterLevelRiverHigh = 3.0, + ModelParametersForPlLines = { - SurfaceLine = surfaceLine, - SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), - WaterLevelRiverHigh = 3.0, - ModelParametersForPlLines = - { - PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD - } - }; - plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); - plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); - plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); - plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); - plLineCreator.SurfaceLine.EnsurePoint(11.0, 0.5); - plLineCreator.SurfaceLine.EnsurePoint(12.0, 0.4); - plLineCreator.SurfaceLine.EnsurePointOfType(13.0, 0.3, CharacteristicPointType.SurfaceLevelInside); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; - plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; - plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; - plLineCreator.WaterLevelPolder = - plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(9)); + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + PlLineOffsetBelowDikeTopAtRiver = 0.5, + PlLineOffsetBelowDikeTopAtPolder = 1.0, + PlLineOffsetBelowShoulderBaseInside = 0.2, + PlLineOffsetBelowDikeToeAtPolder = 0.3 + }; + + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(9)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); Assert.That(plLine.Points[2].X, Is.EqualTo(4.0).Within(cTolerance)); @@ -683,7 +762,7 @@ Assert.That(plLine.Points[7].Z, Is.EqualTo(0.1).Within(cTolerance)); Assert.That(plLine.Points[8].X, Is.EqualTo(13).Within(cTolerance)); Assert.That(plLine.Points[8].Z, Is.EqualTo(0.0).Within(cTolerance)); - } + }); } [Test] @@ -698,38 +777,40 @@ GeometryMustContainPoint = true } }; + surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePoint(11.0, 0.5); + surfaceLine.EnsurePoint(12.0, 0.1); + surfaceLine.EnsurePoint(14.0, 0.5); + surfaceLine.EnsurePointOfType(15.0, 0.0, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), + WaterLevelRiverHigh = 3.0, + ModelParametersForPlLines = { - SurfaceLine = surfaceLine, - SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), - WaterLevelRiverHigh = 3.0, - ModelParametersForPlLines = - { - PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD - } - }; - plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); - plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); - plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); - plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); - plLineCreator.SurfaceLine.EnsurePoint(11.0, 0.5); - plLineCreator.SurfaceLine.EnsurePoint(12.0, 0.1); - plLineCreator.SurfaceLine.EnsurePoint(14.0, 0.5); - plLineCreator.SurfaceLine.EnsurePointOfType(15.0, 0.0, CharacteristicPointType.SurfaceLevelInside); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; - plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; - plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; - plLineCreator.WaterLevelPolder = - plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(9)); + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + PlLineOffsetBelowDikeTopAtRiver = 0.5, + PlLineOffsetBelowDikeTopAtPolder = 1.0, + PlLineOffsetBelowShoulderBaseInside = 0.2, + PlLineOffsetBelowDikeToeAtPolder = 0.3 + }; + + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(9)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); Assert.That(plLine.Points[2].X, Is.EqualTo(4.0).Within(cTolerance)); @@ -746,7 +827,7 @@ Assert.That(plLine.Points[7].Z, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[8].X, Is.EqualTo(15).Within(cTolerance)); Assert.That(plLine.Points[8].Z, Is.EqualTo(0.0).Within(cTolerance)); - } + }); } [Test] @@ -761,36 +842,38 @@ GeometryMustContainPoint = true } }; + surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePoint(11.0, 0.5); + surfaceLine.EnsurePoint(12.0, 0.2); + surfaceLine.EnsurePointOfType(13.0, 0.0, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), + WaterLevelRiverHigh = 3.0, + ModelParametersForPlLines = { - SurfaceLine = surfaceLine, - SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), - WaterLevelRiverHigh = 3.0, - ModelParametersForPlLines = - { - PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD - } - }; - plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); - plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); - plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); - plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); - plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); - plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); - plLineCreator.SurfaceLine.EnsurePoint(11.0, 0.5); - plLineCreator.SurfaceLine.EnsurePoint(12.0, 0.2); - plLineCreator.SurfaceLine.EnsurePointOfType(13.0, 0.0, CharacteristicPointType.SurfaceLevelInside); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; - plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; - plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; - plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; - plLineCreator.WaterLevelPolder = - plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(7)); + PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD + }, + PlLineOffsetBelowDikeTopAtRiver = 0.5, + PlLineOffsetBelowDikeTopAtPolder = 1.0, + PlLineOffsetBelowShoulderBaseInside = 0.2, + PlLineOffsetBelowDikeToeAtPolder = 0.3 + }; + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(7)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); Assert.That(plLine.Points[2].X, Is.EqualTo(4.0).Within(cTolerance)); @@ -803,7 +886,7 @@ Assert.That(plLine.Points[5].Z, Is.EqualTo(1.0).Within(cTolerance)); Assert.That(plLine.Points[6].X, Is.EqualTo(13).Within(cTolerance)); Assert.That(plLine.Points[6].Z, Is.EqualTo(1.0).Within(cTolerance)); - } + }); } /// @@ -813,33 +896,41 @@ public void CreatePL1LowFor1DGeometryWithExpertKnowledgeRRD() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelRiverLow = 3.0; - plLineCreator.IsUseLowWaterLevel = true; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + WaterLevelRiverLow = 3.0, + IsUseLowWaterLevel = true, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4 + }, + SurfaceLine = surfaceLineSimpleDike + }; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); - Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); - Assert.That(plLine.Points[1].X, Is.EqualTo(2.0).Within(cTolerance)); - Assert.That(plLine.Points[1].Z, Is.EqualTo(3.0).Within(cTolerance)); - Assert.That(plLine.Points[2].X, Is.EqualTo(4).Within(cTolerance)); - Assert.That(plLine.Points[2].Z, Is.EqualTo(3.5).Within(cTolerance)); - Assert.That(plLine.Points[3].X, Is.EqualTo(7).Within(cTolerance)); - Assert.That(plLine.Points[3].Z, Is.EqualTo(2.5).Within(cTolerance)); - Assert.That(plLine.Points[4].X, Is.EqualTo(10).Within(cTolerance)); - Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); - Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); - Assert.That(plLine.Points[5].Z, Is.EqualTo(0.9).Within(cTolerance)); + + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(cTolerance)); + Assert.That(plLine.Points[0].Z, Is.EqualTo(3.0).Within(cTolerance)); + Assert.That(plLine.Points[1].X, Is.EqualTo(2.0).Within(cTolerance)); + Assert.That(plLine.Points[1].Z, Is.EqualTo(3.0).Within(cTolerance)); + Assert.That(plLine.Points[2].X, Is.EqualTo(4).Within(cTolerance)); + Assert.That(plLine.Points[2].Z, Is.EqualTo(3.5).Within(cTolerance)); + Assert.That(plLine.Points[3].X, Is.EqualTo(7).Within(cTolerance)); + Assert.That(plLine.Points[3].Z, Is.EqualTo(2.5).Within(cTolerance)); + Assert.That(plLine.Points[4].X, Is.EqualTo(10).Within(cTolerance)); + Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); + Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); + Assert.That(plLine.Points[5].Z, Is.EqualTo(0.9).Within(cTolerance)); + }); } } @@ -850,27 +941,33 @@ public void CreatePL1LowJustAboveToeFor1DGeometryWithExpertKnowledgeRRD() { const double cTolerance = 0.0001; - SurfaceLine2 surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + SurfaceLine2 surfaceLineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); + // Add voorland to dike + surfaceLineSimpleDike.EnsurePointOfType(-2.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLineSimpleDike.EnsurePoint(0.0, 2.0); + surfaceLineSimpleDike.Geometry.SyncCalcPoints(); + surfaceLineSimpleDike.SortPoints(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - Assert.That(plLineCreator, Is.Not.Null); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelRiverLow = 2.1; - plLineCreator.IsUseLowWaterLevel = true; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfacelineSimpleDike; - // Add voorland to dike - plLineCreator.SurfaceLine.EnsurePointOfType(-2.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); - plLineCreator.SurfaceLine.EnsurePoint(0.0, 2.0); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.SurfaceLine.SortPoints(); - // Create Pl1 - plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); - Assert.That(plLine.Points.Count, Is.EqualTo(6)); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + WaterLevelRiverHigh = 4.0, + WaterLevelRiverLow = 2.1, + IsUseLowWaterLevel = true, + ModelParametersForPlLines = + { + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4 + }, + SurfaceLine = surfaceLineSimpleDike + }; + + plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl1, 0.02); + + Assert.That(plLine.Points, Has.Count.EqualTo(6)); + Assert.Multiple(() => + { Assert.That(plLine.Points[0].X, Is.EqualTo(-2.0).Within(cTolerance)); Assert.That(plLine.Points[0].Z, Is.EqualTo(2.1).Within(cTolerance)); Assert.That(plLine.Points[1].X, Is.EqualTo(1.1).Within(cTolerance)); @@ -883,7 +980,7 @@ Assert.That(plLine.Points[4].Z, Is.EqualTo(0.9).Within(cTolerance)); Assert.That(plLine.Points[5].X, Is.EqualTo(12).Within(cTolerance)); Assert.That(plLine.Points[5].Z, Is.EqualTo(0.9).Within(cTolerance)); - } + }); } /// @@ -900,13 +997,16 @@ GeometryMustContainPoint = true } }; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SurfaceLine = surfaceLine; - plLineCreator.ModelParametersForPlLines.PenetrationLength = 6.0; - plLineCreator.HeadInPlLine2 = 4.0; - Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02), Throws.InstanceOf()); - } + SurfaceLine = surfaceLine, + ModelParametersForPlLines = + { + PenetrationLength = 6.0 + }, + HeadInPlLine2 = 4.0 + }; + Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02), Throws.InstanceOf()); } /// @@ -915,11 +1015,16 @@ [Test] public void CreatePL2WithExpertKnowledgeRRDThrowsExceptionIfNoSurfaceLine() { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(); - plLineCreator.SurfaceLine = null; - plLineCreator.ModelParametersForPlLines.PenetrationLength = 6.0; - plLineCreator.HeadInPlLine2 = 4.0; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(), + SurfaceLine = null, + ModelParametersForPlLines = + { + PenetrationLength = 6.0 + }, + HeadInPlLine2 = 4.0 + }; Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02), Throws.InstanceOf()); } @@ -937,14 +1042,17 @@ GeometryMustContainPoint = true } }; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(); - plLineCreator.SurfaceLine = surfaceLine; - plLineCreator.ModelParametersForPlLines.PenetrationLength = 6.0; - plLineCreator.HeadInPlLine2 = 4.0; - Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02), Throws.InstanceOf()); - } + SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(), + SurfaceLine = surfaceLine, + ModelParametersForPlLines = + { + PenetrationLength = 6.0 + }, + HeadInPlLine2 = 4.0 + }; + Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02), Throws.InstanceOf()); } /// @@ -963,32 +1071,40 @@ GeometryMustContainPoint = true } }; + surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); + surfaceLine.Geometry.SyncCalcPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), + ModelParametersForPlLines = { - SurfaceLine = surfaceLine - }; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - plLineCreator.HeadInPlLine2 = cHeadPL2; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); - Assert.That(plLine.Exists(), Is.True); - } + PenetrationLength = cPenetrationLength + }, + HeadInPlLine2 = cHeadPL2 + }; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + Assert.That(plLine.Exists(), Is.True); } [Test] public void CreatePL2WithExpertKnowledgeRRDThrowsExceptionIfPenetrationLengthNegative() { - const double cHeadPL2 = 3.0; + const double cHeadPl2 = 3.0; const double cPenetrationLength = -1.0; - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(); - plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - plLineCreator.HeadInPlLine2 = cHeadPL2; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(), + ModelParametersForPlLines = + { + PenetrationLength = cPenetrationLength + }, + HeadInPlLine2 = cHeadPl2 + }; Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02), Throws.InstanceOf()); } @@ -998,7 +1114,7 @@ [Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthZero() { - const double cHeadPL2 = 3.0; + const double cHeadPl2 = 3.0; const double cPenetrationLength = 0.0; var surfaceLine = new SurfaceLine2 { @@ -1008,24 +1124,28 @@ GeometryMustContainPoint = true } }; + surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + ModelParametersForPlLines = { - SurfaceLine = surfaceLine - }; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); - plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - plLineCreator.HeadInPlLine2 = cHeadPL2; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + PenetrationLength = cPenetrationLength + }, + HeadInPlLine2 = cHeadPl2 + }; - // No extra layer should have been added to profile - Assert.That(plLineCreator.SoilProfile.Layers.Count, Is.EqualTo(4)); + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + Assert.Multiple(() => + { + // No extra layer should have been added to profile + Assert.That(plLineCreator.SoilProfile.Layers, Has.Count.EqualTo(4)); Assert.That(plLine.Exists(), Is.False); - } + }); } /// @@ -1034,7 +1154,7 @@ [Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthAboveThisSandLayer() { - const double cHeadPL2 = 3.0; + const double cHeadPl2 = 3.0; const double cPenetrationLength = 6.0; var surfaceLine = new SurfaceLine2 { @@ -1044,21 +1164,25 @@ GeometryMustContainPoint = true } }; + surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); + surfaceLine.Geometry.SyncCalcPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + SurfaceLine = surfaceLine, + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + ModelParametersForPlLines = { - SurfaceLine = surfaceLine - }; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); - plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); - plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - plLineCreator.HeadInPlLine2 = cHeadPL2; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); - Assert.That(plLine.Exists(), Is.False); - } + PenetrationLength = cPenetrationLength + }, + HeadInPlLine2 = cHeadPl2 + }; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + + Assert.That(plLine.Exists(), Is.False); } /// @@ -1068,21 +1192,26 @@ public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthInThisAquiferLayer() { const double cPenetrationLength = 4.0; - const double cHeadPL2 = 3.0; + const double cHeadPl2 = 3.0; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.HeadInPlLine2 = cHeadPL2; - plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); - Assert.That(plLine.Exists(), Is.False); - } + HeadInPlLine2 = cHeadPl2, + ModelParametersForPlLines = + { + PenetrationLength = cPenetrationLength, + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4 + }, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLineTutorial1 + }; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + + Assert.That(plLine.Exists(), Is.False); } /// @@ -1094,36 +1223,43 @@ const double cPenetrationLength = 4.0; const double cHeadInPlLine2 = 3.0; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.HeadInPlLine2 = cHeadInPlLine2; - plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4; - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - - var location = new Location(); - PlLines plLines = plLineCreator.CreateAllPlLines(location); - PlLine plLine2 = plLines.Lines[PlLineType.Pl2]; - PlLine plLine4 = plLines.Lines[PlLineType.Pl4]; + HeadInPlLine2 = cHeadInPlLine2, + ModelParametersForPlLines = + { + PenetrationLength = cPenetrationLength, + DampingFactorPl3 = 0.3, + DampingFactorPl4 = 0.4 + }, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLineTutorial1 + }; + var location = new Location(); + + PlLines plLines = plLineCreator.CreateAllPlLines(location); + + PlLine plLine2 = plLines.Lines[PlLineType.Pl2]; + PlLine plLine4 = plLines.Lines[PlLineType.Pl4]; + Assert.Multiple(() => + { Assert.That(plLine2.Exists(), Is.True); Assert.That(plLine4.Exists(), Is.True); - Assert.That(plLine2.Points.Count, Is.EqualTo(plLine4.Points.Count)); + Assert.That(plLine2.Points, Has.Count.EqualTo(plLine4.Points.Count)); Assert.That(plLine4.Points[0].Z, Is.EqualTo(4.0)); - for (var pointIndex = 0; pointIndex < plLine4.Points.Count; pointIndex++) - { - Assert.That(plLine2.Points[pointIndex].LocationEquals(plLine4.Points[pointIndex]), Is.True); - } + }); + for (var pointIndex = 0; pointIndex < plLine4.Points.Count; pointIndex++) + { + Assert.That(plLine2.Points[pointIndex].LocationEquals(plLine4.Points[pointIndex]), Is.True); } } [Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthBelowBottomOfThisAquiferLayer() { - const double cHeadPL2 = 3.0; + const double cHeadPl2 = 3.0; const double cPenetrationLength = 3.0; var surfaceLine = new SurfaceLine2 { @@ -1133,164 +1269,209 @@ GeometryMustContainPoint = true } }; + surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); surfaceLine.Geometry.SyncCalcPoints(); + + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; - - surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); - surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); - surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); - surfaceLine.Geometry.SyncCalcPoints(); - plLineCreator.SurfaceLine = surfaceLine; - plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - plLineCreator.HeadInPlLine2 = cHeadPL2; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLine, + HeadInPlLine2 = cHeadPl2, + ModelParametersForPlLines = + { + PenetrationLength = cPenetrationLength + } + }; + int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + + Assert.Multiple(() => + { Assert.That(plLine.Exists(), Is.True); - Assert.That(plLine.Points[0].LocationEquals(new PlLinePoint(1.0, cHeadPL2)), Is.True); - Assert.That(plLine.Points[1].LocationEquals(new PlLinePoint(21.0, cHeadPL2)), Is.True); - // Check if extra layer is added to soilprofile - Assert.That(plLineCreator.SoilProfile.Layers.Count, Is.EqualTo(orgLayerCount + 1)); - Assert.That(plLineCreator.SoilProfile.Layers[orgLayerCount - 1].TopLevel, Is.EqualTo(-2.0).Within(0.01)); - } + Assert.That(plLine.Points[0].LocationEquals(new PlLinePoint(1.0, cHeadPl2)), Is.True); + Assert.That(plLine.Points[1].LocationEquals(new PlLinePoint(21.0, cHeadPl2)), Is.True); + // Check if extra layer is added to soil profile + Assert.That(plLineCreator.SoilProfile.Layers, Has.Count.EqualTo(orgLayerCount + 1)); + }); + Assert.That(plLineCreator.SoilProfile.Layers[orgLayerCount - 1].TopLevel, Is.EqualTo(-2.0).Within(0.01)); } - //[Test] - //public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthBelowBottomOfThisAquiferLayerWithMultipleInfiltrationLayers() - //{ - // const double cHeadPL2 = 3.0; - // const double cPenetrationLength = 2.0; - // var surfaceLine = new SurfaceLine2 - // { - // Geometry = new GeometryPointString(), - // CharacteristicPoints = - // { - // GeometryMustContainPoint = true - // } - // }; - // { - // PLLinesCreator plLineCreator = new PLLinesCreator(); - // plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateMultiInfiltrationLayerProfile(); - // int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; + [Test] + public void CreatePl2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthBelowBottomOfThisAquiferLayerWithMultipleInfiltrationLayers() + { + const double cHeadPl2 = 3.0; + const double cPenetrationLength = 2.0; + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); + surfaceLine.Geometry.SyncCalcPoints(); - // surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); - // surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); - // surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); - // plLineCreator.SurfaceLine = surfaceLine; - // plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - // plLineCreator.HeadInPLLine2 = cHeadPL2; - // PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, 0.02); - // Assert.IsTrue(plLine.Exists()); - // Assert.IsTrue(plLine.Points[0].LocationEquals(new PLLinePoint(1.0, cHeadPL2))); - // Assert.IsTrue(plLine.Points[1].LocationEquals(new PLLinePoint(21.0, cHeadPL2))); - // // Check if extra layer is added to soilprofile - // Assert.AreEqual(orgLayerCount + 1, plLineCreator.SoilProfile.Layers.Count); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateMultiInfiltrationLayerProfile(), + SurfaceLine = surfaceLine, + HeadInPlLine2 = cHeadPl2, + ModelParametersForPlLines = + { + PenetrationLength = cPenetrationLength + } + }; + int originalLayerCount = plLineCreator.SoilProfile.Layers.Count; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + + Assert.Multiple(() => + { + Assert.That(plLine.Exists(), Is.True); + Assert.That(plLine.Points[0].LocationEquals(new PlLinePoint(1.0, cHeadPl2)), Is.True); + Assert.That(plLine.Points[1].LocationEquals(new PlLinePoint(21.0, cHeadPl2)), Is.True); + // Check if extra layer is added to soil profile + Assert.That(plLineCreator.SoilProfile.Layers, Has.Count.EqualTo(originalLayerCount + 1)); - // Assert.IsNotNull(plLineCreator.SoilProfile.BottomAquiferLayer); - // Assert.AreEqual(-5.0, plLineCreator.SoilProfile.BottomAquiferLayer.TopLevel); - // Assert.IsNotNull(plLineCreator.SoilProfile.InBetweenAquiferLayer); - // Assert.AreEqual(1.0, plLineCreator.SoilProfile.InBetweenAquiferLayer.TopLevel); - // Assert.IsNotNull(plLineCreator.SoilProfile.InfiltrationLayer); - // Assert.AreEqual(-3.0, plLineCreator.SoilProfile.InfiltrationLayer.TopLevel); - // } - //} + Assert.That(plLineCreator.SoilProfile.BottomAquiferLayer, Is.Not.Null); + Assert.That(plLineCreator.SoilProfile.InBetweenAquiferLayer, Is.Not.Null); + Assert.That(plLineCreator.SoilProfile.InfiltrationLayer, Is.Not.Null); + }); + Assert.Multiple(() => + { + Assert.That(plLineCreator.SoilProfile.BottomAquiferLayer.TopLevel, Is.EqualTo(-5.0)); + Assert.That(plLineCreator.SoilProfile.InBetweenAquiferLayer.TopLevel, Is.EqualTo(1.0)); + Assert.That(plLineCreator.SoilProfile.InfiltrationLayer.TopLevel, Is.EqualTo(-3.0)); + }); + } - //[Test] - //public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithAquiferLayerInBetweenAndPenetrationLengthExactlyAtBottomOfAInfiltrationLayer() - //{ - // const double cHeadPL2 = 3.0; - // const double cPenetrationLength = 2.7; - // var surfaceLine = new SurfaceLine2 - // { - // Geometry = new GeometryPointString(), - // CharacteristicPoints = - // { - // GeometryMustContainPoint = true - // } - // }; - // { - // PLLinesCreator plLineCreator = new PLLinesCreator(); - // plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateMultiInfiltrationLayerProfile(); - // int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; + [Test] + public void CreatePl2For1DGeometryWithExpertKnowledgeRRDWithAquiferLayerInBetweenAndPenetrationLengthExactlyAtBottomOfAInfiltrationLayer() + { + const double cHeadPl2 = 3.0; + const double cPenetrationLength = 2.7; + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); + surfaceLine.Geometry.SyncCalcPoints(); - // surfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(1.0, 2.0)); - // surfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(10.0, 2.0)); - // surfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(21.0, 2.5)); - // plLineCreator.SurfaceLine = surfaceLine; - // plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - // plLineCreator.HeadInPLLine2 = cHeadPL2; - // PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, 0.02); - // Assert.IsTrue(plLine.Exists()); - // Assert.IsTrue(plLine.Points[0].LocationEquals(new PLLinePoint(1.0, cHeadPL2))); - // Assert.IsTrue(plLine.Points[1].LocationEquals(new PLLinePoint(21.0, cHeadPL2))); - // // Check if no extra layer is added to soilprofile - // Assert.AreEqual(orgLayerCount, plLineCreator.SoilProfile.Layers.Count); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateMultiInfiltrationLayerProfile(), + SurfaceLine = surfaceLine, + HeadInPlLine2 = cHeadPl2, + ModelParametersForPlLines = + { + PenetrationLength = cPenetrationLength + } + }; + int originalLayerCount = plLineCreator.SoilProfile.Layers.Count; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + + Assert.Multiple(() => + { + Assert.That(plLine.Exists(), Is.True); + Assert.That(plLine.Points[0].LocationEquals(new PlLinePoint(1.0, cHeadPl2)), Is.True); + Assert.That(plLine.Points[1].LocationEquals(new PlLinePoint(21.0, cHeadPl2)), Is.True); + // Check if no extra layer is added to soil profile + Assert.That(plLineCreator.SoilProfile.Layers, Has.Count.EqualTo(originalLayerCount)); + Assert.That(plLineCreator.SoilProfile.BottomAquiferLayer, Is.Not.Null); + Assert.That(plLineCreator.SoilProfile.InBetweenAquiferLayer, Is.Not.Null); + Assert.That(plLineCreator.SoilProfile.InBetweenAquiferLayer, Is.Not.Null); + }); + Assert.Multiple(() => + { + Assert.That(plLineCreator.SoilProfile.BottomAquiferLayer.TopLevel, Is.EqualTo(-5.0)); + Assert.That(plLineCreator.SoilProfile.InBetweenAquiferLayer.TopLevel, Is.EqualTo(1.0)); + Assert.That(plLineCreator.SoilProfile.InfiltrationLayer.TopLevel, Is.EqualTo(-2.3)); + }); + } - // Assert.IsNotNull(plLineCreator.SoilProfile.BottomAquiferLayer); - // Assert.AreEqual(-5.0, plLineCreator.SoilProfile.BottomAquiferLayer.TopLevel); - // Assert.IsNotNull(plLineCreator.SoilProfile.InBetweenAquiferLayer); - // Assert.AreEqual(1.0, plLineCreator.SoilProfile.InBetweenAquiferLayer.TopLevel); - // Assert.IsNotNull(plLineCreator.SoilProfile.InfiltrationLayer); - // Assert.AreEqual(-2.3, plLineCreator.SoilProfile.InfiltrationLayer.TopLevel); - // } - //} + [Test] + public void CreatePl2For1DGeometryWithExpertKnowledgeRRDWithAquiferLayerInBetweenAndPenetrationLengthExactlyAtBottomOfSandLayer() + { + const double cHeadPl2 = 3.0; + const double cPenetrationLength = 3.5; + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); + surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); + surfaceLine.Geometry.SyncCalcPoints(); - //[Test] - //public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithAquiferLayerInBetweenAndPenetrationLengthExactlyAtBottomOfSandLayer() - //{ - // const double cHeadPL2 = 3.0; - // const double cPenetrationLength = 3.5; - // var surfaceLine = new SurfaceLine2 - // { - // Geometry = new GeometryPointString(), - // CharacteristicPoints = - // { - // GeometryMustContainPoint = true - // } - // }; - // { - // PLLinesCreator plLineCreator = new PLLinesCreator(); - // plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateMultiInfiltrationLayerProfile(); - // int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateMultiInfiltrationLayerProfile(), + SurfaceLine = surfaceLine, + HeadInPlLine2 = cHeadPl2, + ModelParametersForPlLines = + { + PenetrationLength = cPenetrationLength + } + }; + int originalLayerCount = plLineCreator.SoilProfile.Layers.Count; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl2, 0.02); + + Assert.Multiple(() => + { + Assert.That(plLine.Exists(), Is.True); + Assert.That(plLine.Points[0].LocationEquals(new PlLinePoint(1.0, cHeadPl2)), Is.True); + Assert.That(plLine.Points[1].LocationEquals(new PlLinePoint(21.0, cHeadPl2)), Is.True); + // Check if no extra layer is added to soil profile + Assert.That(plLineCreator.SoilProfile.Layers, Has.Count.EqualTo(originalLayerCount)); - // surfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(1.0, 2.0)); - // surfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(10.0, 2.0)); - // surfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(21.0, 2.5)); - // plLineCreator.SurfaceLine = surfaceLine; - // plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; - // plLineCreator.HeadInPLLine2 = cHeadPL2; - // PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, 0.02); - // Assert.IsTrue(plLine.Exists()); - // Assert.IsTrue(plLine.Points[0].LocationEquals(new PLLinePoint(1.0, cHeadPL2))); - // Assert.IsTrue(plLine.Points[1].LocationEquals(new PLLinePoint(21.0, cHeadPL2))); - // // Check if no extra layer is added to soilprofile - // Assert.AreEqual(orgLayerCount, plLineCreator.SoilProfile.Layers.Count); + Assert.That(plLineCreator.SoilProfile.BottomAquiferLayer, Is.Not.Null); + Assert.That(plLineCreator.SoilProfile.InBetweenAquiferLayer, Is.Not.Null); + Assert.That(plLineCreator.SoilProfile.InfiltrationLayer, Is.Not.Null); + }); + Assert.Multiple(() => + { + Assert.That(plLineCreator.SoilProfile.BottomAquiferLayer.TopLevel, Is.EqualTo(-5.0)); + Assert.That(plLineCreator.SoilProfile.InBetweenAquiferLayer.TopLevel, Is.EqualTo(1.0)); + Assert.That(plLineCreator.SoilProfile.InfiltrationLayer.TopLevel, Is.EqualTo(-1.5)); + }); + } - // Assert.IsNotNull(plLineCreator.SoilProfile.BottomAquiferLayer); - // Assert.AreEqual(-5.0, plLineCreator.SoilProfile.BottomAquiferLayer.TopLevel); - // Assert.IsNotNull(plLineCreator.SoilProfile.InBetweenAquiferLayer); - // Assert.AreEqual(1.0, plLineCreator.SoilProfile.InBetweenAquiferLayer.TopLevel); - // Assert.IsNotNull(plLineCreator.SoilProfile.InfiltrationLayer); - // Assert.AreEqual(-1.5, plLineCreator.SoilProfile.InfiltrationLayer.TopLevel); - // } - //} - [Test] public void CreatePl3For1DGeometryWithExpertKnowledgeRrdThrowsExceptionIfNoAquiferLayers() { const double cDampingFactor = 0.3; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; + SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + ModelParametersForPlLines = + { + DampingFactorPl3 = cDampingFactor + } + }; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = cDampingFactor; - Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02), Throws.InstanceOf()); - } + Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02), Throws.InstanceOf()); } [Test] @@ -1299,14 +1480,20 @@ const double cDampingFactor = 0.3; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator + { + SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + ModelParametersForPlLines = + { + DampingFactorPl4 = cDampingFactor + } + }; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = cDampingFactor; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl4, 0.02); + Assert.That(plLine.Exists(), Is.False); } } @@ -1358,208 +1545,231 @@ //} /// - /// This test evaluates the same stuation as CreatePL3For1DGeometryWithExpertKnowledgeRRD() + /// This test evaluates the same situation as CreatePL3For1DGeometryWithExpertKnowledgeRRD() /// The difference is that here the geometry is entered as a 1d-geometry /// [Test] public void CreatePl3For1DGeometryWithExpertKnowledgeRrd() { const double cDampingFactor = 0.3; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = cDampingFactor; + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + ModelParametersForPlLines = + { + DampingFactorPl3 = cDampingFactor + } + }; - // In this case no HeadInPlLine3 is specified, then the head of PL3 will be equal to WaterLevelRiverHigh - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - CheckPl3For1DGeometryWithExpertKnowledgeRrd(plLine); + // In this case no HeadInPlLine3 is specified, then the head of PL3 will be equal to WaterLevelRiverHigh + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + CheckPl3For1DGeometryWithExpertKnowledgeRrd(plLine); - // In this case HeadInPlLine3 is specified (with same value as WaterLevelRiverHigh above, so result should be the same) - // Change WaterLevelRiverHigh to be sure the value of HeadInPlLine3 is really used - plLineCreator.WaterLevelRiverHigh = 3.0; - plLineCreator.HeadInPlLine3 = 4.0; - plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - CheckPl3For1DGeometryWithExpertKnowledgeRrd(plLine); + // In this case HeadInPlLine3 is specified (with same value as WaterLevelRiverHigh above, so result should be the same) + // Change WaterLevelRiverHigh to be sure the value of HeadInPlLine3 is really used + plLineCreator.WaterLevelRiverHigh = 3.0; + plLineCreator.HeadInPlLine3 = 4.0; + plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + CheckPl3For1DGeometryWithExpertKnowledgeRrd(plLine); - // Specify Head PL2, so it is used for damping, but give it the same value as WaterLevelPolder. - // This will give the same result as when Head PL2 is not specified, because in that case, WaterLevelPolder ius used for damping. - plLineCreator.HeadInPlLine2 = -0.5; - plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - CheckPl3For1DGeometryWithExpertKnowledgeRrd(plLine); + // Specify Head PL2, so it is used for damping, but give it the same value as WaterLevelPolder. + // This will give the same result as when Head PL2 is not specified, because in that case, WaterLevelPolder ius used for damping. + plLineCreator.HeadInPlLine2 = -0.5; + plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + CheckPl3For1DGeometryWithExpertKnowledgeRrd(plLine); - // Specify Head PL2, so it is used for damping, but now use diffeent value as WaterLevelPolder to force different result. - plLineCreator.HeadInPlLine2 = -5.0; - plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - CheckPl3For1DGeometryWithExpertKnowledgeRrdWithHeadPl2Specified(plLine); - } + // Specify Head PL2, so it is used for damping, but now use diffeent value as WaterLevelPolder to force different result. + plLineCreator.HeadInPlLine2 = -5.0; + plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + CheckPl3For1DGeometryWithExpertKnowledgeRrdWithHeadPl2Specified(plLine); } [Test] public void CreatePl3LowFor1DGeometryWithExpertKnowledgeRrd() { const double cDampingFactor = 0.3; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelRiverLow = 1.0; - plLineCreator.IsUseLowWaterLevel = true; - plLineCreator.WaterLevelPolder = -0.5; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = cDampingFactor; - // In this case no HeadInPlLine3 is specified, then the head of Pl3 will be equal to WaterLevelRiverLow - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - CheckPl3LowFor1DGeometryWithExpertKnowledgeRrd(plLine); + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 4.0, + WaterLevelRiverLow = 1.0, + IsUseLowWaterLevel = true, + WaterLevelPolder = -0.5, + ModelParametersForPlLines = + { + DampingFactorPl3 = cDampingFactor + } + }; + // In this case no HeadInPlLine3 is specified, then the head of Pl3 will be equal to WaterLevelRiverLow + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + CheckPl3LowFor1DGeometryWithExpertKnowledgeRrd(plLine); - // In this case HeadInPlLine3 is specified (with same value as WaterLevelRiverLow above, so result should be the same) - // Change WaterLevelRiverLow to be sure the value of HeadInPlLine3 is really used - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.HeadInPlLine3 = 1.0; - plLineCreator.WaterLevelRiverLow = 2.0; - plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - CheckPl3LowFor1DGeometryWithExpertKnowledgeRrd(plLine); - } + // In this case HeadInPlLine3 is specified (with same value as WaterLevelRiverLow above, so result should be the same) + // Change WaterLevelRiverLow to be sure the value of HeadInPlLine3 is really used + plLineCreator.WaterLevelRiverHigh = 4.0; + plLineCreator.HeadInPlLine3 = 1.0; + plLineCreator.WaterLevelRiverLow = 2.0; + plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + CheckPl3LowFor1DGeometryWithExpertKnowledgeRrd(plLine); } [Test] public void CreatePl3For1DGeometryInBlackHoleWithExpertKnowledgeRrd() { const double cDampingFactor = 0.3; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - // Lower profile for 5 m so upper layer is no longer completely above surface - for (var i = 0; i < plLineCreator.SoilProfile.Layers.Count; ++i) + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + ModelParametersForPlLines = { - plLineCreator.SoilProfile.Layers[i].TopLevel -= 5.0; + DampingFactorPl3 = cDampingFactor } + }; - plLineCreator.SoilProfile.BottomLevel -= 5.0; - // Make upper layer astronomically heavy - plLineCreator.SoilProfile.Layers[0].Soil.AbovePhreaticLevel = 1e25; // About twice the entire earth's mass - plLineCreator.SoilProfile.Layers[0].Soil.BelowPhreaticLevel = 1e25; + // Lower profile for 5 m so upper layer is no longer completely above surface + foreach (SoilLayer1D layer in plLineCreator.SoilProfile.Layers) + { + layer.TopLevel -= 5.0; + } + plLineCreator.SoilProfile.BottomLevel -= 5.0; + // Make upper layer astronomically heavy + plLineCreator.SoilProfile.Layers[0].Soil.AbovePhreaticLevel = 1e25; // About twice the entire earth's mass + plLineCreator.SoilProfile.Layers[0].Soil.BelowPhreaticLevel = 1e25; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; + //double dikeBaseLength = plLineCreator.SurfaceLine.GetDikeToeInward().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; + //double lengthFromRiverToe = plLineCreator.SurfaceLine.Points.Last().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; + //double deltaHead = (plLineCreator.WaterLevelRiver - plLineCreator.WaterLevelPolder) * 0.01 * cDampingFactor; + //double slope = deltaHead / dikeBaseLength; + //double headAtDikeToe = plLineCreator.WaterLevelRiver - deltaHead; + //double headAtEnd = plLineCreator.WaterLevelRiver - slope * lengthFromRiverToe; - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = cDampingFactor; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + // PlLine in this situation is supposed to take the shape of the line with no corrections for uplift - //double dikeBaseLength = plLineCreator.SurfaceLine.GetDikeToeInward().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; - //double lengthFromRiverToe = plLineCreator.SurfaceLine.Points.Last().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; - //double deltaHead = (plLineCreator.WaterLevelRiver - plLineCreator.WaterLevelPolder) * 0.01 * cDampingFactor; - //double slope = deltaHead / dikeBaseLength; - //double headAtDikeToe = plLineCreator.WaterLevelRiver - deltaHead; - //double headAtEnd = plLineCreator.WaterLevelRiver - slope * lengthFromRiverToe; + Assert.That(plLine.Points, Has.Count.EqualTo(4)); - // PlLine in this situation is supposed to take the shape of the line with no corrections for uplift + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(tolerance)); // start + Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(tolerance)); // entry point + Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(tolerance)); // dike toe polder + Assert.That(plLine.Points[2].Z, Is.EqualTo(2.65).Within(tolerance)); // head dike toe polder + Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(tolerance)); // dike toe polder + Assert.That(plLine.Points[3].Z, Is.EqualTo(2.16).Within(tolerance)); // head dike toe polder - Assert.That(plLine.Points.Count, Is.EqualTo(4)); - - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(Tolerance)); // start - Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(Tolerance)); // entry point - Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(Tolerance)); // dike toe polder - Assert.That(plLine.Points[2].Z, Is.EqualTo(2.65).Within(Tolerance)); // head dike toe polder - Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(Tolerance)); // dike toe polder - Assert.That(plLine.Points[3].Z, Is.EqualTo(2.16).Within(Tolerance)); // head dike toe polder - - Assert.That(plLine.ZFromX(plLineCreator.SurfaceLine.GetDikeToeInward().X), Is.EqualTo(2.65).Within(Tolerance)); // headAtDikeToe - } + Assert.That(plLine.ZFromX(plLineCreator.SurfaceLine.GetDikeToeInward().X), Is.EqualTo(2.65).Within(tolerance)); // headAtDikeToe + }); } [Test] public void CreatePl3For1DGeometryInOuterSpaceWithExpertKnowledgeRrd() { const double cDampingFactor = 0.3; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - // Lower profile for 5m so upper layer is no longer completely above surface - plLineCreator.SoilProfile.BottomLevel -= 5.0; - for (int i = plLineCreator.SoilProfile.Layers.Count - 1; i >= 0; --i) + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + ModelParametersForPlLines = { - plLineCreator.SoilProfile.Layers[i].TopLevel -= 5.0; - // Make all layers weightless - plLineCreator.SoilProfile.Layers[i].Soil.AbovePhreaticLevel = 0.0; - plLineCreator.SoilProfile.Layers[i].Soil.BelowPhreaticLevel = 0.0; + DampingFactorPl3 = cDampingFactor } + }; - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; + // Lower profile for 5m so upper layer is no longer completely above surface + plLineCreator.SoilProfile.BottomLevel -= 5.0; + for (int i = plLineCreator.SoilProfile.Layers.Count - 1; i >= 0; --i) + { + plLineCreator.SoilProfile.Layers[i].TopLevel -= 5.0; + // Make all layers weightless + plLineCreator.SoilProfile.Layers[i].Soil.AbovePhreaticLevel = 0.0; + plLineCreator.SoilProfile.Layers[i].Soil.BelowPhreaticLevel = 0.0; + } + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); - plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = cDampingFactor; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl3, 0.02); + //double dikeBaseLength = plLineCreator.SurfaceLine.GetDikeToeInward().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; + //double lengthFromRiverToe = plLineCreator.SurfaceLine.Points.Last().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; + //double deltaHead = (plLineCreator.WaterLevelRiver - plLineCreator.WaterLevelPolder) * 0.01 * cDampingFactor; + //double slope = deltaHead / dikeBaseLength; + //double headAtDikeToe = plLineCreator.WaterLevelRiver - deltaHead; + //double headAtEnd = plLineCreator.WaterLevelRiver - slope * lengthFromRiverToe; - //double dikeBaseLength = plLineCreator.SurfaceLine.GetDikeToeInward().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; - //double lengthFromRiverToe = plLineCreator.SurfaceLine.Points.Last().X - plLineCreator.SurfaceLine.CharacteristicPoints[CharacteristicPointType.DikeToeAtRiver].X; - //double deltaHead = (plLineCreator.WaterLevelRiver - plLineCreator.WaterLevelPolder) * 0.01 * cDampingFactor; - //double slope = deltaHead / dikeBaseLength; - //double headAtDikeToe = plLineCreator.WaterLevelRiver - deltaHead; - //double headAtEnd = plLineCreator.WaterLevelRiver - slope * lengthFromRiverToe; + // PlLine in this situation is supposed to burn down to the polder water level from the entry point - // PlLine in this situation is supposed to burn down to the polder water level from the entry point - - Assert.That(plLine.Points.Count, Is.EqualTo(4)); - - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(Tolerance)); // start - Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(Tolerance)); // entry point - Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(Tolerance)); // end - Assert.That(plLine.Points[2].Z, Is.EqualTo(-0.5).Within(Tolerance)); // water level at polder - Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(Tolerance)); // end - Assert.That(plLine.Points[3].Z, Is.EqualTo(-0.5).Within(Tolerance)); // water level at polder - } + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(tolerance)); // start + Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(tolerance)); // entry point + Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(tolerance)); // end + Assert.That(plLine.Points[2].Z, Is.EqualTo(-0.5).Within(tolerance)); // water level at polder + Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(tolerance)); // end + Assert.That(plLine.Points[3].Z, Is.EqualTo(-0.5).Within(tolerance)); // water level at polder + }); } [Test] public void CreatePl4For1DGeometryWithExpertKnowledgeRrd() { const double cDampingFactor = 0.4; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; - plLineCreator.IsAdjustPL3AndPL4SoNoUpliftWillOccurEnabled = false; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = cDampingFactor; + SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 3.0, + WaterLevelPolder = -0.5, + IsAdjustPL3AndPL4SoNoUpliftWillOccurEnabled = false, + ModelParametersForPlLines = + { + DampingFactorPl4 = cDampingFactor + }, // In this case HeadInPlLine3 is specified (with same value as WaterLevelRiverHigh above, so result should be the same) // Change WaterLevelRiverHigh to be sure the value of HeadInPlLine3 is really used - plLineCreator.HeadInPlLine4 = 4.0; - plLineCreator.WaterLevelRiverHigh = 3.0; - PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl4, 0.02); - CheckPl4LowFor1DGeometryWithExpertKnowledgeRrd(plLine); - } + HeadInPlLine4 = 4.0 + }; + + PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl4, 0.02); + + CheckPl4LowFor1DGeometryWithExpertKnowledgeRrd(plLine); } [Test] public void CreatePl4For1DGeometryWithExpertKnowledgeRrdThrowsExceptionIfNoAquifers() { const double cDampingFactor = 0.4; SurfaceLine2 surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.WaterLevelRiverHigh = 4.0; - plLineCreator.WaterLevelPolder = -0.5; + SoilProfile = FactoryForSoilProfiles.CreateSimpleProfile(), + SurfaceLine = surfaceLineTutorial1, + WaterLevelRiverHigh = 4.0, + WaterLevelPolder = -0.5, + ModelParametersForPlLines = + { + DampingFactorPl4 = cDampingFactor + } + }; - plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = cDampingFactor; - Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl4, 0.02), Throws.InstanceOf()); - } + Assert.That(() => plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.Pl4, 0.02), Throws.InstanceOf()); } [Test] @@ -1570,65 +1780,65 @@ { Name = "Location1" }; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; + SurfaceLine = surfaceLineTutorial1 + }; - var locations = new List + var locations = new List + { + location + }; + var gauges = new List + { + new Gauge { - location - }; - var gauges = new List + Name = "G1", + Location = locations[0], + LocalX = 3.2 + }, + new Gauge { - new Gauge - { - Name = "G1", - Location = locations[0], - LocalX = 3.2 - }, - new Gauge - { - Name = "G2", - Location = locations[0], - LocalX = 12.4 - } - // Gauge "G3" is missing - }; - var gaugePlLines = new List(); + Name = "G2", + Location = locations[0], + LocalX = 12.4 + } + // Gauge "G3" is missing + }; + var gaugePlLines = new List(); - var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - X = 1.2, - Z = 4.5 - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - X = 3.4, - Z = 4.5 - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - X = 4.7, - GaugeIDZ = "G1" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - GaugeIDX = "G3", - GaugeIDZ = "G2" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - X = 17.6, - Z = -2.0 - }); - gaugePlLines.Add(gaugePlLine1); + var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 1.2, + Z = 4.5 + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 3.4, + Z = 4.5 + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 4.7, + GaugeIDZ = "G1" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G3", + GaugeIDZ = "G2" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 17.6, + Z = -2.0 + }); + gaugePlLines.Add(gaugePlLine1); - plLineCreator.GaugePlLines = gaugePlLines; - plLineCreator.Gauges = gauges; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; - Assert.That(() => plLineCreator.CreateAllPlLines(locations[0]), Throws.InstanceOf()); - } + plLineCreator.GaugePlLines = gaugePlLines; + plLineCreator.Gauges = gauges; + plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; + Assert.That(() => plLineCreator.CreateAllPlLines(locations[0]), Throws.InstanceOf()); } [Test] @@ -1639,71 +1849,77 @@ { Name = "Location1" }; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.SurfaceLine = surfaceLineTutorial1; - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; - - var locations = new List + SurfaceLine = surfaceLineTutorial1, + ModelParametersForPlLines = { - location - }; - var gauges = new List - { - new Gauge - { - Name = "G1", - Location = locations[0], - LocalX = 15, - Value = 4 - }, - new Gauge - { - Name = "G2", - Location = locations[0], - LocalX = 45, - Value = 1 - } - }; - var gaugePlLines = new List(); + PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD + } + }; - var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); - gaugePlLine1.Points.Add(new GaugePlLinePoint + var locations = new List + { + location + }; + var gauges = new List + { + new Gauge { - X = 0, - GaugeIDZ = "G1" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint + Name = "G1", + Location = locations[0], + LocalX = 15, + Value = 4 + }, + new Gauge { - GaugeIDX = "G1", - GaugeIDZ = "G1" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - GaugeIDX = "G2", - GaugeIDZ = "G2" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - X = 75, - GaugeIDZ = "G2" - }); - gaugePlLines.Add(gaugePlLine1); + Name = "G2", + Location = locations[0], + LocalX = 45, + Value = 1 + } + }; + var gaugePlLines = new List(); - var gaugePlLine2 = new GaugePlLine(PlLineType.Pl2); - gaugePlLines.Add(gaugePlLine2); + var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 0, + GaugeIDZ = "G1" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G1", + GaugeIDZ = "G1" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G2", + GaugeIDZ = "G2" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 75, + GaugeIDZ = "G2" + }); + gaugePlLines.Add(gaugePlLine1); - var gaugePlLine3 = new GaugePlLine(PlLineType.Pl3); - gaugePlLines.Add(gaugePlLine3); + var gaugePlLine2 = new GaugePlLine(PlLineType.Pl2); + gaugePlLines.Add(gaugePlLine2); - var gaugePlLine4 = new GaugePlLine(PlLineType.Pl4); - gaugePlLines.Add(gaugePlLine4); + var gaugePlLine3 = new GaugePlLine(PlLineType.Pl3); + gaugePlLines.Add(gaugePlLine3); - plLineCreator.GaugePlLines = gaugePlLines; - plLineCreator.Gauges = gauges; - PlLines plLines = plLineCreator.CreateAllPlLines(locations[0]); + var gaugePlLine4 = new GaugePlLine(PlLineType.Pl4); + gaugePlLines.Add(gaugePlLine4); - Assert.That(plLines.Lines[PlLineType.Pl1].Points.Count, Is.EqualTo(4)); + plLineCreator.GaugePlLines = gaugePlLines; + plLineCreator.Gauges = gauges; + PlLines plLines = plLineCreator.CreateAllPlLines(locations[0]); + + Assert.That(plLines.Lines[PlLineType.Pl1].Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { Assert.That(plLines.Lines[PlLineType.Pl1].Points[0].X, Is.EqualTo(0)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[0].Z, Is.EqualTo(4)); // The following point.x is the intersection point of PL1 with the dike @@ -1714,10 +1930,10 @@ Assert.That(plLines.Lines[PlLineType.Pl1].Points[3].X, Is.EqualTo(75)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[3].Z, Is.EqualTo(1)); - Assert.That(plLines.Lines[PlLineType.Pl2].Points.Count, Is.EqualTo(0)); - Assert.That(plLines.Lines[PlLineType.Pl3].Points.Count, Is.EqualTo(0)); - Assert.That(plLines.Lines[PlLineType.Pl4].Points.Count, Is.EqualTo(0)); - } + Assert.That(plLines.Lines[PlLineType.Pl2].Points, Is.Empty); + Assert.That(plLines.Lines[PlLineType.Pl3].Points, Is.Empty); + Assert.That(plLines.Lines[PlLineType.Pl4].Points, Is.Empty); + }); } [Test] @@ -1728,83 +1944,89 @@ { Name = "Location1" }; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; - plLineCreator.SurfaceLine = surfaceLineTutorial1; - - var locations = new List + ModelParametersForPlLines = { - location - }; - var gauges = new List - { - new Gauge - { - Name = "G1", - Location = locations[0], - LocalX = 15, - Value = 4 - }, - new Gauge - { - Name = "G2", - Location = locations[0], - LocalX = 20, - Value = 2 - }, - new Gauge - { - Name = "G3", - Location = locations[0], - LocalX = 45, - Value = 1 - } - }; - var gaugePlLines = new List(); + PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD + }, + SurfaceLine = surfaceLineTutorial1 + }; - var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); - gaugePlLine1.Points.Add(new GaugePlLinePoint + var locations = new List + { + location + }; + var gauges = new List + { + new Gauge { - X = 0, - GaugeIDZ = "G1" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint + Name = "G1", + Location = locations[0], + LocalX = 15, + Value = 4 + }, + new Gauge { - GaugeIDX = "G1", - GaugeIDZ = "G1" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint + Name = "G2", + Location = locations[0], + LocalX = 20, + Value = 2 + }, + new Gauge { - GaugeIDX = "G2", - GaugeIDZ = "G2" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - GaugeIDX = "G3", - GaugeIDZ = "G3" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - X = 75, - GaugeIDZ = "G3" - }); - gaugePlLines.Add(gaugePlLine1); + Name = "G3", + Location = locations[0], + LocalX = 45, + Value = 1 + } + }; + var gaugePlLines = new List(); - var gaugePlLine2 = new GaugePlLine(PlLineType.Pl2); - gaugePlLines.Add(gaugePlLine2); + var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 0, + GaugeIDZ = "G1" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G1", + GaugeIDZ = "G1" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G2", + GaugeIDZ = "G2" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G3", + GaugeIDZ = "G3" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 75, + GaugeIDZ = "G3" + }); + gaugePlLines.Add(gaugePlLine1); - var gaugePlLine3 = new GaugePlLine(PlLineType.Pl3); - gaugePlLines.Add(gaugePlLine3); + var gaugePlLine2 = new GaugePlLine(PlLineType.Pl2); + gaugePlLines.Add(gaugePlLine2); - var gaugePlLine4 = new GaugePlLine(PlLineType.Pl4); - gaugePlLines.Add(gaugePlLine4); + var gaugePlLine3 = new GaugePlLine(PlLineType.Pl3); + gaugePlLines.Add(gaugePlLine3); - plLineCreator.GaugePlLines = gaugePlLines; - plLineCreator.Gauges = gauges; - PlLines plLines = plLineCreator.CreateAllPlLines(locations[0]); + var gaugePlLine4 = new GaugePlLine(PlLineType.Pl4); + gaugePlLines.Add(gaugePlLine4); - Assert.That(plLines.Lines[PlLineType.Pl1].Points.Count, Is.EqualTo(4)); + plLineCreator.GaugePlLines = gaugePlLines; + plLineCreator.Gauges = gauges; + PlLines plLines = plLineCreator.CreateAllPlLines(locations[0]); + + Assert.That(plLines.Lines[PlLineType.Pl1].Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { Assert.That(plLines.Lines[PlLineType.Pl1].Points[0].X, Is.EqualTo(0)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[0].Z, Is.EqualTo(4)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[1].X, Is.EqualTo(29.6)); @@ -1814,10 +2036,10 @@ Assert.That(plLines.Lines[PlLineType.Pl1].Points[3].X, Is.EqualTo(75)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[3].Z, Is.EqualTo(1)); - Assert.That(plLines.Lines[PlLineType.Pl2].Points.Count, Is.EqualTo(0)); - Assert.That(plLines.Lines[PlLineType.Pl3].Points.Count, Is.EqualTo(0)); - Assert.That(plLines.Lines[PlLineType.Pl4].Points.Count, Is.EqualTo(0)); - } + Assert.That(plLines.Lines[PlLineType.Pl2].Points, Is.Empty); + Assert.That(plLines.Lines[PlLineType.Pl3].Points, Is.Empty); + Assert.That(plLines.Lines[PlLineType.Pl4].Points, Is.Empty); + }); } [Test] @@ -1828,147 +2050,165 @@ { Name = "Location1" }; + var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { - var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); - plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; - plLineCreator.SurfaceLine = surfaceLineTutorial1; - - var locations = new List + ModelParametersForPlLines = { - location - }; - var gauges = new List - { - new Gauge - { - Name = "G1", - Location = locations[0], - LocalX = 15, - Value = 6 - }, - new Gauge - { - Name = "G2", - Location = locations[0], - LocalX = 20, - Value = 2 - }, - new Gauge - { - Name = "G3", - Location = locations[0], - LocalX = 45, - Value = 1 - } - }; - var gaugePlLines = new List(); + PlLineCreationMethod = PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD + }, + SurfaceLine = surfaceLineTutorial1 + }; - var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); - gaugePlLine1.Points.Add(new GaugePlLinePoint + var locations = new List + { + location + }; + var gauges = new List + { + new Gauge { - X = 0, - GaugeIDZ = "G1" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint + Name = "G1", + Location = locations[0], + LocalX = 15, + Value = 6 + }, + new Gauge { - GaugeIDX = "G1", - GaugeIDZ = "G1" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint + Name = "G2", + Location = locations[0], + LocalX = 20, + Value = 2 + }, + new Gauge { - GaugeIDX = "G2", - GaugeIDZ = "G2" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - GaugeIDX = "G3", - GaugeIDZ = "G3" - }); - gaugePlLine1.Points.Add(new GaugePlLinePoint - { - X = 75, - GaugeIDZ = "G3" - }); - gaugePlLines.Add(gaugePlLine1); + Name = "G3", + Location = locations[0], + LocalX = 45, + Value = 1 + } + }; + var gaugePlLines = new List(); - var gaugePlLine2 = new GaugePlLine(PlLineType.Pl2); - gaugePlLines.Add(gaugePlLine2); + var gaugePlLine1 = new GaugePlLine(PlLineType.Pl1); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 0, + GaugeIDZ = "G1" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G1", + GaugeIDZ = "G1" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G2", + GaugeIDZ = "G2" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + GaugeIDX = "G3", + GaugeIDZ = "G3" + }); + gaugePlLine1.Points.Add(new GaugePlLinePoint + { + X = 75, + GaugeIDZ = "G3" + }); + gaugePlLines.Add(gaugePlLine1); - var gaugePlLine3 = new GaugePlLine(PlLineType.Pl3); - gaugePlLines.Add(gaugePlLine3); + var gaugePlLine2 = new GaugePlLine(PlLineType.Pl2); + gaugePlLines.Add(gaugePlLine2); - var gaugePlLine4 = new GaugePlLine(PlLineType.Pl4); - gaugePlLines.Add(gaugePlLine4); + var gaugePlLine3 = new GaugePlLine(PlLineType.Pl3); + gaugePlLines.Add(gaugePlLine3); - plLineCreator.GaugePlLines = gaugePlLines; - plLineCreator.Gauges = gauges; - PlLines plLines = plLineCreator.CreateAllPlLines(locations[0]); + var gaugePlLine4 = new GaugePlLine(PlLineType.Pl4); + gaugePlLines.Add(gaugePlLine4); - Assert.That(plLines.Lines[PlLineType.Pl1].Points.Count, Is.EqualTo(2)); + plLineCreator.GaugePlLines = gaugePlLines; + plLineCreator.Gauges = gauges; + PlLines plLines = plLineCreator.CreateAllPlLines(locations[0]); + + Assert.That(plLines.Lines[PlLineType.Pl1].Points, Has.Count.EqualTo(2)); + Assert.Multiple(() => + { Assert.That(plLines.Lines[PlLineType.Pl1].Points[0].X, Is.EqualTo(0)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[0].Z, Is.EqualTo(6)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[1].X, Is.EqualTo(75)); Assert.That(plLines.Lines[PlLineType.Pl1].Points[1].Z, Is.EqualTo(6)); - Assert.That(plLines.Lines[PlLineType.Pl2].Points.Count, Is.EqualTo(0)); - Assert.That(plLines.Lines[PlLineType.Pl3].Points.Count, Is.EqualTo(0)); - Assert.That(plLines.Lines[PlLineType.Pl4].Points.Count, Is.EqualTo(0)); - } + Assert.That(plLines.Lines[PlLineType.Pl2].Points, Is.Empty); + Assert.That(plLines.Lines[PlLineType.Pl3].Points, Is.Empty); + Assert.That(plLines.Lines[PlLineType.Pl4].Points, Is.Empty); + }); } private void CheckPl3For1DGeometryWithExpertKnowledgeRrd(PlLine plLine) { // PlLine is supposed to have adjusted points at both banks of the ditch - Assert.That(plLine.Points.Count, Is.EqualTo(4)); - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(Tolerance)); // start - Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(Tolerance)); // entry point - Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[2].X, Is.EqualTo(59.5).Within(Tolerance)); // ditch due to adjustment for uplift - Assert.That(plLine.Points[2].Z, Is.EqualTo(1.637).Within(Tolerance)); // head ditch - Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(Tolerance)); // end - Assert.That(plLine.Points[3].Z, Is.EqualTo(1.3276).Within(Tolerance)); // headAtDikeEnd + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(tolerance)); // start + Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(tolerance)); // entry point + Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[2].X, Is.EqualTo(59.5).Within(tolerance)); // ditch due to adjustment for uplift + Assert.That(plLine.Points[2].Z, Is.EqualTo(1.637).Within(tolerance)); // head ditch + Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(tolerance)); // end + Assert.That(plLine.Points[3].Z, Is.EqualTo(1.3276).Within(tolerance)); // headAtDikeEnd + }); } private void CheckPl3For1DGeometryWithExpertKnowledgeRrdWithHeadPl2Specified(PlLine plLine) { // PlLine is supposed to have adjusted points at both banks of the ditch - Assert.That(plLine.Points.Count, Is.EqualTo(4)); - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(Tolerance)); // start - Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(Tolerance)); // entry point - Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(Tolerance)); // ditch due to adjustment for uplift - Assert.That(plLine.Points[2].Z, Is.EqualTo(1.3).Within(Tolerance)); // head ditch - Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(Tolerance)); // end - Assert.That(plLine.Points[3].Z, Is.EqualTo(0.81).Within(Tolerance)); // headAtDikeEnd + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(tolerance)); // start + Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(tolerance)); // entry point + Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(tolerance)); // ditch due to adjustment for uplift + Assert.That(plLine.Points[2].Z, Is.EqualTo(1.3).Within(tolerance)); // head ditch + Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(tolerance)); // end + Assert.That(plLine.Points[3].Z, Is.EqualTo(0.81).Within(tolerance)); // headAtDikeEnd + }); } private void CheckPl3LowFor1DGeometryWithExpertKnowledgeRrd(PlLine plLine) { - Assert.That(plLine.Points.Count, Is.EqualTo(4)); - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(Tolerance)); // start - Assert.That(plLine.Points[0].Z, Is.EqualTo(1.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(Tolerance)); // toe of dike - Assert.That(plLine.Points[1].Z, Is.EqualTo(1.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(Tolerance)); // end - Assert.That(plLine.Points[2].Z, Is.EqualTo(0.55).Within(Tolerance)); // headAtDikeEnd - Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(Tolerance)); // end - Assert.That(plLine.Points[3].Z, Is.EqualTo(0.06).Within(Tolerance)); // headAtDikeEnd + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(tolerance)); // start + Assert.That(plLine.Points[0].Z, Is.EqualTo(1.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(tolerance)); // toe of dike + Assert.That(plLine.Points[1].Z, Is.EqualTo(1.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(tolerance)); // end + Assert.That(plLine.Points[2].Z, Is.EqualTo(0.55).Within(tolerance)); // headAtDikeEnd + Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(tolerance)); // end + Assert.That(plLine.Points[3].Z, Is.EqualTo(0.06).Within(tolerance)); // headAtDikeEnd + }); } private void CheckPl4LowFor1DGeometryWithExpertKnowledgeRrd(PlLine plLine) { // PlLine is supposed to have adjusted points at dike toe and end - Assert.That(plLine.Points.Count, Is.EqualTo(4)); - Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(Tolerance)); // start - Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(Tolerance)); // entry point - Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(Tolerance)); // water level at river - Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(Tolerance)); // dike toe - Assert.That(plLine.Points[2].Z, Is.EqualTo(2.2).Within(Tolerance)); // head dike toe - Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(Tolerance)); // end - Assert.That(plLine.Points[3].Z, Is.EqualTo(1.71).Within(Tolerance)); // head end + Assert.That(plLine.Points, Has.Count.EqualTo(4)); + Assert.Multiple(() => + { + Assert.That(plLine.Points[0].X, Is.EqualTo(0.0).Within(tolerance)); // start + Assert.That(plLine.Points[0].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[1].X, Is.EqualTo(10.0).Within(tolerance)); // entry point + Assert.That(plLine.Points[1].Z, Is.EqualTo(4.0).Within(tolerance)); // water level at river + Assert.That(plLine.Points[2].X, Is.EqualTo(50.5).Within(tolerance)); // dike toe + Assert.That(plLine.Points[2].Z, Is.EqualTo(2.2).Within(tolerance)); // head dike toe + Assert.That(plLine.Points[3].X, Is.EqualTo(75.0).Within(tolerance)); // end + Assert.That(plLine.Points[3].Z, Is.EqualTo(1.71).Within(tolerance)); // head end + }); } /////