Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapperTests.cs =================================================================== diff -u -r1914 -r1922 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapperTests.cs (.../DamWbiMacroStabilityInwardsKernelWrapperTests.cs) (revision 1914) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapperTests.cs (.../DamWbiMacroStabilityInwardsKernelWrapperTests.cs) (revision 1922) @@ -1,7 +1,6 @@ using System.Collections.Generic; using System.Data; using Deltares.DamEngine.Calculators.KernelWrappers.Common; -using Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStabilityCommon; using Deltares.DamEngine.Calculators.KernelWrappers.DamWbiMacroStabilityInwards; using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces; using Deltares.DamEngine.Calculators.Tests.KernelWrappers.DamMacroStabilityCommon; @@ -22,41 +21,40 @@ [Test] public void TestPrepare() { - const double diff = 0.0001; - var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); kernelWrapper.CreateWbiStabilityCalculator(); IKernelDataInput kernelDataInput; IKernelDataOutput kernelDataOutput; var kernelInput = new DamKernelInput(); - // ToDo MWDAM-1356: Not clear yet what must be done in Prepare and XML input not written yet. Temporary test code added. + // Situation 1: no uplift. Expected PrepareResult.NotRelevant + kernelWrapper.tmpPresumePrepareIsUplift = false; //ToDo replace by input that makes IsUplift false + var prepareResult = kernelWrapper.Prepare(kernelInput, 0, out kernelDataInput, out kernelDataOutput); + Assert.AreEqual(PrepareResult.NotRelevant, prepareResult); + DamWbiMacroStabilityOutput damMacroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; + Assert.AreEqual(CalculationResult.NoRun, damMacroStabilityOutput.CalculationResult); + Assert.AreEqual(false, damMacroStabilityOutput.UpliftSituation.IsUplift); + + // Situation 2: there is uplift and prepare succeeds. Expected PrepareResult.Successful + // ToDo MWDAM-1356: Not clear yet what must be done in Prepare and XML input not written yet. // start of temporary test code - kernelInput.RiverLevelHigh = 0.5; - var prepareResult1 = kernelWrapper.Prepare(kernelInput, 0, out kernelDataInput, out kernelDataOutput); - // test preparing the input - DamWbiMacroStabilityInput damMacroStabilityInput1 = (DamWbiMacroStabilityInput)kernelDataInput; - Assert.AreEqual(0.234, damMacroStabilityInput1.TmpWbiMacroIn, diff); - // test result of the InitializeForDeterministic, currently failing because the xml input is not written yet - //Assert.AreEqual(PrepareResult.Successful, prepareResult1); - Assert.AreEqual(PrepareResult.Failed, prepareResult1); - // test preparing the output - DamWbiMacroStabilityOutput damMacroStabilityOutput1 = (DamWbiMacroStabilityOutput)kernelDataOutput; - Assert.AreEqual(CalculationResult.NoRun, damMacroStabilityOutput1.CalculationResult); + kernelWrapper.tmpPresumePrepareIsUplift = true; //ToDo replace by input that makes IsUplift true + kernelWrapper.tmpPresumePrepareSucceeds = true; //ToDo replace by input that makes prepare succeed + prepareResult = kernelWrapper.Prepare(kernelInput, 0, out kernelDataInput, out kernelDataOutput); + Assert.AreEqual(PrepareResult.Successful, prepareResult); + damMacroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; + Assert.AreEqual(CalculationResult.NoRun, damMacroStabilityOutput.CalculationResult); + Assert.AreEqual(true, damMacroStabilityOutput.UpliftSituation.IsUplift); - kernelInput.RiverLevelHigh = 1.5; - var prepareResult2 = kernelWrapper.Prepare(kernelInput, 0, out kernelDataInput, out kernelDataOutput); - // test preparing the input - DamWbiMacroStabilityInput damMacroStabilityInput2 = (DamWbiMacroStabilityInput)kernelDataInput; - Assert.AreEqual(1.234, damMacroStabilityInput2.TmpWbiMacroIn, diff); - // test result of the InitializeForDeterministic, currently failing because the xml input is not written yet - //Assert.AreEqual(PrepareResult.Successful, prepareResult1); - Assert.AreEqual(PrepareResult.Failed, prepareResult2); - // test preparing the output - DamWbiMacroStabilityOutput damMacroStabilityOutput2 = (DamWbiMacroStabilityOutput)kernelDataOutput; - Assert.AreEqual(CalculationResult.NoRun, damMacroStabilityOutput2.CalculationResult); - // end of temporary test code + // Situation 3: there is uplift and prepare fails. Expected PrepareResult.Failed + kernelWrapper.tmpPresumePrepareIsUplift = true; //ToDo replace by input that makes IsUplift true + kernelWrapper.tmpPresumePrepareSucceeds = false; //ToDo replace by input that makes prepare fail + prepareResult = kernelWrapper.Prepare(kernelInput, 0, out kernelDataInput, out kernelDataOutput); + Assert.AreEqual(PrepareResult.Failed, prepareResult); + damMacroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; + Assert.AreEqual(CalculationResult.NoRun, damMacroStabilityOutput.CalculationResult); + Assert.AreEqual(true, damMacroStabilityOutput.UpliftSituation.IsUplift); } [Test] @@ -81,7 +79,7 @@ messages.Clear(); // ToDo MWDAM-1367: Not clear yet what input must be provided to make Validate succeed. Temporary test code added. // start of temporary test code - macroStabilityInput2.TmpWbiMacroIn = 1.1; + kernelWrapper.tmpPresumeInputValid = true; //ToDo replace by input that makes Validate succeed // end of temporary test code errorCount = kernelWrapper.Validate(macroStabilityInput2, macroStabilityOutput2, out messages); Assert.IsTrue(errorCount == 0); @@ -91,33 +89,32 @@ [Test] public void TestPostProcess() { + const double diff = 0.0001; var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); var kernelInput = CreateDamKernelInputForTest(); DamWbiMacroStabilityOutput macroStabilityOutput = new DamWbiMacroStabilityOutput(); - - // Fill macroStabilityOutput with calculation output - macroStabilityOutput.CalculationResult = CalculationResult.NoLicense; - var macroStabilityOutputItem = new DamWbiMacroStabilityOutputItem(); - macroStabilityOutputItem.CalculationResult = CalculationResult.Succeeded; - macroStabilityOutputItem.SafetyFactor = 2.34; - // ToDo: Add all output items when it is clear what will be in macroStabilityOutputItem - macroStabilityOutput.StabilityOutputItems = new List(); - macroStabilityOutput.StabilityOutputItems.Add(macroStabilityOutputItem); - DesignScenario designScenario = new DesignScenario { Location = kernelInput.Location }; List results; - + macroStabilityOutput.CalculationResult = CalculationResult.Succeeded; + var macroStabilityOutputItem = new DamWbiMacroStabilityOutputItem(); + macroStabilityOutputItem.CalculationResult = CalculationResult.Succeeded; + macroStabilityOutput.UpliftSituation = new UpliftSituation { IsUplift = true }; + macroStabilityOutputItem.SafetyFactor = 2.34; + macroStabilityOutput.StabilityOutputItems = new List(); + macroStabilityOutput.StabilityOutputItems.Add(macroStabilityOutputItem); kernelWrapper.PostProcess(kernelInput, macroStabilityOutput, designScenario, "", out results); Assert.IsTrue(results.Count > 0); foreach (var result in results) { - // ToDo: CalculationResult of macroStabilityOutputItem is used. CalculationResult of macroStabilityOutput is ignored. Correct? - Assert.AreEqual(macroStabilityOutputItem.CalculationResult, result.CalculationResult); - Assert.AreEqual(macroStabilityOutputItem.SafetyFactor, result.StabilityDesignResults.SafetyFactor); - // ToDo: Add all output items when it is clear what parts of StabilityDesignResults will be filled + Assert.AreEqual(CalculationResult.Succeeded, result.CalculationResult); + Assert.AreEqual(true, ((UpliftSituation)result.StabilityDesignResults.UpliftSituation).IsUplift); + Assert.AreEqual(0, result.StabilityDesignResults.NumberOfIterations); //NumberOfIterations can not be set for this test, so always zero here + Assert.AreEqual(2.34, result.StabilityDesignResults.SafetyFactor, diff); + Assert.AreEqual(kernelInput.Location.SurfaceLine, result.StabilityDesignResults.RedesignedSurfaceLine); + Assert.AreEqual(kernelInput.SubSoilScenario.ToString(), result.ProfileName); } } @@ -132,9 +129,7 @@ // Run the dll List messages; DamWbiMacroStabilityInput macroStabilityInput = (DamWbiMacroStabilityInput)kernelDataInput; - // start of temporary test code - macroStabilityInput.TmpWbiMacroIn = 0.2; // test code: execute fails when TmpWbiMacroIn <=1 - // end of temporary test code + kernelWrapper.tmpPresumeRunSucceeds = false; //ToDo replace by input that makes Execute fail kernelWrapper.Execute(kernelDataInput, kernelDataOutput, out messages); // ToDo MWDAM-1357: Parse the xml output from the kernel must be done DamWbiMacroStabilityOutput macroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; @@ -166,12 +161,7 @@ //Assert.IsTrue(errorCount == 0); // Run the dll - // ToDo MWDAM-1356: Input must be set first in Prepare - // start of temporary test code - DamWbiMacroStabilityInput macroStabilityInput = (DamWbiMacroStabilityInput)kernelDataInput; - macroStabilityInput.TmpWbiMacroIn = 1.2; // test code: execute succeeds when TmpWbiMacroIn 1 - // end of temporary test code - + kernelWrapper.tmpPresumeRunSucceeds = true; //ToDo replace by input that makes Execute succeed kernelWrapper.Execute(kernelDataInput, kernelDataOutput, out messages); DamWbiMacroStabilityOutput macroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; @@ -181,7 +171,7 @@ Assert.AreEqual(0, messages.Count); Assert.AreEqual(CalculationResult.Succeeded, macroStabilityOutput.CalculationResult); Assert.AreEqual(1, macroStabilityOutput.StabilityOutputItems.Count); - Assert.AreEqual(1.357, macroStabilityOutput.StabilityOutputItems[0].SafetyFactor, diff); + Assert.AreEqual(1.357, macroStabilityOutput.StabilityOutputItems[0].SafetyFactor, diff); // ToDo replace by actual value when calculation is done and output is parsed // end of temporary test code // Fill the design results Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapper.cs =================================================================== diff -u -r1914 -r1922 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapper.cs (.../DamWbiMacroStabilityInwardsKernelWrapper.cs) (revision 1914) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapper.cs (.../DamWbiMacroStabilityInwardsKernelWrapper.cs) (revision 1922) @@ -2,7 +2,6 @@ using System.Collections.Generic; using System.Data; using System.Linq; -using System.Xml.Linq; using Deltares.DamEngine.Calculators.DikesDesign; using Deltares.DamEngine.Calculators.KernelWrappers.Common; using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces; @@ -20,6 +19,11 @@ public class DamWbiMacroStabilityInwardsKernelWrapper : IKernelWrapper { private WTIStabilityCalculation wbiMacroStabilityCalculator = null; + private int lastIterationIndex = 0; + public bool tmpPresumePrepareSucceeds; + public bool tmpPresumePrepareIsUplift; + public bool tmpPresumeInputValid; + public bool tmpPresumeRunSucceeds; /// /// Prepares the specified dam kernel input. @@ -40,27 +44,39 @@ { CalculationResult = CalculationResult.NoRun }; - kernelDataOutput = macroStabilityOutput; try { - // ToDo MWDAM-1356: Not clear yet what parts are required for input. Temporary test code added. - // start of temporary test code - if (damKernelInput.RiverLevelHigh > 1) + // Determine whether there is uplift + //ToDo MWDAM-1358 var upliftSituation = UpliftHelper.DetermineStabilityUplift(damKernelInput, false); + var upliftSituation = new UpliftSituation(); + upliftSituation.IsUplift = tmpPresumePrepareIsUplift; // temporary code for testing + + macroStabilityOutput.UpliftSituation = upliftSituation; + kernelDataOutput = macroStabilityOutput; + if (upliftSituation.IsUplift) { - macroStabilityInput.TmpWbiMacroIn = 1.234; + var xmlInput = CreateXmlInput(macroStabilityInput); + // ToDo MWDAM-1356: Not clear yet what parts are required for input. Temporary test code added. + //ToDo wbiMacroStabilityCalculator.InitializeForDeterministic(xmlInput); + //ToDo return PrepareResult.Successful; + if (tmpPresumePrepareSucceeds) + { + return PrepareResult.Successful; + } + else + { + return PrepareResult.Failed; + } } else { - macroStabilityInput.TmpWbiMacroIn = 0.234; + return PrepareResult.NotRelevant; } - // end of temporary test code - var xmlInput = CreateXmlInput(macroStabilityInput); - wbiMacroStabilityCalculator.InitializeForDeterministic(xmlInput); - return PrepareResult.Successful; } catch { + kernelDataOutput = macroStabilityOutput; return PrepareResult.Failed; } } @@ -85,14 +101,13 @@ { ThrowWhenWbiMacroStabilityCalculatorNull(wbiMacroStabilityCalculator); messages = new List(); - DamWbiMacroStabilityInput macroStabilityInput = (DamWbiMacroStabilityInput)kernelDataInput; - DamWbiMacroStabilityOutput macroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; string kernelMessage = wbiMacroStabilityCalculator.Validate(); ParseValidationResult(kernelMessage, messages); + DamWbiMacroStabilityOutput macroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; // ToDo MWDAM-1367: Not clear yet what input must be provided to make Validate succeed. Temporary test code added. // start of temporary test code - if (macroStabilityInput.TmpWbiMacroIn > 1.0) + if (tmpPresumeInputValid) { // only an info/warning message, presumed input valid for test messages.Add(new LogMessage() @@ -167,7 +182,7 @@ // ToDo MWDAM-1356: setting input is not done yet. Temporary test code added. // start of temporary test code - if (macroStabilityInput.TmpWbiMacroIn > 1) + if (tmpPresumeRunSucceeds) { //presume run succeeded macroStabilityOutput.CalculationResult = CalculationResult.Succeeded; @@ -188,7 +203,7 @@ { // ToDo MWDAM-1357: Parse the xml from the kernel, fill results and add message with type Error, Info or Warning var macroStabilityOutputItem = new DamWbiMacroStabilityOutputItem(); - // start of temporary test code, set safety factor to 1.357 + // start of temporary test code macroStabilityOutputItem.SafetyFactor = 1.357; // end of temporary test code macroStabilityOutput.StabilityOutputItems.Add(macroStabilityOutputItem); @@ -225,13 +240,11 @@ { var designResult = NewDesignResult(damKernelInput, designScenario, macroStabilityOutputItem); FillDesignResult(macroStabilityOutputItem, designResult); - // ToDo: Add NumberOfIterations and UpliftSituation? - //designResult.StabilityDesignResults.NumberOfIterations = lastIterationIndex; - //designResult.StabilityDesignResults.UpliftSituation = macroStabilityOutput.UpliftSituation; + designResult.StabilityDesignResults.NumberOfIterations = lastIterationIndex; + designResult.StabilityDesignResults.UpliftSituation = macroStabilityOutput.UpliftSituation; designResults.Add(designResult); } } - // ToDo: multiple runs (multiple modeltypes) as for DGeoStability? Fill overall result. } private DesignResult NewDesignResult(DamKernelInput damKernelInput, DesignScenario designScenario, @@ -245,19 +258,15 @@ CalculationResult = CalculationResult.RunFailed }; designResult.StabilityDesignResults = new StabilityDesignResults(); - // ToDo: Add all stuff as for DGeoStability? var stabilityDesignResults = new StabilityDesignResults(); -// stabilityDesignResults.RedesignedSurfaceLine = damKernelInput.Location.SurfaceLine; -// designResult.BaseFileName = Path.GetFileNameWithoutExtension(macroStabilityOutputItem.ProjectFileName); -// designResult.ProfileName = soilProfile2DName; + stabilityDesignResults.RedesignedSurfaceLine = damKernelInput.Location.SurfaceLine; + designResult.ProfileName = soilProfile2DName; designResult.StabilityDesignResults = stabilityDesignResults; -// designResult.CalculationSubDir = DamMacroStabilityUtils.GetCalculationSubDir(macroStabilityOutputItem.StabilityModelType); return designResult; } private static void FillDesignResult(DamWbiMacroStabilityOutputItem macroStabilityOutputItem, DesignResult designResult) { - //ToDo Same code as for DGeoStability? designResult.CalculationResult = macroStabilityOutputItem.CalculationResult; designResult.StabilityDesignResults.StabilityModelType = macroStabilityOutputItem.StabilityModelType; if (designResult.CalculationResult == CalculationResult.Succeeded) Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityOutput.cs =================================================================== diff -u -r1901 -r1922 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityOutput.cs (.../DamWbiMacroStabilityOutput.cs) (revision 1901) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityOutput.cs (.../DamWbiMacroStabilityOutput.cs) (revision 1922) @@ -1,5 +1,6 @@ using System.Collections.Generic; using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces; +using Deltares.DamEngine.Data.General; using Deltares.DamEngine.Data.Standard.Calculation; namespace Deltares.DamEngine.Calculators.KernelWrappers.DamWbiMacroStabilityInwards @@ -22,6 +23,12 @@ /// public List StabilityOutputItems { get; set; } - //ToDo Add UpliftSituation? + /// + /// Gets or sets the uplift situation. + /// + /// + /// The uplift situation. + /// + public UpliftSituation UpliftSituation { get; set; } } } Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInput.cs =================================================================== diff -u -r1913 -r1922 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInput.cs (.../DamWbiMacroStabilityInput.cs) (revision 1913) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInput.cs (.../DamWbiMacroStabilityInput.cs) (revision 1922) @@ -4,8 +4,7 @@ { public class DamWbiMacroStabilityInput : IKernelDataInput { - //ToDo MWDAM-1356: Not clear yet what input must be provided. TmpWbiMacroIn is used for test, replace later by actual input. + //ToDo MWDAM-1356: Not clear yet what input must be provided //probably something like FailureMechanismParametersMStab - public double TmpWbiMacroIn { get; set; } } }