Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamPipingBligh/DamPipingBlighKernelWrapper.cs =================================================================== diff -u -r680 -r684 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamPipingBligh/DamPipingBlighKernelWrapper.cs (.../DamPipingBlighKernelWrapper.cs) (revision 680) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamPipingBligh/DamPipingBlighKernelWrapper.cs (.../DamPipingBlighKernelWrapper.cs) (revision 684) @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Data; +using Deltares.DamEngine.Calculators.General; using Deltares.DamEngine.Calculators.KernelWrappers.Common; using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces; using Deltares.DamEngine.Calculators.Uplift; @@ -19,7 +20,6 @@ /// public class DamPipingBlighKernelWrapper : IKernelWrapper { - private const double factorMeterToMicroMeter = 1.0e6; private const double defaultFluidisationGradient = 0.3; public const double DefaultMaxReturnValue = 90.0; @@ -59,7 +59,7 @@ xExit = upliftLocationAndResult.X; surfaceLevel = surfaceLine.Geometry.GetZatX(upliftLocationAndResult.X); SoilLayer1D heaveLayer = soilProfile1D.GetLayerWithName(upliftLocationAndResult.LayerWhereUpliftOccuresId); - d70 = factorMeterToMicroMeter * heaveLayer.Soil.DiameterD70; + d70 = Physics.FactorMeterToMicroMeter * heaveLayer.Soil.DiameterD70; var topLevelAquifer = soilProfile1D.GetLayerWithName(upliftLocationAndResult.LayerWhereUpliftOccuresId).TopLevel; dCoverLayer = DamPipingHelper.DetermineHeightCoverLayer(topLevelAquifer, surfaceLevel); } @@ -187,6 +187,8 @@ { throw new NoNullAllowedException("No output object defined for Bligh"); } + + // TODO: for now this only works for 1D profiles and NoAdaption of geometry string soilProfile2DName = "soilProfile2DName"; var damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification() { @@ -203,6 +205,7 @@ var pipingDesignResults = new PipingDesignResults(PipingModelType.Bligh); pipingDesignResults.BlighFactor = damPipingBlighOutput.FoSp; pipingDesignResults.BlighHcritical = damPipingBlighOutput.Hc; + // TODO: for now this only works for NoAdaption of geometry; if adaption is enabled, the real redesigned surfaceline has to be assigned pipingDesignResults.RedesignedSurfaceLine = damKernelInput.Location.SurfaceLine; designResult.PipingDesignResults = pipingDesignResults; designResult.CalculationResult = damPipingBlighOutput.CalculationResult; Index: dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/PLLinesCreatorTest.cs =================================================================== diff -u --- dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/PLLinesCreatorTest.cs (revision 0) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/PLLinesCreatorTest.cs (revision 684) @@ -0,0 +1,1972 @@ +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 NUnit.Framework; + +namespace Deltares.DamEngine.Calculators.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 GeometryPointString(), + 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); + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + /// + /// Create a simple surfaceline without shoulder + /// + /// the created surfaceline + static private SurfaceLine2 CreateSurfacelineDikeWithSlopingShoulder() + { + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + 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); + surfaceLine.Geometry.SyncCalcPoints(); + 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 GeometryPointString(), + 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); + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + + /// + /// Test if PL1 created correctly if PolderLevel above toe at polder + /// + [Test] + public void CreatePL1WithPolderLevelHigherDikeToeAtPolder() + { + const double cTolerance = 0.0001; + var surfacelineSimpleDike = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineDikeWithSlopingShoulder(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineDikeWithSlopingShoulder(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 + } + }; + { + PLLinesCreator plLineCreator = new 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 } + }; + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 coudl cause a problem in PLLinesCreator.ValidatePhreaticBelowDike + /// + [Test] + public void CreatePL1For1DGeometryWithExpertKnowledgeRRDIfRiverlevelEqualsTopOfDike() + { + const double cTolerance = 0.0001; + var surfacelineSimpleDike = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + var plLineCreator = new 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 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 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 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 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 = CreateSurfacelineSimpleDike(); + { + PLLinesCreator plLineCreator = new 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 + } + }; + { + 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 = 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 + } + }; + { + PLLinesCreator plLineCreator = new 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 + } + }; + { + PLLinesCreator plLineCreator = new 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; + PLLinesCreator plLineCreator = new 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 + } + }; + { + PLLinesCreator plLineCreator = new 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 + } + }; + { + PLLinesCreator plLineCreator = new 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(); + { + 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 = 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(); + { + 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 = 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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(); + { + PLLinesCreator plLineCreator = new 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" + }; + { + 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() + { + var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + 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() + { + var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + 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() + { + var surfaceLineTutorial1 = FactoryForSurfaceLines.CreateSurfaceLineTutorial1(); + 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; + // 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); + // } + //} + + + } +} Index: dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/FactoryForSoilProfiles.cs =================================================================== diff -u --- dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/FactoryForSoilProfiles.cs (revision 0) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/FactoryForSoilProfiles.cs (revision 684) @@ -0,0 +1,944 @@ +using Deltares.DamEngine.Calculators.General; +using Deltares.DamEngine.Data.Geotechnics; + +namespace Deltares.DamEngine.Calculators.Tests +{ + public class FactoryForSoilProfiles + { + /// + /// Create simple soil profile + /// + /// soil profile + public static SoilProfile1D CreateSimpleProfile() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D(); + layer.TopLevel = 10.0; + layer.Soil = new Soil("Clay", 16.0, 12.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -20.0; + + return soilProfile; + } + + /// + /// Create twolayer soilprofile + /// + /// soil profile + public static SoilProfile1D CreateTwoLayerProfile() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D(); + layer.TopLevel = 10.0; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + layer.WaterpressureInterpolationModel = WaterpressureInterpolationModel.Automatic; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D(); + layer.TopLevel = 2.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + layer.WaterpressureInterpolationModel = WaterpressureInterpolationModel.Hydrostatic; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -10.0; + + return soilProfile; + } + + /// + /// Create two layer soil profile with pleistocene sand layer only + /// + /// soil profile + public static SoilProfile1D CreateHeavyClaySandProfileForHydraulicShortcutEvaluator() + { + SoilProfile1D soilProfile = CreateClaySandProfile(); + soilProfile.Layers[0].Soil.BelowPhreaticLevel = 22.0; + soilProfile.Layers[0].Soil.AbovePhreaticLevel = 20.0; + foreach (var layer in soilProfile.Layers) + { + layer.Soil.DryUnitWeight = layer.Soil.AbovePhreaticLevel - 2; + } + return soilProfile; + } + + /// + /// Create two layer soil profile with pleistocene sand layer only + /// + /// soil profile + public static SoilProfile1D CreateClaySandProfile() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 10.0; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + layer.Soil.SoilType = SoilType.Clay; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -5.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -10.0; + + return soilProfile; + } + + /// + /// Gammadry and Gammywet are both set to 1 for testing purposes + /// + /// + public static SoilProfile1D CreateClaySandClaySandProfileForPipingBligh() + { + SoilProfile1D soilProfile = CreateClaySandClaySandProfile(); + foreach (var layer in soilProfile.Layers) + { + layer.Soil.BelowPhreaticLevel = 1; + layer.Soil.AbovePhreaticLevel = 1; + layer.Soil.DiameterD70 = 0.00018; + } + return soilProfile; + } + + public static SoilProfile1D CreateClaySandProfileForPipingBligh() + { + SoilProfile1D soilProfile = CreateClaySandProfile(); + foreach (var layer in soilProfile.Layers) + { + layer.Soil.BelowPhreaticLevel = 1; + layer.Soil.AbovePhreaticLevel = 1; + layer.Soil.DiameterD70 = 0.00018; + } + return soilProfile; + } + + /// + /// Create four layer soil profile with pleistocene and intermediate sand layer + /// + /// soil profile + public static SoilProfile1D CreateClaySandClaySandProfile() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 10.0; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + + layer.IsAquifer = false; + layer.Soil.SoilType = SoilType.Clay; + layer.Soil.DryUnitWeight = layer.Soil.AbovePhreaticLevel - 1.0; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 1.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + + layer.IsAquifer = true; + layer.Soil.SoilType = SoilType.Sand; + layer.Soil.DryUnitWeight = layer.Soil.AbovePhreaticLevel - 1.0; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -1.5; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + + layer.IsAquifer = false; + layer.Soil.SoilType = SoilType.Clay; + layer.Soil.DryUnitWeight = layer.Soil.AbovePhreaticLevel - 1.0; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -5.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + + layer.IsAquifer = true; + layer.Soil.SoilType = SoilType.Sand; + layer.Soil.DryUnitWeight = layer.Soil.AbovePhreaticLevel - 1.0; + soilProfile.Layers.Add(layer); + soilProfile.BottomLevel = -10.0; + return soilProfile; + } + + /// + /// Create six layer soil profile with 3 aquifers + /// + /// soil profile + public static SoilProfile1D CreateClaySandClaySandClaySandProfile() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 10.0; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 1.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -1.5; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -5.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -7.0; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -9.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -10.0; + + return soilProfile; + } + + /// + /// Create five layer soil profile with 1 aquifer + /// + /// soil profile + public static SoilProfile1D Create5LayerProfileWith1Aquifer() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 10.0; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + layer.Soil.SoilType = SoilType.Clay; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 1.0; + layer.Soil = new Soil("Alg-zand (0-30)", 10.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + layer.Soil.SoilType = SoilType.Clay; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -1.5; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + layer.Soil.SoilType = SoilType.Clay; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -5.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + layer.Soil.SoilType = SoilType.Clay; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -7.0; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + layer.Soil.SoilType = SoilType.Clay; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -10.0; + + return soilProfile; + } + + /// + /// Create four layer soil profile with pleistocene and intermediate sand layer with multiple infiltration layers + /// + /// soil profile + public static SoilProfile1D CreateMultiInfiltrationLayerProfile() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 10.0; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 1.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -1.5; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -2.3; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -3.2; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -4.1; + layer.Soil = new Soil("HW-OBO", 12.0, 10.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -5.0; + layer.Soil = new Soil("Alg-zand (0-30)", 22.0, 20.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -10.0; + + return soilProfile; + } + + /// + /// Create complex soilprofile + /// + /// soil profile + public static SoilProfile1D CreateComplexProfile() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 10.0; + layer.Soil = new Soil("HW-OBO", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -0.6; + layer.Soil = new Soil("HW-DUN", 16.8, 15.8); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -1.8; + layer.Soil = new Soil("HW-DUOzand", 18.7, 17.7); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -2.8; + layer.Soil = new Soil("HW-HVN", 11.4, 10.4); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -4.0; + layer.Soil = new Soil("HW-HVN", 11.40, 10.40); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -5.0; + layer.Soil = new Soil("Alg-zand (0-30)", 19.0, 18.0); + layer.Soil.DryUnitWeight = 0.01; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -10.0; + return soilProfile; + } + + ///// + ///// Create three layer soil profile with pleistocene and intermediate sand layer + ///// + ///// soil profile + //public static SoilProfile1D CreatePipingSellmeijerProfileWithTwoSandlayers() + //{ + // var soilProfile = new SoilProfile1D(); + + // var layer = new SoilLayer1D() + // { + // Name = GetNewUniqueLayerId(soilProfile) + // }; + // layer.TopLevel = 10.0; + // layer.Soil = new Soil("Topmaterial", 1.0, 1.0, 0.0003, Physics.FactorMicroMeterToMeter*300.0, 0.5, 57.0); + // layer.Soil.DryUnitWeight = 0.01; + // layer.IsAquifer = false; + // soilProfile.Layers.Add(layer); + + // layer = new SoilLayer1D() + // { + // Name = GetNewUniqueLayerId(soilProfile) + // }; + // layer.TopLevel = -2.0; + // layer.Soil = new Soil("Sand upper", 22.0, 20.0, 0.0001, Physics.FactorMicroMeterToMeter*200.0, 0.25, 37.0); + // layer.Soil.DryUnitWeight = 0.01; + // layer.IsAquifer = true; + // soilProfile.Layers.Add(layer); + + // layer = new SoilLayer1D() + // { + // Name = GetNewUniqueLayerId(soilProfile) + // }; + // layer.TopLevel = -3.99; + // layer.Soil = new Soil("Clay", 22.0, 20.0, 0.0001, Physics.FactorMicroMeterToMeter*200.0, 0.25, 37.0); + // layer.Soil.DryUnitWeight = 0.01; + // layer.IsAquifer = false; + // soilProfile.Layers.Add(layer); + + // layer = new SoilLayer1D() + // { + // Name = GetNewUniqueLayerId(soilProfile) + // }; + // layer.TopLevel = -4.0; + // layer.Soil = new Soil("Sand lower", 22.0, 20.0, 0.0002, Physics.FactorMicroMeterToMeter*300.0, 0.35, 47.0); + // layer.Soil.DryUnitWeight = 0.01; + // layer.IsAquifer = true; + // soilProfile.Layers.Add(layer); + + // soilProfile.BottomLevel = -10.0; + + // return soilProfile; + //} + + /// + /// Create two layer soil profile with pleistocene sand layer (no intermediate layer + /// + /// soil profile + public static SoilProfile1D CreatePipingSellmeijerProfileWithOneSandlayer() + { + var soilProfile = new SoilProfile1D(); + + var layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = 10.0; + layer.Soil = new Soil("Topmaterial", 1.0, 1.0) + { + PermeabKx = 0.0003, + DiameterD70 = Physics.FactorMicroMeterToMeter * 300.0, + WhitesConstant = 0.5, BeddingAngle = 57.0 + }; + layer.IsAquifer = false; + soilProfile.Layers.Add(layer); + + layer = new SoilLayer1D() + { + Name = GetNewUniqueLayerId(soilProfile) + }; + layer.TopLevel = -2.0; + layer.Soil = new Soil("Sand", 22.0, 20.0) + { + PermeabKx = 0.0001, + DiameterD70 = Physics.FactorMicroMeterToMeter * 200.0, + WhitesConstant = 0.25, + BeddingAngle = 37.0 + }; + layer.IsAquifer = true; + soilProfile.Layers.Add(layer); + + soilProfile.BottomLevel = -10.0; + + return soilProfile; + } + + ///// + ///// Gammadry and Gammywet are both set to 10.0 for testing purposes + ///// + ///// + //public static SoilProfile1D CreatePipingDesignSellmeijerDesign() + //{ + // SoilProfile1D soilProfile = CreatePipingSellmeijerProfileWithTwoSandlayers(); + // foreach (var layer in soilProfile.Layers) + // { + // layer.Soil.BelowPhreaticLevel = 5.0; + // layer.Soil.AbovePhreaticLevel = 5.0; + // } + // return soilProfile; + //} + + + public static SoilProfile1D CreateTestProfile() + { + var sand = new Soil(); + sand.Name = "zand"; + sand.AbovePhreaticLevel = 15; + sand.BelowPhreaticLevel = 17; + sand.SoilType = SoilType.Sand; + + var clay = new Soil(); + clay.Name = "klei"; + clay.AbovePhreaticLevel = 18; + clay.BelowPhreaticLevel = 20; + clay.SoilType = SoilType.Clay; + + var clay2 = new Soil(); + clay2.Name = "klei2"; + clay2.AbovePhreaticLevel = 20; + clay2.BelowPhreaticLevel = 22; + clay2.SoilType = SoilType.Clay; + + var soilProfile = new SoilProfile1D(); + soilProfile.Name = "TestProf"; + + var layer1 = new SoilLayer1D(); + layer1.Name = "layer1"; + layer1.TopLevel = 10; + layer1.Soil = clay; + layer1.IsAquifer = false; + soilProfile.Layers.Add(layer1); + + var layer2 = new SoilLayer1D(); + layer2.Name = "layer2"; + layer2.TopLevel = -3; + layer2.Soil = clay2; + layer2.IsAquifer = false; + soilProfile.Layers.Add(layer2); + + var layer3 = new SoilLayer1D(); + layer3.Name = "layer3"; + layer3.TopLevel = -10; + layer3.Soil = sand; + layer3.IsAquifer = true; + soilProfile.Layers.Add(layer3); + + return soilProfile; + } + + public static SoilProfile1D CreateSimpleTestProfile() + { + var sand = new Soil(); + sand.Name = "zand"; + sand.AbovePhreaticLevel = 15; + sand.BelowPhreaticLevel = 17; + sand.SoilType = SoilType.Sand; + + var clay = new Soil(); + clay.Name = "klei"; + clay.AbovePhreaticLevel = 18; + clay.BelowPhreaticLevel = 20; + clay.SoilType = SoilType.Clay; + + var soilProfile = new SoilProfile1D(); + soilProfile.Name = "TestProf"; + + var layer1 = new SoilLayer1D(); + layer1.Name = "layer1"; + layer1.TopLevel = 10; + layer1.Soil = clay; + layer1.IsAquifer = false; + soilProfile.Layers.Add(layer1); + + var layer2 = new SoilLayer1D(); + layer2.Name = "layer2"; + layer2.TopLevel = -3; + layer2.Soil = sand; + layer2.IsAquifer = true; + soilProfile.Layers.Add(layer2); + + return soilProfile; + } + + public static SoilProfile1D CreateTestProfileTwoAquifers() + { + var sandTop = new Soil(); + sandTop.Name = "zandtop"; + sandTop.AbovePhreaticLevel = 18; + sandTop.BelowPhreaticLevel = 20; + sandTop.SoilType = SoilType.Sand; + + var clay = new Soil(); + clay.Name = "klei"; + clay.AbovePhreaticLevel = 18; + clay.BelowPhreaticLevel = 20; + clay.SoilType = SoilType.Clay; + + var sandBottom = new Soil(); + sandBottom.Name = "zandbottom"; + sandBottom.AbovePhreaticLevel = 15; + sandBottom.BelowPhreaticLevel = 17; + sandBottom.SoilType = SoilType.Sand; + + var peat = new Soil(); + peat.Name = "veen"; + peat.AbovePhreaticLevel = 5; + peat.BelowPhreaticLevel = 10.5; + peat.SoilType = SoilType.Peat; + + var soilProfile = new SoilProfile1D(); + soilProfile.Name = "TestProf"; + + var layer1 = new SoilLayer1D(); + layer1.Name = "layer1"; + layer1.TopLevel = 10; + layer1.Soil = clay; + layer1.IsAquifer = false; + soilProfile.Layers.Add(layer1); + + var layer2 = new SoilLayer1D(); + layer2.Name = "layer2"; + layer2.TopLevel = -5; + layer2.Soil = sandTop; + layer2.IsAquifer = true; + soilProfile.Layers.Add(layer2); + + var layer3 = new SoilLayer1D(); + layer3.Name = "layer3"; + layer3.TopLevel = -6; + layer3.Soil = peat; + layer3.IsAquifer = false; + soilProfile.Layers.Add(layer3); + + var layer4 = new SoilLayer1D(); + layer4.Name = "layer4"; + layer4.TopLevel = -10; + layer4.Soil = sandBottom; + layer4.IsAquifer = true; + soilProfile.Layers.Add(layer4); + + var layer5 = new SoilLayer1D(); + layer5.Name = "layer5"; + layer5.TopLevel = -13; + layer5.Soil = clay; + layer5.IsAquifer = false; + soilProfile.Layers.Add(layer5); + + return soilProfile; + } + + public static SoilProfile1D CreateTestProfileThreeCoverSublayersOneAquifer() + { + var coverSublayer1 = new Soil(); + coverSublayer1.Name = "cover sublayer 1"; + coverSublayer1.AbovePhreaticLevel = 15; + coverSublayer1.BelowPhreaticLevel = 17; + coverSublayer1.SoilType = SoilType.Clay; + + var coverSublayer2 = new Soil(); + coverSublayer2.Name = "cover sublayer 2"; + coverSublayer2.AbovePhreaticLevel = 12; + coverSublayer2.BelowPhreaticLevel = 14; + coverSublayer2.SoilType = SoilType.Clay; + + var coverSublayer3 = new Soil(); + coverSublayer3.Name = "cover sublayer 3"; + coverSublayer3.AbovePhreaticLevel = 10; + coverSublayer3.BelowPhreaticLevel = 10.5; + coverSublayer3.SoilType = SoilType.Peat; + + var pleistocene = new Soil(); + pleistocene.Name = "pleistocene"; + pleistocene.AbovePhreaticLevel = 18; + pleistocene.BelowPhreaticLevel = 20; + pleistocene.SoilType = SoilType.Sand; + + var soilProfile = new SoilProfile1D(); + soilProfile.Name = "TestProfileWithThreeCoverSublayersOneAquifer"; + + var layer1 = new SoilLayer1D(); + layer1.Name = "layer1"; + layer1.TopLevel = 100; + layer1.Soil = coverSublayer1; + layer1.IsAquifer = false; + soilProfile.Layers.Add(layer1); + + var layer2 = new SoilLayer1D(); + layer2.Name = "layer2"; + layer2.TopLevel = -1.9; + layer2.Soil = coverSublayer2; + layer2.IsAquifer = false; + soilProfile.Layers.Add(layer2); + + var layer3 = new SoilLayer1D(); + layer3.Name = "layer3"; + layer3.TopLevel = -2.5; + layer3.Soil = coverSublayer3; + layer3.IsAquifer = false; + soilProfile.Layers.Add(layer3); + + var layer4 = new SoilLayer1D(); + layer4.Name = "layer4"; + layer4.TopLevel = -3.1; + layer4.Soil = pleistocene; + layer4.IsAquifer = true; + soilProfile.Layers.Add(layer4); + + return soilProfile; + } + + public static SoilProfile1D CreateTestProfileTwoCoverSublayersTwoAquifers() + { + var coverSublayer1 = new Soil(); + coverSublayer1.Name = "cover sublayer 1"; + coverSublayer1.AbovePhreaticLevel = 15; + coverSublayer1.BelowPhreaticLevel = 17; + coverSublayer1.SoilType = SoilType.Clay; + + var coverSublayer2 = new Soil(); + coverSublayer2.Name = "cover sublayer 2"; + coverSublayer2.AbovePhreaticLevel = 12; + coverSublayer2.BelowPhreaticLevel = 14; + coverSublayer2.SoilType = SoilType.Clay; + + var aquifer1 = new Soil(); + aquifer1.Name = "aquifer 1"; + aquifer1.AbovePhreaticLevel = 10; + aquifer1.BelowPhreaticLevel = 10.5; + aquifer1.SoilType = SoilType.Peat; + + var aquifer2 = new Soil(); + aquifer2.Name = "aquifer 2"; + aquifer2.AbovePhreaticLevel = 18; + aquifer2.BelowPhreaticLevel = 20; + aquifer2.SoilType = SoilType.Sand; + + var soilProfile = new SoilProfile1D(); + soilProfile.Name = "TestProfileWithTwoCoverSublayersTwoAquifers"; + + var layer1 = new SoilLayer1D(); + layer1.Name = "layer1"; + layer1.TopLevel = 100; + layer1.Soil = coverSublayer1; + layer1.IsAquifer = false; + soilProfile.Layers.Add(layer1); + + var layer2 = new SoilLayer1D(); + layer2.Name = "layer2"; + layer2.TopLevel = -1.9; + layer2.Soil = coverSublayer2; + layer2.IsAquifer = false; + soilProfile.Layers.Add(layer2); + + var layer3 = new SoilLayer1D(); + layer3.Name = "layer3"; + layer3.TopLevel = -2.5; + layer3.Soil = aquifer1; + layer3.IsAquifer = true; + soilProfile.Layers.Add(layer3); + + var layer4 = new SoilLayer1D(); + layer4.Name = "layer4"; + layer4.TopLevel = -3.1; + layer4.Soil = aquifer2; + layer4.IsAquifer = true; + soilProfile.Layers.Add(layer4); + + return soilProfile; + } + + public static SoilProfile1D CreateTestProfileOneCoverLayerOneInBetweenAquifer() + { + var coverLayer = new Soil(); + coverLayer.Name = "cover layer"; + coverLayer.AbovePhreaticLevel = 15; + coverLayer.BelowPhreaticLevel = 17; + coverLayer.SoilType = SoilType.Clay; + + var inBetweenAquifer = new Soil(); + inBetweenAquifer.Name = "in between aquifer"; + inBetweenAquifer.AbovePhreaticLevel = 12; + inBetweenAquifer.BelowPhreaticLevel = 14; + inBetweenAquifer.SoilType = SoilType.Clay; + + var deepAquitard = new Soil(); + deepAquitard.Name = "deep aquitard"; + deepAquitard.AbovePhreaticLevel = 10; + deepAquitard.BelowPhreaticLevel = 10.5; + deepAquitard.SoilType = SoilType.Peat; + + var deepAquifer = new Soil(); + deepAquifer.Name = "deep aquifer"; + deepAquifer.AbovePhreaticLevel = 18; + deepAquifer.BelowPhreaticLevel = 20; + deepAquifer.SoilType = SoilType.Sand; + + var soilProfile = new SoilProfile1D(); + soilProfile.Name = "TestProfileWithOneCoverLayerOneInBetweenAquifer"; + + var layer1 = new SoilLayer1D(); + layer1.Name = "layer1"; + layer1.TopLevel = 100; + layer1.Soil = coverLayer; + layer1.IsAquifer = false; + soilProfile.Layers.Add(layer1); + + var layer2 = new SoilLayer1D(); + layer2.Name = "layer2"; + layer2.TopLevel = -1.9; + layer2.Soil = inBetweenAquifer; + layer2.IsAquifer = true; + soilProfile.Layers.Add(layer2); + + var layer3 = new SoilLayer1D(); + layer3.Name = "layer3"; + layer3.TopLevel = -2.5; + layer3.Soil = deepAquitard; + layer3.IsAquifer = false; + soilProfile.Layers.Add(layer3); + + var layer4 = new SoilLayer1D(); + layer4.Name = "layer4"; + layer4.TopLevel = -3.1; + layer4.Soil = deepAquifer; + layer4.IsAquifer = true; + soilProfile.Layers.Add(layer4); + + return soilProfile; + } + private static string GetNewUniqueLayerId(SoilProfile1D soilProfile1D) + { + int num = 0; + string id; + do + { + id = "L" + (object)num++; + } + while (soilProfile1D.GetLayerWithName(id) != null); + return id; + } + } +} \ No newline at end of file Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/General/Physics.cs =================================================================== diff -u --- dam engine/trunk/src/Deltares.DamEngine.Calculators/General/Physics.cs (revision 0) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/General/Physics.cs (revision 684) @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Deltares.DamEngine.Calculators.General +{ + class Physics + { + public const double FactorMicroMeterToMeter = 1E-06; + public const double FactorMeterToMicroMeter = 1000000.0; + public const double GravityConstant = 9.81; + public const double WaterDensity = 1000.0; + public const double WaterViscosity = 1.33E-06; + public const double UnitWeightOfwater = 9.81; + } +} Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj =================================================================== diff -u -r683 -r684 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj (.../Deltares.DamEngine.Calculators.csproj) (revision 683) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj (.../Deltares.DamEngine.Calculators.csproj) (revision 684) @@ -77,6 +77,7 @@ + Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs =================================================================== diff -u -r670 -r684 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs (.../PLLinesCreator.cs) (revision 670) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs (.../PLLinesCreator.cs) (revision 684) @@ -1583,34 +1583,34 @@ phreaticLine.Points.Add(pointBelowHighLevel); break; -// case PLLineCreationMethod.ExpertKnowledgeRRD: -// //Add points below surface of dike talud riverside until toe of dike riverside -// foreach (GeometryPoint point in SurfaceLine.Geometry.Points.Where( -// point => point.X > intersectionLowWaterLevelWithDike.X && -// point.X <= pointDikeToeAtRiver.X)) -// { -// if (!surfaceLine.IsNonWaterRetainingObjectPoint(point)) -// { -// phreaticLine.Points.Add(new PLLinePoint(point.X, point.Z - cPLLineOffsetBelowSurface)); -// } -// } -// -// // Add points below crest of dike -// double offsetDikeTopAtRiver = this.waterLevelRiverHigh - PlLineOffsetBelowDikeTopAtRiver; -// double offsetDikeTopAtPolder = this.waterLevelRiverHigh - PlLineOffsetBelowDikeTopAtPolder; -// GeometryPoint pointDikeTopAtRiver = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver); -// GeometryPoint pointDikeTopAtPolder = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder); -// if (pointDikeTopAtRiver != null) -// phreaticLine.Points.Add(new PLLinePoint(pointDikeTopAtRiver.X, offsetDikeTopAtRiver)); -// -// if (pointDikeTopAtRiver != null && pointDikeTopAtPolder != null) -// { -// CreateOptionalPointAtDikeCrestMiddle(phreaticLine, pointDikeTopAtRiver, pointDikeTopAtPolder); -// } -// -// if (pointDikeTopAtPolder != null) -// phreaticLine.Points.Add(new PLLinePoint(pointDikeTopAtPolder.X, offsetDikeTopAtPolder)); -// break; + case PLLineCreationMethod.ExpertKnowledgeRRD: + //Add points below surface of dike talud riverside until toe of dike riverside + foreach (GeometryPoint point in SurfaceLine.Geometry.Points.Where( + point => point.X > intersectionLowWaterLevelWithDike.X && + point.X <= pointDikeToeAtRiver.X)) + { + //if (!surfaceLine.IsNonWaterRetainingObjectPoint(point)) + //{ + phreaticLine.Points.Add(new PLLinePoint(point.X, point.Z - cPLLineOffsetBelowSurface)); + //} + } + + // Add points below crest of dike + double offsetDikeTopAtRiver = this.waterLevelRiverHigh - PlLineOffsetBelowDikeTopAtRiver; + double offsetDikeTopAtPolder = this.waterLevelRiverHigh - PlLineOffsetBelowDikeTopAtPolder; + GeometryPoint pointDikeTopAtRiver = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver); + GeometryPoint pointDikeTopAtPolder = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder); + if (pointDikeTopAtRiver != null) + phreaticLine.Points.Add(new PLLinePoint(pointDikeTopAtRiver.X, offsetDikeTopAtRiver)); + + if (pointDikeTopAtRiver != null && pointDikeTopAtPolder != null) + { + CreateOptionalPointAtDikeCrestMiddle(phreaticLine, pointDikeTopAtRiver, pointDikeTopAtPolder); + } + + if (pointDikeTopAtPolder != null) + phreaticLine.Points.Add(new PLLinePoint(pointDikeTopAtPolder.X, offsetDikeTopAtPolder)); + break; } } Index: dam engine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs =================================================================== diff -u -r452 -r684 --- dam engine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs (.../SurfaceLine2Extensions.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2Extensions.cs (.../SurfaceLine2Extensions.cs) (revision 684) @@ -249,6 +249,7 @@ line.CharacteristicPoints.Annotate(index, type.Value); } } + line.Geometry.SyncCalcPoints(); } /// Index: dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/FactoryForSurfaceLines.cs =================================================================== diff -u --- dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/FactoryForSurfaceLines.cs (revision 0) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/PlLinesCreator/FactoryForSurfaceLines.cs (revision 684) @@ -0,0 +1,533 @@ +using Deltares.DamEngine.Data.Geometry; +using Deltares.DamEngine.Data.Geotechnics; + +namespace Deltares.DamEngine.Calculators.Tests +{ + public class FactoryForSurfaceLines + { + /// + /// Create simple soil profile, that is almost the same as Tutorial 1 + /// + /// soil profile + public static SurfaceLine2 CreateSurfaceLineTutorial1(bool includingTraffic = false) + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Name = "Tutorial1", + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + // Next point adjusted so create PL line can be tested better + surfaceLine.EnsurePointOfType(0.0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(10.0, 0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtRiver); + if (includingTraffic) + { + surfaceLine.EnsurePointOfType(35.0, 5, CharacteristicPointType.TrafficLoadOutside); + surfaceLine.EnsurePointOfType(38.5, 5, CharacteristicPointType.TrafficLoadInside); + } + surfaceLine.EnsurePointOfType(40.5, 5, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(50.5, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(58.5, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(59.5, -2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(61.5, -2, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(61.5, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(75.0, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial2() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Name = "Tutorial1" + }; + + // Next point adjusted so create PL line can be tested better + surfaceLine.EnsurePointOfType(0.0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(10.0, 0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(40.5, 5, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(50.5, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(58.5, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(59.5, -2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(61.5, -2, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(61.5, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(75.0, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial1WithOutsideShoulder() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Name = "Tutorial1", + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(10, 0, CharacteristicPointType.DikeToeAtRiver); + //Berm + surfaceLine.EnsurePointOfType(10, 2, CharacteristicPointType.ShoulderTopOutside); + surfaceLine.EnsurePointOfType(27.5, 3, CharacteristicPointType.ShoulderBaseInside); + //End Berm + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(40.5, 5, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(50.5, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(58.5, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(59.5, -2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(61.5, -2, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(61.5, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(75.00, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial1MissingCharacteristicPointDikeTopAtRiver() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(17, 0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial1MissingCharacteristicPointDikeTopAtPolder() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePoint(0, 0); + surfaceLine.EnsurePointOfType(17, 0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial1MissingCharacteristicPointDikeToeAtPolder() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(17, 0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial1PhreaticLowerPolderWaterLevel() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePointOfType(0, -1, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(17, -1, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(40.5, 5, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(50.5, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(58.5, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(59.5, -2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(61.5, -2, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(61.5, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(75.0, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial1PhreaticAboveSurface() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(17, 0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(40.5, 5, CharacteristicPointType.DikeTopAtPolder); + //Evil point (phreatic above surface) + surfaceLine.EnsurePoint(46, 0.250); + surfaceLine.EnsurePointOfType(50.5, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(58.5, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(59.5, -2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(60.5, -2, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(61.5, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(75.0, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineTutorial1WithShoulder() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(17, 0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(40.5, 5, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(48.25, 1.25, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(52.25, 1.25, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(54.75, 0.0, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(58.5, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(59.5, -2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(61.5, -2, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(61.5, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(75.0, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineForPipingBligh() + { + //Surface line tutorial 1 + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + + surfaceLine.EnsurePoint(0, 2.5); + surfaceLine.EnsurePoint(2, 2.5); + surfaceLine.EnsurePointOfType(3.5, 4, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePoint(5.5, 4); + surfaceLine.EnsurePointOfType(7.5, 2, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePoint(9.5, 2); + surfaceLine.EnsurePoint(10, 1.5); + surfaceLine.EnsurePoint(11, 2); + surfaceLine.EnsurePoint(13, 2); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateRealisticSurfaceLineForHeightAdapter() + { + var surfaceLine = new SurfaceLine2 + { + Geometry = new GeometryPointString(), + CharacteristicPoints = + { + GeometryMustContainPoint = true + } + }; + var pointSurfaceLevelOutside = new GeometryPoint + { + X = -27.0, Z = 12.4 + }; + var pointDikeToeAtRiver = new GeometryPoint + { + X = -17.4, Z = 12.4 + }; + var pointDikeTopAtRiver = new GeometryPoint + { + X = 0, Z = 18.2 + }; + var pointTrafficLoadOutside = new GeometryPoint + { + X = 1.0, Z = 18.2 + }; + var pointTrafficLoadInside = new GeometryPoint + { + X = 6.0, Z = 18.2 + }; + var pointDikeTopAtPolder = new GeometryPoint + { + X = 7.0, Z = 18.2 + }; + var pointInsteekShoulderInside = new GeometryPoint + { + X = 26.520, Z = 12.10 + }; + var pointTopShoulderInside = new GeometryPoint + { + X = 26.620, Z = 12.10 + }; + var pointDikeToeAtPolder = new GeometryPoint + { + X = 26.840, Z = 12.0 + }; + var pointDitchDikeSide = new GeometryPoint + { + X = 29.840, Z = 12.0 + }; + var pointBottomDitchDikeSide = new GeometryPoint + { + X = 30.840, Z = 11.0 + }; + var pointBottomDitchPolderSide = new GeometryPoint + { + X = 38.840, Z = 11.0 + }; + var pointDitchPolderSide = new GeometryPoint + { + X = 39.840, Z = 12 + }; + var pointSurfaceLevelInside = new GeometryPoint + { + X = 140, Z = 12 + }; + + surfaceLine.EnsurePointOfType(pointSurfaceLevelOutside.X, pointSurfaceLevelOutside.Z, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(pointDikeToeAtRiver.X, pointDikeToeAtRiver.Z, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(pointDikeTopAtRiver.X, pointDikeTopAtRiver.Z, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside); + surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside); + surfaceLine.EnsurePointOfType(pointDikeTopAtPolder.X, pointDikeTopAtPolder.Z, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(pointInsteekShoulderInside.X, pointInsteekShoulderInside.Z, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(pointTopShoulderInside.X, pointTopShoulderInside.Z, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineBm4_01() + { + var surfaceLine = new SurfaceLine2 + { + CharacteristicPoints = + { + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + surfaceLine.EnsurePointOfType(0.0, 0.1, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(4.0, 0.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(6.4, 1.3, CharacteristicPointType.ShoulderTopOutside); + surfaceLine.EnsurePointOfType(7.9, 1.5, CharacteristicPointType.ShoulderBaseOutside); + surfaceLine.EnsurePointOfType(10.0, 3.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(13, 3.2, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(15.6, 1.2, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(17, 1.0, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(18.6, 0.2, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(23, 0.1, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(26, -0.45, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(28.5, -0.48, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(31, 0.0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(45, 0.1, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineBm4_02() + { + var surfaceLine = new SurfaceLine2 + { + CharacteristicPoints = + { + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + surfaceLine.EnsurePointOfType(0.0, 1.0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(30.0, 0.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(45.0, 6.0, CharacteristicPointType.ShoulderTopOutside); + surfaceLine.EnsurePointOfType(55.0, 7.0, CharacteristicPointType.ShoulderBaseOutside); + surfaceLine.EnsurePointOfType(80.0, 16.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(85.0, 16.3, CharacteristicPointType.TrafficLoadOutside); + surfaceLine.EnsurePointOfType(90.0, 16.6, CharacteristicPointType.TrafficLoadInside); + surfaceLine.EnsurePointOfType(95.0, 16.9, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(120.0, 5.5, CharacteristicPointType.ShoulderBaseInside); + surfaceLine.EnsurePointOfType(127.0, 4.8, CharacteristicPointType.ShoulderTopInside); + surfaceLine.EnsurePointOfType(140.0, 0.5, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(165.0, 0.0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(175.0, -3.4, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(188.0, -3.0, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(200.0, 0.0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(220.0, -0.5, CharacteristicPointType.SurfaceLevelInside); + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSimpleSurfaceLineForExitPointTest() + { + var surfaceLine = new SurfaceLine2 + { + Name = "SimpleExitPoint" + }; + + surfaceLine.EnsurePointOfType(0.0, 0, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine.EnsurePointOfType(10.0, 0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine.EnsurePointOfType(34.5, 5, CharacteristicPointType.DikeTopAtRiver); + surfaceLine.EnsurePointOfType(40.5, 5, CharacteristicPointType.DikeTopAtPolder); + surfaceLine.EnsurePointOfType(50.5, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePoint(60.5, -1); + surfaceLine.EnsurePointOfType(75.0, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateHorizontalSurfaceLineForBenchmark1() + { + var surfaceLine = new SurfaceLine2 + { + Name = "HorizontalLine" + }; + + surfaceLine.EnsurePointOfType(30, -0.2, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(70, -0.2, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateDescendingSurfaceLineForBenchmark2() + { + var surfaceLine = new SurfaceLine2 + { + Name = "NonHorizontalLine" + }; + + surfaceLine.EnsurePointOfType(30, -0.2, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(70, -1.8, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateHorizontalSurfaceLineWithSymmetricalDitchForBenchmark5() + { + var surfaceLine = new SurfaceLine2 + { + Name = "HorizontalLineWithSymmetricalDitch" + }; + + surfaceLine.EnsurePointOfType(30, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(35, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(36, -1.2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(37, -1.2, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(38, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(70, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateNonHorizontalLineWithAsymmetricalDitchForBenchmark6() + { + var surfaceLine = new SurfaceLine2 + { + Name = "NonHorizontalLineWithAsymmetricalDitch" + }; + + surfaceLine.EnsurePointOfType(30, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(35.2, -0.208, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(36, -1.2, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(37, -1.3, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(38, -0.5, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(70, -0.8, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineWithAsymmetricalDitchHighPolderSide() + { + var surfaceLine = new SurfaceLine2 + { + Name = "AsymmetricalDitchHighPolderSide" + }; + + surfaceLine.EnsurePointOfType(30, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(35, 0, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(36, -1, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(37, -1, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(38, 1, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(70, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + + public static SurfaceLine2 CreateSurfaceLineWithAsymmetricalDitchHighDikeSide() + { + var surfaceLine = new SurfaceLine2 + { + Name = "AsymmetricalDitchHighPolderSide" + }; + + surfaceLine.EnsurePointOfType(30, 0, CharacteristicPointType.DikeToeAtPolder); + surfaceLine.EnsurePointOfType(35, 3, CharacteristicPointType.DitchDikeSide); + surfaceLine.EnsurePointOfType(36, -1, CharacteristicPointType.BottomDitchDikeSide); + surfaceLine.EnsurePointOfType(37, -1, CharacteristicPointType.BottomDitchPolderSide); + surfaceLine.EnsurePointOfType(38, 0, CharacteristicPointType.DitchPolderSide); + surfaceLine.EnsurePointOfType(70, 0, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine.Geometry.SyncCalcPoints(); + return surfaceLine; + } + } +} \ No newline at end of file Index: dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/PipingBlighTests.cs =================================================================== diff -u -r659 -r684 --- dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/PipingBlighTests.cs (.../PipingBlighTests.cs) (revision 659) +++ dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/PipingBlighTests.cs (.../PipingBlighTests.cs) (revision 684) @@ -47,7 +47,7 @@ // Profielnaam = soilprofile_01 // PL3 opdrijven = 0.582 // PL3 stijghoogte aangepast = 1.262 - // PL3 locatie opdriven lokaal = 35.0 + // PL3 locatie opdrijven lokaal = 35.0 // PL4 opdrijven = 0.0 // PL4 stijghoogte aangepast = 0.0 // PL4 locatie opdrijven lokaal = 0.0 Index: dam engine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs =================================================================== diff -u -r452 -r684 --- dam engine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs (.../GeometryPointString.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs (.../GeometryPointString.cs) (revision 684) @@ -574,6 +574,7 @@ public virtual void SortPointsByXAscending() { calcPoints.Sort(); + points.Sort(); } /// Index: dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj =================================================================== diff -u -r683 -r684 --- dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj (.../Deltares.DamEngine.Calculators.Tests.csproj) (revision 683) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj (.../Deltares.DamEngine.Calculators.Tests.csproj) (revision 684) @@ -49,6 +49,9 @@ + + +