Example #1
0
        public void ToMacroStabilityInwardsGridConfiguration_ValidMacroStabilityInwardsGrid_ReturnsNewMacroStabilityInwardsGridConfigurationWithParametersSet()
        {
            // Setup
            var random = new Random(31);

            var grid = new MacroStabilityInwardsGrid(random.NextRoundedDouble(0.0, 1.0),
                                                     random.NextRoundedDouble(2.0, 3.0),
                                                     random.NextRoundedDouble(2.0, 3.0),
                                                     random.NextRoundedDouble(0.0, 1.0))
            {
                NumberOfHorizontalPoints = random.Next(1, 100),
                NumberOfVerticalPoints   = random.Next(1, 100)
            };

            // Call
            MacroStabilityInwardsGridConfiguration configuration = grid.ToMacroStabilityInwardsGridConfiguration();

            // Assert
            Assert.AreEqual(grid.XLeft, configuration.XLeft, grid.XLeft.GetAccuracy());
            Assert.AreEqual(grid.XRight, configuration.XRight, grid.XRight.GetAccuracy());
            Assert.AreEqual(grid.ZTop, configuration.ZTop, grid.ZTop.GetAccuracy());
            Assert.AreEqual(grid.ZBottom, configuration.ZBottom, grid.ZBottom.GetAccuracy());
            Assert.AreEqual(grid.NumberOfHorizontalPoints, configuration.NumberOfHorizontalPoints);
            Assert.AreEqual(grid.NumberOfVerticalPoints, configuration.NumberOfVerticalPoints);
        }
Example #2
0
        public void Constructor_SetProperties_ExpectedValues()
        {
            // Setup
            var    random  = new Random(31);
            double xLeft   = random.NextDouble();
            double xRight  = random.NextDouble();
            double zTop    = random.NextDouble();
            double zBottom = random.NextDouble();
            int    numberOfHorizontalPoints = random.Next();
            int    numberOfVerticalPoints   = random.Next();

            // Call
            var configuration = new MacroStabilityInwardsGridConfiguration
            {
                XLeft   = xLeft,
                XRight  = xRight,
                ZTop    = zTop,
                ZBottom = zBottom,
                NumberOfHorizontalPoints = numberOfHorizontalPoints,
                NumberOfVerticalPoints   = numberOfVerticalPoints
            };

            // Assert
            Assert.AreEqual(xLeft, configuration.XLeft);
            Assert.AreEqual(xRight, configuration.XRight);
            Assert.AreEqual(zTop, configuration.ZTop);
            Assert.AreEqual(zBottom, configuration.ZBottom);
            Assert.AreEqual(numberOfHorizontalPoints, configuration.NumberOfHorizontalPoints);
            Assert.AreEqual(numberOfVerticalPoints, configuration.NumberOfVerticalPoints);
        }
Example #3
0
        public void GetMacroStabilityInwardsGridConfiguration_DescendantElementNameNotFound_ReturnNull()
        {
            // Setup
            const string descendantElementName = "descendantElement";

            var element = new XElement("Root", new XElement(descendantElementName));

            // Call
            MacroStabilityInwardsGridConfiguration configuration = element.GetMacroStabilityInwardsGridConfiguration("differentElementName");

            // Assert
            Assert.IsNull(configuration);
        }
Example #4
0
        public void Constructor_ExpectedValues()
        {
            // Call
            var configuration = new MacroStabilityInwardsGridConfiguration();

            // Assert
            Assert.IsNull(configuration.XLeft);
            Assert.IsNull(configuration.XRight);
            Assert.IsNull(configuration.ZTop);
            Assert.IsNull(configuration.ZBottom);
            Assert.IsNull(configuration.NumberOfHorizontalPoints);
            Assert.IsNull(configuration.NumberOfVerticalPoints);
        }
Example #5
0
        public void GetMacroStabilityInwardsGridConfiguration_WithoutProperties_ReturnMacroStabilityInwardsGridConfiguration()
        {
            // Setup
            const string descendantElementName = "descendantElement";

            var element = new XElement("Root", new XElement(descendantElementName));

            // Call
            MacroStabilityInwardsGridConfiguration configuration = element.GetMacroStabilityInwardsGridConfiguration(descendantElementName);

            // Assert
            Assert.IsNull(configuration.XLeft);
            Assert.IsNull(configuration.XRight);
            Assert.IsNull(configuration.ZTop);
            Assert.IsNull(configuration.ZBottom);
            Assert.IsNull(configuration.NumberOfHorizontalPoints);
            Assert.IsNull(configuration.NumberOfVerticalPoints);
        }
