Contains tests for class PLLineCreator

//---------------------------------------------------------------------- using Deltares.Geometry; using Deltares.Geotechnics; using Deltares.Geotechnics.GeotechnicalGeometry; using System.Collections.Generic; using Deltares.Dam.Data; using Deltares.Geotechnics.SurfaceLines; using Deltares.Geotechnics.TestUtils; using Deltares.Soilbase; using NUnit.Framework; namespace Deltares.Dam.Tests { [TestFixture] public class PLLinesCreatorTest { private double Tolerance = 0.001; [TestFixtureSetUp] public void TestFixtureSetup() { } [SetUp] public void TestSetup() { } ///

/// Create a simple surfaceline without shoulder ///

/// the created surfaceline static private SurfaceLine2 CreateSurfacelineSimpleDike() { var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); 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); return surfaceLine; } ///

/// Create a simple surfaceline without shoulder ///

/// the created surfaceline static private SurfaceLine2 CreateSurfacelineDikeWithSlopingShoulder() { var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); surfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); surfaceLine.EnsurePointOfType(4.0, 5.0, CharacteristicPointType.DikeTopAtRiver); surfaceLine.EnsurePointOfType(7.0, 5.0, CharacteristicPointType.DikeTopAtPolder); surfaceLine.EnsurePointOfType(9.0, 3.0, CharacteristicPointType.ShoulderBaseInside); surfaceLine.EnsurePointOfType(11.0, 2.5, CharacteristicPointType.ShoulderTopInside); surfaceLine.EnsurePointOfType(12.5, 1.0, CharacteristicPointType.DikeToeAtPolder); surfaceLine.EnsurePointOfType(15.0, 1.0, CharacteristicPointType.SurfaceLevelInside); return surfaceLine; } ///

/// Create a simple surfaceline without shoulder and Ditch at PolderSide ///

/// the created surfaceline static private SurfaceLine2 CreateSurfacelineSimpleDikeWithDitchAtPolderSide() { var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); surfaceLine.EnsurePointOfType(10.0, 0.0, CharacteristicPointType.DikeToeAtRiver); surfaceLine.EnsurePointOfType(20.0, 5.0, CharacteristicPointType.DikeTopAtRiver); surfaceLine.EnsurePointOfType(25.0, 5.0, CharacteristicPointType.DikeTopAtPolder); surfaceLine.EnsurePointOfType(30.0, 0.0, CharacteristicPointType.DikeToeAtPolder); surfaceLine.EnsurePointOfType(35.0, 0.0, CharacteristicPointType.DitchDikeSide); surfaceLine.EnsurePointOfType(36.0, -1.0, CharacteristicPointType.BottomDitchDikeSide); surfaceLine.EnsurePointOfType(38.0, -1.0, CharacteristicPointType.BottomDitchPolderSide); surfaceLine.EnsurePointOfType(39.0, 0.0, CharacteristicPointType.DitchPolderSide); surfaceLine.EnsurePointOfType(100.0, 0.0, CharacteristicPointType.SurfaceLevelInside); return surfaceLine; } ///

/// Create a simple surfaceline without shoulder and NWO at PolderSide ///

/// the created surfaceline static private SurfaceLine2 CreateSurfacelineSimpleDikeWithNWOAtPolderSide() { var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); surfaceLine.EnsurePointOfType(10.0, 0.0, CharacteristicPointType.DikeToeAtRiver); surfaceLine.EnsurePointOfType(20.0, 5.0, CharacteristicPointType.DikeTopAtRiver); surfaceLine.EnsurePointOfType(25.0, 5.0, CharacteristicPointType.DikeTopAtPolder); surfaceLine.EnsurePointOfType(30.0, 0.0, CharacteristicPointType.DikeToeAtPolder); surfaceLine.EnsurePointOfType(35.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint1); surfaceLine.EnsurePointOfType(36.0, -2.0, CharacteristicPointType.NonWaterRetainingObjectPoint2); surfaceLine.EnsurePointOfType(38.0, -2.0, CharacteristicPointType.NonWaterRetainingObjectPoint3); surfaceLine.EnsurePointOfType(39.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint4); surfaceLine.EnsurePointOfType(100.0, 0.0, CharacteristicPointType.SurfaceLevelInside); return surfaceLine; } ///

/// Create a simple surfaceline without shoulder and NWO + Ditch at right of NWO at PolderSide ///

/// the created surfaceline static private SurfaceLine2 CreateSurfacelineSimpleDikeWithNWOAndDitchRightAtPolderSide() { var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); surfaceLine.EnsurePointOfType(10.0, 0.0, CharacteristicPointType.DikeToeAtRiver); surfaceLine.EnsurePointOfType(20.0, 5.0, CharacteristicPointType.DikeTopAtRiver); surfaceLine.EnsurePointOfType(25.0, 5.0, CharacteristicPointType.DikeTopAtPolder); surfaceLine.EnsurePointOfType(30.0, 0.0, CharacteristicPointType.DikeToeAtPolder); surfaceLine.EnsurePointOfType(35.0, 0.0, CharacteristicPointType.NonWaterRetainingObjectPoint1); surfaceLine.EnsurePointOfType(36.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint2); surfaceLine.EnsurePointOfType(38.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint3); surfaceLine.EnsurePointOfType(39.0, 0.0, CharacteristicPointType.NonWaterRetainingObjectPoint4); surfaceLine.EnsurePointOfType(45.0, 0.0, CharacteristicPointType.DitchDikeSide); surfaceLine.EnsurePointOfType(46.0, -1.0, CharacteristicPointType.BottomDitchDikeSide); surfaceLine.EnsurePointOfType(48.0, -1.0, CharacteristicPointType.BottomDitchPolderSide); surfaceLine.EnsurePointOfType(49.0, 0.0, CharacteristicPointType.DitchPolderSide); surfaceLine.EnsurePointOfType(100.0, 0.0, CharacteristicPointType.SurfaceLevelInside); return surfaceLine; } ///

/// Create a simple surfaceline without shoulder and NWO + Ditch at left of NWO at PolderSide ///

/// the created surfaceline static private SurfaceLine2 CreateSurfacelineSimpleDikeWithNWOAndDitchLeftAtPolderSide() { var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); surfaceLine.EnsurePointOfType(10.0, 0.0, CharacteristicPointType.DikeToeAtRiver); surfaceLine.EnsurePointOfType(20.0, 5.0, CharacteristicPointType.DikeTopAtRiver); surfaceLine.EnsurePointOfType(25.0, 5.0, CharacteristicPointType.DikeTopAtPolder); surfaceLine.EnsurePointOfType(30.0, 0.0, CharacteristicPointType.DikeToeAtPolder); surfaceLine.EnsurePointOfType(35.0, 0.0, CharacteristicPointType.DitchDikeSide); surfaceLine.EnsurePointOfType(36.0, -1.0, CharacteristicPointType.BottomDitchDikeSide); surfaceLine.EnsurePointOfType(38.0, -1.0, CharacteristicPointType.BottomDitchPolderSide); surfaceLine.EnsurePointOfType(39.0, 0.0, CharacteristicPointType.DitchPolderSide); surfaceLine.EnsurePointOfType(45.0, 0.0, CharacteristicPointType.NonWaterRetainingObjectPoint1); surfaceLine.EnsurePointOfType(46.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint2); surfaceLine.EnsurePointOfType(48.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint3); surfaceLine.EnsurePointOfType(49.0, 0.0, CharacteristicPointType.NonWaterRetainingObjectPoint4); surfaceLine.EnsurePointOfType(100.0, 0.0, CharacteristicPointType.SurfaceLevelInside); return surfaceLine; } ///

