//-----------------------------------------------------------------------
// <copyright file="SurfaceLineHeightAdapterTest.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>03-12-2009</date>
// <summary>Tests for SurfaceLineHeightAdapter</summary>
//-----------------------------------------------------------------------

using Deltares.Dam.TestHelper;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.TestUtils;
using Deltares.Standard;
using Deltares.Standard.Logging;
using Deltares.Standard.TestUtils;

namespace Deltares.Dam.Tests
{
    using System.IO;
    using Deltares.Dam.Data;
    using Deltares.Soilbase;
    using NUnit.Framework;

    [TestFixture]
    public class StabilityCalculatorTest
    {
        const double tolerance = 0.0001;

        [TearDown]
        public void TearDown()
        {
            LogManager.Clear();
        }

        [Test]
        public void IsFirstParameterMinimalSafetyFactor()
        {
            var results1 = new MStabResults();
            results1.zone1.safetyFactor = 2.0;
            results1.zone1.circleSurfacePointRightXCoordinate = 12.0;
            var results2 = new MStabResults();
            results2.zone1.safetyFactor = 3.0;
            results2.zone1.circleSurfacePointRightXCoordinate = 10.0;
            var actualResult = StabilityCalculator.MinMStabResults(results1, results2);
            Assert.AreEqual(results1.zone1.safetyFactor, actualResult.zone1.safetyFactor, tolerance);
            Assert.AreEqual(results1.zone1.circleSurfacePointRightXCoordinate, actualResult.zone1.circleSurfacePointRightXCoordinate, tolerance);
        }

        [Test]
        public void IsSecondParameterMinimalSafetyFactor()
        {
            var results1 = new MStabResults();
            results1.zone1.safetyFactor = 2.0;
            results1.zone1.circleSurfacePointRightXCoordinate = 12.0;
            var results2 = new MStabResults();
            results2.zone1.safetyFactor = 1.0;
            results2.zone1.circleSurfacePointRightXCoordinate = 10.0;
            var actualResult = StabilityCalculator.MinMStabResults(results1, results2);
            Assert.AreEqual(results2.zone1.safetyFactor, actualResult.zone1.safetyFactor, tolerance);
            Assert.AreEqual(results2.zone1.circleSurfacePointRightXCoordinate, actualResult.zone1.circleSurfacePointRightXCoordinate, tolerance);
        }

        [Test]
        [Category(Categories.Slow)]
        public void CanCalculateStabilitySafetyFactorGeometry1D()
        {
            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                SoilProfile1D soilProfile = FactoryForStabilityTests.CreateSoilProfile();

                const double cToleranceSafetyFactor = 0.001;
                using (var stabilityCalculator = SetupStabilityCalculator())
                {
                    stabilityCalculator.Calculate(scenario, soilProfile, null, 0);
                    Assert.AreEqual(1.486, scenario.GetMStabResults(soilProfile, "").Value.zone1.safetyFactor,
                        cToleranceSafetyFactor);
                }
            }
        }

