Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperOutput.cs
===================================================================
diff -u -r6404 -r6421
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperOutput.cs (.../FillEngineFromMacroStabilityWrapperOutput.cs) (revision 6404)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperOutput.cs (.../FillEngineFromMacroStabilityWrapperOutput.cs) (revision 6421)
@@ -36,7 +36,7 @@
///
/// Fills the engine results from the MacroStabilityWrapper
///
-public class FillEngineFromMacroStabilityWrapperOutput
+public static class FillEngineFromMacroStabilityWrapperOutput
{
///
/// Fills the engine data with results.
@@ -156,61 +156,63 @@
outputItem.ResultSlices = new List();
foreach (Slice slice in minimumSafetyCurveBase.Slices)
{
- var resultSlice = new StabilityResultSlice();
- resultSlice.TopLeftPoint = new Point2D(slice.TopLeftPoint.X, slice.TopLeftPoint.Z);
- resultSlice.TopRightPoint = new Point2D(slice.TopRightPoint.X, slice.TopRightPoint.Z);
- resultSlice.BottomLeftPoint = new Point2D(slice.BottomLeftPoint.X, slice.BottomLeftPoint.Z);
- resultSlice.BottomRightPoint = new Point2D(slice.BottomRightPoint.X, slice.BottomRightPoint.Z);
- resultSlice.Name = slice.Name;
- resultSlice.Width = slice.Width;
- resultSlice.ArcLength = slice.ArcLength;
- resultSlice.TopAngle = slice.TopAngle;
- resultSlice.BottomAngle = slice.BottomAngle;
- resultSlice.CohesionInput = slice.CohesionInput;
- resultSlice.CohesionOutput = slice.CohesionOutput;
- resultSlice.FrictionAngleInput = slice.FrictionAngleInput;
- resultSlice.FrictionAngleOutput = slice.FrictionAngleOutput;
- resultSlice.YieldStress = slice.YieldStress;
- resultSlice.OCR = slice.OCR;
- resultSlice.POP = slice.POP;
- resultSlice.DegreeOfConsolidationPorePressure = slice.DegreeOfConsolidationPorePressure;
- resultSlice.PorePressureDueToDegreeOfConsolidationLoad = slice.PorePressureDueToDegreeOfConsolidationLoad;
- resultSlice.DilatancyInput = slice.DilatancyInput;
- resultSlice.ExternalLoad = slice.ExternalLoad;
- resultSlice.HydrostaticPorePressure = slice.HydrostaticPorePressure;
- resultSlice.LeftForce = slice.LeftForce;
- resultSlice.LeftForceAngle = slice.LeftForceAngle;
- resultSlice.LeftForceY = slice.LeftForceY;
- resultSlice.RightForce = slice.RightForce;
- resultSlice.RightForceAngle = slice.RightForceAngle;
- resultSlice.RightForceY = slice.RightForceY;
- resultSlice.LoadStress = slice.LoadStress;
- resultSlice.NormalStress = slice.NormalStress;
- resultSlice.PorePressure = slice.PorePressure;
- resultSlice.HorizontalPorePressure = slice.HorizontalPorePressure;
- resultSlice.VerticalPorePressure = slice.VerticalPorePressure;
- resultSlice.PiezometricPorePressure = slice.PiezometricPorePressure;
- resultSlice.EffectiveStress = slice.EffectiveStress;
- resultSlice.ExcessPorePressure = slice.ExcessPorePressure;
- resultSlice.ShearStressInput = slice.ShearStressInput;
- resultSlice.ShearStressOutput = slice.ShearStressOutput;
- resultSlice.SoilStress = slice.SoilStress;
- resultSlice.TotalPorePressure = slice.TotalPorePressure;
- resultSlice.TotalStress = slice.TotalStress;
- resultSlice.Weight = slice.Weight;
- resultSlice.SuInput = slice.SuInput;
- resultSlice.SuOutput = slice.SuOutput;
- resultSlice.ShearStrengthModel = ConversionHelper.ConvertToDamShearStrengthModel(slice.ShearStrengthModelType);
- resultSlice.HorizontalSoilQuakeStress = slice.HorizontalSoilQuakeStress;
- resultSlice.StrengthIncreaseExponent = slice.StrengthIncreaseExponent;
- resultSlice.UpliftFactor = slice.UpliftFactor;
- resultSlice.VerticalSoilQuakeStress = slice.VerticalSoilQuakeStress;
- resultSlice.WaterQuakeStress = slice.WaterQuakeStress;
- resultSlice.UpliftReductionFactor = slice.UpliftReductionFactor;
- resultSlice.RatioCuPc = slice.RatioCuPc;
- resultSlice.ResultantForce = slice.ResultantForce;
- resultSlice.ResultantMoment = slice.ResultantMoment;
- resultSlice.ResultantAngle = slice.ResultantAngle;
+ var resultSlice = new StabilityResultSlice
+ {
+ TopLeftPoint = new Point2D(slice.TopLeftPoint.X, slice.TopLeftPoint.Z),
+ TopRightPoint = new Point2D(slice.TopRightPoint.X, slice.TopRightPoint.Z),
+ BottomLeftPoint = new Point2D(slice.BottomLeftPoint.X, slice.BottomLeftPoint.Z),
+ BottomRightPoint = new Point2D(slice.BottomRightPoint.X, slice.BottomRightPoint.Z),
+ Name = slice.Name,
+ Width = slice.Width,
+ ArcLength = slice.ArcLength,
+ TopAngle = slice.TopAngle,
+ BottomAngle = slice.BottomAngle,
+ CohesionInput = slice.CohesionInput,
+ CohesionOutput = slice.CohesionOutput,
+ FrictionAngleInput = slice.FrictionAngleInput,
+ FrictionAngleOutput = slice.FrictionAngleOutput,
+ YieldStress = slice.YieldStress,
+ OCR = slice.OCR,
+ POP = slice.POP,
+ DegreeOfConsolidationPorePressure = slice.DegreeOfConsolidationPorePressure,
+ PorePressureDueToDegreeOfConsolidationLoad = slice.PorePressureDueToDegreeOfConsolidationLoad,
+ DilatancyInput = slice.DilatancyInput,
+ ExternalLoad = slice.ExternalLoad,
+ HydrostaticPorePressure = slice.HydrostaticPorePressure,
+ LeftForce = slice.LeftForce,
+ LeftForceAngle = slice.LeftForceAngle,
+ LeftForceY = slice.LeftForceY,
+ RightForce = slice.RightForce,
+ RightForceAngle = slice.RightForceAngle,
+ RightForceY = slice.RightForceY,
+ LoadStress = slice.LoadStress,
+ NormalStress = slice.NormalStress,
+ PorePressure = slice.PorePressure,
+ HorizontalPorePressure = slice.HorizontalPorePressure,
+ VerticalPorePressure = slice.VerticalPorePressure,
+ PiezometricPorePressure = slice.PiezometricPorePressure,
+ EffectiveStress = slice.EffectiveStress,
+ ExcessPorePressure = slice.ExcessPorePressure,
+ ShearStressInput = slice.ShearStressInput,
+ ShearStressOutput = slice.ShearStressOutput,
+ SoilStress = slice.SoilStress,
+ TotalPorePressure = slice.TotalPorePressure,
+ TotalStress = slice.TotalStress,
+ Weight = slice.Weight,
+ SuInput = slice.SuInput,
+ SuOutput = slice.SuOutput,
+ ShearStrengthModel = ConversionHelper.ConvertToDamShearStrengthModel(slice.ShearStrengthModelType),
+ HorizontalSoilQuakeStress = slice.HorizontalSoilQuakeStress,
+ StrengthIncreaseExponent = slice.StrengthIncreaseExponent,
+ UpliftFactor = slice.UpliftFactor,
+ VerticalSoilQuakeStress = slice.VerticalSoilQuakeStress,
+ WaterQuakeStress = slice.WaterQuakeStress,
+ UpliftReductionFactor = slice.UpliftReductionFactor,
+ RatioCuPc = slice.RatioCuPc,
+ ResultantForce = slice.ResultantForce,
+ ResultantMoment = slice.ResultantMoment,
+ ResultantAngle = slice.ResultantAngle
+ };
outputItem.ResultSlices.Add(resultSlice);
}
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/MacroStabilityKernelOutputToEngineTests.cs
===================================================================
diff -u -r6413 -r6421
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/MacroStabilityKernelOutputToEngineTests.cs (.../MacroStabilityKernelOutputToEngineTests.cs) (revision 6413)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/MacroStabilityKernelOutputToEngineTests.cs (.../MacroStabilityKernelOutputToEngineTests.cs) (revision 6421)
@@ -22,6 +22,8 @@
using System.Collections.Generic;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityInwards;
+using Deltares.DamEngine.Data.General;
+using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.MacroStability.Io.XmlOutput;
@@ -32,6 +34,8 @@
[TestFixture]
public class MacroStabilityKernelOutputToEngineTests
{
+ private readonly double tolerance = 0.0005;
+
[Test]
[TestCase(StabilityModelOption.Bishop, false)]
[TestCase(StabilityModelOption.Bishop, true)]
@@ -54,16 +58,85 @@
CompareOutput(kernelOutput, damEngineOutput);
}
- private static void CompareOutput(FullOutputModelType kernelOutput, MacroStabilityOutput damEngineOutput)
+ private void CompareOutput(FullOutputModelType kernelOutput, MacroStabilityOutput damEngineOutput)
{
Assert.Multiple(() =>
{
Assert.That(damEngineOutput.StabilityOutputItems[0].CalculationResult, Is.EqualTo(kernelOutput.StabilityOutput.Succeeded ? CalculationResult.Succeeded : CalculationResult.RunFailed));
Assert.That(damEngineOutput.StabilityOutputItems[0].SafetyFactor, Is.EqualTo(kernelOutput.StabilityOutput.SafetyFactor));
Assert.That(damEngineOutput.StabilityOutputItems[0].StabilityModelType, Is.EqualTo(OutputConversionHelper.ConvertToStabilityModelType(kernelOutput.StabilityOutput.ModelOption)));
});
+ switch (damEngineOutput.StabilityOutputItems[0].StabilityModelType)
+ {
+ case StabilityModelType.Bishop:
+ CompareBishopSlipPlane((SlidingCircleMinimumSafetyCurveType) kernelOutput.StabilityOutput.MinimumSafetyCurve, damEngineOutput.StabilityOutputItems[0]);
+ break;
+ case StabilityModelType.UpliftVan:
+ CompareUpliftVanSlipPlane((DualSlidingCircleMinimumSafetyCurveType) kernelOutput.StabilityOutput.MinimumSafetyCurve, damEngineOutput.StabilityOutputItems[0]);
+ break;
+ }
+
+ CompareSlices(kernelOutput.StabilityOutput.MinimumSafetyCurve, damEngineOutput.StabilityOutputItems[0]);
}
+ private void CompareBishopSlipPlane(SlidingCircleMinimumSafetyCurveType stabilityOutputMinimumSafetyCurve, MacroStabilityOutputItem stabilityOutputItem)
+ {
+ Assert.Multiple(() =>
+ {
+ Assert.That(stabilityOutputMinimumSafetyCurve.Center.X, Is.EqualTo(stabilityOutputItem.ActiveCenterPoint.X).Within(tolerance));
+ Assert.That(stabilityOutputMinimumSafetyCurve.Center.Z, Is.EqualTo(stabilityOutputItem.ActiveCenterPoint.Z).Within(tolerance));
+ Assert.That(stabilityOutputMinimumSafetyCurve.Radius, Is.EqualTo(stabilityOutputItem.ActiveCenterPointRadius).Within(tolerance));
+ });
+ }
+
+ private void CompareUpliftVanSlipPlane(DualSlidingCircleMinimumSafetyCurveType stabilityOutputMinimumSafetyCurve, MacroStabilityOutputItem stabilityOutputItem)
+ {
+ Assert.Multiple(() =>
+ {
+ Assert.That(stabilityOutputMinimumSafetyCurve.ActiveCircleCenter.X, Is.EqualTo(stabilityOutputItem.ActiveCenterPoint.X).Within(tolerance));
+ Assert.That(stabilityOutputMinimumSafetyCurve.ActiveCircleCenter.Z, Is.EqualTo(stabilityOutputItem.ActiveCenterPoint.Z).Within(tolerance));
+ Assert.That(stabilityOutputMinimumSafetyCurve.ActiveCircleRadius, Is.EqualTo(stabilityOutputItem.ActiveCenterPointRadius).Within(tolerance));
+ Assert.That(stabilityOutputMinimumSafetyCurve.PassiveCircleCenter.X, Is.EqualTo(stabilityOutputItem.PassiveCenterPoint.X).Within(tolerance));
+ Assert.That(stabilityOutputMinimumSafetyCurve.PassiveCircleCenter.Z, Is.EqualTo(stabilityOutputItem.PassiveCenterPoint.Z).Within(tolerance));
+ Assert.That(stabilityOutputMinimumSafetyCurve.PassiveCircleRadius, Is.EqualTo(stabilityOutputItem.PassiveCenterPointRadius).Within(tolerance));
+ });
+ }
+
+ private void CompareSlices(MinimumSafetyCurveBaseType stabilityOutputMinimumSafetyCurve, MacroStabilityOutputItem stabilityOutputItem)
+ {
+ Assert.That(stabilityOutputItem.ResultSlices, Has.Count.EqualTo(stabilityOutputMinimumSafetyCurve.Slices.Length), "Number of slices is not equal");
+ for (var sliceIndex = 0; sliceIndex < stabilityOutputMinimumSafetyCurve.Slices.Length; sliceIndex++)
+ {
+ MinimumSafetyCurveBaseTypeSlice kernelSlice = stabilityOutputMinimumSafetyCurve.Slices[sliceIndex];
+ StabilityResultSlice engineSlice = stabilityOutputItem.ResultSlices[sliceIndex];
+ Assert.Multiple(() =>
+ {
+ Assert.That(kernelSlice.Name, Is.EqualTo(engineSlice.Name), "Slice names are not equal");
+ Assert.That(kernelSlice.TopLeftPoint.X, Is.EqualTo(engineSlice.TopLeftPoint.X).Within(tolerance));
+ Assert.That(kernelSlice.TopLeftPoint.Z, Is.EqualTo(engineSlice.TopLeftPoint.Z).Within(tolerance));
+ Assert.That(kernelSlice.TopRightPoint.X, Is.EqualTo(engineSlice.TopRightPoint.X).Within(tolerance));
+ Assert.That(kernelSlice.TopRightPoint.Z, Is.EqualTo(engineSlice.TopRightPoint.Z).Within(tolerance));
+ Assert.That(kernelSlice.BottomLeftPoint.X, Is.EqualTo(engineSlice.BottomLeftPoint.X).Within(tolerance));
+ Assert.That(kernelSlice.BottomLeftPoint.Z, Is.EqualTo(engineSlice.BottomLeftPoint.Z).Within(tolerance));
+ Assert.That(kernelSlice.BottomRightPoint.X, Is.EqualTo(engineSlice.BottomRightPoint.X).Within(tolerance));
+ Assert.That(kernelSlice.BottomRightPoint.Z, Is.EqualTo(engineSlice.BottomRightPoint.Z).Within(tolerance));
+ Assert.That(kernelSlice.Width, Is.EqualTo(engineSlice.Width).Within(tolerance));
+ Assert.That(kernelSlice.ArcLength, Is.EqualTo(engineSlice.ArcLength).Within(tolerance));
+ Assert.That(kernelSlice.TopAngle, Is.EqualTo(engineSlice.TopAngle).Within(tolerance));
+ Assert.That(kernelSlice.BottomAngle, Is.EqualTo(engineSlice.BottomAngle).Within(tolerance));
+ Assert.That(kernelSlice.CohesionInput, Is.EqualTo(engineSlice.CohesionInput).Within(tolerance));
+ Assert.That(kernelSlice.CohesionOutput, Is.EqualTo(engineSlice.CohesionOutput).Within(tolerance));
+ Assert.That(kernelSlice.FrictionAngleInput, Is.EqualTo(engineSlice.FrictionAngleInput).Within(tolerance));
+ Assert.That(kernelSlice.FrictionAngleOutput, Is.EqualTo(engineSlice.FrictionAngleOutput).Within(tolerance));
+ Assert.That(kernelSlice.YieldStress, Is.EqualTo(engineSlice.YieldStress).Within(tolerance));
+ Assert.That(kernelSlice.OCR, Is.EqualTo(engineSlice.OCR).Within(tolerance));
+ Assert.That(kernelSlice.DegreeOfConsolidationPorePressure, Is.EqualTo(engineSlice.DegreeOfConsolidationPorePressure).Within(tolerance));
+ Assert.That(kernelSlice.PorePressureDueToDegreeOfConsolidationLoad, Is.EqualTo(engineSlice.PorePressureDueToDegreeOfConsolidationLoad).Within(tolerance));
+ Assert.That(kernelSlice.HydrostaticPorePressure, Is.EqualTo(engineSlice.HydrostaticPorePressure).Within(tolerance));
+ });
+ }
+ }
+
private static FullOutputModelType CreateFullOutputModel(StabilityModelOption modelOption, bool isSucceeded)
{
var fullOutputModel = new FullOutputModelType