// Copyright (C) Stichting Deltares 2018. All rights reserved. // // This file is part of the Dam Engine. // // The Dam Engine is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see . // // All names, logos, and references to "Deltares" are registered trademarks of // Stichting Deltares and remain full property of Stichting Deltares at all times. // All rights reserved. using System.Collections.Generic; using Deltares.DamEngine.Calculators.PlLinesCreator; using Deltares.DamEngine.Data.General; using Deltares.DamEngine.Data.General.Gauges; using Deltares.DamEngine.Data.General.PlLines; using Deltares.DamEngine.Data.Geometry; using Deltares.DamEngine.Data.Geotechnics; using Deltares.DamEngine.TestHelpers.Factories; using NUnit.Framework; namespace Deltares.DamEngine.Calculators.Tests.PlLinesCreator { [TestFixture] public class PlLinesCreatorTest { private double Tolerance = 0.001; [TestFixtureSetUp] public void TestFixtureSetup() { } [SetUp] public void TestSetup() { } ///

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

[Test] public void CreatePL1WithPolderLevelHigherDikeToeAtPolder() { const double cTolerance = 0.0001; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfacelineDikeWithSlopingShoulder = FactoryForSurfaceLines.CreateSurfacelineDikeWithSlopingShoulder(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineDikeWithSlopingShoulder; plLineCreator.WaterLevelPolder = 2.75; // CharacteristicPointType.ShoulderTopInside.Z = 2.5; CharacteristicPointType.ShoulderBaseInside.Z = 3.0); PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfacelineDikeWithSlopingShoulder = FactoryForSurfaceLines.CreateSurfacelineDikeWithSlopingShoulder(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.5; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineDikeWithSlopingShoulder; 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() { var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z + 0.1; 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; // Add shoulder; this should not affect the creation of the phreatic line plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 4.0, CharacteristicPointType.ShoulderBaseInside); plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 4.0, CharacteristicPointType.ShoulderTopInside); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.SurfaceLine.SortPoints(); plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 3.0; // <===================== low waterlevel crossing dike plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; // <===================== low waterlevel below surfacelevel plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; 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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator{SurfaceLine = surfaceLine}; Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 3.0; // <===================== low waterlevel crossing dike plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); plLineCreator.SurfaceLine.EnsurePoint(1.5, 2.5); plLineCreator.SurfaceLine.EnsurePoint(2.5, 3.0); plLineCreator.SurfaceLine.EnsurePoint(3.0, 4.0); plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 5.0, CharacteristicPointType.DikeTopAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 5.0, CharacteristicPointType.DikeTopAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { SurfaceLine = surfaceLine }; Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; // <===================== low waterlevel below surfacelevel plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeLinearInDike; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); plLineCreator.SurfaceLine.EnsurePoint(1.5, 2.5); plLineCreator.SurfaceLine.EnsurePoint(2.5, 3.0); plLineCreator.SurfaceLine.EnsurePoint(3.0, 4.0); plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 5.0, CharacteristicPointType.DikeTopAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 5.0, CharacteristicPointType.DikeTopAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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 could cause a problem in PlLinesCreator.ValidatePhreaticBelowDike ///

[Test] public void CreatePl1For1DGeometryWithExpertKnowledgeRrdIfRiverlevelEqualsTopOfDike() { const double cTolerance = 0.0001; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.ModelParametersForPlLines.PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { SoilProfile = FactoryForSoilProfiles.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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), WaterLevelRiverHigh = 3.0, ModelParametersForPlLines = { PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD } }; plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(12.0, 1.0, CharacteristicPointType.SurfaceLevelInside); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), WaterLevelRiverHigh = 3.0, ModelParametersForPlLines = { PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD } }; plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); plLineCreator.SurfaceLine.EnsurePoint(11.0, 0.5); plLineCreator.SurfaceLine.EnsurePoint(12.0, 0.4); plLineCreator.SurfaceLine.EnsurePointOfType(13.0, 0.3, CharacteristicPointType.SurfaceLevelInside); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), WaterLevelRiverHigh = 3.0, ModelParametersForPlLines = { PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD } }; plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); plLineCreator.SurfaceLine.EnsurePoint(11.0, 0.5); plLineCreator.SurfaceLine.EnsurePoint(12.0, 0.1); plLineCreator.SurfaceLine.EnsurePoint(14.0, 0.5); plLineCreator.SurfaceLine.EnsurePointOfType(15.0, 0.0, CharacteristicPointType.SurfaceLevelInside); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { var plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator { SurfaceLine = surfaceLine, SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(), WaterLevelRiverHigh = 3.0, ModelParametersForPlLines = { PlLineCreationMethod = PlLineCreationMethod.ExpertKnowledgeRRD } }; plLineCreator.SurfaceLine.EnsurePointOfType(0.0, 2.0, CharacteristicPointType.SurfaceLevelOutside); plLineCreator.SurfaceLine.EnsurePointOfType(1.0, 2.0, CharacteristicPointType.DikeToeAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(4.0, 4.0, CharacteristicPointType.DikeTopAtRiver); plLineCreator.SurfaceLine.EnsurePointOfType(7.0, 4.0, CharacteristicPointType.DikeTopAtPolder); plLineCreator.SurfaceLine.EnsurePointOfType(8.0, 2.0, CharacteristicPointType.ShoulderBaseInside); plLineCreator.SurfaceLine.EnsurePointOfType(9.0, 2.0, CharacteristicPointType.ShoulderTopInside); plLineCreator.SurfaceLine.EnsurePointOfType(10.0, 1.0, CharacteristicPointType.DikeToeAtPolder); plLineCreator.SurfaceLine.EnsurePoint(11.0, 0.5); plLineCreator.SurfaceLine.EnsurePoint(12.0, 0.2); plLineCreator.SurfaceLine.EnsurePointOfType(13.0, 0.0, CharacteristicPointType.SurfaceLevelInside); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.PlLineOffsetBelowDikeTopAtRiver = 0.5; plLineCreator.PlLineOffsetBelowDikeTopAtPolder = 1.0; plLineCreator.PlLineOffsetBelowShoulderBaseInside = 0.2; plLineCreator.PlLineOffsetBelowDikeToeAtPolder = 0.3; plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 3.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; 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; var surfacelineSimpleDike = FactoryForSurfaceLines.CreateSurfacelineSimpleDike(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); Assert.IsNotNull(plLineCreator); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateComplexProfile(); plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfacelineSimpleDike; // Add voorland to dike plLineCreator.SurfaceLine.EnsurePointOfType(-2.0, 0.0, CharacteristicPointType.SurfaceLevelOutside); plLineCreator.SurfaceLine.EnsurePoint(0.0, 2.0); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.SurfaceLine.SortPoints(); // Create Pl1 plLineCreator.WaterLevelPolder = plLineCreator.SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z - 1.0; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL1, 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() { var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.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() { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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() { var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator{SurfaceLine = surfaceLine}; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandProfile(); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPlLine2 = cHeadPL2; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL2, 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; Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator{SurfaceLine = surfaceLine}; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPlLine2 = cHeadPL2; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL2, 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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator{SurfaceLine = surfaceLine}; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); plLineCreator.SurfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); plLineCreator.SurfaceLine.Geometry.SyncCalcPoints(); plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPlLine2 = cHeadPL2; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL2, 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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.HeadInPlLine2 = cHeadPL2; plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL2, 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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.HeadInPlLine2 = cHeadInPlLine2; plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = 0.3; plLineCreator.ModelParametersForPlLines.DampingFactorPL4 = 0.4; plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; Location primaryLocation = new Location(); 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; var surfaceLine = new SurfaceLine2 { Geometry = new GeometryPointString(), CharacteristicPoints = { GeometryMustContainPoint = true } }; surfaceLine.Geometry.SyncCalcPoints(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); surfaceLine.Geometry.SyncCalcPoints(); plLineCreator.SurfaceLine = surfaceLine; plLineCreator.ModelParametersForPlLines.PenetrationLength = cPenetrationLength; plLineCreator.HeadInPlLine2 = cHeadPL2; PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL2, 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; // var surfaceLine = new SurfaceLine2 // { // Geometry = new GeometryPointString(), // CharacteristicPoints = // { // GeometryMustContainPoint = true // } // }; // { // PLLinesCreator plLineCreator = new PLLinesCreator(); // plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateMultiInfiltrationLayerProfile(); // int orgLayerCount = plLineCreator.SoilProfile.Layers.Count; // surfaceLine.AddCharacteristicPoint(new GeometryPoint(1.0, 2.0)); // surfaceLine.AddCharacteristicPoint(new GeometryPoint(10.0, 2.0)); // surfaceLine.AddCharacteristicPoint(new GeometryPoint(21.0, 2.5)); // 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; // var surfaceLine = new SurfaceLine2 // { // Geometry = new GeometryPointString(), // CharacteristicPoints = // { // GeometryMustContainPoint = true // } // }; // { // PLLinesCreator plLineCreator = new PLLinesCreator(); // plLineCreator.SoilProfile = FactoryForSoilProfiles.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; // var surfaceLine = new SurfaceLine2 // { // Geometry = new GeometryPointString(), // CharacteristicPoints = // { // GeometryMustContainPoint = true // } // }; // { // PLLinesCreator plLineCreator = new PLLinesCreator(); // plLineCreator.SoilProfile = FactoryForSoilProfiles.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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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; // var surfaceLineTutorial1 = FactoryForSurfaceLines.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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); plLineCreator.SurfaceLine = surfaceLineTutorial1; plLineCreator.WaterLevelRiverHigh = 4.0; plLineCreator.WaterLevelRiverLow = 1.0; plLineCreator.IsUseLowWaterLevel = true; plLineCreator.WaterLevelPolder = -0.5; plLineCreator.ModelParametersForPlLines.DampingFactorPL3 = cDampingFactor; // In this case no HeadInPlLine3 is specified, then the head of Pl3 will be equal to WaterLevelRiverLow PlLine plLine = plLineCreator.CreatePlLineByExpertKnowledge(PlLineType.PL3, 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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); // Lower profile for 5 m so upper layer is no longer completely above surface for (var i = 0; i < plLineCreator.SoilProfile.Layers.Count; ++i) { 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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.CreateClaySandClaySandProfile(); // Lower profile for 5m so upper layer is no longer completely above surface plLineCreator.SoilProfile.BottomLevel -= 5.0; for (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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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; var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator(); plLineCreator.SoilProfile = FactoryForSoilProfiles.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() { var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); var location = new Location { Name = "Location1" }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.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() { var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); var location = new Location { Name = "Location1" }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.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() { var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); var location = new Location { Name = "Location1" }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.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() { var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); var location = new Location { Name = "Location1" }; { Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.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; // var surfacelineSimpleDike = FactoryForSurfaceLines.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); // } //} } }