Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapperTests.cs =================================================================== diff -u -r1913 -r1914 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapperTests.cs (.../DamWbiMacroStabilityInwardsKernelWrapperTests.cs) (revision 1913) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapperTests.cs (.../DamWbiMacroStabilityInwardsKernelWrapperTests.cs) (revision 1914) @@ -1,6 +1,7 @@ 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; @@ -24,6 +25,8 @@ const double diff = 0.0001; var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); + kernelWrapper.CreateWbiStabilityCalculator(); + IKernelDataInput kernelDataInput; IKernelDataOutput kernelDataOutput; var kernelInput = new DamKernelInput(); @@ -36,6 +39,7 @@ 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; @@ -47,6 +51,7 @@ 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; @@ -58,6 +63,7 @@ public void TestValidate() { var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); + kernelWrapper.CreateWbiStabilityCalculator(); // Validate without setting values. Expected error messages. var macroStabilityInput1 = new DamWbiMacroStabilityInput(); @@ -93,9 +99,7 @@ macroStabilityOutput.CalculationResult = CalculationResult.NoLicense; var macroStabilityOutputItem = new DamWbiMacroStabilityOutputItem(); macroStabilityOutputItem.CalculationResult = CalculationResult.Succeeded; - var zoneResults = macroStabilityOutputItem.Zone1Results; - zoneResults.SafetyFactor = 2.34; - macroStabilityOutputItem.Zone1Results = zoneResults; + 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); @@ -112,23 +116,48 @@ { // ToDo: CalculationResult of macroStabilityOutputItem is used. CalculationResult of macroStabilityOutput is ignored. Correct? Assert.AreEqual(macroStabilityOutputItem.CalculationResult, result.CalculationResult); - Assert.AreEqual(zoneResults.SafetyFactor, result.StabilityDesignResults.SafetyFactor); + Assert.AreEqual(macroStabilityOutputItem.SafetyFactor, result.StabilityDesignResults.SafetyFactor); // ToDo: Add all output items when it is clear what parts of StabilityDesignResults will be filled } } [Test] - public void TestFullCalculation() + public void TestFullCalculationFails() { + var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); + kernelWrapper.CreateWbiStabilityCalculator(); + + IKernelDataInput kernelDataInput = new DamWbiMacroStabilityInput(); + IKernelDataOutput kernelDataOutput = new DamWbiMacroStabilityOutput(); + // 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.Execute(kernelDataInput, kernelDataOutput, out messages); + // ToDo MWDAM-1357: Parse the xml output from the kernel must be done + DamWbiMacroStabilityOutput macroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; + Assert.IsTrue(messages.Count > 0); + // ToDo MWDAM-1357: the kernel has no input data, therefore it will fail. Test is better when it has input data but fails for another reason + Assert.AreEqual(CalculationResult.UnexpectedError, macroStabilityOutput.CalculationResult); + } + + [Test] + public void TestFullCalculationSucceeds() + { const double diff = 0.0001; var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); + kernelWrapper.CreateWbiStabilityCalculator(); // Prepare the wrapper. Result is input for the calculation dll IKernelDataInput kernelDataInput; IKernelDataOutput kernelDataOutput; var kernelInput = CreateDamKernelInputForTest(); kernelWrapper.Prepare(kernelInput, 0, out kernelDataInput, out kernelDataOutput); + // ToDo MWDAM-1356: xml input not written yet. Skip for now. + //Assert.AreEqual(PrepareResult.Successful, prepareResult1); // Validate the input List messages; @@ -137,14 +166,22 @@ //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.Execute(kernelDataInput, kernelDataOutput, out messages); DamWbiMacroStabilityOutput macroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; + + // ToDo MWDAM-1356: Input must be set first in Prepare + // ToDo MWDAM-1357 Parse the xml output from the kernel must be done + // start of temporary test code Assert.AreEqual(0, messages.Count); Assert.AreEqual(CalculationResult.Succeeded, macroStabilityOutput.CalculationResult); - // ToDo: Not clear how kernel must be connected. Temporary test code added. - // start of temporary test code Assert.AreEqual(1, macroStabilityOutput.StabilityOutputItems.Count); - Assert.AreEqual(1.357, macroStabilityOutput.StabilityOutputItems[0].Zone1Results.SafetyFactor, diff); + Assert.AreEqual(1.357, macroStabilityOutput.StabilityOutputItems[0].SafetyFactor, diff); // end of temporary test code // Fill the design results @@ -180,7 +217,7 @@ { List messages; var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); - kernelWrapper.Execute(null, null, out messages); ; + kernelWrapper.Execute(null, null, out messages); } [Test] @@ -203,6 +240,17 @@ kernelWrapper.PostProcess(null, null, null, "", out results); } + [Test] + [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen reken object gedefinieerd voor WBI Macrostabiliteit")] + [SetUICulture("nl-NL")] + public void TestThrowsExceptionWhenDamKernelIsNull() + { + var kernelWrapper = new DamWbiMacroStabilityInwardsKernelWrapper(); + IKernelDataInput kernelDataInput; + IKernelDataOutput kernelDataOutput; + kernelWrapper.Prepare(null, 0, out kernelDataInput, out kernelDataOutput); + } + private static DamKernelInput CreateDamKernelInputForTest() { // ToDo: Not clear yet what parts apply to Wbi Stability. For now, minimal implementation. Add DamWbiMacroStabilityTestHelper? Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapper.cs =================================================================== diff -u -r1913 -r1914 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapper.cs (.../DamWbiMacroStabilityInwardsKernelWrapper.cs) (revision 1913) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityInwardsKernelWrapper.cs (.../DamWbiMacroStabilityInwardsKernelWrapper.cs) (revision 1914) @@ -19,6 +19,8 @@ { public class DamWbiMacroStabilityInwardsKernelWrapper : IKernelWrapper { + private WTIStabilityCalculation wbiMacroStabilityCalculator = null; + /// /// Prepares the specified dam kernel input. /// @@ -31,6 +33,7 @@ /// public PrepareResult Prepare(DamKernelInput damKernelInput, int iterationIndex, out IKernelDataInput kernelDataInput, out IKernelDataOutput kernelDataOutput) { + ThrowWhenWbiMacroStabilityCalculatorNull(wbiMacroStabilityCalculator); var macroStabilityInput = new DamWbiMacroStabilityInput(); kernelDataInput = macroStabilityInput; var macroStabilityOutput = new DamWbiMacroStabilityOutput @@ -50,11 +53,10 @@ { macroStabilityInput.TmpWbiMacroIn = 0.234; } - // end of temporary test code - var calculator = CreateWbiStabilityCalculator(kernelDataInput); + var xmlInput = CreateXmlInput(macroStabilityInput); - calculator.InitializeForDeterministic(xmlInput); + wbiMacroStabilityCalculator.InitializeForDeterministic(xmlInput); return PrepareResult.Successful; } catch @@ -81,11 +83,11 @@ /// public int Validate(IKernelDataInput kernelDataInput, IKernelDataOutput kernelDataOutput, out List messages) { + ThrowWhenWbiMacroStabilityCalculatorNull(wbiMacroStabilityCalculator); messages = new List(); DamWbiMacroStabilityInput macroStabilityInput = (DamWbiMacroStabilityInput)kernelDataInput; DamWbiMacroStabilityOutput macroStabilityOutput = (DamWbiMacroStabilityOutput)kernelDataOutput; - var calculator = CreateWbiStabilityCalculator(kernelDataInput); - string kernelMessage = calculator.Validate(); + string kernelMessage = wbiMacroStabilityCalculator.Validate(); ParseValidationResult(kernelMessage, messages); // ToDo MWDAM-1367: Not clear yet what input must be provided to make Validate succeed. Temporary test code added. @@ -142,50 +144,62 @@ } - private static void PerformWbiStabilityCalculation(out List messages, DamWbiMacroStabilityOutput macroStabilityOutput, + private void PerformWbiStabilityCalculation(out List messages, DamWbiMacroStabilityOutput macroStabilityOutput, DamWbiMacroStabilityInput macroStabilityInput) { + ThrowWhenWbiMacroStabilityCalculatorNull(wbiMacroStabilityCalculator); macroStabilityOutput.CalculationResult = CalculationResult.NoRun; messages = new List(); - try - { - macroStabilityOutput.StabilityOutputItems = new List(); - var calculator = CreateWbiStabilityCalculator(macroStabilityInput); + macroStabilityOutput.StabilityOutputItems = new List(); - // ToDo: Not clear how kernel must be connected. Skip actual calculation. Temporary result for test added. - //string result = calculator.Run(); - // start of temporary test code + //this must be code when prepare is done +// try +// { +// string kernelMessage = wbiMacroStabilityCalculator.Run(); +// ParseRunResult(kernelMessage, macroStabilityOutput, messages); +// macroStabilityOutput.CalculationResult = CalculationResult.Succeeded; +// } +// catch (Exception e) +// { +// macroStabilityOutput.CalculationResult = CalculationResult.UnexpectedError; +// messages.Add(new LogMessage(LogMessageType.Error, null, e.Message)); +// } + + // ToDo MWDAM-1356: setting input is not done yet. Temporary test code added. + // start of temporary test code + if (macroStabilityInput.TmpWbiMacroIn > 1) + { + //presume run succeeded macroStabilityOutput.CalculationResult = CalculationResult.Succeeded; - var macroStabilityOutputItem = new DamWbiMacroStabilityOutputItem(); - var zoneResults = macroStabilityOutputItem.Zone1Results; - zoneResults.SafetyFactor = 1.357; - macroStabilityOutputItem.Zone1Results = zoneResults; - macroStabilityOutput.StabilityOutputItems.Add(macroStabilityOutputItem); - // end of temporary test code + ParseRunResult("", macroStabilityOutput, messages); } - catch (Exception e) + else { + //presume run failed macroStabilityOutput.CalculationResult = CalculationResult.UnexpectedError; - messages.Add(new LogMessage(LogMessageType.Error, null, e.Message)); + messages.Add(new LogMessage(LogMessageType.Error, null, "run failed")); } + // end of temporary test code + + } + private void ParseRunResult(string xmlRunResult, DamWbiMacroStabilityOutput macroStabilityOutput, List messages) + { + // 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 + macroStabilityOutputItem.SafetyFactor = 1.357; + // end of temporary test code + macroStabilityOutput.StabilityOutputItems.Add(macroStabilityOutputItem); + } /// /// Creates the calculator for Wbi stability based on kernel input. /// - /// The kernel data input. - /// - /// No input object defined - private static WTIStabilityCalculation CreateWbiStabilityCalculator(IKernelDataInput kernelDataInput) + public void CreateWbiStabilityCalculator() { - DamWbiMacroStabilityInput macroStabilityInput = (DamWbiMacroStabilityInput)kernelDataInput; - ThrowWhenWbiMacroStabilityKernelInputNull(macroStabilityInput); - var calculator = new WTIStabilityCalculation - { - // ToDo not clear yet what input is expected - }; - return calculator; + wbiMacroStabilityCalculator = new WTIStabilityCalculation(); } /// @@ -248,21 +262,7 @@ designResult.StabilityDesignResults.StabilityModelType = macroStabilityOutputItem.StabilityModelType; if (designResult.CalculationResult == CalculationResult.Succeeded) { - designResult.StabilityDesignResults.Zone1SafetyFactor = - macroStabilityOutputItem.Zone1Results.SafetyFactor; - designResult.StabilityDesignResults.LocalZone1EntryPointX = - macroStabilityOutputItem.Zone1Results.CircleSurfacePointLeftXCoordinate; - designResult.StabilityDesignResults.LocalZone1ExitPointX = - macroStabilityOutputItem.Zone1Results.CircleSurfacePointRightXCoordinate; - - designResult.StabilityDesignResults.SafetyFactor = designResult.StabilityDesignResults.Zone1SafetyFactor; - if (macroStabilityOutputItem.Zone2Results != null) - { - var zone2 = (DamWbiMacroStabilityOutputItem.ResultsSingleZone)macroStabilityOutputItem.Zone2Results; - designResult.StabilityDesignResults.Zone2SafetyFactor = zone2.SafetyFactor; - designResult.StabilityDesignResults.LocalZone2EntryPointX = zone2.CircleSurfacePointLeftXCoordinate; - designResult.StabilityDesignResults.LocalZone2ExitPointX = zone2.CircleSurfacePointRightXCoordinate; - } + designResult.StabilityDesignResults.SafetyFactor = macroStabilityOutputItem.SafetyFactor; } } @@ -278,6 +278,7 @@ throw new NoNullAllowedException(Resources.DamWbiMacroStabilityKernelWrapper_NoWbiMacroStabilityInputObjectDefined); } } + /// /// Throws the when wbi macro stability kernel output is not assigned. /// @@ -303,7 +304,15 @@ throw new NoNullAllowedException(Resources.DamWbiMacroStabilityKernelWrapper_NoDamInputObjectDefinedForWbiMacroStability); } } - + + public static void ThrowWhenWbiMacroStabilityCalculatorNull(WTIStabilityCalculation wbiMacroStabilityCalculator) + { + if (wbiMacroStabilityCalculator == null) + { + throw new NoNullAllowedException(Resources.DamWbiMacroStabilityKernelWrapper_NoDamKernelObjectDefinedForWbiMacroStability); + } + } + public ShoulderDesign CalculateDesignAtPoint(DamKernelInput damKernelInput, IKernelDataInput kernelDataInput, IKernelDataOutput kernelDataOutput, GeometryPoint point, out List messages) { Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.Designer.cs =================================================================== diff -u -r1901 -r1914 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.Designer.cs (.../Resources.Designer.cs) (revision 1901) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.Designer.cs (.../Resources.Designer.cs) (revision 1914) @@ -227,6 +227,15 @@ } /// + /// Looks up a localized string similar to No calculator object defined for WBI Macro Stability. + /// + internal static string DamWbiMacroStabilityKernelWrapper_NoDamKernelObjectDefinedForWbiMacroStability { + get { + return ResourceManager.GetString("DamWbiMacroStabilityKernelWrapper_NoDamKernelObjectDefinedForWbiMacroStability", resourceCulture); + } + } + + /// /// Looks up a localized string similar to No input object defined for WBI Macro Stability. /// internal static string DamWbiMacroStabilityKernelWrapper_NoWbiMacroStabilityInputObjectDefined { Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.resx =================================================================== diff -u -r1901 -r1914 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.resx (.../Resources.resx) (revision 1901) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.resx (.../Resources.resx) (revision 1914) @@ -291,4 +291,7 @@ No Dam input object defined for WBI Macro Stability + + No calculator object defined for WBI Macro Stability + \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.nl-NL.resx =================================================================== diff -u -r1901 -r1914 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.nl-NL.resx (.../Resources.nl-NL.resx) (revision 1901) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Properties/Resources.nl-NL.resx (.../Resources.nl-NL.resx) (revision 1914) @@ -171,6 +171,9 @@ Geen Dam invoer object gedefinieerd voor WBI Macrostabiliteit + + Geen reken object gedefinieerd voor WBI Macrostabiliteit + Geen invoer object gedefinieerd voor WBI Macrostabiliteit Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityOutputItem.cs =================================================================== diff -u -r1901 -r1914 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityOutputItem.cs (.../DamWbiMacroStabilityOutputItem.cs) (revision 1901) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamWbiMacroStabilityInwards/DamWbiMacroStabilityOutputItem.cs (.../DamWbiMacroStabilityOutputItem.cs) (revision 1914) @@ -14,38 +14,14 @@ public CalculationResult CalculationResult { get; set; } /// - /// Structure holding the resuls per zone + /// Gets or sets the safety factor. /// - public struct ResultsSingleZone - { - public double SafetyFactor; - public double CircleSurfacePointLeftXCoordinate; - public double CircleSurfacePointRightXCoordinate; - public void Init() - { - SafetyFactor = 0.0; - CircleSurfacePointLeftXCoordinate = 0.0; - CircleSurfacePointRightXCoordinate = 0.0; - } - } - - /// - /// Gets or sets the zone1 results. - /// /// - /// The zone1. + /// The safety factor. /// - public DamWbiMacroStabilityOutputItem.ResultsSingleZone Zone1Results { get; set; } + public double SafetyFactor { get; set; } /// - /// Gets or sets the zone2 results. - /// - /// - /// The zone2. - /// - public DamWbiMacroStabilityOutputItem.ResultsSingleZone? Zone2Results { get; set; } - - /// /// Gets or sets the type of the stability model. /// ///