/// Create a simple surfaceline without shoulder and NWO at RiverSide ///

/// the created surfaceline static private SurfaceLine2 CreateSurfacelineSimpleDikeWithNWOAtRiverSide() { var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.EnsurePointOfType(0.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); surfaceLine.EnsurePointOfType(5.0, 0.0, CharacteristicPointType.NonWaterRetainingObjectPoint1); surfaceLine.EnsurePointOfType(6.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint2); surfaceLine.EnsurePointOfType(8.0, -1.0, CharacteristicPointType.NonWaterRetainingObjectPoint3); surfaceLine.EnsurePointOfType(9.0, 0.0, CharacteristicPointType.NonWaterRetainingObjectPoint4); surfaceLine.EnsurePointOfType(10.0, 0.0, CharacteristicPointType.DikeToeAtRiver); surfaceLine.EnsurePointOfType(20.0, 5.0, CharacteristicPointType.DikeTopAtRiver); surfaceLine.EnsurePointOfType(25.0, 5.0, CharacteristicPointType.DikeTopAtPolder); surfaceLine.EnsurePointOfType(30.0, 0.0, CharacteristicPointType.DikeToeAtPolder); surfaceLine.EnsurePointOfType(100.0, 0.0, CharacteristicPointType.SurfaceLevelInside); return surfaceLine; } ///

/// Test if PL1 created correctly if PolderLevel above toe at polder ///

[Test] public void CreatePL1WithPolderLevelHigherDikeToeAtPolder() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(9.25, plLine.Points[2].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[2].Z, cTolerance); Assert.AreEqual(12, plLine.Points[3].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[3].Z, cTolerance); plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.5; // Default value plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(9.25, plLine.Points[4].X, cTolerance); // this point and following points are raised to match polderlevel Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[4].Z, cTolerance); Assert.AreEqual(12, plLine.Points[5].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[5].Z, cTolerance); } } ///

/// Test if PL1 created correctly if PolderLevel above shoulder top inside ///