        [Test, Ignore("This test only proves that the .NET Stability kernel is connected to the DAM stability kernel. It shows the results are not identical")]
        public void CanCalculateStabilitySafetyFactorGeometry1D_UsingDotNetKernel()
        {
            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                SoilProfile1D soilProfile = FactoryForStabilityTests.CreateSoilProfile();

                const double cToleranceSafetyFactor = 0.001;
                using (var stabilityCalculator = SetupStabilityCalculator())
                {
                    stabilityCalculator.SelectedStabilityKernelType = StabilityKernelType.DamClassicDotNet;
                    stabilityCalculator.Calculate(scenario, soilProfile, null, 0);
                    Assert.AreEqual(1.486, scenario.GetMStabResults(soilProfile, "").Value.zone1.safetyFactor,
                        cToleranceSafetyFactor);
                }
            }
        }
        
        [Test]
        [Category(Categories.Slow)]
        public void CanCalculateStabilitySafetyFactorGeometry1D_UsingWTIStabilityKernel()
        {
            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                SoilProfile1D soilProfile = FactoryForStabilityTests.CreateSoilProfile();

                const double cToleranceSafetyFactor = 0.1;
                using (var stabilityCalculator = SetupStabilityCalculator())
                {
                    stabilityCalculator.SelectedStabilityKernelType = StabilityKernelType.DamClassicWti;
                    stabilityCalculator.Calculate(scenario, soilProfile, null, 0);
                    Assert.AreEqual(1.6231, scenario.GetMStabResults(soilProfile, "").Value.zone1.safetyFactor,
                        cToleranceSafetyFactor);
                }
            }
        }

        private static StabilityCalculator SetupStabilityCalculator()
        {
            const double cTrafficLoad = 10.0;
            const double cMinimalCircleDepth = 1.0;
            const double cSafetyFactorStabilityInnerSlope = 1.1;
            const string cmstabProgramPath = ".\\DGeoStability.exe";
            //#BKA zie failed test map: resultaten van versie 505 verschillen van 902 Laten zien aan Han + overleg!! Ook PipingFactorSellmeijerCalculator met Han nagaan evenals wens Ray voor uplift tangentlines 
            ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines();
            MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();
            DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification =
                new DamFailureMechanismeCalculationSpecification();
            damFailureMechanismeCalculationSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityInside;
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters =
                mstabParameters;
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType =
                MStabZonesType.NoZones;
            StabilityCalculator stabilityCalculator =
                new StabilityCalculator(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab,
                    ProgramType.MStab, modelParametersForPLLines,
                    cTrafficLoad, cMinimalCircleDepth, cSafetyFactorStabilityInnerSlope,
                    cmstabProgramPath, cmstabProgramPath, null, null, null, null, ProbabilisticType.Deterministic);
            return stabilityCalculator;
        }

        [Test]
        [Category(Categories.Slow)]
        public void CanCalculateStabilitySafetyFactorHorizontalBalanceGeometry1D()
        {
            const double cToleranceSafetyFactor = 0.001;
            const double cTrafficLoad = 10.0;
            const double cMinimalCircleDepth = 1.0;
            const double cSafetyFactorStabilityInnerSlope = 1.1;
            const string cmstabProgramPath = ".\\DGeoStability.exe";

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                SoilProfile1D soilProfile = FactoryForStabilityTests.CreateSoilProfile();
                ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines();
                MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();
                mstabParameters.Model = MStabModelType.HorizontalBalance;
                mstabParameters.SearchMethod = MStabSearchMethod.Grid;
                DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification();
                damFailureMechanismeCalculationSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityInside;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters =
                    mstabParameters;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType =
                    MStabZonesType.NoZones;
                using (
                    StabilityCalculator stabilityCalculator =
                        new StabilityCalculator(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab,
                            ProgramType.MStab, modelParametersForPLLines,
                            cTrafficLoad, cMinimalCircleDepth, cSafetyFactorStabilityInnerSlope,
                            cmstabProgramPath, cmstabProgramPath, null, null, null, null, ProbabilisticType.Deterministic))
                {
                    scenario.RiverLevel = 4.0;
                    scenario.Location.PolderLevel = -1.0;
                    stabilityCalculator.Calculate(scenario, soilProfile, null, 0);
                    // the following calculation result has been obtained from a trial test run
                    Assert.AreEqual(10.169, scenario.GetMStabResults(soilProfile, "").Value.zone1.safetyFactor, cToleranceSafetyFactor);
                }
            }
        }

        [Test, Ignore("This test requires SlopeW with a valid license")]
        public void CanCalculateStabilitySafetyFactorGeometry1DUsingSlopeW()
        {
            const double cToleranceSafetyFactor = 0.001;
            const double cTrafficLoad = 10.0;
            const double cMinimalCircleDepth = 1.0;
            const double cSafetyFactorStabilityInnerSlope = 1.1;
            const string cmstabProgramPath = ".\\Slope2.exe";

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                SoilProfile1D soilProfile = FactoryForStabilityTests.CreateSoilProfile();
                ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines();
                MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();
                DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification();
                damFailureMechanismeCalculationSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityInside;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters =
                    mstabParameters;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType =
                    MStabZonesType.NoZones;
                using (StabilityCalculator stabilityCalculator = new StabilityCalculator(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab,
                            ProgramType.SlopeW, modelParametersForPLLines, cTrafficLoad, 
                            cMinimalCircleDepth, cSafetyFactorStabilityInnerSlope, cmstabProgramPath, 
                            cmstabProgramPath, null, null, null, null, ProbabilisticType.Deterministic))
                {
                    stabilityCalculator.Calculate(scenario, soilProfile, null, 0);
                    Assert.AreEqual(1.6555, scenario.GetMStabResults(soilProfile, "").Value.zone1.safetyFactor, cToleranceSafetyFactor);
                }
            }
        }

        /// <summary>
        /// This test fails on some Windows 7 x64 machines
        /// 
        /// This test now fails because of rev. 12881, where the Bishop grid is enlarged, which causes the calculation to find a local slipcircle in the ditch
        /// </summary>
        [Test, Ignore("This test fails on some Windows 7 x64 machines")]
        public void CanCalculateStabilityProbablitityGeometry1D()
        {
            const double cToleranceProbability = 0.00001;
            const double cTrafficLoad = 10.0;
            const double cMinimalCircleDepth = 1.0;
            const double cSafetyFactorStabilityInnerSlope = 1.1;
            const string cmstabProgramPath = ".\\DGeoStability.exe";

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                SoilProfile1D soilProfile = FactoryForStabilityTests.CreateSoilProfile();
                ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines();
                MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();
                mstabParameters.SearchMethod = MStabSearchMethod.Grid;
                DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification =
                    new DamFailureMechanismeCalculationSpecification();
                damFailureMechanismeCalculationSpecification.FailureMechanismSystemType =
                    FailureMechanismSystemType.StabilityInside;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters =
                    mstabParameters;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType =
                    MStabZonesType.NoZones;
                using (StabilityCalculator stabilityCalculator =
                    new StabilityCalculator(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab,
                        ProgramType.MStab, modelParametersForPLLines,
                        cTrafficLoad, cMinimalCircleDepth, cSafetyFactorStabilityInnerSlope,
                        cmstabProgramPath, cmstabProgramPath, null, null, null, null, ProbabilisticType.Probabilistic))
                {
                    stabilityCalculator.Calculate(scenario, soilProfile, null, 0);
                    // The expected value is read from the dumpfile itself
                    Assert.AreEqual(0.0057654520770, scenario.GetFailureProbabilityStability(soilProfile, "").Value,
                        cToleranceProbability);
                }
            }
        }

        /// <summary>
        /// This test fails on some Windows 7 x64 machines
        /// </summary>
        [Test, Ignore("This test fails on some Windows 7 x64 machines")]
        public void CanCalculateStabilityProbablitityAdvancedGeometry1D()
        {
            const double cToleranceProbability = 0.00001;
            const double cTrafficLoad = 10.0;
            const double cMinimalCircleDepth = 1.0;
            const double cSafetyFactorStabilityInnerSlope = 1.1;
            const string cmstabProgramPath = ".\\DGeoStability.exe";

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                scenario.DikeTableHeight = 5;
                scenario.RiverLevel = 3;
                scenario.WaterHeightDecimeringsHoogte = 0.75;
                scenario.MaxWaterLevel = 10;
                SoilProfile1D soilProfile = FactoryForStabilityTests.CreateSoilProfile();
                ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines();
                MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();
                mstabParameters.SearchMethod = MStabSearchMethod.Grid;
                DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification =
                    new DamFailureMechanismeCalculationSpecification();
                damFailureMechanismeCalculationSpecification.FailureMechanismSystemType =
                    FailureMechanismSystemType.StabilityInside;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters =
                    mstabParameters;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType =
                    MStabZonesType.NoZones;

                using (StabilityCalculator stabilityCalculator =
                    new StabilityCalculator(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab,
                        ProgramType.MStab, modelParametersForPLLines,
                        cTrafficLoad, cMinimalCircleDepth, cSafetyFactorStabilityInnerSlope,
                        cmstabProgramPath, cmstabProgramPath, null, null, null, null, ProbabilisticType.ProbabilisticFragility))
                {
                    stabilityCalculator.Calculate(scenario, soilProfile, null, 0);
                    // The expected value is read from the dumpfile itself
                    Assert.AreEqual(0.002362116352747, scenario.GetFailureProbabilityStability(soilProfile, "").Value,
                        cToleranceProbability);
                }
            }
        }

        [Test]
        [Category(Categories.Slow)]
        public void CanCalculateStabilitySafetyFactorGeometry2D()
        {
            // setup
            const double cToleranceSafetyFactor = 0.001;
            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                var soilGeometry2DName = SoilGeometry2DName();
                using (StabilityCalculator stabilityCalculator = SetUpStabilityCalculator())
                {
                    // call
                    stabilityCalculator.Calculate(scenario, null, soilGeometry2DName, 0);
                    // assert
                    // The expected value is read from the dumpfile itself
                    Assert.AreEqual(1.5570,
                        scenario.GetMStabResults(null, Path.GetFileName(soilGeometry2DName)).Value.zone1.safetyFactor,
                        cToleranceSafetyFactor);
                }
            }
        }

        [Test, Ignore("This test only proves that the .NET Stability kernel is connected to the DAM stability kernel. It shows the results are not identical")]
        public void CanCalculateStabilitySafetyFactorGeometry2D_UsingNETkernel()
        {
            // setup
            const double cToleranceSafetyFactor = 0.001;
            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                var soilGeometry2DName = SoilGeometry2DName();
                using (StabilityCalculator stabilityCalculator = SetUpStabilityCalculator())
                {
                    // use the .NET Stability kernel
                    stabilityCalculator.SelectedStabilityKernelType = StabilityKernelType.DamClassicDotNet;
                    // call
                    stabilityCalculator.Calculate(scenario, null, soilGeometry2DName, 0);
                    // assert
                    using (var results = stabilityCalculator.GetDotNetStabilityKernelResults())
                    {
                        Assert.AreEqual(1.5570, results.Stability.MinimumSafetyCurve.SafetyFactor, cToleranceSafetyFactor);
                    }
                }
            }
        }

        [Test]
        [Category(Categories.Slow)]
        public void CanCalculateStabilitySafetyFactorGeometry2D_UsingWTIStabilitykernel()
        {
            // setup
            const double cToleranceSafetyFactor = 0.01;
            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                var soilGeometry2DName = SoilGeometry2DName();
                using (StabilityCalculator stabilityCalculator = SetUpStabilityCalculator())
                {
                    // use the .NET Stability kernel
                    stabilityCalculator.SelectedStabilityKernelType = StabilityKernelType.DamClassicWti;
                    // call
                    stabilityCalculator.Calculate(scenario, null, soilGeometry2DName, 0);
                    // assert
                    Assert.AreEqual(1.5885,
                        scenario.GetMStabResults(null, Path.GetFileName(soilGeometry2DName)).Value.zone1.safetyFactor,
                        cToleranceSafetyFactor);
                    //var results = stabilityCalculator.GetDotNetStabilityKernelResults();
                    //Assert.AreEqual(1.5570, results.Stability.MinimumSafetyCurve.SafetyFactor, cToleranceSafetyFactor);
                }
            }
        }

        private static StabilityCalculator SetUpStabilityCalculator()
        {
            const double cTrafficLoad = 10.0;
            const double cMinimalCircleDepth = 1.0;
            const double cSafetyFactorStabilityInnerSlope = 1.1;
            const string cMStabProgramPath = ".\\DGeoStability.exe";

            ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines();
            MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();
            string soilDatabaseName = FactoryForStabilityTests.cSoilDatabaseName;
            soilDatabaseName = Path.GetFullPath(soilDatabaseName);
            mstabParameters.SoilDatabaseName = soilDatabaseName;
            DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification =
                new DamFailureMechanismeCalculationSpecification();
            damFailureMechanismeCalculationSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityInside;
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters =
                mstabParameters;
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType =
                MStabZonesType.NoZones;
            var soilBaseDb = SoilbaseDB.Create(soilDatabaseName);
            StabilityCalculator stabilityCalculator =
                new StabilityCalculator(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab,
                    ProgramType.MStab, modelParametersForPLLines,
                    cTrafficLoad, cMinimalCircleDepth, cSafetyFactorStabilityInnerSlope,
                    cMStabProgramPath, cMStabProgramPath, null, null, soilBaseDb, soilBaseDb.CreateSoilList(),
                    ProbabilisticType.Deterministic);
            return stabilityCalculator;
        }

        private static string SoilGeometry2DName()
        {
            const string cSoilGeometry2DName = @"TestData\1D1.sti";
            string soilGeometry2DName = cSoilGeometry2DName;
            soilGeometry2DName = Path.GetFullPath(soilGeometry2DName);
            return soilGeometry2DName;
        }

        [Test, Ignore("This test requires SlopeW with a valid license")]
        public void CanCalculateStabilitySafetyFactorGeometry2DUsingSlopeW()
        {
            const double cToleranceSafetyFactor = 0.001;
            const double cTrafficLoad = 10.0;
            const double cMinimalCircleDepth = 1.0;
            const double cSafetyFactorStabilityInnerSlope = 1.1;
            const string cMStabProgramPath = ".\\Slope2.exe";
            const string cSoilGeometry2DName = @"TestData\1D1.sti";

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                string soilGeometry2DName = cSoilGeometry2DName;
                ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines();
                MStabParameters mstabParameters = FactoryForStabilityTests.CreateMStabParameters();

                soilGeometry2DName = Path.GetFullPath(soilGeometry2DName);
                string soilDatabaseName = FactoryForStabilityTests.cSoilDatabaseName;
                soilDatabaseName = Path.GetFullPath(soilDatabaseName);
                mstabParameters.SoilDatabaseName = soilDatabaseName;
                DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification =
                    new DamFailureMechanismeCalculationSpecification();
                damFailureMechanismeCalculationSpecification.FailureMechanismSystemType =
                    FailureMechanismSystemType.StabilityInside;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters =
                    mstabParameters;
                damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType =
                    MStabZonesType.NoZones;
                var soilBaseDb = SoilbaseDB.Create(soilDatabaseName);
                using (StabilityCalculator stabilityCalculator =
                    new StabilityCalculator(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab,
                        ProgramType.SlopeW, modelParametersForPLLines,
                        cTrafficLoad, cMinimalCircleDepth, cSafetyFactorStabilityInnerSlope,
                        cMStabProgramPath, cMStabProgramPath, null, null, soilBaseDb, soilBaseDb.CreateSoilList(),
                        ProbabilisticType.Deterministic))
                {
                    stabilityCalculator.Calculate(scenario, null, soilGeometry2DName, 0);
                    Assert.AreEqual(1.7353,
                        scenario.GetMStabResults(null, Path.GetFileName(soilGeometry2DName)).Value.zone1.safetyFactor,
                        cToleranceSafetyFactor);
                }
            }
        }

        [Test]
        public void IsDetermineProperWaterlevelsForProbabilisticAdvancedWorkingForHighMaxLevel()
        {
            const double cToleranceSafetyFactor = 0.001;

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                scenario.RiverLevel = 0;
                scenario.WaterHeightDecimeringsHoogte = 1;
                scenario.MaxWaterLevel = 20;
                double[] waterLevels = scenario.DetermineProperWaterlevelsForProbabilisticAdvanced();
                Assert.AreEqual(1.0, waterLevels[0], cToleranceSafetyFactor);
                Assert.AreEqual(0.0, waterLevels[1], cToleranceSafetyFactor);
                Assert.AreEqual(-1.0, waterLevels[2], cToleranceSafetyFactor);
            }
        }

        [Test]
        public void IsDetermineProperWaterlevelsForProbabilisticAdvancedWorkingForLowMaxLevel()
        {
            const double cToleranceSafetyFactor = 0.001;

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                scenario.RiverLevel = 0;
                scenario.WaterHeightDecimeringsHoogte = 1;
                scenario.MaxWaterLevel = -20;
                double[] waterLevels = scenario.DetermineProperWaterlevelsForProbabilisticAdvanced();
                Assert.AreEqual(-20.0, waterLevels[0], cToleranceSafetyFactor);
                Assert.AreEqual(-20.0, waterLevels[1], cToleranceSafetyFactor);
                Assert.AreEqual(-20.0, waterLevels[2], cToleranceSafetyFactor);
            }
        }

        [Test]
        public void IsDetermineProperWaterlevelsForProbabilisticAdvancedWorkingForMaxLevelBelowTopLevel()
        {
            const double cToleranceSafetyFactor = 0.001;

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                scenario.RiverLevel = 0;
                scenario.WaterHeightDecimeringsHoogte = 1;
                scenario.MaxWaterLevel = 0.5;
                double[] waterLevels = scenario.DetermineProperWaterlevelsForProbabilisticAdvanced();
                Assert.AreEqual(0.5, waterLevels[0], cToleranceSafetyFactor);
                Assert.AreEqual(0.0, waterLevels[1], cToleranceSafetyFactor);
                Assert.AreEqual(-1.0, waterLevels[2], cToleranceSafetyFactor);
            }
        }

        [Test]
        public void IsDetermineProperWaterlevelsForProbabilisticAdvancedWorkingForMaxLevelBelowRiverLevel()
        {
            const double cToleranceSafetyFactor = 0.001;

            using (var line = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1())
            using (var location = new Location())
            {
                Scenario scenario = FactoryForStabilityTests.CreateScenarioForLocation(location, line);
                scenario.RiverLevel = 0;
                scenario.WaterHeightDecimeringsHoogte = 1;
                scenario.MaxWaterLevel = -0.5;
                double[] waterLevels = scenario.DetermineProperWaterlevelsForProbabilisticAdvanced();
                Assert.AreEqual(-0.5, waterLevels[0], cToleranceSafetyFactor);
                Assert.AreEqual(-0.5, waterLevels[1], cToleranceSafetyFactor);
                Assert.AreEqual(-1.0, waterLevels[2], cToleranceSafetyFactor);
            }
        }
    }
}