Example #6
0
        public void GetMacroStabilityInwardsGridConfiguration_WithNumberOfVerticalPoints_ReturnMacroStabilityInwardsGridConfiguration()
        {
            // Setup
            var          random = new Random(31);
            double       numberOfVerticalPoints = random.Next();
            const string descendantElementName  = "descendantElement";

            var element = new XElement("Root", new XElement(descendantElementName,
                                                            new XElement("aantalpuntenverticaal", numberOfVerticalPoints)));

            // Call
            MacroStabilityInwardsGridConfiguration configuration = element.GetMacroStabilityInwardsGridConfiguration(descendantElementName);

            // Assert
            Assert.IsNull(configuration.XLeft);
            Assert.IsNull(configuration.XRight);
            Assert.IsNull(configuration.ZTop);
            Assert.IsNull(configuration.ZBottom);
            Assert.IsNull(configuration.NumberOfHorizontalPoints);
            Assert.AreEqual(numberOfVerticalPoints, configuration.NumberOfVerticalPoints);
        }
Example #7
0
        public void GetMacroStabilityInwardsGridConfiguration_ValidDescendantElement_ReturnMacroStabilityInwardsGridConfiguration()
        {
            // Setup
            var          random  = new Random(31);
            double       xLeft   = random.NextDouble();
            double       xRight  = random.NextDouble();
            double       zTop    = random.NextDouble();
            double       zBottom = random.NextDouble();
            double       numberOfHorizontalPoints = random.Next();
            double       numberOfVerticalPoints   = random.Next();
            const string descendantElementName    = "descendantElement";

            var xLeftElement   = new XElement("xlinks", xLeft);
            var xRightElement  = new XElement("xrechts", xRight);
            var zTopElement    = new XElement("zboven", zTop);
            var zBottomElement = new XElement("zonder", zBottom);
            var numberOfHorizontalPointsElement = new XElement("aantalpuntenhorizontaal", numberOfHorizontalPoints);
            var numberOfVerticalPointsElement   = new XElement("aantalpuntenverticaal", numberOfVerticalPoints);

            var element = new XElement("Root", new XElement(descendantElementName,
                                                            xLeftElement,
                                                            xRightElement,
                                                            zTopElement,
                                                            zBottomElement,
                                                            numberOfHorizontalPointsElement,
                                                            numberOfVerticalPointsElement));

            // Call
            MacroStabilityInwardsGridConfiguration configuration = element.GetMacroStabilityInwardsGridConfiguration(descendantElementName);

            // Assert
            Assert.AreEqual(xLeft, configuration.XLeft);
            Assert.AreEqual(xRight, configuration.XRight);
            Assert.AreEqual(zTop, configuration.ZTop);
            Assert.AreEqual(zBottom, configuration.ZBottom);
            Assert.AreEqual(numberOfHorizontalPoints, configuration.NumberOfHorizontalPoints);
            Assert.AreEqual(numberOfVerticalPoints, configuration.NumberOfVerticalPoints);
        }
        private static void AssertConfiguration(MacroStabilityInwardsCalculationConfiguration configuration, bool hydraulicBoundaryLocation)
        {
            Assert.AreEqual("Calculation", configuration.Name);

            if (hydraulicBoundaryLocation)
            {
                Assert.IsNull(configuration.AssessmentLevel);
                Assert.AreEqual("Locatie", configuration.HydraulicBoundaryLocationName);
            }
            else
            {
                Assert.AreEqual(1.1, configuration.AssessmentLevel);
                Assert.IsNull(configuration.HydraulicBoundaryLocationName);
            }

            Assert.AreEqual("Profielschematisatie", configuration.SurfaceLineName);
            Assert.AreEqual("Ondergrondmodel", configuration.StochasticSoilModelName);
            Assert.AreEqual("Ondergrondschematisatie", configuration.StochasticSoilProfileName);

            Assert.AreEqual(ConfigurationDikeSoilScenario.SandDikeOnClay, configuration.DikeSoilScenario);
            Assert.AreEqual(10.5, configuration.WaterLevelRiverAverage);

            Assert.IsTrue(configuration.DrainageConstructionPresent);
            Assert.AreEqual(10.6, configuration.XCoordinateDrainageConstruction);
            Assert.AreEqual(10.7, configuration.ZCoordinateDrainageConstruction);

            Assert.AreEqual(10.9, configuration.MinimumLevelPhreaticLineAtDikeTopRiver);
            Assert.AreEqual(10.8, configuration.MinimumLevelPhreaticLineAtDikeTopPolder);

            Assert.IsTrue(configuration.AdjustPhreaticLine3And4ForUplift);

            Assert.AreEqual(20.1, configuration.PiezometricHeadPhreaticLine2Inwards);
            Assert.AreEqual(20.2, configuration.PiezometricHeadPhreaticLine2Outwards);
            Assert.AreEqual(10.1, configuration.LeakageLengthInwardsPhreaticLine3);
            Assert.AreEqual(10.2, configuration.LeakageLengthOutwardsPhreaticLine3);
            Assert.AreEqual(10.3, configuration.LeakageLengthInwardsPhreaticLine4);
            Assert.AreEqual(10.4, configuration.LeakageLengthOutwardsPhreaticLine4);

            MacroStabilityInwardsLocationInputConfiguration dailyConfiguration = configuration.LocationInputDaily;

            Assert.IsNotNull(dailyConfiguration);
            Assert.AreEqual(2.2, dailyConfiguration.WaterLevelPolder);
            Assert.IsTrue(dailyConfiguration.UseDefaultOffsets);
            Assert.AreEqual(2.21, dailyConfiguration.PhreaticLineOffsetBelowDikeTopAtRiver);
            Assert.AreEqual(2.24, dailyConfiguration.PhreaticLineOffsetBelowDikeToeAtPolder);
            Assert.AreEqual(2.22, dailyConfiguration.PhreaticLineOffsetBelowDikeTopAtPolder);
            Assert.AreEqual(2.23, dailyConfiguration.PhreaticLineOffsetBelowShoulderBaseInside);

            MacroStabilityInwardsLocationInputExtremeConfiguration extremeConfiguration = configuration.LocationInputExtreme;

            Assert.IsNotNull(extremeConfiguration);
            Assert.AreEqual(15.2, extremeConfiguration.WaterLevelPolder);
            Assert.AreEqual(16.2, extremeConfiguration.PenetrationLength);
            Assert.IsFalse(extremeConfiguration.UseDefaultOffsets);
            Assert.AreEqual(15.21, extremeConfiguration.PhreaticLineOffsetBelowDikeTopAtRiver);
            Assert.AreEqual(15.24, extremeConfiguration.PhreaticLineOffsetBelowDikeToeAtPolder);
            Assert.AreEqual(15.22, extremeConfiguration.PhreaticLineOffsetBelowDikeTopAtPolder);
            Assert.AreEqual(15.23, extremeConfiguration.PhreaticLineOffsetBelowShoulderBaseInside);

            Assert.AreEqual(0.4, configuration.SlipPlaneMinimumDepth);
            Assert.AreEqual(0.5, configuration.SlipPlaneMinimumLength);
            Assert.AreEqual(0.6, configuration.MaximumSliceWidth);

            Assert.IsTrue(configuration.CreateZones);
            Assert.AreEqual(ConfigurationZoningBoundariesDeterminationType.Manual, configuration.ZoningBoundariesDeterminationType);
            Assert.AreEqual(10.0, configuration.ZoneBoundaryLeft);
            Assert.AreEqual(43.5, configuration.ZoneBoundaryRight);

            Assert.IsTrue(configuration.MoveGrid);
            Assert.AreEqual(ConfigurationGridDeterminationType.Automatic, configuration.GridDeterminationType);

            Assert.AreEqual(ConfigurationTangentLineDeterminationType.LayerSeparated, configuration.TangentLineDeterminationType);
            Assert.AreEqual(10, configuration.TangentLineZTop);
            Assert.AreEqual(1, configuration.TangentLineZBottom);
            Assert.AreEqual(5, configuration.TangentLineNumber);

            MacroStabilityInwardsGridConfiguration leftGridConfiguration = configuration.LeftGrid;

            Assert.IsNotNull(leftGridConfiguration);
            Assert.IsNaN(leftGridConfiguration.XLeft);
            Assert.IsNaN(leftGridConfiguration.XRight);
            Assert.IsNaN(leftGridConfiguration.ZTop);
            Assert.IsNaN(leftGridConfiguration.ZBottom);
            Assert.AreEqual(6, leftGridConfiguration.NumberOfVerticalPoints);
            Assert.AreEqual(5, leftGridConfiguration.NumberOfHorizontalPoints);

            MacroStabilityInwardsGridConfiguration rightGridConfiguration = configuration.RightGrid;

            Assert.IsNotNull(rightGridConfiguration);
            Assert.AreEqual(1, rightGridConfiguration.XLeft);
            Assert.AreEqual(2, rightGridConfiguration.XRight);
            Assert.AreEqual(4, rightGridConfiguration.ZTop);
            Assert.AreEqual(3, rightGridConfiguration.ZBottom);
            Assert.AreEqual(5, rightGridConfiguration.NumberOfVerticalPoints);
            Assert.AreEqual(6, rightGridConfiguration.NumberOfHorizontalPoints);

            ScenarioConfiguration scenarioConfiguration = configuration.Scenario;

            Assert.IsNotNull(scenarioConfiguration);
            Assert.AreEqual(8.8, scenarioConfiguration.Contribution);
            Assert.IsFalse(scenarioConfiguration.IsRelevant);
        }