[Test] public void CreatePL1WithPolderLevelBetweenShoulderBaseInsideAndShoulderTopInside() { const double cTolerance = 0.0001; using (var surfacelineDikeWithSlopingShoulder = CreateSurfacelineDikeWithSlopingShoulder()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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 = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineDikeWithSlopingShoulder; plLineCreator.WaterLevelPolder = 2.75; // CharacteristicPointType.ShoulderTopInside.Z = 2.5; CharacteristicPointType.ShoulderBaseInside.Z = 3.0); PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(7, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[3].Z, cTolerance); Assert.AreEqual(9.0, plLine.Points[4].X, cTolerance); // This point has offset below surfacelevel of PlLineOffsetBelowShoulderBaseInside Assert.AreEqual(2.9, plLine.Points[4].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[5].X, cTolerance); // This point and following points are raised to match polderlevel Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[5].Z, cTolerance); Assert.AreEqual(15, plLine.Points[6].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[6].Z, cTolerance); } } ///

/// Test if PL1 created correctly if PolderLevel above shoulder base inside ///

[Test] public void CreatePL1WithPolderLevelHigherShoulderBaseInside() { const double cTolerance = 0.0001; using (var surfacelineDikeWithSlopingShoulder = CreateSurfacelineDikeWithSlopingShoulder()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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 = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineDikeWithSlopingShoulder; plLineCreator.WaterLevelPolder = 3.25; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Lower than PlLineOffsetBelowDikeTopAtPolder PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.5, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.5, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.5, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8.75, plLine.Points[4].X, cTolerance); // This point and following points are raised to match polderlevel Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[4].Z, cTolerance); Assert.AreEqual(15, plLine.Points[5].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[5].Z, cTolerance); plLineCreator.WaterLevelPolder = 3.75; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Higher than PlLineOffsetBelowDikeTopAtPolder plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.5, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.5, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.5, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); // This point and following points are raised to match polderlevel Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8.25, plLine.Points[4].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[4].Z, cTolerance); Assert.AreEqual(15, plLine.Points[5].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[5].Z, cTolerance); plLineCreator.WaterLevelPolder = 4.25; // CharacteristicPointType.ShoulderBaseInside.Z = 3.0); Higher than PlLineOffsetBelowDikeTopAtRiver plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.5, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.5, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.5, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance);// This point and following points are raised to match polderlevel Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[3].Z, cTolerance); Assert.AreEqual(7.75, plLine.Points[4].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[4].Z, cTolerance); Assert.AreEqual(15, plLine.Points[5].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[5].Z, cTolerance); } } ///

/// Test if exception thrown if PolderLevel above top of dike ///

[Test] [ExpectedException(typeof(PLLinesCreatorException))] public void ThrowsWhenPolderLevelHigherDikeTopAtPolder() { using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z + 0.1; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); } } ///

/// Test if PL1 is created correctly with expert knowledge ///

[Test] public void CreatePL1For1DGeometryWithExpertKnowledgeLinearInDike() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(10, plLine.Points[2].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[2].Z, cTolerance); Assert.AreEqual(12, plLine.Points[3].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[3].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge ///

[Test] public void CreatePL1For1DGeometryWithExpertKnowledgeLinearInDikeWithShoulder() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfileTests.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.SortPoints(); plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(10, plLine.Points[2].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[2].Z, cTolerance); Assert.AreEqual(12, plLine.Points[3].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[3].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge when low water crosses dike ///

[Test] public void CreatePL1LowMidFor1DGeometryWithExpertKnowledgeLinearInDike() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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 = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(5, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(2.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.9, plLine.Points[2].Z, cTolerance); Assert.AreEqual(10, plLine.Points[3].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[3].Z, cTolerance); Assert.AreEqual(12, plLine.Points[4].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[4].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge when low water below surface level ///

[Test] public void CreatePL1LowLowFor1DGeometryWithExpertKnowledgeLinearInDike() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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 = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(5, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.9, plLine.Points[2].Z, cTolerance); Assert.AreEqual(10, plLine.Points[3].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[3].Z, cTolerance); Assert.AreEqual(12, plLine.Points[4].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[4].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge when low water crosses multi segment dike ///

[Test] public void CreatePL1LowMidFor1DGeometryWithExpertKnowledgeLinearInDikeWithMultiSegmentTalud() { const double cTolerance = 0.0001; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator{SurfaceLine = surfaceLine}; Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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 = FactoryForSoilProfileTests.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.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(5, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(2.5, plLine.Points[1].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.9, plLine.Points[2].Z, cTolerance); Assert.AreEqual(10, plLine.Points[3].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[3].Z, cTolerance); Assert.AreEqual(12, plLine.Points[4].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[4].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge when low water below multi segment surface level ///

[Test] public void CreatePL1LowLowFor1DGeometryWithExpertKnowledgeLinearInDikeWithMultiSegmentTalud() { const double cTolerance = 0.0001; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator { SurfaceLine = surfaceLine }; Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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 = FactoryForSoilProfileTests.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.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(7, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(1.5, plLine.Points[2].X, cTolerance); Assert.AreEqual(2.4, plLine.Points[2].Z, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.9, plLine.Points[3].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[4].X, cTolerance); Assert.AreEqual(3.9, plLine.Points[4].Z, cTolerance); Assert.AreEqual(10, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[5].Z, cTolerance); Assert.AreEqual(12, plLine.Points[6].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[6].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge with complex profile ///

[Test] public void CreatePL1For1DGeometryWithExpertKnowledgeRRD() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtRiver, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtPolder, plLine.Points[3].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[4].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[4].Z, cTolerance); Assert.AreEqual(12, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[5].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge with complex profile when waterlevel of river equlas top of dike /// This coudl cause a problem in PLLinesCreator.ValidatePhreaticBelowDike ///

[Test] public void CreatePL1For1DGeometryWithExpertKnowledgeRRDIfRiverlevelEqualsTopOfDike() { const double cTolerance = 0.0001; using(var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.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, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh, plLine.Points[0].Z, cTolerance); Assert.AreEqual(plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).X, plLine.Points[1].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtRiver, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelRiverHigh - plLineCreator.PlLineOffsetBelowDikeTopAtPolder, plLine.Points[3].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[4].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[4].Z, cTolerance); Assert.AreEqual(12, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[5].Z, cTolerance); } } ///

/// Test if PL1 creation expert knowledge with does not create pl-line below polderlevel ///

[Test] public void CreatePL1_WithPointBelowDikeTopAtPolderLowerPolderLevel_ReturnsPointAtPolderLevel() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { var plLineCreator = new PLLinesCreator { SoilProfile = FactoryForSoilProfileTests.CreateClaySandProfile(), WaterLevelRiverHigh = 2.5, ModelParametersForPLLines = { PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeRRD } }; 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, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[0].Z, cTolerance); Assert.AreEqual(4, plLine.Points[2].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7, plLine.Points[3].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[3].Z, cTolerance); Assert.AreEqual(10, plLine.Points[4].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[4].Z, cTolerance); Assert.AreEqual(12, plLine.Points[5].X, cTolerance); Assert.AreEqual(plLineCreator.WaterLevelPolder, plLine.Points[5].Z, cTolerance); } } ///

/// Test if PL1 creation expert knowledge can be configured with /// PlLineOffsetBelowShoulderBaseInside and PlLineOffsetBelowDikeToeAtPolder ///

[Test] public void CreatePL1_WithPointBelowShoulderAndPointBelowToeDefined_ReturnsCorrectPl1() { const double cTolerance = 0.0001; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { var plLineCreator = new PLLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfileTests.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.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, DamType.Regional, 0.02); Assert.AreEqual(7, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8.0, plLine.Points[4].X, cTolerance); Assert.AreEqual(1.8, plLine.Points[4].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.7, plLine.Points[5].Z, cTolerance); Assert.AreEqual(12, plLine.Points[6].X, cTolerance); Assert.AreEqual(0.7, plLine.Points[6].Z, cTolerance); } } [Test] public void CreatePL1_WithPointBelowShoulderAndPointBelowToeDefinedWithSlopingSurfaceAtPolderSide_ReturnsCorrectPl1() { const double cTolerance = 0.0001; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { var plLineCreator = new PLLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfileTests.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.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, DamType.Regional, 0.02); Assert.AreEqual(9, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8.0, plLine.Points[4].X, cTolerance); Assert.AreEqual(1.8, plLine.Points[4].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.7, plLine.Points[5].Z, cTolerance); Assert.AreEqual(11, plLine.Points[6].X, cTolerance); Assert.AreEqual(0.2, plLine.Points[6].Z, cTolerance); Assert.AreEqual(12, plLine.Points[7].X, cTolerance); Assert.AreEqual(0.1, plLine.Points[7].Z, cTolerance); Assert.AreEqual(13, plLine.Points[8].X, cTolerance); Assert.AreEqual(0.0, plLine.Points[8].Z, cTolerance); } } [Test] public void CreatePL1_WithPointBelowShoulderAndPointBelowToeDefinedWithSlopingSurfaceAtPolderSidePartBelowPolderLevel_ReturnsCorrectPl1() { const double cTolerance = 0.0001; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { var plLineCreator = new PLLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfileTests.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.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, DamType.Regional, 0.02); Assert.AreEqual(9, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8.0, plLine.Points[4].X, cTolerance); Assert.AreEqual(1.8, plLine.Points[4].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.7, plLine.Points[5].Z, cTolerance); Assert.AreEqual(11, plLine.Points[6].X, cTolerance); Assert.AreEqual(0.2, plLine.Points[6].Z, cTolerance); Assert.AreEqual(11.5, plLine.Points[7].X, cTolerance); Assert.AreEqual(0.0, plLine.Points[7].Z, cTolerance); Assert.AreEqual(15, plLine.Points[8].X, cTolerance); Assert.AreEqual(0.0, plLine.Points[8].Z, cTolerance); } } [Test] public void CreatePL1_WithPointBelowShoulderAndPointBelowToeDefinedWithSlopingSurfaceAtPolderSideAllBelowPolderLevel_ReturnsCorrectPl1() { const double cTolerance = 0.0001; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { var plLineCreator = new PLLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfileTests.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.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, DamType.Regional, 0.02); Assert.AreEqual(7, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(4.0, plLine.Points[2].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.0, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8.0, plLine.Points[4].X, cTolerance); Assert.AreEqual(1.8, plLine.Points[4].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[5].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[5].Z, cTolerance); Assert.AreEqual(13, plLine.Points[6].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[6].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge with complex profile and low waterlevel ///

[Test] public void CreatePL1LowFor1DGeometryWithExpertKnowledgeRRD() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 3.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(2.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(10, plLine.Points[4].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[4].Z, cTolerance); Assert.AreEqual(12, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[5].Z, cTolerance); } } ///

/// Test if PL1 is created correctly with expert knowledge with complex profile and low waterlevel below toe of dike riverside ///

[Test] public void CreatePL1LowBelowToeFor1DGeometryWithExpertKnowledgeRRD() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.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.SortPoints(); // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(8, plLine.Points.Count); Assert.AreEqual(-2.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(-1.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(0, plLine.Points[2].X, cTolerance); Assert.AreEqual(1.9, plLine.Points[2].Z, cTolerance); Assert.AreEqual(1, plLine.Points[3].X, cTolerance); Assert.AreEqual(1.9, plLine.Points[3].Z, cTolerance); Assert.AreEqual(4, plLine.Points[4].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[4].Z, cTolerance); Assert.AreEqual(7, plLine.Points[5].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(10, plLine.Points[6].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[6].Z, cTolerance); Assert.AreEqual(12, plLine.Points[7].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[7].Z, cTolerance); } } ///

/// Test if exception is thrown when creating PL2 with no soilprofile ///

[Test] [ExpectedException(typeof(PLLinesCreatorException))] public void CreatePL2WithExpertKnowledgeRRDThrowsExceptionIfNoSoilProfile() { using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SurfaceLine = surfaceLine; plLineCreator.ModelParametersForPLLines.PenetrationLength = 6.0; plLineCreator.HeadInPLLine2 = 4.0; plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); } } ///

/// Test if exception is thrown when creating PL2 with no surface line ///

[Test] [ExpectedException(typeof(PLLinesCreatorException))] public void CreatePL2WithExpertKnowledgeRRDThrowsExceptionIfNoSurfaceLine() { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateSimpleProfile(); plLineCreator.SurfaceLine = null; plLineCreator.ModelParametersForPLLines.PenetrationLength = 6.0; plLineCreator.HeadInPLLine2 = 4.0; plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); } ///

/// Test if exception is thrown when creating PL2 if no aquifer present ///

[Test] [ExpectedException(typeof(PLLinesCreatorException))] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDThrowsExceptionIfNoAquiferLayerAtAll() { using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateSimpleProfile(); plLineCreator.SurfaceLine = surfaceLine; plLineCreator.ModelParametersForPLLines.PenetrationLength = 6.0; plLineCreator.HeadInPLLine2 = 4.0; plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); } } ///

/// Test if PL2 is created correctly if no inbetween aquifer present ///

[Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDIfNoAquiferLayerInBetween() { const double cHeadPL2 = 3.0; const double cPenetrationLength = 6.0; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator{SurfaceLine = surfaceLine}; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandProfile(); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(1.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(10.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(21.0, 2.5)); plLineCreator.ModelParametersForPLLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPLLine2 = cHeadPL2; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); Assert.IsTrue(plLine.Exists()); } } [Test] [ExpectedException(typeof(PLLinesCreatorException))] public void CreatePL2WithExpertKnowledgeRRDThrowsExceptionIfPenetrationLengthNegative() { const double cHeadPL2 = 3.0; const double cPenetrationLength = -1.0; PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateSimpleProfile(); plLineCreator.ModelParametersForPLLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPLLine2 = cHeadPL2; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); } ///

/// Test if PL2 is created correctly if no inbetween aquifer present and penetration length = 0 ///

[Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthZero() { const double cHeadPL2 = 3.0; const double cPenetrationLength = 0.0; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator{SurfaceLine = surfaceLine}; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(1.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(10.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(21.0, 2.5)); plLineCreator.ModelParametersForPLLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPLLine2 = cHeadPL2; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); // No extra layer should have been added to profile Assert.AreEqual(4, plLineCreator.SoilProfile.Layers.Count); Assert.IsFalse(plLine.Exists()); } } ///

/// Test if PL2 is created correctly if no inbetween aquifer present and penetration length above that aquifer ///

[Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthAboveThisSandLayer() { const double cHeadPL2 = 3.0; const double cPenetrationLength = 6.0; using (var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator{SurfaceLine = surfaceLine}; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(1.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(10.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(GeometryPoint.CreateNewXZPoint(21.0, 2.5)); plLineCreator.ModelParametersForPLLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPLLine2 = cHeadPL2; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); Assert.IsFalse(plLine.Exists()); } } ///

/// Test if PL2 is created correctly if no inbetween aquifer present and penetration length ending in that aquifer ///

[Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthInThisAquiferLayer() { const double cPenetrationLength = 4.0; const double cHeadPL2 = 3.0; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new 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 = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL2, DamType.Regional, 0.02); Assert.IsFalse(plLine.Exists()); } } ///

/// Test if PL2 and PL4 are created correctly if no inbetween aquifer present and penetration length ending in that aquifer ///

[Test] public void CreatePL2andPL4For1DGeometryWithExpertKnowledgeRRDWithAllWithSandLayerInBetweenAndPenetrationLengthInThisAquiferLayer() { const double cPenetrationLength = 4.0; const double cHeadInPLLine2 = 3.0; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new 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 = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; using (Location primaryLocation = new Location()) using (Location regionalLocation = new Location()) { primaryLocation.DamType = DamType.Primary; PLLines plLines = plLineCreator.CreateAllPLLines(primaryLocation); PLLine plLine2 = plLines.Lines[PLLineType.PL2]; PLLine plLine4 = plLines.Lines[PLLineType.PL4]; Assert.IsTrue(plLine2.Exists()); Assert.IsTrue(plLine4.Exists()); Assert.AreEqual(plLine4.Points.Count, plLine2.Points.Count); Assert.AreEqual(plLine4.Points[0].Z, 4.0); for (int pointIndex = 0; pointIndex < plLine4.Points.Count; pointIndex++) { Assert.IsTrue(plLine2.Points[pointIndex].LocationEquals(plLine4.Points[pointIndex])); } regionalLocation.DamType = DamType.Regional; plLines = plLineCreator.CreateAllPLLines(regionalLocation); plLine2 = plLines.Lines[PLLineType.PL2]; plLine4 = plLines.Lines[PLLineType.PL4]; Assert.IsTrue(plLine2.Exists()); Assert.IsTrue(plLine4.Exists()); Assert.AreEqual(plLine4.Points.Count, plLine2.Points.Count); Assert.AreEqual(plLine4.Points[0].Z, -0.5); } } } [Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthBelowBottomOfThisAquiferLayer() { const double cHeadPL2 = 3.0; const double cPenetrationLength = 3.0; using(var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; 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, DamType.Regional, 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); Assert.AreEqual(-2.0, plLineCreator.SoilProfile.Layers[orgLayerCount - 1].TopLevel, 0.01); } } [Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithSandLayerInBetweenAndPenetrationLengthBelowBottomOfThisAquiferLayerWithMultipleInfiltrationLayers() { const double cHeadPL2 = 3.0; const double cPenetrationLength = 2.0; using(var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateMultiInfiltrationLayerProfile(); int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; 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, DamType.Regional, 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); 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); } } [Test] public void CreatePL2For1DGeometryWithExpertKnowledgeRRDWithAquiferLayerInBetweenAndPenetrationLengthExactlyAtBottomOfAInfiltrationLayer() { const double cHeadPL2 = 3.0; const double cPenetrationLength = 2.7; using(var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateMultiInfiltrationLayerProfile(); int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; 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, DamType.Regional, 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.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; using(var surfaceLine = new SurfaceLine2 { Geometry = new LocalizedGeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateMultiInfiltrationLayerProfile(); int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; 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, DamType.Regional, 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.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] [ExpectedException(typeof(PLLinesCreatorException))] public void CreatePL3For1DGeometryWithExpertKnowledgeRRDThrowsExceptionIfNoAquiferLayers() { const double cDampingFactor = 0.3; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateSimpleProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = cDampingFactor; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL3, DamType.Regional, 0.02); } } [Test] public void CreatePL4For1DGeometryWithExpertKnowledgeRRDIfNoInBetweenAquiferLayer() { const double cDampingFactor = 0.3; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = cDampingFactor; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL4, DamType.Regional, 0.02); Assert.IsFalse(plLine.Exists()); } } ///

/// This test evaluates the same stuation as CreatePL3For1DGeometryWithExpertKnowledgeRRD() /// The difference is that here the geometry is entered as a 2d-geometry ///

[Test] public void CreatePL3For2DGeometryWithExpertKnowledgeRRD() { string soilGeometry2DName = @"TestData\PLLineCreation.sti"; string soilDatabaseName = @"TestData\PLLineCreation.mdb"; string cDikeMaterial = "HW-OBO"; const double cDampingFactor = 0.3; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilGeometryType = SoilGeometryType.SoilGeometry2D; plLineCreator.SoilProfile = null; plLineCreator.SoilGeometry2DName = soilGeometry2DName; plLineCreator.SoilBaseDB = SoilbaseDB.Create(soilDatabaseName); plLineCreator.SoilList = plLineCreator.SoilBaseDB.CreateSoilList(); plLineCreator.DikeEmbankmentMaterial = plLineCreator.SoilBaseDB.GetSoil(cDikeMaterial); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = cDampingFactor; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL3, DamType.Regional, 0.02); //double headAtDikeToe = plLineCreator.WaterLevelRiver - (plLineCreator.WaterLevelRiver - plLineCreator.WaterLevelPolder) * 0.01 * cDampingFactor; // PLLine is supposed to have adjusted points at both banks of the ditch Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, Tolerance); // start Assert.AreEqual(4.0, plLine.Points[0].Z, Tolerance); // water level at river Assert.AreEqual(10.0, plLine.Points[1].X, Tolerance); // entry point Assert.AreEqual(4.0, plLine.Points[1].Z, Tolerance); // water level at river Assert.AreEqual(61.5, plLine.Points[2].X, Tolerance); // left ditch bank Assert.AreEqual(1.6376, plLine.Points[2].Z, Tolerance); // Assert.AreEqual(75.0, plLine.Points[3].X, Tolerance); // end Assert.AreEqual(1.3676, plLine.Points[3].Z, Tolerance); // headAtDikeEnd //Assert.AreEqual(?, plLine.ZFromX(plLineCreator.SurfaceLine.GetDikeToeInward().X), Tolerance); // headAtDikeToe } } ///

/// This test evaluates the same stuation as CreatePL3For1DGeometryWithExpertKnowledgeRRD() /// The difference is that here the geometry is entered as a 1d-geometry ///

[Test] public void CreatePL3For1DGeometryWithExpertKnowledgeRRD() { const double cDampingFactor = 0.3; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.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, DamType.Regional, 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, DamType.Regional, 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, DamType.Regional, 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, DamType.Regional, 0.02); CheckPL3For1DGeometryWithExpertKnowledgeRRDWithHeadPl2Specified(plLine); } } private void CheckPL3For1DGeometryWithExpertKnowledgeRRD(PLLine plLine) { // PLLine is supposed to have adjusted points at both banks of the ditch Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, Tolerance); // start Assert.AreEqual(4.0, plLine.Points[0].Z, Tolerance); // water level at river Assert.AreEqual(10.0, plLine.Points[1].X, Tolerance); // entry point Assert.AreEqual(4.0, plLine.Points[1].Z, Tolerance); // water level at river Assert.AreEqual(59.5, plLine.Points[2].X, Tolerance); // ditch due to adjustment for uplift Assert.AreEqual(1.637, plLine.Points[2].Z, Tolerance); // head ditch Assert.AreEqual(75.0, plLine.Points[3].X, Tolerance); // end Assert.AreEqual(1.3276, plLine.Points[3].Z, Tolerance); // headAtDikeEnd } private void CheckPL3For1DGeometryWithExpertKnowledgeRRDWithHeadPl2Specified(PLLine plLine) { // PLLine is supposed to have adjusted points at both banks of the ditch Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, Tolerance); // start Assert.AreEqual(4.0, plLine.Points[0].Z, Tolerance); // water level at river Assert.AreEqual(10.0, plLine.Points[1].X, Tolerance); // entry point Assert.AreEqual(4.0, plLine.Points[1].Z, Tolerance); // water level at river Assert.AreEqual(50.5, plLine.Points[2].X, Tolerance); // ditch due to adjustment for uplift Assert.AreEqual(1.3, plLine.Points[2].Z, Tolerance); // head ditch Assert.AreEqual(75.0, plLine.Points[3].X, Tolerance); // end Assert.AreEqual(0.81, plLine.Points[3].Z, Tolerance); // headAtDikeEnd } [Test] public void CreatePL3LowFor1DGeometryWithExpertKnowledgeRRD() { const double cDampingFactor = 0.3; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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, DamType.Regional, 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, DamType.Regional, 0.02); CheckPL3LowFor1DGeometryWithExpertKnowledgeRRD(plLine); } } private void CheckPL3LowFor1DGeometryWithExpertKnowledgeRRD(PLLine plLine) { Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, Tolerance); // start Assert.AreEqual(1.0, plLine.Points[0].Z, Tolerance); // water level at river Assert.AreEqual(10.0, plLine.Points[1].X, Tolerance); // toe of dike Assert.AreEqual(1.0, plLine.Points[1].Z, Tolerance); // water level at river Assert.AreEqual(50.5, plLine.Points[2].X, Tolerance); // end Assert.AreEqual(0.55, plLine.Points[2].Z, Tolerance); // headAtDikeEnd Assert.AreEqual(75.0, plLine.Points[3].X, Tolerance); // end Assert.AreEqual(0.06, plLine.Points[3].Z, Tolerance); // headAtDikeEnd } [Test] public void CreatePL3For1DGeometryInBlackHoleWithExpertKnowledgeRRD() { const double cDampingFactor = 0.3; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.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) { plLineCreator.SoilProfile.Layers[i].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; plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = cDampingFactor; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL3, DamType.Regional, 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; // PLLine in this situation is supposed to take the shape of the line with no corrections for uplift Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, Tolerance); // start Assert.AreEqual(4.0, plLine.Points[0].Z, Tolerance); // water level at river Assert.AreEqual(10.0, plLine.Points[1].X, Tolerance); // entry point Assert.AreEqual(4.0, plLine.Points[1].Z, Tolerance); // water level at river Assert.AreEqual(50.5, plLine.Points[2].X, Tolerance); // dike toe polder Assert.AreEqual(2.65, plLine.Points[2].Z, Tolerance); // head dike toe polder Assert.AreEqual(75.0, plLine.Points[3].X, Tolerance); // dike toe polder Assert.AreEqual(2.16, plLine.Points[3].Z, Tolerance); // head dike toe polder Assert.AreEqual(2.65, plLine.ZFromX(plLineCreator.SurfaceLine.GetDikeToeInward().X), Tolerance); // headAtDikeToe } } [Test] public void CreatePL3For1DGeometryInOuterSpaceWithExpertKnowledgeRRD() { const double cDampingFactor = 0.3; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); // Lower profile for 5m so upper layer is no longer completely above surface plLineCreator.SoilProfile.BottomLevel -= 5.0; for (var 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; } plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = cDampingFactor; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL3, DamType.Regional, 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; // PLLine in this situation is supposed to burn down to the polder water level from the entry point Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, Tolerance); // start Assert.AreEqual(4.0, plLine.Points[0].Z, Tolerance); // water level at river Assert.AreEqual(10.0, plLine.Points[1].X, Tolerance); // entry point Assert.AreEqual(4.0, plLine.Points[1].Z, Tolerance); // water level at river Assert.AreEqual(50.5, plLine.Points[2].X, Tolerance); // end Assert.AreEqual(-0.5, plLine.Points[2].Z, Tolerance); // water level at polder Assert.AreEqual(75.0, plLine.Points[3].X, Tolerance); // end Assert.AreEqual(-0.5, plLine.Points[3].Z, Tolerance); // water level at polder } } [Test] public void CreatePL4For1DGeometryWithExpertKnowledgeRRD() { const double cDampingFactor = 0.4; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.IsAdjustPL3AndPL4SoNoUpliftWillOccurEnabled = false; // In this case no HeadInPLLine3 is specified, then the head of PL3 will be equal to WaterLevelRiverHigh plLineCreator.IsHydraulicShortcut = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = cDampingFactor; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL4, DamType.Regional, 0.02); CheckPL4LowFor1DGeometryWithExpertKnowledgeRRD(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.IsHydraulicShortcut = false; plLineCreator.HeadInPLLine4 = 4.0; plLineCreator.WaterLevelRiverHigh = 3.0; plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL4, DamType.Regional, 0.02); CheckPL4LowFor1DGeometryWithExpertKnowledgeRRD(plLine); } } private void CheckPL4LowFor1DGeometryWithExpertKnowledgeRRD(PLLine plLine) { // PLLine is supposed to have adjusted points at dike toe and end Assert.AreEqual(4, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, Tolerance); // start Assert.AreEqual(4.0, plLine.Points[0].Z, Tolerance); // water level at river Assert.AreEqual(10.0, plLine.Points[1].X, Tolerance); // entry point Assert.AreEqual(4.0, plLine.Points[1].Z, Tolerance); // water level at river Assert.AreEqual(50.5, plLine.Points[2].X, Tolerance); // dike toe Assert.AreEqual(2.2, plLine.Points[2].Z, Tolerance); // head dike toe Assert.AreEqual(75.0, plLine.Points[3].X, Tolerance); // end Assert.AreEqual(1.71, plLine.Points[3].Z, Tolerance); // head end } [Test] [ExpectedException(typeof(PLLinesCreatorException))] public void CreatePL4For1DGeometryWithExpertKnowledgeRRDThrowsExceptionIfNoAquifers() { const double cDampingFactor = 0.4; using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateSimpleProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = cDampingFactor; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL4, DamType.Regional, 0.02); } } [Test] [ExpectedException(typeof(PLLinesCreatorException))] public void CreatePLLinesFromGaugesWithNonExistentGauge() { using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) using (var location = new Location { Name = "Location1" }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SurfaceLine = surfaceLineTutorial1; var locations = new List { location }; var gauges = new List { 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(); GaugePLLine 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; PLLines plLines = plLineCreator.CreateAllPLLines(locations[0]); } } [Test] public void CreatePLLinesFromGauges() { using(var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) using (var location = new Location { Name = "Location1" }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; var locations = new List { 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(); GaugePLLine 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); GaugePLLine gaugePLLine2 = new GaugePLLine(PLLineType.PL2); gaugePLLines.Add(gaugePLLine2); GaugePLLine gaugePLLine3 = new GaugePLLine(PLLineType.PL3); gaugePLLines.Add(gaugePLLine3); GaugePLLine gaugePLLine4 = new GaugePLLine(PLLineType.PL4); gaugePLLines.Add(gaugePLLine4); plLineCreator.GaugePLLines = gaugePLLines; plLineCreator.Gauges = gauges; PLLines plLines = plLineCreator.CreateAllPLLines(locations[0]); Assert.AreEqual(4, plLines.Lines[PLLineType.PL1].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL1].Points[0].X); Assert.AreEqual(4, plLines.Lines[PLLineType.PL1].Points[0].Z); // The following point.x is the intersection point of PL1 with the dike Assert.AreEqual(29.6, plLines.Lines[PLLineType.PL1].Points[1].X); Assert.AreEqual(4, plLines.Lines[PLLineType.PL1].Points[1].Z); Assert.AreEqual(45, plLines.Lines[PLLineType.PL1].Points[2].X); Assert.AreEqual(1, plLines.Lines[PLLineType.PL1].Points[2].Z); Assert.AreEqual(75, plLines.Lines[PLLineType.PL1].Points[3].X); Assert.AreEqual(1, plLines.Lines[PLLineType.PL1].Points[3].Z); Assert.AreEqual(0, plLines.Lines[PLLineType.PL2].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL3].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL4].Points.Count); } } [Test] public void CreatePLLinesFromGaugesMoses() { using(var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) using (var location = new Location { Name = "Location1" }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; plLineCreator.SurfaceLine = surfaceLineTutorial1; var locations = new List { 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(); GaugePLLine 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); GaugePLLine gaugePLLine2 = new GaugePLLine(PLLineType.PL2); gaugePLLines.Add(gaugePLLine2); GaugePLLine gaugePLLine3 = new GaugePLLine(PLLineType.PL3); gaugePLLines.Add(gaugePLLine3); GaugePLLine gaugePLLine4 = new GaugePLLine(PLLineType.PL4); gaugePLLines.Add(gaugePLLine4); plLineCreator.GaugePLLines = gaugePLLines; plLineCreator.Gauges = gauges; PLLines plLines = plLineCreator.CreateAllPLLines(locations[0]); Assert.AreEqual(4, plLines.Lines[PLLineType.PL1].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL1].Points[0].X); Assert.AreEqual(4, plLines.Lines[PLLineType.PL1].Points[0].Z); Assert.AreEqual(29.6, plLines.Lines[PLLineType.PL1].Points[1].X); Assert.AreEqual(4, plLines.Lines[PLLineType.PL1].Points[1].Z); Assert.AreEqual(45, plLines.Lines[PLLineType.PL1].Points[2].X); Assert.AreEqual(1, plLines.Lines[PLLineType.PL1].Points[2].Z); Assert.AreEqual(75, plLines.Lines[PLLineType.PL1].Points[3].X); Assert.AreEqual(1, plLines.Lines[PLLineType.PL1].Points[3].Z); Assert.AreEqual(0, plLines.Lines[PLLineType.PL2].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL3].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL4].Points.Count); } } [Test] public void CreatePLLinesFromGaugesNoah() { using (var surfaceLineTutorial1 = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1()) using (var location = new Location { Name = "Location1" }) { PLLinesCreator plLineCreator = new PLLinesCreator(); plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD; plLineCreator.SurfaceLine = surfaceLineTutorial1; var locations = new List { 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(); GaugePLLine 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); GaugePLLine gaugePLLine2 = new GaugePLLine(PLLineType.PL2); gaugePLLines.Add(gaugePLLine2); GaugePLLine gaugePLLine3 = new GaugePLLine(PLLineType.PL3); gaugePLLines.Add(gaugePLLine3); GaugePLLine gaugePLLine4 = new GaugePLLine(PLLineType.PL4); gaugePLLines.Add(gaugePLLine4); plLineCreator.GaugePLLines = gaugePLLines; plLineCreator.Gauges = gauges; PLLines plLines = plLineCreator.CreateAllPLLines(locations[0]); Assert.AreEqual(2, plLines.Lines[PLLineType.PL1].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL1].Points[0].X); Assert.AreEqual(6, plLines.Lines[PLLineType.PL1].Points[0].Z); Assert.AreEqual(75, plLines.Lines[PLLineType.PL1].Points[1].X); Assert.AreEqual(6, plLines.Lines[PLLineType.PL1].Points[1].Z); Assert.AreEqual(0, plLines.Lines[PLLineType.PL2].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL3].Points.Count); Assert.AreEqual(0, plLines.Lines[PLLineType.PL4].Points.Count); } } ///

/// Define input based on 2d geometry for PLLine creator ///

/// /// private static PLLinesCreator DefinePLLineCreatorFor2DGeometry(SurfaceLine2 surfaceline) { string soilGeometry2DName = @"TestData\1D1.sti"; string soilDatabaseName = @"TestData\soilmaterials.mdb"; string cDikeMaterial = "OA"; PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilGeometryType = SoilGeometryType.SoilGeometry2D; plLineCreator.SoilProfile = null; plLineCreator.SoilGeometry2DName = soilGeometry2DName; plLineCreator.SoilBaseDB = SoilbaseDB.Create(soilDatabaseName); plLineCreator.DikeEmbankmentMaterial = plLineCreator.SoilBaseDB.GetSoil(cDikeMaterial); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPLLines.PenetrationLength = 1.0; plLineCreator.HeadInPLLine2 = 0.0; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPLLines.PLLineCreationMethod = PLLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.SurfaceLine = surfaceline; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; return plLineCreator; } [Test] public void CreatePL1For2DGeometryWithExpertKnowledgeRRD() { const double cTolerance = 0.0001; using (var surfacelineSimpleDike = CreateSurfacelineSimpleDike()) { PLLinesCreator plLineCreator = DefinePLLineCreatorFor2DGeometry(surfacelineSimpleDike); PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(3.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(4.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(4, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(7, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(10, plLine.Points[4].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[4].Z, cTolerance); Assert.AreEqual(12, plLine.Points[5].X, cTolerance); Assert.AreEqual(0.9, plLine.Points[5].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithDryDitchPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithDitchAtPolderSide = CreateSurfacelineSimpleDikeWithDitchAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithDitchAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(8, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(36, plLine.Points[5].X, cTolerance); Assert.AreEqual(-1.0, plLine.Points[5].Z, cTolerance); Assert.AreEqual(38, plLine.Points[6].X, cTolerance); Assert.AreEqual(-1.0, plLine.Points[6].Z, cTolerance); Assert.AreEqual(100, plLine.Points[7].X, cTolerance); Assert.AreEqual(-1.0, plLine.Points[7].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithWetDitchPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithDitchAtPolderSide = CreateSurfacelineSimpleDikeWithDitchAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithDitchAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(8, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(35.5, plLine.Points[5].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(38.5, plLine.Points[6].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[6].Z, cTolerance); Assert.AreEqual(100, plLine.Points[7].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[7].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithWetDitchPolderSideAndDitchDikSideSameAsDikeToeAtPolder() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithDitchAtPolderSide = CreateSurfacelineSimpleDikeWithDitchAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithDitchAtPolderSide; // Let DitchDikeSide coincide with DikeToeAtPolder var toeOfDike = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(toeOfDike.X, toeOfDike.Z, CharacteristicPointType.DitchDikeSide); plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(8, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); // Following point should be lowered to polderlevel i.s.o. PlLineOffsetBelowDikeToeAtPolder because DitchDikeSide and DikeToeAtPolder are the same Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[4].Z, cTolerance); Assert.AreEqual(33.0, plLine.Points[5].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(38.5, plLine.Points[6].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[6].Z, cTolerance); Assert.AreEqual(100, plLine.Points[7].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[7].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithEmptyNWOPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtPolderSide = CreateSurfacelineSimpleDikeWithNWOAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(11, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(35.490, plLine.Points[5].X, cTolerance); Assert.AreEqual(-1.50, plLine.Points[5].Z, cTolerance); Assert.AreEqual(35.50, plLine.Points[6].X, cTolerance); Assert.AreEqual(-1.510, plLine.Points[6].Z, cTolerance); Assert.AreEqual(36, plLine.Points[7].X, cTolerance); Assert.AreEqual(-2.01, plLine.Points[7].Z, cTolerance); Assert.AreEqual(38, plLine.Points[8].X, cTolerance); Assert.AreEqual(-2.01, plLine.Points[8].Z, cTolerance); Assert.AreEqual(38.510, plLine.Points[9].X, cTolerance); Assert.AreEqual(-1.50, plLine.Points[9].Z, cTolerance); Assert.AreEqual(100, plLine.Points[10].X, cTolerance); Assert.AreEqual(-1.50, plLine.Points[10].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithNormalNWOPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtPolderSide = CreateSurfacelineSimpleDikeWithNWOAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.None; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(7, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(35.5, plLine.Points[5].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(100, plLine.Points[6].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[6].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithEmptyNWOWithDitchLeftPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAndDitchLeftAtPolderSide = CreateSurfacelineSimpleDikeWithNWOAndDitchLeftAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAndDitchLeftAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(12, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(35.5, plLine.Points[5].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(38.5, plLine.Points[6].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[6].Z, cTolerance); Assert.AreEqual(45.490, plLine.Points[7].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[7].Z, cTolerance); Assert.AreEqual(46.0, plLine.Points[8].X, cTolerance); Assert.AreEqual(-1.01, plLine.Points[8].Z, cTolerance); Assert.AreEqual(48.0, plLine.Points[9].X, cTolerance); Assert.AreEqual(-1.01, plLine.Points[9].Z, cTolerance); Assert.AreEqual(48.510, plLine.Points[10].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[10].Z, cTolerance); Assert.AreEqual(100, plLine.Points[11].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[11].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithNormalNWOWithDitchLeftPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAndDitchLeftAtPolderSide = CreateSurfacelineSimpleDikeWithNWOAndDitchLeftAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAndDitchLeftAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.None; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(8, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(35.5, plLine.Points[5].X, cTolerance); // river side ditch Assert.AreEqual(-0.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(38.5, plLine.Points[6].X, cTolerance); // polder side ditch Assert.AreEqual(-0.5, plLine.Points[6].Z, cTolerance); Assert.AreEqual(100, plLine.Points[7].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[7].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithEmptyNWOWithDitchRightPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAndDitchRightAtPolderSide = CreateSurfacelineSimpleDikeWithNWOAndDitchRightAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAndDitchRightAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(12, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(35.490, plLine.Points[5].X, cTolerance); // river side NWO Assert.AreEqual(-0.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(35.50, plLine.Points[6].X, cTolerance); // moved intersection point (nwo-ploderlevel) Assert.AreEqual(-0.51, plLine.Points[6].Z, cTolerance); Assert.AreEqual(36.0, plLine.Points[7].X, cTolerance); // river side bottom NWO Assert.AreEqual(-1.01, plLine.Points[7].Z, cTolerance); Assert.AreEqual(38.0, plLine.Points[8].X, cTolerance); // polder side bottom NWO Assert.AreEqual(-1.01, plLine.Points[8].Z, cTolerance); Assert.AreEqual(38.510, plLine.Points[9].X, cTolerance); // polder side NWO Assert.AreEqual(-0.50, plLine.Points[9].Z, cTolerance); Assert.AreEqual(48.50, plLine.Points[10].X, cTolerance); // polder side ditch Assert.AreEqual(-0.50, plLine.Points[10].Z, cTolerance); Assert.AreEqual(100, plLine.Points[11].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[11].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithNormalNWOWithDitchRightPolderSide() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAndDitchRightAtPolderSide = CreateSurfacelineSimpleDikeWithNWOAndDitchRightAtPolderSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAndDitchRightAtPolderSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.None; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(8, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(35.5, plLine.Points[5].X, cTolerance); // river side NWO Assert.AreEqual(-0.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(48.5, plLine.Points[6].X, cTolerance); // polder side ditch Assert.AreEqual(-0.5, plLine.Points[6].Z, cTolerance); Assert.AreEqual(100, plLine.Points[7].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[7].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithEmptyNWORiverSideWaterAboveNWO() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtRiverSide = CreateSurfacelineSimpleDikeWithNWOAtRiverSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtRiverSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(100, plLine.Points[5].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[5].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithEmptyNWORiverSideWaterBelowNWO() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtRiverSide = CreateSurfacelineSimpleDikeWithNWOAtRiverSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = -3.0; plLineCreator.WaterLevelRiverLow = -4.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtRiverSide; plLineCreator.SurfaceLine.Geometry.Points[0].Z = -4.0; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 5.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(-4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(-3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[4].Z, cTolerance); Assert.AreEqual(100, plLine.Points[5].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[5].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithEmptyNWORiverSideWaterInNWO() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtRiverSide = CreateSurfacelineSimpleDikeWithNWOAtRiverSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = -0.5; plLineCreator.WaterLevelRiverLow = -0.5; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtRiverSide; plLineCreator.SurfaceLine.Geometry.Points[0].Z = -3; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.MakeEmpty; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); // Note: this does not test the specific NWO code making an empty NWO for the riverside as that's already handled (slightly differently) by the general code. // #bka : I do not know how to create a test that will test the specific code because getting a riverwaterlevel to run through the NWO seems impossible. Assert.AreEqual(11, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[0].Z, cTolerance); Assert.AreEqual(4.166666667, plLine.Points[1].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[1].Z, cTolerance); Assert.AreEqual(5.40443, plLine.Points[2].X, cTolerance); Assert.AreEqual(-0.41443, plLine.Points[2].Z, cTolerance); Assert.AreEqual(6, plLine.Points[3].X, cTolerance); Assert.AreEqual(-1.01, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8, plLine.Points[4].X, cTolerance); Assert.AreEqual(-1.01, plLine.Points[4].Z, cTolerance); Assert.AreEqual(8.829, plLine.Points[5].X, cTolerance); Assert.AreEqual(-0.181, plLine.Points[5].Z, cTolerance); Assert.AreEqual(10, plLine.Points[6].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[6].Z, cTolerance); Assert.AreEqual(20, plLine.Points[7].X, cTolerance); Assert.AreEqual(-1, plLine.Points[7].Z, cTolerance); Assert.AreEqual(25, plLine.Points[8].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[8].Z, cTolerance); Assert.AreEqual(30, plLine.Points[9].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[9].Z, cTolerance); Assert.AreEqual(100, plLine.Points[10].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[10].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithNormalNWORiverSideWaterAboveNWO() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtRiverSide = CreateSurfacelineSimpleDikeWithNWOAtRiverSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtRiverSide; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.None; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(12.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(1.0, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(2.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[4].Z, cTolerance); Assert.AreEqual(100, plLine.Points[5].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[5].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithNormalNWORiverSideWaterBelowNWO() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtRiverSide = CreateSurfacelineSimpleDikeWithNWOAtRiverSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = -3.0; plLineCreator.WaterLevelRiverLow = -5.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtRiverSide; plLineCreator.SurfaceLine.Geometry.Points[0].Z = -5; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.None; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 5.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(6, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(-5.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[1].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[1].Z, cTolerance); Assert.AreEqual(20, plLine.Points[2].X, cTolerance); Assert.AreEqual(-3.5, plLine.Points[2].Z, cTolerance); Assert.AreEqual(25, plLine.Points[3].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[3].Z, cTolerance); Assert.AreEqual(30, plLine.Points[4].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[4].Z, cTolerance); Assert.AreEqual(100, plLine.Points[5].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[5].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithNormalNWORiverSideWaterPartialyInNWO() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtRiverSide = CreateSurfacelineSimpleDikeWithNWOAtRiverSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = -3.0; plLineCreator.WaterLevelRiverLow = -5.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtRiverSide; plLineCreator.SurfaceLine.Geometry.Points[0].Z = -4; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.None; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 5.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(8, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(-4.0, plLine.Points[0].Z, cTolerance); Assert.AreEqual(5.79328, plLine.Points[1].X, cTolerance); Assert.AreEqual(-0.80328, plLine.Points[1].Z, cTolerance); Assert.AreEqual(8.19672, plLine.Points[2].X, cTolerance); Assert.AreEqual(-0.80328, plLine.Points[2].Z, cTolerance); Assert.AreEqual(10.0, plLine.Points[3].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[3].Z, cTolerance); Assert.AreEqual(20, plLine.Points[4].X, cTolerance); Assert.AreEqual(-3.5, plLine.Points[4].Z, cTolerance); Assert.AreEqual(25, plLine.Points[5].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[5].Z, cTolerance); Assert.AreEqual(30, plLine.Points[6].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[6].Z, cTolerance); Assert.AreEqual(100, plLine.Points[7].X, cTolerance); Assert.AreEqual(-4.5, plLine.Points[7].Z, cTolerance); } } [Test] public void CreateSimplePL1ForSurfaceWithNormalNWORiverSideWaterInNWO() { const double cTolerance = 0.0001; using (var surfacelineSimpleDikeWithNwoAtRiverSide = CreateSurfacelineSimpleDikeWithNWOAtRiverSide()) { PLLinesCreator plLineCreator = new PLLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = -0.5; plLineCreator.WaterLevelRiverLow = -0.5; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfileTests.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDikeWithNwoAtRiverSide; plLineCreator.SurfaceLine.Geometry.Points[0].Z = -3; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 0.5; plLineCreator.NWOPhreaticAdaption = PhreaticAdaptionType.None; // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.5; PLLine plLine = plLineCreator.CreatePLLineByExpertKnowledge(PLLineType.PL1, DamType.Regional, 0.02); Assert.AreEqual(10, plLine.Points.Count); Assert.AreEqual(0.0, plLine.Points[0].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[0].Z, cTolerance); Assert.AreEqual(4.166666667, plLine.Points[1].X, cTolerance); Assert.AreEqual(-0.5, plLine.Points[1].Z, cTolerance); Assert.AreEqual(5.41444, plLine.Points[2].X, cTolerance); Assert.AreEqual(-0.41444, plLine.Points[2].Z, cTolerance); Assert.AreEqual(8.59556, plLine.Points[3].X, cTolerance); Assert.AreEqual(-0.41444, plLine.Points[3].Z, cTolerance); Assert.AreEqual(8.829, plLine.Points[4].X, cTolerance); Assert.AreEqual(-0.41444, plLine.Points[4].Z, cTolerance); Assert.AreEqual(10, plLine.Points[5].X, cTolerance); Assert.AreEqual(-0.1, plLine.Points[5].Z, cTolerance); Assert.AreEqual(20, plLine.Points[6].X, cTolerance); Assert.AreEqual(-1, plLine.Points[6].Z, cTolerance); Assert.AreEqual(25, plLine.Points[7].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[7].Z, cTolerance); Assert.AreEqual(30, plLine.Points[8].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[8].Z, cTolerance); Assert.AreEqual(100, plLine.Points[9].X, cTolerance); Assert.AreEqual(-1.5, plLine.Points[9].Z, cTolerance); } } } }