// Copyright (C) Stichting Deltares 2024. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see .
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Interface;
using Deltares.DamEngine.TestHelpers.Factories;
using NUnit.Framework;
namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon;
public class PlLinesToWaternetConverterTests
{
private const string mapTestFiles = @"KernelWrappers\MacroStabilityCommon\TestFiles\";
private const double precision3Decimals = 0.00051;
private const double precision5Decimals = 0.0000051;
private const double penetrationLength = 0.5;
private static readonly Random random = new(21);
private static readonly double leftCoordinate = random.NextDouble();
private static readonly double rightCoordinate = leftCoordinate + 1;
[Test]
[TestCase(10, -5, 10, 10)]
[TestCase(10, 5, 10, 10.01)]
[TestCase(10, 5, 0.005, 10.0025)]
public void GivenALineWithVerticalPart_WhenCorrectingToAvoidUpwardsLine_ThenExpectedLineReturned(double xPoint2, double heightVerticalPart, double distancePoints3And4, double expectedXPoint3)
{
// Setup
IList points = new List();
points.Add(new Point2D(xPoint2 - 10, 0));
points.Add(new Point2D(xPoint2, 0));
points.Add(new Point2D(xPoint2, heightVerticalPart));
points.Add(new Point2D(xPoint2 + distancePoints3And4, heightVerticalPart));
points.Add(new Point2D(xPoint2 + distancePoints3And4 + 10, heightVerticalPart));
// Call
PlLinesToWaternetConverter.AvoidUpwardsVerticalLine(points);
// Assert
Assert.That(points, Has.Count.EqualTo(5));
Assert.Multiple(() =>
{
Assert.That(points[0].X, Is.EqualTo(xPoint2 - 10).Within(precision5Decimals));
Assert.That(points[0].Z, Is.EqualTo(0).Within(precision5Decimals));
Assert.That(points[1].X, Is.EqualTo(xPoint2).Within(precision5Decimals));
Assert.That(points[1].Z, Is.EqualTo(0).Within(precision5Decimals));
Assert.That(points[2].X, Is.EqualTo(expectedXPoint3).Within(precision5Decimals));
Assert.That(points[2].Z, Is.EqualTo(heightVerticalPart).Within(precision5Decimals));
Assert.That(points[3].X, Is.EqualTo(xPoint2 + distancePoints3And4).Within(precision5Decimals));
Assert.That(points[3].Z, Is.EqualTo(heightVerticalPart).Within(precision5Decimals));
Assert.That(points[4].X, Is.EqualTo(xPoint2 + distancePoints3And4 + 10).Within(precision5Decimals));
Assert.That(points[4].Z, Is.EqualTo(heightVerticalPart).Within(precision5Decimals));
});
}
[Test]
public void GivenALine_WhenSplittingAtTwoPoints_ThenReturnsThreeNewLines()
{
// Setup
var line = new Line(new Point2D(0, 0), new Point2D(90, 9));
var xCoordinatesToBeAdded = new List()
{
30,
60
};
List splitLines = [];
// Call
PlLinesToWaternetConverter.SplitLineAtXCoordinate(xCoordinatesToBeAdded, line, splitLines);
// Assert
Assert.That(splitLines, Has.Count.EqualTo(3));
Assert.Multiple(() =>
{
Assert.That(splitLines[0].BeginPoint.X, Is.EqualTo(0));
Assert.That(splitLines[0].BeginPoint.Z, Is.EqualTo(0));
Assert.That(splitLines[0].EndPoint.X, Is.EqualTo(30));
Assert.That(splitLines[0].EndPoint.Z, Is.EqualTo(3));
Assert.That(splitLines[1].BeginPoint.X, Is.EqualTo(30));
Assert.That(splitLines[1].BeginPoint.Z, Is.EqualTo(3));
Assert.That(splitLines[1].EndPoint.X, Is.EqualTo(60));
Assert.That(splitLines[1].EndPoint.Z, Is.EqualTo(6));
Assert.That(splitLines[2].BeginPoint.X, Is.EqualTo(60));
Assert.That(splitLines[2].BeginPoint.Z, Is.EqualTo(6));
Assert.That(splitLines[2].EndPoint.X, Is.EqualTo(90));
Assert.That(splitLines[2].EndPoint.Z, Is.EqualTo(9));
});
}
[Test]
public void GivenPlLinesWithoutPoints_WhenCreatingWaternetBasedOnPlLinesAnd1DSoilProfile_ThenReturnsEmptyWaternet()
{
// Setup
SoilProfile1D soilProfile = FactoryForSoilProfiles.CreateSoilProfile1DWithTwoClustersOfInBetweenAquifers(out SurfaceLine2 surfaceLine);
var plLines = new PlLines();
// Call
Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile, surfaceLine, penetrationLength, IntrusionVerticalWaterPressureType.Standard);
Assert.Multiple(() =>
{
// Assert
Assert.That(waternet.PhreaticLine, Is.Null);
Assert.That(waternet.HeadLineList, Is.Empty);
Assert.That(waternet.WaternetLineList, Is.Empty);
});
}
public class Given1DSoilProfileWithTwoClustersOfInBetweenAquifers
{
private static SurfaceLine2 surfaceLine;
private readonly SoilProfile1D soilProfile1D = FactoryForSoilProfiles.CreateSoilProfile1DWithTwoClustersOfInBetweenAquifers(out surfaceLine);
[TestCase(IntrusionVerticalWaterPressureType.Standard, -2.110, 6)]
[TestCase(IntrusionVerticalWaterPressureType.Linear, 1.212, 6)]
[TestCase(IntrusionVerticalWaterPressureType.HydroStatic, -2.110, 6)]
[TestCase(IntrusionVerticalWaterPressureType.FullHydroStatic, -30.000, 1)]
[TestCase(IntrusionVerticalWaterPressureType.SemiTimeDependent, -2.110, 7)]
public void WhenCreatingWaternetBasedOnPlLinesWithPhreaticLineInTopOfHighestAquitard_ThenReturnsValidWaternet(IntrusionVerticalWaterPressureType? pressureType, double levelWaternetPl1, int waternetLineCount)
{
const double pL1Level = 0.0;
const double xLeft = 0.0;
const double xRight = 100.0;
PlLines plLines = CreateAllPlLines(xLeft, xRight, pL1Level);
Assert.Multiple(() =>
{
Assert.That(soilProfile1D.GetInBetweenAquiferClusters, Has.Count.EqualTo(2).Within(precision3Decimals));
Assert.That(soilProfile1D.GetInBetweenAquiferClusters[0].Item1.TopLevel, Is.EqualTo(-2.111).Within(precision3Decimals));
Assert.That(soilProfile1D.GetInBetweenAquiferClusters[0].Item2.BottomLevel, Is.EqualTo(-3.373).Within(precision3Decimals));
Assert.That(soilProfile1D.GetInBetweenAquiferClusters[1].Item1.TopLevel, Is.EqualTo(-4.151).Within(precision3Decimals));
Assert.That(soilProfile1D.GetInBetweenAquiferClusters[1].Item2.BottomLevel, Is.EqualTo(-5.373).Within(precision3Decimals));
Assert.That(soilProfile1D.BottomAquiferLayer.TopLevel, Is.EqualTo(-6.111).Within(precision3Decimals));
});
const double penetrateLength = 2.1;
Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile1D, surfaceLine, penetrateLength, pressureType);
// Pl 1 is the phreatic line and gets waternet line to bottom level of the deepest layer where PL 1 lies
// Pl 2 gets waternet line to level of BottomAquiferLayer.TopLevel + penetrationLength
// Pl 3 gets waternet line to level of BottomAquiferLayer
// Pl 4 gets 4 waternet lines to level of InBetweenAquiferLayer.TopLevel and InBetweenAquiferLayer.BottomLevel for both in-between aquifers
Assert.That(waternet.WaternetLineList, Has.Count.EqualTo(waternetLineCount));
Assert.Multiple(() =>
{
// phreatic line (PL 1)
Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2));
Assert.That(waternet.PhreaticLine.Points[0].X, Is.EqualTo(xLeft).Within(precision3Decimals));
Assert.That(waternet.PhreaticLine.Points[0].Z, Is.EqualTo(pL1Level).Within(precision3Decimals));
Assert.That(waternet.PhreaticLine.Points[1].X, Is.EqualTo(xRight).Within(precision3Decimals));
Assert.That(waternet.PhreaticLine.Points[1].Z, Is.EqualTo(pL1Level).Within(precision3Decimals));
WaternetLine waternetLinePl1 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line phreatic line");
// expected: waternet line connected to pl1 has level:
// - for DAM Standard and Semi time dependent types, -2.111 m + 1 mm (Pl1 is in layer 2 from 0 m to -2.111 m)
// - for Linear type, 1.212 (the surface level)
// - for Hydrostatic type, -2.111 m + 1 mm (Pl1 is in layer 2 from 0 m to -2.111 m)
// - for Full hydrostatic, -30 (the bottom of the geometry)
Assert.That(waternetLinePl1.HeadLine.Points, Is.EqualTo(waternet.PhreaticLine.Points));
Assert.That(waternetLinePl1.HeadLine.Name, Is.EqualTo(waternet.PhreaticLine.Name));
Assert.That(waternetLinePl1.Points, Has.Count.EqualTo(2));
Assert.That(waternetLinePl1.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl1.Points[0].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals));
Assert.That(waternetLinePl1.Points[1].X, Is.EqualTo(100).Within(precision3Decimals));
Assert.That(waternetLinePl1.Points[1].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals));
});
// PL 2
WaternetLine waternetLinePl2 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Penetration zone lower aquifer");
if (pressureType == IntrusionVerticalWaterPressureType.SemiTimeDependent)
{
Assert.Multiple(() =>
{
Assert.That(waternet.HeadLineList[0].Points, Has.Count.EqualTo(2));
Assert.That(waternet.HeadLineList[0].Name, Is.EqualTo("Head line 2 (PL 2)"));
// check the points of first headline that represents pl 2
Assert.That(waternet.HeadLineList[0].Points[0].X, Is.EqualTo(xLeft).Within(precision3Decimals));
Assert.That(waternet.HeadLineList[0].Points[0].Z, Is.EqualTo(-6).Within(precision3Decimals));
Assert.That(waternet.HeadLineList[0].Points[1].X, Is.EqualTo(xRight).Within(precision3Decimals));
Assert.That(waternet.HeadLineList[0].Points[1].Z, Is.EqualTo(-6).Within(precision3Decimals));
// expected: waternet line connected to pl2 has level -6.111 + 2.1 = -4.011
Assert.That(waternetLinePl2.HeadLine, Is.EqualTo(waternet.HeadLineList[0]));
Assert.That(waternetLinePl2.Points, Has.Count.EqualTo(2));
Assert.That(waternetLinePl2.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl2.Points[0].Z, Is.EqualTo(-4.011).Within(precision3Decimals));
Assert.That(waternetLinePl2.Points[1].X, Is.EqualTo(100).Within(precision3Decimals));
Assert.That(waternetLinePl2.Points[1].Z, Is.EqualTo(-4.011).Within(precision3Decimals));
});
}
else
{
Assert.That(waternetLinePl2, Is.Null);
}
// PL 3 and PL 4
WaternetLine waternetLinePl3 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line lower aquifer");
WaternetLine waternetLinePl4TopInBetweenAquiferTop = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer top (1)");
WaternetLine waternetLinePl4TopInBetweenAquiferBottom = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer bottom (1)");
WaternetLine waternetLinePl4BottomInBetweenAquiferTop = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer top (2)");
WaternetLine waternetLinePl4BottomInBetweenAquiferBottom = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer bottom (2)");
if (pressureType != IntrusionVerticalWaterPressureType.FullHydroStatic)
{
Assert.Multiple(() =>
{
// expected: waternet line connected to pl3 has level -6.111
Assert.That(waternetLinePl3.HeadLine.Name, Is.EqualTo("Head line 3 (PL 3)"));
Assert.That(waternetLinePl3.Points, Has.Count.EqualTo(2));
});
Assert.Multiple(() =>
{
Assert.That(waternetLinePl3.Points[0].Z, Is.EqualTo(-6.111).Within(precision3Decimals));
// expected: highest waternet lines connected to pl4 have levels -2.111 and -3.373
Assert.That(waternetLinePl4TopInBetweenAquiferTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points, Has.Count.EqualTo(2));
Assert.That(waternetLinePl4TopInBetweenAquiferBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points, Has.Count.EqualTo(2));
});
Assert.Multiple(() =>
{
Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[0].Z, Is.EqualTo(-2.111).Within(precision3Decimals));
Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[1].X, Is.EqualTo(100).Within(precision3Decimals));
Assert.That(waternetLinePl4TopInBetweenAquiferTop.Points[1].Z, Is.EqualTo(-2.111).Within(precision3Decimals));
Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[0].Z, Is.EqualTo(-3.373).Within(precision3Decimals));
Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[1].X, Is.EqualTo(100).Within(precision3Decimals));
Assert.That(waternetLinePl4TopInBetweenAquiferBottom.Points[1].Z, Is.EqualTo(-3.373).Within(precision3Decimals));
// expected: lowest waternet lines 4 connected to pl4 have levels -4.151 and -5.373
Assert.That(waternetLinePl4BottomInBetweenAquiferTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points, Has.Count.EqualTo(2));
Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points, Has.Count.EqualTo(2));
});
Assert.Multiple(() =>
{
Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[0].Z, Is.EqualTo(-4.151).Within(precision3Decimals));
Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[1].X, Is.EqualTo(100).Within(precision3Decimals));
Assert.That(waternetLinePl4BottomInBetweenAquiferTop.Points[1].Z, Is.EqualTo(-4.151).Within(precision3Decimals));
Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[0].Z, Is.EqualTo(-5.373).Within(precision3Decimals));
Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[1].X, Is.EqualTo(100).Within(precision3Decimals));
Assert.That(waternetLinePl4BottomInBetweenAquiferBottom.Points[1].Z, Is.EqualTo(-5.373).Within(precision3Decimals));
});
}
else
{
Assert.Multiple(() =>
{
Assert.That(waternetLinePl3, Is.Null);
Assert.That(waternetLinePl4TopInBetweenAquiferTop, Is.Null);
Assert.That(waternetLinePl4TopInBetweenAquiferBottom, Is.Null);
Assert.That(waternetLinePl4BottomInBetweenAquiferTop, Is.Null);
Assert.That(waternetLinePl4BottomInBetweenAquiferBottom, Is.Null);
});
}
}
[TestCase(IntrusionVerticalWaterPressureType.Standard, -6.110)]
[TestCase(IntrusionVerticalWaterPressureType.Linear, 1.212)]
[TestCase(IntrusionVerticalWaterPressureType.HydroStatic, -2.110)]
[TestCase(IntrusionVerticalWaterPressureType.FullHydroStatic, -30.000)]
[TestCase(IntrusionVerticalWaterPressureType.SemiTimeDependent, -6.110)]
public void WhenCreatingWaternetBasedOnPlLinesWithPhreaticLineGoingThroughBottomAquifer_ThenExpectedWaternetLineForPl1Returned(IntrusionVerticalWaterPressureType? pressureType, double levelWaternetPl1)
{
PlLines plLines = CreateAllPlLines(0.0, 100.0, -29.0);
const double penetrateLength = 2.1;
Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile1D, surfaceLine, penetrateLength, pressureType);
// Expected: waternet line connected to pl1 has level:
// - for DAM Standard and Semi time dependent types, -6.111 m + 1 mm (Pl1 is in bottom aquifer)
// - for Linear type, 1.212 (the surface level)
// - for Hydrostatic type, -2.111 m + 1 mm (Pl1 is in layer 2 from 0 m to -2.111 m)
// - for Full hydrostatic, -30 (the bottom of the geometry)
Assert.Multiple(() =>
{
WaternetLine waternetLinePl1 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line phreatic line");
Assert.That(waternetLinePl1.HeadLine.Points, Is.EqualTo(waternet.PhreaticLine.Points));
Assert.That(waternetLinePl1.HeadLine.Name, Is.EqualTo(waternet.PhreaticLine.Name));
Assert.That(waternetLinePl1.Points, Has.Count.EqualTo(2));
Assert.That(waternetLinePl1.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl1.Points[0].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals));
Assert.That(waternetLinePl1.Points[1].X, Is.EqualTo(100).Within(precision3Decimals));
Assert.That(waternetLinePl1.Points[1].Z, Is.EqualTo(levelWaternetPl1).Within(precision3Decimals));
});
}
}
[Test]
public void GivenNullPlLines_WhenCreatingWaternetBasedOnPlLinesAnd1DSoilProfile_ThenReturnsNoHeadLines()
{
PlLines plLines = CreateAllPlLines();
SoilProfile1D soilProfile1D = FactoryForSoilProfiles.CreateSoilProfile1DWithTwoClustersOfInBetweenAquifers(out SurfaceLine2 surfaceLine);
Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile1D, surfaceLine, 0.5, IntrusionVerticalWaterPressureType.SemiTimeDependent);
// head lines
Assert.That(waternet.HeadLineList, Has.Count.EqualTo(3));
Assert.Multiple(() =>
{
Assert.That(waternet.HeadLineList[0].Points, Has.Count.EqualTo(2));
Assert.That(waternet.HeadLineList[1].Points, Has.Count.EqualTo(2));
Assert.That(waternet.HeadLineList[2].Points, Has.Count.EqualTo(2));
// phreatic line
Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2));
});
// check that no headline are added when Pl2, Pl3 or Pl4 does not exist or has no points
plLines.Lines[PlLineType.Pl3] = null;
plLines.Lines[PlLineType.Pl4].Points.Clear();
waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile1D, surfaceLine, 0.5, IntrusionVerticalWaterPressureType.SemiTimeDependent);
// head lines
Assert.That(waternet.HeadLineList, Has.Count.EqualTo(1));
Assert.Multiple(() =>
{
Assert.That(waternet.HeadLineList[0].Points, Has.Count.EqualTo(2));
// phreatic line
Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2));
});
}
public class Given2DSoilProfileWithTwoClustersOfInBetweenAquifersAndVerticalLayerSeparations
{
private static readonly SoilProfile2D soilProfile = Create2DSoilProfileWithTwoClustersOfInBetweenAquifersAndVerticalLayerSeparations();
private readonly SurfaceLine2 surfaceLine = FactoryForSurfaceLines.CreateHorizontalSurfaceLine(20, leftCoordinate, rightCoordinate);
[TestCase(IntrusionVerticalWaterPressureType.Standard, -9.999, 6, 2)]
[TestCase(IntrusionVerticalWaterPressureType.Linear, 20.000, 6, 2)]
[TestCase(IntrusionVerticalWaterPressureType.HydroStatic, 10.001, 6, 2)]
[TestCase(IntrusionVerticalWaterPressureType.FullHydroStatic, -35.000, 1, 0)]
[TestCase(IntrusionVerticalWaterPressureType.SemiTimeDependent, -9.999, 7, 3, penetrationLength)]
[TestCase(IntrusionVerticalWaterPressureType.SemiTimeDependent, -9.999, 6, 2, 0)]
public void WhenCreatingWaternetBasedOnPlLinesWithPhreaticLineInAquitardNr3_ThenReturnsValidWaternet(IntrusionVerticalWaterPressureType? pressureType, double levelWaternetPl1, int waternetLineCount, int headlineCount, double penetrationZone = double.NaN)
{
PlLines plLines = CreateAllPlLines();
// Call
Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile, surfaceLine, penetrationZone, pressureType);
// Assert
AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.Points);
Assert.That(waternet.HeadLineList, Has.Count.EqualTo(headlineCount));
var indexHeadlinePl3 = 0;
var indexHeadlinePl4 = 1;
if (pressureType == IntrusionVerticalWaterPressureType.SemiTimeDependent && penetrationZone > 0)
{
AssertGeometry(plLines.Lines[PlLineType.Pl2].Points, waternet.HeadLineList[0].Points);
indexHeadlinePl3 += 1;
indexHeadlinePl4 += 1;
}
if (pressureType != IntrusionVerticalWaterPressureType.FullHydroStatic)
{
AssertGeometry(plLines.Lines[PlLineType.Pl3].Points, waternet.HeadLineList[indexHeadlinePl3].Points);
AssertGeometry(plLines.Lines[PlLineType.Pl4].Points, waternet.HeadLineList[indexHeadlinePl4].Points);
}
Assert.That(waternet.WaternetLineList, Has.Count.EqualTo(waternetLineCount));
WaternetLine pl1WaternetLine = waternet.WaternetLineList.Find(w => w.HeadLine.Name == waternet.PhreaticLine.Name);
Assert.That(pl1WaternetLine.HeadLine.Name, Is.SameAs(waternet.PhreaticLine.Name));
Point2D[] expectedWaternetLine1 =
[
new(leftCoordinate, levelWaternetPl1),
new(rightCoordinate, levelWaternetPl1)
];
AssertGeometry(expectedWaternetLine1, pl1WaternetLine.Points);
Point2D[] expectedBottomAquiferCoordinates =
[
new(leftCoordinate, -25),
new(rightCoordinate, -25)
];
WaternetLine pl2WaternetLine = waternet.WaternetLineList.Find(w => w.HeadLine.Name == "Head line 2 (PL 2)");
if (pressureType == IntrusionVerticalWaterPressureType.SemiTimeDependent && penetrationZone > 0)
{
Assert.That(pl2WaternetLine.HeadLine, Is.SameAs(waternet.HeadLineList[0]));
Point2D[] offSetAquiferCoordinates = expectedBottomAquiferCoordinates.Select(aquiferCoordinate => new Point2D(aquiferCoordinate.X, aquiferCoordinate.Z + penetrationLength))
.ToArray();
AssertGeometry(offSetAquiferCoordinates, pl2WaternetLine.Points);
}
else
{
Assert.That(pl2WaternetLine, Is.Null);
}
if (waternetLineCount > 1)
{
WaternetLine pl3WaternetLine = waternet.WaternetLineList.Find(w => w.HeadLine.Name == "Head line 3 (PL 3)");
Assert.That(pl3WaternetLine.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl3]));
AssertGeometry(expectedBottomAquiferCoordinates, pl3WaternetLine.Points);
WaternetLine pl4WaternetLine1Top = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer top (1)");
Assert.That(pl4WaternetLine1Top.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4]));
AssertGeometry([
new Point2D(leftCoordinate, 10),
new Point2D(rightCoordinate, 10)
], pl4WaternetLine1Top.Points);
WaternetLine pl4WaternetLineBottom = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer bottom (1)");
Assert.That(pl4WaternetLineBottom.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4]));
AssertGeometry([
new Point2D(leftCoordinate, 0),
new Point2D(rightCoordinate, 0)
], pl4WaternetLineBottom.Points);
WaternetLine pl4WaternetLine2Top = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer top (2)");
Assert.That(pl4WaternetLine2Top.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4]));
AssertGeometry([
new Point2D(leftCoordinate, -10),
new Point2D(rightCoordinate, -10)
], pl4WaternetLine2Top.Points);
WaternetLine pl4WaternetLine2Bottom = waternet.WaternetLineList.Find(w => w.Name == "Waternet line in-between aquifer bottom (2)");
Assert.That(pl4WaternetLine2Bottom.HeadLine, Is.SameAs(waternet.HeadLineList[indexHeadlinePl4]));
AssertGeometry([
new Point2D(leftCoordinate, -20),
new Point2D(rightCoordinate, -20)
], pl4WaternetLine2Bottom.Points);
}
}
[TestCase(IntrusionVerticalWaterPressureType.Standard, -24.999)]
[TestCase(IntrusionVerticalWaterPressureType.Linear, 20.000)]
[TestCase(IntrusionVerticalWaterPressureType.HydroStatic, 10.001)]
[TestCase(IntrusionVerticalWaterPressureType.FullHydroStatic, -35.000)]
[TestCase(IntrusionVerticalWaterPressureType.SemiTimeDependent, -24.999)]
public void WhenCreatingWaternetBasedOnPlLinesWithPhreaticLineGoingThroughBottomAquifer_ThenExpectedWaternetLineForPl1Returned(IntrusionVerticalWaterPressureType? pressureType, double expectedLevelWaternetPl1)
{
PlLines plLines = CreateAllPlLines(-32);
// Call
Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile, surfaceLine, 0, pressureType);
// Assert
AssertGeometry(plLines.Lines[PlLineType.Pl1].Points, waternet.PhreaticLine.Points);
WaternetLine pl1WaternetLine = waternet.WaternetLineList.Find(w => w.HeadLine.Name == waternet.PhreaticLine.Name);
Assert.That(pl1WaternetLine.HeadLine.Name, Is.SameAs(waternet.PhreaticLine.Name));
Point2D[] expectedWaternetLine1 =
[
new(leftCoordinate, expectedLevelWaternetPl1),
new(rightCoordinate, expectedLevelWaternetPl1)
];
AssertGeometry(expectedWaternetLine1, pl1WaternetLine.Points);
}
///
/// X_a X_b
/// --------------------------------------------------- Level 20 m
/// Aquitard 1
/// ----------------|----------------|----------------- Level 10 m
/// Aquifer 2a | Aquifer 2b | Aquifer 2c
/// ----------------|----------------|----------------- Level 0 m
/// Aquitard 3
/// ----------------|----------------|----------------- Level -10 m
/// Aquifer 4a | Aquifer 4b | Aquifer 4c
/// ----------------|----------------|----------------- Level -20 m
/// Aquitard 5
/// ----------------|----------------|----------------- Level -25 m
/// Aquifer 6a | Aquifer 6b | Aquifer 6c
/// ----------------|----------------|----------------- Level -30 m
/// Aquifer 7a | Aquifer 7b | Aquifer 7c
/// ----------------|----------------|----------------- Level -35 m
///
private static SoilProfile2D Create2DSoilProfileWithTwoClustersOfInBetweenAquifersAndVerticalLayerSeparations()
{
double xA = leftCoordinate + (rightCoordinate - leftCoordinate) / 3;
double xB = rightCoordinate - (rightCoordinate - leftCoordinate) / 3;
var soilProfile = new SoilProfile2D
{
Geometry = new GeometryData
{
Left = leftCoordinate,
Right = rightCoordinate,
Bottom = -35
}
};
// Setup
SoilLayer2D aquitard1 = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(20, 10, leftCoordinate, rightCoordinate, soilProfile,null,false);
SoilLayer2D aquifer2A = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(10, 0, leftCoordinate, xA, soilProfile,null, true);
SoilLayer2D aquifer2B = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(10, 0, xA, xB, soilProfile,null, true);
SoilLayer2D aquifer2C = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(10, 0, xB, rightCoordinate, soilProfile, null, true);
SoilLayer2D aquitard3 = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(0, -10, leftCoordinate, rightCoordinate, soilProfile,null, false);
SoilLayer2D aquifer4A = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-10, -20, leftCoordinate, xA, soilProfile,null, true);
SoilLayer2D aquifer4B = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-10, -20, xA, xB, soilProfile,null, true);
SoilLayer2D aquifer4C = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-10, -20, xB, rightCoordinate, soilProfile,null, true);
SoilLayer2D aquitard5 = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-20, -25, leftCoordinate, rightCoordinate, soilProfile,null, false);
SoilLayer2D aquifer6A = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-25, -30, leftCoordinate, xA, soilProfile,null, true);
SoilLayer2D aquifer6B = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-25, -30, xA, xB, soilProfile,null, true);
SoilLayer2D aquifer6C = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-25, -30, xB, rightCoordinate, soilProfile,null, true);
SoilLayer2D aquifer7A = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-30, -35, leftCoordinate, xA, soilProfile,null, true);
SoilLayer2D aquifer7B = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-30, -35, xA, xB, soilProfile,null, true);
SoilLayer2D aquifer7C = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-30, -35, xB, rightCoordinate, soilProfile,null, true);
soilProfile.Surfaces.Add(aquitard1);
soilProfile.Surfaces.Add(aquifer2A);
soilProfile.Surfaces.Add(aquifer2B);
soilProfile.Surfaces.Add(aquifer2C);
soilProfile.Surfaces.Add(aquitard3);
soilProfile.Surfaces.Add(aquifer4A);
soilProfile.Surfaces.Add(aquifer4B);
soilProfile.Surfaces.Add(aquifer4C);
soilProfile.Surfaces.Add(aquitard5);
soilProfile.Surfaces.Add(aquifer6A);
soilProfile.Surfaces.Add(aquifer6B);
soilProfile.Surfaces.Add(aquifer6C);
soilProfile.Surfaces.Add(aquifer7A);
soilProfile.Surfaces.Add(aquifer7B);
soilProfile.Surfaces.Add(aquifer7C);
soilProfile.Geometry.Surfaces.Add(aquitard1.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer2A.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer2B.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer2C.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquitard3.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer4A.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer4B.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer4C.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquitard5.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer6A.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer6B.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer6C.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer7A.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer7B.GeometrySurface);
soilProfile.Geometry.Surfaces.Add(aquifer7C.GeometrySurface);
return soilProfile;
}
}
[Test]
public void TestConvertLevelToWaternetLine()
{
const double level = 1.234;
const double left = -50.111;
const double right = 50.123;
WaternetLine waternetLine = PlLinesToWaternetConverter.CreateWaternetLine(level, left, right);
Assert.That(waternetLine.Points, Has.Count.EqualTo(2));
Assert.Multiple(() =>
{
Assert.That(waternetLine.Points[0].X, Is.EqualTo(-50.111).Within(precision3Decimals));
Assert.That(waternetLine.Points[0].Z, Is.EqualTo(1.234).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].X, Is.EqualTo(50.123).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].Z, Is.EqualTo(1.234).Within(precision3Decimals));
});
}
[Test]
public void Given2DProfileDWP1AndPl1FromTutorialStability_WhenCreatingTheWaternetLineForPL1ForDAMStandard_ThenExpectedWaternetLineReturned()
{
// Setup
const string inputFilename = "InputTutorialStabilitySoilProfileDWP1.xml";
string fullInputFilename = Path.Combine(mapTestFiles, inputFilename);
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
string inputString = File.ReadAllText(fullInputFilename);
var engineInterface = new EngineInterface(inputString);
SoilProfile2D soilProfile = engineInterface.DamProjectData.Dike.SoilProfiles2D[0];
var pL1 = new PlLine();
pL1.Points.Add(new PlLinePoint(0, 4.4));
pL1.Points.Add(new PlLinePoint(43.51, 4.4));
pL1.Points.Add(new PlLinePoint(46.42, 3.9));
pL1.Points.Add(new PlLinePoint(50.59, 3.9));
pL1.Points.Add(new PlLinePoint(60.76, 2.69));
pL1.Points.Add(new PlLinePoint(69.06, 1.6));
pL1.Points.Add(new PlLinePoint(74.75, 1.6));
pL1.Points.Add(new PlLinePoint(80.78, 1.6));
// Call
WaternetLine waternetLine = PlLinesToWaternetConverter.CreateWaternetLineForPhreaticLineForDamStandard(soilProfile, pL1);
// Assert
Assert.That(waternetLine, Has.Count.EqualTo(9));
Assert.Multiple(() =>
{
Assert.That(waternetLine.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLine.Points[0].Z, Is.EqualTo(0.92).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].X, Is.EqualTo(10.14).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].Z, Is.EqualTo(0.95).Within(precision3Decimals));
Assert.That(waternetLine.Points[2].X, Is.EqualTo(17.08).Within(precision3Decimals));
Assert.That(waternetLine.Points[2].Z, Is.EqualTo(0.88).Within(precision3Decimals));
Assert.That(waternetLine.Points[3].X, Is.EqualTo(19.45).Within(precision3Decimals));
Assert.That(waternetLine.Points[3].Z, Is.EqualTo(0.81).Within(precision3Decimals));
Assert.That(waternetLine.Points[4].X, Is.EqualTo(20.62).Within(precision3Decimals));
Assert.That(waternetLine.Points[4].Z, Is.EqualTo(0.3).Within(precision3Decimals));
Assert.That(waternetLine.Points[5].X, Is.EqualTo(21.84).Within(precision3Decimals));
Assert.That(waternetLine.Points[5].Z, Is.EqualTo(-0.61).Within(precision3Decimals));
Assert.That(waternetLine.Points[6].X, Is.EqualTo(23.08).Within(precision3Decimals));
Assert.That(waternetLine.Points[6].Z, Is.EqualTo(-0.38).Within(precision3Decimals));
Assert.That(waternetLine.Points[7].X, Is.EqualTo(24.61).Within(precision3Decimals));
Assert.That(waternetLine.Points[7].Z, Is.EqualTo(0.63).Within(precision3Decimals));
Assert.That(waternetLine.Points[8].X, Is.EqualTo(80.78).Within(precision3Decimals));
Assert.That(waternetLine.Points[8].Z, Is.EqualTo(0.63).Within(precision3Decimals));
});
}
///
/// E I
/// A |--------------------\------------------\-------------------| M Level 0 m
/// | Aquitard 1 \ F Aquitard 2 \ J Aquitard 3 |
/// B |----------------------\------------------\-----------------| N Level -8 m
/// | Aquitard 4 \ G Aquitard 5 \ K Aquitard 6 |
/// C |------------------------\------------------\---------------| O Level -12 m
/// | Aquitard 7 \ H Aquitard 8 \ L Aquit. 9 |
/// D |--------------------------\------------------\-------------| P Level -15 m
/// | |
/// | bottom aquifer layer |
/// |-----------------------------------------------------------| Level -20 m
///
[Test]
[TestCase(2, 0)]
[TestCase(-5, -8)]
[TestCase(-10, -12)]
[TestCase(-13, -15)]
[TestCase(-17, -15)]
public void Given2DProfileWithInclinedLayerSeparations_WhenCreatingTheWaternetLineForPL1ForDAMStandardOption_ThenExpectedWaternetLineReturned(double pL1Level, double expectedWaternetLineLevel)
{
// Setup
double xMiddle1 = leftCoordinate + (rightCoordinate - leftCoordinate) / 3;
double xMiddle2 = leftCoordinate + 2 * (rightCoordinate - leftCoordinate) / 3;
var pointA = new Point2D(leftCoordinate, 0);
var pointB = new Point2D(leftCoordinate, -8);
var pointC = new Point2D(leftCoordinate, -12);
var pointD = new Point2D(leftCoordinate, -15);
var pointE = new Point2D(xMiddle1, 0);
var pointF = new Point2D(xMiddle1 + 0.0001, -8);
var pointG = new Point2D(xMiddle1 + 0.0002, -12);
var pointH = new Point2D(xMiddle1 + 0.0003, -15);
var pointI = new Point2D(xMiddle2, 0);
var pointJ = new Point2D(xMiddle2 + 0.0001, -8);
var pointK = new Point2D(xMiddle2 + 0.0002, -12);
var pointL = new Point2D(xMiddle2 + 0.0003, -15);
var pointM = new Point2D(rightCoordinate, 0);
var pointN = new Point2D(rightCoordinate, -8);
var pointO = new Point2D(rightCoordinate, -12);
var pointP = new Point2D(rightCoordinate, -15);
var soilProfile = new SoilProfile2D
{
Geometry = new GeometryData
{
Left = leftCoordinate,
Right = rightCoordinate,
Bottom = -20
},
Name = "SoilProfileTest"
};
SoilLayer2D soilLayer1 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointA, pointE, pointF, pointB, soilProfile, new Soil("Layer1"));
SoilLayer2D soilLayer2 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointE, pointI, pointJ, pointF, soilProfile, new Soil("Layer2"));
SoilLayer2D soilLayer3 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointI, pointM, pointN, pointJ, soilProfile, new Soil("Layer3"));
SoilLayer2D soilLayer4 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointB, pointF, pointG, pointC, soilProfile, new Soil("Layer4"));
SoilLayer2D soilLayer5 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointF, pointJ, pointK, pointG, soilProfile, new Soil("Layer5"));
SoilLayer2D soilLayer6 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointJ, pointN, pointO, pointK, soilProfile, new Soil("Layer6"));
SoilLayer2D soilLayer7 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointC, pointG, pointH, pointD, soilProfile, new Soil("Layer7"));
SoilLayer2D soilLayer8 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointG, pointK, pointL, pointH, soilProfile, new Soil("Layer8"));
SoilLayer2D soilLayer9 = FactoryForSoilProfiles.CreateQuadrilateralSoilLayer2D(pointK, pointO, pointP, pointL, soilProfile, new Soil("Layer9"));
SoilLayer2D soilLayerBottom = FactoryForSoilProfiles.CreateRectangularSoilLayer2D(-15, -20, leftCoordinate, rightCoordinate, soilProfile,null, true);
soilProfile.Surfaces.Add(soilLayer1);
soilProfile.Surfaces.Add(soilLayer2);
soilProfile.Surfaces.Add(soilLayer3);
soilProfile.Surfaces.Add(soilLayer4);
soilProfile.Surfaces.Add(soilLayer5);
soilProfile.Surfaces.Add(soilLayer6);
soilProfile.Surfaces.Add(soilLayer7);
soilProfile.Surfaces.Add(soilLayer8);
soilProfile.Surfaces.Add(soilLayer9);
soilProfile.Surfaces.Add(soilLayerBottom);
soilProfile.Geometry.Surfaces.Add(new GeometrySurface());
soilProfile.Geometry.SurfaceLine.Points.Add(new Point2D(leftCoordinate, 0));
soilProfile.Geometry.SurfaceLine.Points.Add(new Point2D(rightCoordinate, 0));
PlLines plLines = CreateAllPlLines(pL1Level);
// Call
WaternetLine waternetLine = PlLinesToWaternetConverter.CreateWaternetLineForPhreaticLineForDamStandard(soilProfile, plLines.Lines[PlLineType.Pl1]);
// Assert
Assert.That(waternetLine, Has.Count.EqualTo(2));
Assert.Multiple(() =>
{
Assert.That(waternetLine.Points[0].X, Is.EqualTo(leftCoordinate).Within(precision3Decimals));
Assert.That(waternetLine.Points[0].Z, Is.EqualTo(expectedWaternetLineLevel).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].X, Is.EqualTo(rightCoordinate).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].Z, Is.EqualTo(expectedWaternetLineLevel).Within(precision3Decimals));
});
}
///
/// PL 1
/// ==========================================\\ Level 2 m
/// B /------------------\ C \\ Level 0 m
/// | / Dike \ \\ E J
/// |--------------/----------------------\------\\----\ /-------| Level -5 m
/// | A Layer 1 D \\====\==========/========| Level -6 m
/// | \ / |
/// |-----------------------------------------------------\ F I /----------| Level -10 m
/// | Layer 2 G \----/ H | Level -12.5 m
/// |-----------------------------------------------------------------------| Level -15 m
/// | Bottom aquifer layer |
/// |-----------------------------------------------------------------------| Level -20 m
///
[Test]
public void Given2DProfileWithPl1AboveTheDikeAndCuttingTheDitch_WhenCreatingTheWaternetLineForPL1ForDAMStandardOption_ThenExpectedWaternetLineReturned()
{
// Setup
SurfaceLine2 surfaceLine = FactoryForSurfaceLines.CreateSurfaceLineWithDikeAndDitch(0, -12.5);
SoilProfile1D soilProfile1D = FactoryForSoilProfiles.Create4LayersProfileWith1BottomAquifer();
var soilSurfaceProfile = new SoilSurfaceProfile
{
SoilProfile = soilProfile1D,
SurfaceLine2 = surfaceLine,
DikeEmbankmentMaterial = new Soil(),
Name = "Test"
};
SoilProfile2D soilProfile2D = soilSurfaceProfile.ConvertToSoilProfile2D();
const double xLeft = 0;
const double xPointF = 59.3;
const double xPointG = 59.5;
const double xPointH = 61.5;
const double xPointI = 61.7;
const double xPl1A = -30;
const double xPl1B = -20;
const double xRight = 75;
var plLine = new PlLine
{
Name = "Phreatic line"
};
plLine.Points.Add(new PlLinePoint(xLeft, 2));
plLine.Points.Add(new PlLinePoint(xPl1A, 2));
plLine.Points.Add(new PlLinePoint(xPl1B, -6));
plLine.Points.Add(new PlLinePoint(xRight, -6));
// Call
WaternetLine waternetLine = PlLinesToWaternetConverter.CreateWaternetLineForPhreaticLineForDamStandard(soilProfile2D, plLine);
// Assert
Assert.That(waternetLine, Has.Count.EqualTo(6));
Assert.Multiple(() =>
{
Assert.That(waternetLine.Points[0].X, Is.EqualTo(xLeft).Within(precision3Decimals));
Assert.That(waternetLine.Points[0].Z, Is.EqualTo(-10).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].X, Is.EqualTo(xPointF).Within(precision3Decimals));
Assert.That(waternetLine.Points[1].Z, Is.EqualTo(-10).Within(precision3Decimals));
Assert.That(waternetLine.Points[2].X, Is.EqualTo(xPointG).Within(precision3Decimals));
Assert.That(waternetLine.Points[2].Z, Is.EqualTo(-12.5).Within(precision3Decimals));
Assert.That(waternetLine.Points[3].X, Is.EqualTo(xPointH).Within(precision3Decimals));
Assert.That(waternetLine.Points[3].Z, Is.EqualTo(-12.5).Within(precision3Decimals));
Assert.That(waternetLine.Points[4].X, Is.EqualTo(xPointI).Within(precision3Decimals));
Assert.That(waternetLine.Points[4].Z, Is.EqualTo(-10).Within(precision3Decimals));
Assert.That(waternetLine.Points[5].X, Is.EqualTo(xRight).Within(precision3Decimals));
Assert.That(waternetLine.Points[5].Z, Is.EqualTo(-10).Within(precision3Decimals));
});
}
///
/// _______ Level 10 m
/// / Clay \
/// /---------\ Level 6 m
/// / Aquifer \
/// /-------------\ X=58.5 X=62.5 Level 2 m
/// -----------/ Clay \------\ /-------- Level 0 m
/// -----------------------------------\ /--------- Level -2 m
/// In between aquifer \ /
/// -------------------------------------\ /----------- Level -4 m
/// Clay \ /
/// ---------------------------------------\ /------------- Level -6 m
/// \_____/ Level -8 m
/// Bottom aquifer X=59.5 X=61.5
/// ------------------------------------------------------------- Level -10 m
///
[Test]
public void GivenSoilProfile2DWithAquiferInDikeBodyAndAquifersCuttingTheDitch_WhenCreatingWaternetLine_ThenExpectedWaternetLineReturned()
{
SurfaceLine2 surfaceLine = FactoryForSurfaceLines.CreateSurfaceLineWithDikeAndDitch(10, -8);
SoilProfile1D soilProfile1D = FactoryForSoilProfiles.CreateClaySandClaySandClaySandProfile(10, 6, 2, 0 -2, -4, -6);
soilProfile1D.BottomLevel = -10;
var soilSurfaceProfile = new SoilSurfaceProfile
{
SoilProfile = soilProfile1D,
SurfaceLine2 = surfaceLine,
DikeEmbankmentMaterial = new Soil(),
Name = "Test"
};
SoilProfile2D soilProfile2D = soilSurfaceProfile.ConvertToSoilProfile2D();
const double pL1Level = 0;
PlLines plLines = CreateAllPlLines(pL1Level);
// Call
Waternet waternet = PlLinesToWaternetConverter.CreateWaternetBasedOnPlLines(plLines, soilProfile2D, surfaceLine, 0, IntrusionVerticalWaterPressureType.Standard);
// Assert
Assert.That(waternet.WaternetLineList, Has.Count.EqualTo(6));
// phreatic line (PL 1)
Assert.Multiple(() =>
{
Assert.That(waternet.PhreaticLine.Points, Has.Count.EqualTo(2));
WaternetLine waternetLinePl1 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line phreatic line");
Assert.That(waternetLinePl1.HeadLine.Points, Is.EqualTo(waternet.PhreaticLine.Points));
Assert.That(waternetLinePl1.HeadLine.Name, Is.EqualTo(waternet.PhreaticLine.Name));
Assert.That(waternetLinePl1.Points, Has.Count.EqualTo(10));
});
// no PL 2
WaternetLine waternetLinePl2 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Penetration zone lower aquifer");
Assert.That(waternetLinePl2, Is.Null);
// PL 3
WaternetLine waternetLinePl3 = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line lower aquifer");
Assert.Multiple(() =>
{
Assert.That(waternetLinePl3.HeadLine.Name, Is.EqualTo("Head line 3 (PL 3)"));
Assert.That(waternetLinePl3.Points, Has.Count.EqualTo(6));
Assert.That(waternetLinePl3.Points[0].X, Is.EqualTo(0));
Assert.That(waternetLinePl3.Points[0].Z, Is.EqualTo(-6));
Assert.That(waternetLinePl3.Points[1].X, Is.EqualTo(59.25));
Assert.That(waternetLinePl3.Points[1].Z, Is.EqualTo(-6));
Assert.That(waternetLinePl3.Points[2].X, Is.EqualTo(59.5));
Assert.That(waternetLinePl3.Points[2].Z, Is.EqualTo(-8));
Assert.That(waternetLinePl3.Points[3].X, Is.EqualTo(61.5));
Assert.That(waternetLinePl3.Points[3].Z, Is.EqualTo(-8));
Assert.That(waternetLinePl3.Points[4].X, Is.EqualTo(61.75));
Assert.That(waternetLinePl3.Points[4].Z, Is.EqualTo(-6));
Assert.That(waternetLinePl3.Points[5].X, Is.EqualTo(75));
Assert.That(waternetLinePl3.Points[5].Z, Is.EqualTo(-6));
});
// PL 4: 4 waternet lines expected at top and bottom and at both sides of the ditch
// No waternet line expected for the in-between aquifer in the dike body
WaternetLine waternetLinePl4LeftDitchTop = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer top (1)");
WaternetLine waternetLinePl4LeftDitchBottom = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer bottom (1)");
WaternetLine waternetLinePl4RightDitchTop = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer top (2)");
WaternetLine waternetLinePl4RightDitchBottom = waternet.WaternetLineList.Find(waternetLine => waternetLine.Name == "Waternet line in-between aquifer bottom (2)");
Assert.Multiple(() =>
{
Assert.That(waternetLinePl4LeftDitchTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4LeftDitchTop.Points, Has.Count.EqualTo(3));
Assert.That(waternetLinePl4LeftDitchBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4LeftDitchBottom.Points, Has.Count.EqualTo(2));
Assert.That(waternetLinePl4RightDitchTop.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4RightDitchTop.Points, Has.Count.EqualTo(3));
Assert.That(waternetLinePl4RightDitchBottom.HeadLine.Name, Is.EqualTo("Head line 4 (PL 4)"));
Assert.That(waternetLinePl4RightDitchBottom.Points, Has.Count.EqualTo(2));
});
Assert.Multiple(() =>
{
Assert.That(waternetLinePl4LeftDitchTop.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchTop.Points[0].Z, Is.EqualTo(-2).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchTop.Points[1].X, Is.EqualTo(58.75).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchTop.Points[1].Z, Is.EqualTo(-2).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchTop.Points[2].X, Is.EqualTo(59).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchTop.Points[2].Z, Is.EqualTo(-4).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchBottom.Points[0].X, Is.EqualTo(0).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchBottom.Points[0].Z, Is.EqualTo(-4).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchBottom.Points[1].X, Is.EqualTo(59).Within(precision3Decimals));
Assert.That(waternetLinePl4LeftDitchBottom.Points[1].Z, Is.EqualTo(-4).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchTop.Points[0].X, Is.EqualTo(62).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchTop.Points[0].Z, Is.EqualTo(-4).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchTop.Points[1].X, Is.EqualTo(62.25).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchTop.Points[1].Z, Is.EqualTo(-2).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchTop.Points[2].X, Is.EqualTo(75).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchTop.Points[2].Z, Is.EqualTo(-2).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchBottom.Points[0].X, Is.EqualTo(62).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchBottom.Points[0].Z, Is.EqualTo(-4).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchBottom.Points[1].X, Is.EqualTo(75).Within(precision3Decimals));
Assert.That(waternetLinePl4RightDitchBottom.Points[1].Z, Is.EqualTo(-4).Within(precision3Decimals));
});
}
private static SoilLayer2D CreateSoilLayer2D(Point2D topLeftCoordinate, Point2D topRightCoordinate,
Point2D bottomRightCoordinate, Point2D bottomLeftCoordinate, bool isAquifer)
{
return new SoilLayer2D
{
GeometrySurface = new GeometrySurface
{
OuterLoop = new GeometryLoop
{
CurveList =
{
new GeometryCurve(topLeftCoordinate, topRightCoordinate),
new GeometryCurve(topRightCoordinate, bottomRightCoordinate),
new GeometryCurve(bottomRightCoordinate, bottomLeftCoordinate),
new GeometryCurve(bottomLeftCoordinate, topLeftCoordinate)
}
}
},
IsAquifer = isAquifer
};
}
private static void AssertGeometry(IEnumerable expectedPoints, IEnumerable actualPoints)
{
int expectedNrOfPoints = expectedPoints.Count();
Assert.That(actualPoints.Count(), Is.EqualTo(expectedNrOfPoints));
for (var i = 0; i < expectedNrOfPoints; i++)
{
Point2D expectedPoint = expectedPoints.ElementAt(i);
Point2D actualPoint = actualPoints.ElementAt(i);
Assert.Multiple(() =>
{
Assert.That(actualPoint.X, Is.EqualTo(expectedPoint.X).Within(precision5Decimals));
Assert.That(actualPoint.Z, Is.EqualTo(expectedPoint.Z).Within(precision5Decimals));
});
}
}
private static void AssertGeometry(IEnumerable expectedPoints, IEnumerable actualPoints)
{
int expectedNrOfPoints = expectedPoints.Count();
Assert.That(actualPoints.Count(), Is.EqualTo(expectedNrOfPoints));
for (var i = 0; i < expectedNrOfPoints; i++)
{
GeometryPoint expectedPoint = expectedPoints.ElementAt(i);
GeometryPoint actualPoint = actualPoints.ElementAt(i);
Assert.Multiple(() =>
{
Assert.That(actualPoint.X, Is.EqualTo(expectedPoint.X).Within(precision5Decimals));
Assert.That(actualPoint.Z, Is.EqualTo(expectedPoint.Z).Within(precision5Decimals));
});
}
}
private static PlLines CreateAllPlLines(double pl1Level = -5)
{
return CreateAllPlLines(leftCoordinate, rightCoordinate, pl1Level);
}
private static PlLines CreateAllPlLines(double xLeft, double xRight, double pl1Level = -5)
{
var plLines = new PlLines();
PlLine plLine = plLines.Lines[PlLineType.Pl1];
plLine.Name = "Phreatic line";
plLine.Points.Add(new PlLinePoint(xLeft, pl1Level));
plLine.Points.Add(new PlLinePoint(xRight, pl1Level));
plLine = plLines.Lines[PlLineType.Pl2];
plLine.Name = "PL 2";
plLine.Points.Add(new PlLinePoint(xLeft, -6));
plLine.Points.Add(new PlLinePoint(xRight, -6));
plLine = plLines.Lines[PlLineType.Pl3];
plLine.Name = "PL 3";
plLine.Points.Add(new PlLinePoint(xLeft, -7));
plLine.Points.Add(new PlLinePoint(xRight, -7));
plLine = plLines.Lines[PlLineType.Pl4];
plLine.Name = "PL 4";
plLine.Points.Add(new PlLinePoint(xLeft, -8));
plLine.Points.Add(new PlLinePoint(xRight, -8));
return plLines;
}
}