Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/EngineToMacroStabilityKernelInputTests.cs =================================================================== diff -u -r6366 -r6402 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/EngineToMacroStabilityKernelInputTests.cs (.../EngineToMacroStabilityKernelInputTests.cs) (revision 6366) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/EngineToMacroStabilityKernelInputTests.cs (.../EngineToMacroStabilityKernelInputTests.cs) (revision 6402) @@ -28,16 +28,14 @@ using Deltares.DamEngine.Data.General; using Deltares.DamEngine.Data.Geometry; using Deltares.DamEngine.Data.Geotechnics; -using Deltares.DamEngine.TestHelpers; using Deltares.DamEngine.TestHelpers.Factories; -using Deltares.MacroStability.Interface; using Deltares.MacroStability.Io.XmlInput; -using Deltares.MacroStability.Kernel; using KellermanSoftware.CompareNetObjects; using NUnit.Framework; using CharacteristicPointType = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType; using Point2D = Deltares.DamEngine.Data.Geometry.Point2D; using Soil = Deltares.DamEngine.Data.Geotechnics.Soil; +using SoilProfileType = Deltares.MacroStability.Io.XmlInput.SoilProfileType; using UpliftVanCalculationGrid = Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.UpliftVanCalculationGrid; namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon.MacroStabilityIo; @@ -85,11 +83,9 @@ var fillMacroStabilityKernelInputFromEngine = new FillMacroStabilityKernelInputFromEngine { - UpliftVanCalculationGrid = expectedUpliftVanCalculationGrid, - TrafficLoad = expectedTrafficLoad + UpliftVanCalculationGrid = expectedUpliftVanCalculationGrid, // TODO The: this is not correct, it should be filled in CreateMacroStabilityInterface() + TrafficLoad = expectedTrafficLoad // TODO The: this is not correct, it should be filled in CreateMacroStabilityInterface() }; - - fillMacroStabilityKernelInputFromEngine.UpliftVanCalculationGrid = expectedUpliftVanCalculationGrid; // TODO The: this is not correct, it should be filled in CreateMacroStabilityInterface() // Create the Macrostability kernel model FullInputModelType fullInputModel = fillMacroStabilityKernelInputFromEngine.CreateFullInputModel( @@ -100,20 +96,19 @@ //fillEngineFromMacroStabilityWrapperInput.FillDamProjectDataFromKernelModel(expectedMacrostabilityInput); // // // Then the data models are equal - // CompareStabilityModel(expectedParametersMStab, fillEngineFromMacroStabilityWrapperInput.FailureMechanismParametersMStab); - // CompareSoilModel(expectedSoilList, fillEngineFromMacroStabilityWrapperInput.SoilList); - // CompareSoilProfile2D(expectedSoilProfile2D, fillEngineFromMacroStabilityWrapperInput.SoilProfile2D); - // CompareSurfaceLine(expectedSurfaceLine2D, fillEngineFromMacroStabilityWrapperInput.SurfaceLine2); - // CompareTrafficLoad(expectedTrafficLoad, fillEngineFromMacroStabilityWrapperInput.TrafficLoad); - // CompareTrafficLoadDegreeOfConsolidations(expectedConsolidationValues, fillEngineFromMacroStabilityWrapperInput.TrafficLoadDegreeOfConsolidations); - // SlipCircleDefinition expectedUpliftVanCalculationGridSettings = expectedParametersMStab.MStabParameters.SlipCircleDefinition; - // CompareUpliftVanCalculationGridSettings(expectedUpliftVanCalculationGridSettings, - // fillEngineFromMacroStabilityWrapperInput.SlipCircleDefinition); - // - // bool isAutoTangentLine = expectedUpliftVanCalculationGridSettings.UpliftVanTangentLinesDefinition == TangentLinesDefinition.Specified; - // CompareUpliftVanCalculationGrid(expectedUpliftVanCalculationGrid, fillEngineFromMacroStabilityWrapperInput.UpliftVanCalculationGrid, isAutoTangentLine); - // CompareWaternet(expectedWaternet, fillEngineFromMacroStabilityWrapperInput.Waternet); - // //Todo : add and or implement comparer per item as these are added to the code + CompareStabilityModel(expectedParametersMStab, fullInputModel.StabilityModel); + CompareSoilModel(expectedSoilList, fullInputModel.StabilityModel.Soils); + CompareSoilProfile2D(expectedSoilProfile2D, fullInputModel.StabilityModel.ConstructionStages[0].SoilProfile, fullInputModel.StabilityModel.Soils); + CompareSurfaceLine(expectedSurfaceLine2D, fullInputModel.PreprocessingInput.PreConstructionStages[0].Surfaceline); + CompareTrafficLoad(expectedTrafficLoad, fullInputModel.StabilityModel.ConstructionStages[0].UniformLoads[0]); + CompareTrafficLoadDegreeOfConsolidations(expectedConsolidationValues, fullInputModel.StabilityModel.ConstructionStages[0].ConsolidationValues, + fullInputModel.StabilityModel.ConstructionStages[0].SoilProfile.SoilSurfaces, fullInputModel.StabilityModel.Soils); + SlipCircleDefinition expectedUpliftVanCalculationGridSettings = expectedParametersMStab.MStabParameters.SlipCircleDefinition; + CompareUpliftVanCalculationGridSettings(expectedUpliftVanCalculationGridSettings, fullInputModel.PreprocessingInput.SearchAreaConditions); + bool areTangentLineSpecified = expectedUpliftVanCalculationGridSettings.UpliftVanTangentLinesDefinition == TangentLinesDefinition.Specified; + CompareUpliftVanCalculationGrid(expectedUpliftVanCalculationGrid, fullInputModel.StabilityModel.UpliftVanCalculationGrid, areTangentLineSpecified); + CompareWaternet(expectedWaternet, fullInputModel.StabilityModel.ConstructionStages[0].Waternet); + //Todo : add and or implement comparer per item as these are added to the code } [TestCase(1)] @@ -216,201 +211,274 @@ } } - private static void CompareTrafficLoad(TrafficLoad expectedTrafficLoad, TrafficLoad actualTrafficLoad) + private static void CompareTrafficLoad(TrafficLoad expectedTrafficLoad, UniformLoadType actualTrafficLoad) { - var compare = new CompareLogic - { - Config = - { - MaxDifferences = 100 - } - }; - compare.Config.MembersToInclude = new List - { - "XEnd", - "XStart", - "Pressure" - }; - ComparisonResult result = compare.Compare(expectedTrafficLoad, actualTrafficLoad); - Assert.That(result.Differences, Is.Empty, "Differences found read/write kernel Traffic Load"); + Assert.That(actualTrafficLoad.XStart, Is.EqualTo(expectedTrafficLoad.XStart).Within(GeometryConstants.Tolerance)); + Assert.That(actualTrafficLoad.XEnd, Is.EqualTo(expectedTrafficLoad.XEnd).Within(GeometryConstants.Tolerance)); + Assert.That(actualTrafficLoad.Pressure, Is.EqualTo(expectedTrafficLoad.Pressure).Within(GeometryConstants.Tolerance)); } - private static void CompareTrafficLoadDegreeOfConsolidations(IList expectedDegreeOfConsolidations, IList actualDegreeOfConsolidation) + private static void CompareTrafficLoadDegreeOfConsolidations(IList expectedDegreeOfConsolidations, + ConsolidationValuesTypeConsolidationValue[] actualDegreeOfConsolidations, + SoilSurfaceType[] actualSurfaceTypes, SoilType[] actualSoils) { int expectedNrOfDegreeOfConsolidation = expectedDegreeOfConsolidations.Count; - Assert.That(actualDegreeOfConsolidation, Has.Count.EqualTo(expectedNrOfDegreeOfConsolidation)); - - var compare = new CompareLogic - { - Config = - { - MaxDifferences = 100 - } - }; + Assert.That(actualDegreeOfConsolidations, Has.Length.EqualTo(expectedNrOfDegreeOfConsolidation)); for (var i = 0; i < expectedNrOfDegreeOfConsolidation; i++) { - - compare.Config.MembersToInclude = new List + SoilSurfaceType actualSurfaceType = FindSurfaceByKey(actualDegreeOfConsolidations[i].Consolidated, actualSurfaceTypes); + Soil damSoil = InputConversionHelper.ConvertToDamSoil(actualSoils[actualSurfaceType.Soil]); + Assert.Multiple(() => { - "Consolidator", - "Consolidated", - "Value" - }; - ComparisonResult result = compare.Compare(expectedDegreeOfConsolidations, actualDegreeOfConsolidation); - Assert.That(result.Differences, Is.Empty, "Differences found read/write kernel Consolidation Values"); + Assert.That(actualDegreeOfConsolidations[i].Value, Is.EqualTo(expectedDegreeOfConsolidations[i].DegreeOfConsolidation).Within(GeometryConstants.Tolerance)); + // There is only ever 1 Traffic load (as Consolidator)to refer too so do not check + Assert.That(damSoil.Name, Is.EqualTo(expectedDegreeOfConsolidations[i].SoilName)); + }); } } + private static SoilSurfaceType FindSurfaceByKey(int key, SoilSurfaceType[] types) + { + foreach (SoilSurfaceType soilSurfaceType in types) + { + if (soilSurfaceType.Key == key) + { + return soilSurfaceType; + } + } + + return null; + } + private static void CompareUpliftVanCalculationGridSettings(SlipCircleDefinition expectedSlipCircleDefinition, - SlipCircleDefinition actualSlipCircleDefinition) + SearchAreaConditionsType actualSlipCircleDefinition) { - Assert.That(actualSlipCircleDefinition.UpliftVanGridSizeDetermination, Is.EqualTo(expectedSlipCircleDefinition.UpliftVanGridSizeDetermination)); - Assert.That(actualSlipCircleDefinition.UpliftVanTangentLinesDefinition, Is.EqualTo(expectedSlipCircleDefinition.UpliftVanTangentLinesDefinition)); + Assert.That(actualSlipCircleDefinition.AutoSearchArea, Is.EqualTo(expectedSlipCircleDefinition.UpliftVanGridSizeDetermination == GridSizeDetermination.Automatic)); + if (actualSlipCircleDefinition.AutoTangentLines) + { + Assert.That(actualSlipCircleDefinition.OnlyAbovePleistoceen, Is.EqualTo(expectedSlipCircleDefinition.UpliftVanTangentLinesDefinition == TangentLinesDefinition.Automatic)); + } + else + { + Assert.That(expectedSlipCircleDefinition.UpliftVanTangentLinesDefinition, Is.EqualTo(TangentLinesDefinition.Specified)); + } // Note: do not test UpliftVanTangentLinesDistance as there is no way to be sure of equal values as determination to and from involves rounding. - //Assert.AreEqual(expectedSlipCircleDefinition.UpliftVanTangentLinesDistance, actualSlipCircleDefinition.UpliftVanTangentLinesDistance); } private static void CompareUpliftVanCalculationGrid(UpliftVanCalculationGrid expectedSlipPlaneUpliftVan, - UpliftVanCalculationGrid actualSlipPlaneUpliftVan, bool isAutoTangentLine) + UpliftVanCalculationGridType actualSlipPlaneUpliftVan, bool areTangentLineSpecified) { Assert.Multiple(() => { - Assert.That(actualSlipPlaneUpliftVan.LeftGridXLeft, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXLeft)); - Assert.That(actualSlipPlaneUpliftVan.LeftGridXRight, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXRight)); - Assert.That(actualSlipPlaneUpliftVan.LeftGridZTop, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZTop)); - Assert.That(actualSlipPlaneUpliftVan.LeftGridZBottom, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZBottom)); - Assert.That(actualSlipPlaneUpliftVan.LeftGridXCount, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXCount)); - Assert.That(actualSlipPlaneUpliftVan.LeftGridZCount, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZCount)); + Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridXLeft, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXLeft)); + Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridXRight, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXRight)); + Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridZTop, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZTop)); + Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridZBottom, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZBottom)); + Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridXNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridXCount)); + Assert.That(actualSlipPlaneUpliftVan.LeftGrid.GridZNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.LeftGridZCount)); - Assert.That(actualSlipPlaneUpliftVan.RightGridXLeft, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXLeft)); - Assert.That(actualSlipPlaneUpliftVan.RightGridXRight, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXRight)); - Assert.That(actualSlipPlaneUpliftVan.RightGridZTop, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZTop)); - Assert.That(actualSlipPlaneUpliftVan.RightGridZBottom, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZBottom)); - Assert.That(actualSlipPlaneUpliftVan.RightGridXCount, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXCount)); - Assert.That(actualSlipPlaneUpliftVan.RightGridZCount, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZCount)); + Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridXLeft, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXLeft)); + Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridXRight, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXRight)); + Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridZTop, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZTop)); + Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridZBottom, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZBottom)); + Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridXNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridXCount)); + Assert.That(actualSlipPlaneUpliftVan.RightGrid.GridZNumber, Is.EqualTo(expectedSlipPlaneUpliftVan.RightGridZCount)); }); - if (!isAutoTangentLine) + if (areTangentLineSpecified) { - Assert.That(actualSlipPlaneUpliftVan.TangentLineLevels, Is.EqualTo(expectedSlipPlaneUpliftVan.TangentLineLevels).AsCollection); + Assert.That(actualSlipPlaneUpliftVan.TangentLines, Is.EqualTo(expectedSlipPlaneUpliftVan.TangentLineLevels).AsCollection); } } - private static void CompareWaternet(Waternet expectedWaternet, Waternet actualWaternet) + private static void CompareWaternet(Waternet expectedWaternet, WaternetType actualWaternet) { Assert.That(actualWaternet.Name, Is.EqualTo(expectedWaternet.Name)); - CompareLine(expectedWaternet.PhreaticLine, actualWaternet.PhreaticLine); - CompareWaternetHeadLines(expectedWaternet.HeadLineList, actualWaternet.HeadLineList); - CompareWaternetLines(actualWaternet.WaternetLineList, expectedWaternet.WaternetLineList); + CompareHeadLine(expectedWaternet.PhreaticLine, actualWaternet.PhreaticLine); + CompareWaternetHeadLines(expectedWaternet.HeadLineList, actualWaternet.HeadLines); + CompareWaternetLines(expectedWaternet.WaternetLineList, actualWaternet.WaternetLines, actualWaternet.HeadLines); } - private static void CompareWaternetLines(IEnumerable actualWaternetLines, - IEnumerable expectedWaternetLines) + private static void CompareWaternetLines(List expectedWaternetLines, + WaternetTypeWaternetLine[] actualWaternetLines, HeadLineType[] actualHeadLines) { - int expectedNrOfWaternetLines = actualWaternetLines.Count(); - Assert.That(actualWaternetLines.Count(), Is.EqualTo(expectedNrOfWaternetLines)); - for (var i = 0; i < expectedNrOfWaternetLines; i++) + Assert.That(actualWaternetLines.Count, Is.EqualTo(expectedWaternetLines.Count)); + for (var i = 0; i < expectedWaternetLines.Count; i++) { WaternetLine expectedWaternetLine = expectedWaternetLines.ElementAt(i); - WaternetLine actualWaternetLine = actualWaternetLines.ElementAt(i); - CompareLine(expectedWaternetLine, actualWaternetLine); - CompareLine(expectedWaternetLine.HeadLine, actualWaternetLine.HeadLine); + WaternetTypeWaternetLine actualWaternetLine = actualWaternetLines[i]; + CompareWaternetLine(expectedWaternetLine, actualWaternetLine); + HeadLineType associatedHeadLine = FindAssociatedHeadLine(actualWaternetLine.AssociatedHeadLine, actualHeadLines); + CompareHeadLine(expectedWaternetLine.HeadLine, associatedHeadLine); } } - private static void CompareWaternetHeadLines(IEnumerable expectedHeadLines, - IEnumerable actualHeadLines) + private static HeadLineType FindAssociatedHeadLine(int associatedHeadLine, HeadLineType[] actualHeadLines) { - int expectedNrOfHeadLines = expectedHeadLines.Count(); - Assert.That(actualHeadLines.Count(), Is.EqualTo(expectedNrOfHeadLines)); + foreach (HeadLineType headLine in actualHeadLines) + { + if (headLine.Key == associatedHeadLine) + { + return headLine; + } + } - for (var i = 0; i < expectedNrOfHeadLines; i++) + return null; + } + + private static void CompareWaternetHeadLines(List expectedHeadLines, + HeadLineType[] actualHeadLines) + { + Assert.That(actualHeadLines.Count, Is.EqualTo(expectedHeadLines.Count)); + + for (var i = 0; i < expectedHeadLines.Count; i++) { HeadLine expectedHeadLine = expectedHeadLines.ElementAt(i); - HeadLine actualHeadLine = actualHeadLines.ElementAt(i); - CompareLine(expectedHeadLine, actualHeadLine); + HeadLineType actualHeadLine = actualHeadLines.ElementAt(i); + CompareHeadLine(expectedHeadLine, actualHeadLine); } } - private static void CompareLine(TLineType expectedHeadLine, TLineType actualHeadLine) - where TLineType : GeometryPointString + private static void CompareHeadLine(GeometryPointString expectedHeadLine, HeadLineType actualHeadLine) { - Assert.That(actualHeadLine.Name, Is.EqualTo(expectedHeadLine.Name)); - + //CompareWaternetLine(expectedHeadLine, actualHeadLine.WaternetLine); + Assert.That(actualHeadLine.WaternetLine.Name, Is.EqualTo(expectedHeadLine.Name)); List expectedPoints = expectedHeadLine.Points; - int expectedNrOfPoints = expectedPoints.Count; - List actualPoints = actualHeadLine.Points; - Assert.That(actualPoints, Has.Count.EqualTo(expectedNrOfPoints)); - for (var i = 0; i < expectedNrOfPoints; i++) + List actualPoints = actualHeadLine.WaternetLine.Points.ToList(); + Assert.That(actualPoints, Has.Count.EqualTo(expectedPoints.Count)); + for (var i = 0; i < expectedPoints.Count; i++) { Point2D expectedCoordinate = expectedPoints[i]; - Point2D actualCoordinate = actualPoints[i]; + Point2D actualCoordinateAsPoint2D = new Point2D(actualPoints[i].X, actualPoints[i].Z); + Assert.That(expectedCoordinate.LocationEquals(actualCoordinateAsPoint2D), Is.True); + } + } + + private static void CompareWaternetLine(GeometryPointString expectedWaternetLine, WaternetTypeWaternetLine actualWaternetLine) + { + Assert.That(actualWaternetLine.Name, Is.EqualTo(expectedWaternetLine.Name)); - Assert.That(expectedCoordinate.LocationEquals(actualCoordinate), Is.True); + List expectedPoints = expectedWaternetLine.Points; + List actualPoints = actualWaternetLine.Points.ToList(); + Assert.That(actualPoints, Has.Count.EqualTo(expectedPoints.Count)); + for (var i = 0; i < expectedPoints.Count; i++) + { + Point2D expectedCoordinate = expectedPoints[i]; + Point2D actualCoordinateAsPoint2D = new Point2D(actualPoints[i].X, actualPoints[i].Z); + Assert.That(expectedCoordinate.LocationEquals(actualCoordinateAsPoint2D), Is.True); } } - private static void CompareSurfaceLine(SurfaceLine2 expectedSurfaceLine2, SurfaceLine2 actualSurfaceLine2) + private static void CompareSurfaceLine(SurfaceLine2 expectedSurfaceLine2, SurfaceLineType actualSurfaceLine2) { CharacteristicPointSet expectedCharacteristicPoints = expectedSurfaceLine2.CharacteristicPoints; - CharacteristicPointSet actualCharacteristicPoints = actualSurfaceLine2.CharacteristicPoints; - var compare = new CompareLogic + SurfaceLineTypeCharacteristicPoint[] actualCharacteristicPoints = actualSurfaceLine2.CharacteristicPoints; + Assert.That(actualCharacteristicPoints.Length, Is.EqualTo(expectedCharacteristicPoints.Count)); + for (int i = 0; i < actualCharacteristicPoints.Length; i++) { - Config = + Assert.That(actualCharacteristicPoints[i].CharacteristicPointType, + Is.EqualTo(InputConversionHelper.ConvertToMacroStabilityCharacteristicPointType( + expectedSurfaceLine2.CharacteristicPoints[i].CharacteristicPointType))); + Assert.That(actualCharacteristicPoints[i].GeometryPoint.X, Is.EqualTo(expectedSurfaceLine2.CharacteristicPoints[i].Point.X).Within(GeometryConstants.Tolerance)); + Assert.That(actualCharacteristicPoints[i].GeometryPoint.Z, Is.EqualTo(expectedSurfaceLine2.CharacteristicPoints[i].Point.Z).Within(GeometryConstants.Tolerance)); + } + } + + private static void CompareSoilProfile2D(SoilProfile2D expectedSoilProfile, SoilProfileType actualSoilProfile, SoilType[] actualSoils) + { + Assert.Multiple(() => + { + Assert.That(actualSoilProfile.SoilSurfaces, Has.Length.EqualTo(expectedSoilProfile.Surfaces.Count)); + Assert.That(actualSoilProfile.Geometry.Points.Length, Is.EqualTo(expectedSoilProfile.Geometry.Points.Count)); + Assert.That(actualSoilProfile.Geometry.Curves.Length, Is.EqualTo(expectedSoilProfile.Geometry.Curves.Count)); + Assert.That(actualSoilProfile.Geometry.GeometrySurfaces.Length, Is.EqualTo(expectedSoilProfile.Geometry.Surfaces.Count)); + }); + for (var i = 0; i < expectedSoilProfile.Surfaces.Count; i++) + { + Soil damSoil = InputConversionHelper.ConvertToDamSoil(actualSoils[actualSoilProfile.SoilSurfaces[i].Soil]); + CompareSoil(damSoil, expectedSoilProfile.Surfaces[i].Soil); + Assert.Multiple(() => { - MaxDifferences = 100 - } - }; - compare.Config.MembersToIgnore = new List + Assert.That(actualSoilProfile.SoilSurfaces[i].WaterPressureInterpolationModel, Is.EqualTo( + InputConversionHelper.ConvertToMacroStabilityWaterPressureInterpolationModel(expectedSoilProfile.Surfaces[i].WaterpressureInterpolationModel))); + Assert.That(actualSoilProfile.SoilSurfaces[i].IsAquifer, Is.EqualTo(expectedSoilProfile.Surfaces[i].IsAquifer)); + }); + } + + for (var j = 0; j < expectedSoilProfile.Geometry.Points.Count; j++) { - "Owner" - }; - ComparisonResult result = compare.Compare(expectedCharacteristicPoints, actualCharacteristicPoints); - Assert.That(result.Differences, Is.Empty, "Differences found read/write kernel SurfaceLine"); + Assert.Multiple(() => + { + Assert.That(actualSoilProfile.Geometry.Points[j].X, Is.EqualTo(expectedSoilProfile.Geometry.Points[j].X).Within(GeometryConstants.Tolerance)); + Assert.That(actualSoilProfile.Geometry.Points[j].Z, Is.EqualTo(expectedSoilProfile.Geometry.Points[j].Z).Within(GeometryConstants.Tolerance)); + }); + } + + for (var j = 0; j < expectedSoilProfile.Geometry.Curves.Count; j++) + { + PointType headPoint = FindPointByKey(actualSoilProfile.Geometry.Curves[j].HeadPoint, actualSoilProfile.Geometry.Points); + PointType endPoint = FindPointByKey(actualSoilProfile.Geometry.Curves[j].EndPoint, actualSoilProfile.Geometry.Points); + Assert.Multiple(() => + { + Assert.That(headPoint.X, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].HeadPoint.X).Within(GeometryConstants.Tolerance)); + Assert.That(headPoint.Z, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].HeadPoint.Z).Within(GeometryConstants.Tolerance)); + Assert.That(endPoint.X, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].EndPoint.X).Within(GeometryConstants.Tolerance)); + Assert.That(endPoint.Z, Is.EqualTo(expectedSoilProfile.Geometry.Curves[j].EndPoint.Z).Within(GeometryConstants.Tolerance)); + }); + } } - private static void CompareSoilProfile2D(SoilProfile2D expectedSoilProfile, SoilProfile2D actualSoilProfile) + private static PointType FindPointByKey(int pointKey, PointType[] points) { - var compare = new CompareLogic + foreach (PointType point in points) { - Config = + if (point.Key == pointKey) { - MaxDifferences = 100 + return point; } - }; - compare.Config.MembersToIgnore = soilParametersToIgnore; - compare.Config.MembersToIgnore.Add("Name"); - ComparisonResult result = compare.Compare(expectedSoilProfile, actualSoilProfile); - Assert.That(result.Differences, Is.Empty, "Differences found read/write kernel SoilProfile2D"); + } + + return null; } - private static void CompareSoilModel(SoilList expectedSoils, SoilList actualSoils) + private static void CompareSoilModel(SoilList expectedSoils, SoilType[] actualSoils) { - Assert.That(actualSoils.Soils, Has.Count.EqualTo(expectedSoils.Soils.Count), "Soil Count does not match"); + Assert.That(actualSoils, Has.Length.EqualTo(expectedSoils.Soils.Count), "Soil Count does not match"); + int i = 0; foreach (Soil expectedSoil in expectedSoils.Soils) { - Soil actualSoil = actualSoils.Soils.SingleOrDefault(soil => soil.Name.Equals(expectedSoil.Name)); + Soil actualSoil = InputConversionHelper.ConvertToDamSoil(actualSoils[i]); + CompareSoil(actualSoil, expectedSoil); + i++; + } + } + + private static void CompareSoil(Soil actualSoil, Soil expectedSoil) + { + Assert.Multiple(() => + { + Assert.That(actualSoil.Name, Is.EqualTo(expectedSoil.Name)); Assert.That(actualSoil, Is.Not.Null, $"Soil {expectedSoil.Name} not found"); - var compare = new CompareLogic + }); + var compare = new CompareLogic + { + Config = { - Config = - { - MaxDifferences = 100 - } - }; - compare.Config.MembersToIgnore = soilParametersToIgnore; - ComparisonResult result = compare.Compare(expectedSoil, actualSoil); - Assert.That(result.Differences, Is.Empty, "Differences found read/write kernel SoilModel"); - } + MaxDifferences = 100, + MembersToIgnore = soilParametersToIgnore + } + }; + ComparisonResult result = compare.Compare(expectedSoil, actualSoil); + Assert.That(result.Differences, Is.Empty, "Differences found read/write kernel SoilModel"); } - private static void CompareStabilityModel(FailureMechanismParametersMStab expectedStabilityModel, FailureMechanismParametersMStab actualStabilityModel) + private static void CompareStabilityModel(FailureMechanismParametersMStab expectedStabilityModel, StabilityInputType actualStabilityModel) { Assert.Multiple(() => { - Assert.That(actualStabilityModel.MStabParameters.SearchMethod, Is.EqualTo(expectedStabilityModel.MStabParameters.SearchMethod)); - Assert.That(actualStabilityModel.MStabParameters.Model, Is.EqualTo(expectedStabilityModel.MStabParameters.Model)); - Assert.That(actualStabilityModel.MStabParameters.GridPosition, Is.EqualTo(expectedStabilityModel.MStabParameters.GridPosition)); + Assert.That(actualStabilityModel.SearchAlgorithm, Is.EqualTo(InputConversionHelper.ConvertToMacroStabilitySearchMethod(expectedStabilityModel.MStabParameters.SearchMethod))); + Assert.That(actualStabilityModel.ModelOption, Is.EqualTo(InputConversionHelper.ConvertToMacroStabilityModelOption(expectedStabilityModel.MStabParameters.Model))); + Assert.That(actualStabilityModel.Orientation, Is.EqualTo(InputConversionHelper.ConvertToMacroStabilityGridOrientation(expectedStabilityModel.MStabParameters.GridPosition))); }); }