Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityWrapperInputFromEngine.cs =================================================================== diff -u -r2944 -r2947 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityWrapperInputFromEngine.cs (.../FillMacroStabilityWrapperInputFromEngine.cs) (revision 2944) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityWrapperInputFromEngine.cs (.../FillMacroStabilityWrapperInputFromEngine.cs) (revision 2947) @@ -24,11 +24,18 @@ using System.Linq; using Deltares.DamEngine.Calculators.KernelWrappers.Common; using Deltares.DamEngine.Data.General; +using Deltares.DamEngine.Data.Geometry; using Deltares.DamEngine.Data.Geotechnics; using Deltares.MacroStability.CSharpWrapper; -using WaterNet = Deltares.DamEngine.Data.Geometry.Waternet; +using Waternet = Deltares.DamEngine.Data.Geometry.Waternet; using Deltares.MacroStability.CSharpWrapper.Input; +using HeadLine = Deltares.DamEngine.Data.Geometry.HeadLine; using KernelUpliftVanCalculationGrid = Deltares.MacroStability.CSharpWrapper.UpliftVanCalculationGrid; +using KernelWaternet = Deltares.MacroStability.CSharpWrapper.Input.Waternet; +using KernelMacroStabilityInput = Deltares.MacroStability.CSharpWrapper.Input.MacroStabilityInput; +using KernelPoint2D = Deltares.MacroStability.CSharpWrapper.Point2D; +using KernelWaternetLine = Deltares.MacroStability.CSharpWrapper.Input.WaternetLine; +using KernelHeadLine = Deltares.MacroStability.CSharpWrapper.Input.HeadLine; namespace Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo @@ -60,7 +67,7 @@ public MacroStabilityInput CreateMacroStabilityInput(DamKernelInput damKernelInput, FailureMechanismParametersMStab failureMechanismParametersMStab, Data.Geometry.Waternet waterNet) { soilsDictionary.Clear(); - var macroStabilityInput = new MacroStabilityInput(); + var macroStabilityInput = new KernelMacroStabilityInput(); macroStabilityInput.StabilityModel = new StabilityInput(); // ToDo check whether this is needed. macroStabilityInput.PreprocessingInput = new PreprocessingInput(); // ToDo check whether this is needed. macroStabilityInput.StabilityModel.UpliftVanCalculationGrid = new KernelUpliftVanCalculationGrid(); @@ -79,6 +86,8 @@ var preConstructionLastStage = macroStabilityInput.PreprocessingInput.PreConstructionStages.Last(); preConstructionLastStage.Surfaceline = new SurfaceLine(); TransferSurfaceLine(damKernelInput.Location.SurfaceLine, preConstructionLastStage.Surfaceline); + + lastStage.Waternet = new KernelWaternet(); TransferWaternet(waterNet, lastStage.Waternet); TransferUpliftVanCalculationGrid(UpliftVanCalculationGrid, macroStabilityInput.StabilityModel.UpliftVanCalculationGrid, macroStabilityInput.PreprocessingInput.SearchAreaConditions); @@ -113,12 +122,12 @@ private void TransferSoilProfile(SoilProfile2D damSoilProfile2D, MacroStability.CSharpWrapper.Input.SoilProfile kernelSoilProfile, IList preconsolidationStresses) { // Add points - var pointsDictionary = new Dictionary(); + var pointsDictionary = new Dictionary(); kernelSoilProfile.Geometry = new Geometry(); - kernelSoilProfile.Geometry.Points = new List(); + kernelSoilProfile.Geometry.Points = new List(); foreach (var damPoint in damSoilProfile2D.Geometry.Points) { - var kernelPoint = new Point2D(damPoint.X, damPoint.Z); + var kernelPoint = new KernelPoint2D(damPoint.X, damPoint.Z); kernelSoilProfile.Geometry.Points.Add(kernelPoint); pointsDictionary.Add(damPoint, kernelPoint); } @@ -187,7 +196,7 @@ foreach (var preconsolidationStress in damSoilProfile2D.PreconsolidationStresses) { var kernelPrecon = new PreconsolidationStress(); - kernelPrecon.Point = new Point2D(preconsolidationStress.X, preconsolidationStress.Z); + kernelPrecon.Point = new KernelPoint2D(preconsolidationStress.X, preconsolidationStress.Z); kernelPrecon.StressValue = preconsolidationStress.StressValue; preconsolidationStresses.Add(kernelPrecon); } @@ -203,61 +212,52 @@ kernelCharPoint.CharacteristicPoint = ConversionHelper.ConvertToMacroStabilityCharacteristicPointType( damCharPoint.CharacteristicPointType); - kernelCharPoint.GeometryPoint = new Point2D(damCharPoint.X, damCharPoint.Z); + kernelCharPoint.GeometryPoint = new KernelPoint2D(damCharPoint.X, damCharPoint.Z); kernelSurfaceLine.CharacteristicPoints.Add(kernelCharPoint); } } - private void TransferWaternet(WaterNet damWaternet, Deltares.MacroStability.CSharpWrapper.Input.Waternet kernelWaternet) + private void TransferWaternet(Waternet damWaternet, KernelWaternet kernelWaternet) { - // // Properties - // kernelWaternet.IsGenerated = damWaternet.IsGenerated; - // kernelWaternet.UnitWeight = damWaternet.UnitWeight; - // - // // Phreatic Line - // kernelWaternet.PhreaticLine = new PhreaticLine() - // { - // Name = damWaternet.PhreaticLine.Name - // - // }; - // foreach (var damPoint in damWaternet.PhreaticLine.CalcPoints) - // { - // kernelWaternet.PhreaticLine.CalcPoints.Add(new Point2D(damPoint.X, damPoint.Z)); - // } - // dictHeadLines.Add(damWaternet.PhreaticLine, kernelWaternet.PhreaticLine); - // - // // Head Lines - // foreach (var damHeadLine in damWaternet.HeadLineList) - // { - // var kernelHeadLine = new HeadLine() - // { - // Name = damHeadLine.Name - // }; - // foreach (var damPoint in damHeadLine.CalcPoints) - // { - // kernelHeadLine.CalcPoints.Add(new Point2D(damPoint.X, damPoint.Z)); - // } - // kernelWaternet.HeadLineList.Add(kernelHeadLine); - // dictHeadLines.Add(damHeadLine, kernelHeadLine); - // } - // - // // Waternet Lines - // foreach (var damWaternetLine in damWaternet.WaternetLineList) - // { - // var kernelWaternetLine = new WaternetLine() - // { - // Name = damWaternetLine.Name - // }; - // foreach (var damPoint in damWaternetLine.CalcPoints) - // { - // kernelWaternetLine.CalcPoints.Add(new Point2D(damPoint.X, damPoint.Z)); - // } - // - // kernelWaternetLine.HeadLine = dictHeadLines[damWaternetLine.HeadLine]; - // kernelWaternet.WaternetLineList.Add(kernelWaternetLine); - // } + var headLineMapping = new Dictionary(); + + kernelWaternet.Name = damWaternet.Name; + + // Phreatic Line + PhreaticLine phreaticLine = damWaternet.PhreaticLine; + kernelWaternet.PhreaticLine = CreateLine(phreaticLine); + headLineMapping.Add(damWaternet.PhreaticLine, kernelWaternet.PhreaticLine); + + // Head Lines + foreach (var damHeadLine in damWaternet.HeadLineList) + { + var kernelHeadLine = CreateLine(damHeadLine); + kernelWaternet.HeadLines.Add(kernelHeadLine); + headLineMapping.Add(damHeadLine, kernelHeadLine); + } + + // Waternet Lines + foreach (var damWaternetLine in damWaternet.WaternetLineList) + { + var kernelWaternetLine = CreateLine(damWaternetLine); + kernelWaternetLine.AssociatedHeadLine = headLineMapping[damWaternetLine.HeadLine]; + + kernelWaternet.WaternetLines.Add(kernelWaternetLine); + } } + private static TKernelLineType CreateLine(GeometryPointString geometry) + where TKernelLineType : KernelWaternetLine, new() + { + var line = new TKernelLineType + { + Name = geometry.Name, + Points = geometry.CalcPoints.Select(p => new KernelPoint2D(p.X, p.Z)).ToList() + }; + + return line; + } + private void TransferUpliftVanCalculationGrid(UpliftVanCalculationGrid damUpliftVanCalculationGrid, KernelUpliftVanCalculationGrid kernelUpliftVanCalculationGrid, SearchAreaConditions kernelSearchAreaConditions) Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperInput.cs =================================================================== diff -u -r2944 -r2947 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperInput.cs (.../FillEngineFromMacroStabilityWrapperInput.cs) (revision 2944) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillEngineFromMacroStabilityWrapperInput.cs (.../FillEngineFromMacroStabilityWrapperInput.cs) (revision 2947) @@ -27,9 +27,14 @@ using Deltares.DamEngine.Data.Geotechnics; using Deltares.MacroStability.CSharpWrapper.Input; using CharacteristicPoint = Deltares.DamEngine.Data.Geotechnics.CharacteristicPoint; +using HeadLine = Deltares.DamEngine.Data.Geometry.HeadLine; using Soil = Deltares.DamEngine.Data.Geotechnics.Soil; using SurfaceLine2 = Deltares.DamEngine.Data.Geotechnics.SurfaceLine2; using KernelUpliftVanCalculationGrid = Deltares.MacroStability.CSharpWrapper.UpliftVanCalculationGrid; +using KernelWaternet = Deltares.MacroStability.CSharpWrapper.Input.Waternet; +using KernelHeadLine = Deltares.MacroStability.CSharpWrapper.Input.HeadLine; +using KernelWaternetLine = Deltares.MacroStability.CSharpWrapper.Input.WaternetLine; +using WaternetLine = Deltares.DamEngine.Data.Geometry.WaternetLine; namespace Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo @@ -93,6 +98,7 @@ "Trafficload cannot be constructed because there are too many uniform loads defined ({0}", kernelUniformLoads.Count)); } + var kernelUniformLoad = kernelUniformLoads[0]; TrafficLoad = new TrafficLoad() { @@ -130,59 +136,52 @@ UpliftVanCalculationGrid.TangentLineCount = tangentLines.Count() - 1; // -1 as the ZTop coordinate is inclusive } - private void TransferWaternet(MacroStability.CSharpWrapper.Input.Waternet kernelWaternet) + private void TransferWaternet(KernelWaternet kernelWaternet) { - // Waternet = new Data.Geometry.Waternet(); - // // Properties - // Waternet.IsGenerated = kernelWaternet.IsGenerated; - // Waternet.UnitWeight = kernelWaternet.UnitWeight; - // - // // Phreatic Line - // var damPhreaticLine = new PhreaticLine() - // { - // Name = kernelWaternet.PhreaticLine.Name - // }; - // foreach (var kernelPoint in kernelWaternet.PhreaticLine.CalcPoints) - // { - // damPhreaticLine.CalcPoints.Add(new Data.Geometry.Point2D(kernelPoint.X, kernelPoint.Z)); - // } - // dictHeadLines.Add(kernelWaternet.PhreaticLine, damPhreaticLine); - // Waternet.PhreaticLine = damPhreaticLine; - // - // // Head Lines - // foreach (var kernelHeadLine in kernelWaternet.HeadLineList) - // { - // var damHeadLine = new HeadLine() - // { - // Name = kernelHeadLine.Name - // }; - // foreach (var kernelPoint in kernelHeadLine.CalcPoints) - // { - // damHeadLine.CalcPoints.Add(new Data.Geometry.Point2D(kernelPoint.X, kernelPoint.Z)); - // } - // Waternet.HeadLineList.Add(damHeadLine); - // dictHeadLines.Add(kernelHeadLine, damHeadLine); - // } - // - // // Waternet Lines - // foreach (var kernelWaternetLine in kernelWaternet.WaternetLineList) - // { - // var damWaternetLine = new WaternetLine() - // { - // Name = kernelWaternetLine.Name - // }; - // foreach (var kernelPoint in kernelWaternetLine.CalcPoints) - // { - // damWaternetLine.CalcPoints.Add(new Data.Geometry.Point2D(kernelPoint.X, kernelPoint.Z)); - // } - // - // damWaternetLine.HeadLine = dictHeadLines[kernelWaternetLine.HeadLine]; - // Waternet.WaternetLineList.Add(damWaternetLine); - // } + var headLineMapping = new Dictionary(); + + Waternet = new Data.Geometry.Waternet + { + Name = kernelWaternet.Name + }; + + // Phreatic line + PhreaticLine phreaticLine = CreateLine(kernelWaternet.PhreaticLine); + Waternet.PhreaticLine = phreaticLine; + headLineMapping.Add(kernelWaternet.PhreaticLine, phreaticLine); + + // Head Lines + foreach (KernelHeadLine kernelHeadLine in kernelWaternet.HeadLines) + { + HeadLine headLine = CreateLine(kernelHeadLine); + Waternet.HeadLineList.Add(headLine); + headLineMapping.Add(kernelHeadLine, headLine); + } + + // Waternet Lines + foreach (ReferenceLine kernelWaternetLine in kernelWaternet.WaternetLines) + { + var waternetLine = CreateLine(kernelWaternetLine); + waternetLine.HeadLine = headLineMapping[kernelWaternetLine.AssociatedHeadLine]; + Waternet.WaternetLineList.Add(waternetLine); + } } - private void TransferSurfaceLine(SurfaceLine kernelSurfaceLine) + private static TLineType CreateLine(KernelWaternetLine waternetLine) + where TLineType : GeometryPointString, new() { + var lineType = new TLineType + { + Name = waternetLine.Name + }; + var coordinates = waternetLine.Points.Select(p => new Point2D(p.X, p.Z)).ToArray(); + lineType.CalcPoints.AddRange(coordinates); + + return lineType; + } + + private void TransferSurfaceLine(MacroStability.CSharpWrapper.Input.SurfaceLine kernelSurfaceLine) + { SurfaceLine2 = new SurfaceLine2(); foreach (var kernelCharPoint in kernelSurfaceLine.CharacteristicPoints) { @@ -257,6 +256,7 @@ { damLoop.CurveList.Add(curvesDictionary[damCurve]); } + loopsDictionary.Add(kernelLoop, damLoop); SoilProfile2D.Geometry.Loops.Add(damLoop); } @@ -271,10 +271,11 @@ { damSurface.InnerLoops.Add(loopsDictionary[damInnerLoop]); } + geometrySurfacesDictionary.Add(kernelSurface, damSurface); SoilProfile2D.Geometry.Surfaces.Add(damSurface); } - + // Add soil surfaces foreach (var kernelSoilLayer2D in kernelSoilProfile2D.SoilSurfaces) { @@ -298,6 +299,5 @@ SoilProfile2D.PreconsolidationStresses.Add(damPreConsolidationStress); } } - } -} +} \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIoTests.cs =================================================================== diff -u -r2943 -r2947 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIoTests.cs (.../MacroStabilityIoTests.cs) (revision 2943) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIoTests.cs (.../MacroStabilityIoTests.cs) (revision 2947) @@ -27,6 +27,7 @@ using NUnit.Framework; using Deltares.DamEngine.Data.General; using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo; +using Deltares.DamEngine.Data.Geometry; using Deltares.DamEngine.Data.Geotechnics; using Deltares.DamEngine.TestHelpers; using Deltares.DamEngine.TestHelpers.Factories; @@ -77,7 +78,6 @@ Pressure = 6.0, XStart = expectedSurfaceLine2D.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X, XEnd = expectedSurfaceLine2D.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X, - }; var fillMacroStabilityWrapperInputFromEngine = new FillMacroStabilityWrapperInputFromEngine { @@ -96,16 +96,16 @@ // reverse that input to the engine data var fillEngineFromMacroStabilityWrapperInput = new FillEngineFromMacroStabilityWrapperInput(); 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); CompareUpliftVanCalculationGrid(expectedUpliftVanCalculationGrid, fillEngineFromMacroStabilityWrapperInput.UpliftVanCalculationGrid); + CompareWaternet(expectedWaternet, fillEngineFromMacroStabilityWrapperInput.Waternet); //Todo : add and or implement comparer per item as these are added to the code - } private static UpliftVanCalculationGrid CreateExampleUpliftVanCalculationGrid() @@ -150,7 +150,7 @@ var headLine = new HeadLine() { Name = "Test Head line" - }; + }; waterNet.HeadLineList.Add(headLine); var waternetLine = new Data.Geometry.WaternetLine() { @@ -161,7 +161,7 @@ return waterNet; } - + private void CompareTrafficLoad(TrafficLoad expectedTrafficLoad, TrafficLoad actualTrafficLoad) { var compare = new CompareLogic { Config = { MaxDifferences = 100 } }; @@ -176,7 +176,7 @@ Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Traffic Load"); } - private void CompareUpliftVanCalculationGrid(UpliftVanCalculationGrid expectedSlipPlaneUpliftVan, + private void CompareUpliftVanCalculationGrid(UpliftVanCalculationGrid expectedSlipPlaneUpliftVan, UpliftVanCalculationGrid actualSlipPlaneUpliftVan) { Assert.AreEqual(expectedSlipPlaneUpliftVan.LeftGridXLeft, actualSlipPlaneUpliftVan.LeftGridXLeft); @@ -198,31 +198,69 @@ Assert.AreEqual(expectedSlipPlaneUpliftVan.TangentLineCount, actualSlipPlaneUpliftVan.TangentLineCount); } - private void CompareWaternet(Data.Geometry.Waternet expectedWaternet, Data.Geometry.Waternet actualWaternet) + private static void CompareWaternet(Waternet expectedWaternet, Waternet actualWaternet) { - var compare = new CompareLogic { Config = { MaxDifferences = 100 } }; - compare.Config.MembersToIgnore = new List() + Assert.AreEqual(expectedWaternet.Name, actualWaternet.Name); + CompareLine(expectedWaternet.PhreaticLine, actualWaternet.PhreaticLine); + + // Head Lines + CompareWaternetHeadLines(expectedWaternet.HeadLineList, actualWaternet.HeadLineList); + + // Waternet lines + CompareWaternetLines(actualWaternet.WaternetLineList, expectedWaternet.WaternetLineList); + } + + private static void CompareWaternetLines(IEnumerable actualWaternetLines, + IEnumerable expectedWaternetLines) + { + int expectedNrOfWaternetLines = actualWaternetLines.Count(); + Assert.AreEqual(expectedNrOfWaternetLines, actualWaternetLines.Count()); + for (int i = 0; i < expectedNrOfWaternetLines; i++) { - "Waternet", - "Owner" - }; - ComparisonResult result; - Assert.AreEqual(expectedWaternet.IsGenerated, actualWaternet.IsGenerated); - Assert.AreEqual(expectedWaternet.UnitWeight, actualWaternet.UnitWeight); - result = compare.Compare(expectedWaternet.PhreaticLine, actualWaternet.PhreaticLine); - Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Waternet.PhreaticLine"); - result = compare.Compare(expectedWaternet.WaternetLineList, actualWaternet.WaternetLineList); - Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Waternet.WaternetLineList"); - result = compare.Compare(expectedWaternet.HeadLineList, actualWaternet.HeadLineList); - Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Waternet.HeadLineList"); -// Assert.AreEqual(expectedWaternet.ExternalWaterLevel, actualWaternet.ExternalWaterLevel); + WaternetLine expectedWaternetLine = expectedWaternetLines.ElementAt(i); + WaternetLine actualWaternetLine = actualWaternetLines.ElementAt(i); + CompareLine(expectedWaternetLine, actualWaternetLine); + CompareLine(expectedWaternetLine.HeadLine, actualWaternetLine.HeadLine); + } } + private static void CompareWaternetHeadLines(IEnumerable expectedHeadLines, + IEnumerable actualHeadLines) + { + int expectedNrOfHeadLines = expectedHeadLines.Count(); + Assert.AreEqual(expectedNrOfHeadLines, actualHeadLines.Count()); + + for (int i = 0; i < expectedNrOfHeadLines; i++) + { + HeadLine expectedHeadLine = expectedHeadLines.ElementAt(i); + HeadLine actualHeadLine = actualHeadLines.ElementAt(i); + CompareLine(expectedHeadLine, actualHeadLine); + } + } + + private static void CompareLine(TLineType expectedHeadLine, TLineType actualHeadLine) + where TLineType : GeometryPointString + { + Assert.AreEqual(expectedHeadLine.Name, actualHeadLine.Name); + + var expectedCalcPoints = expectedHeadLine.CalcPoints; + int expectedNrOfCalcPoints = expectedCalcPoints.Count; + var actualCalcPoints = actualHeadLine.CalcPoints; + Assert.AreEqual(expectedNrOfCalcPoints, actualCalcPoints.Count); + for (int i = 0; i < expectedNrOfCalcPoints; i++) + { + Point2D expectedCoordinate = expectedCalcPoints[i]; + Point2D actualCoordinate = actualCalcPoints[i]; + + Assert.True(expectedCoordinate.LocationEquals(actualCoordinate)); + } + } + private void CompareSurfaceLine(SurfaceLine2 expectedSurfaceLine2, SurfaceLine2 actualSurfaceLine2) { CharacteristicPointSet expectedCharacteristicPoints = expectedSurfaceLine2.CharacteristicPoints; CharacteristicPointSet actualCharacteristicPoints = actualSurfaceLine2.CharacteristicPoints; - var compare = new CompareLogic { Config = { MaxDifferences = 100 } }; + var compare = new CompareLogic {Config = {MaxDifferences = 100}}; compare.Config.MembersToIgnore = new List() { "Owner" @@ -233,7 +271,7 @@ private void CompareSoilProfile2D(SoilProfile2D expectedSoilProfile, SoilProfile2D actualSoilProfile) { - var compare = new CompareLogic { Config = { MaxDifferences = 100 } }; + var compare = new CompareLogic {Config = {MaxDifferences = 100}}; compare.Config.MembersToIgnore = SoilParametersToIgnore; compare.Config.MembersToIgnore.Add("Name"); var result = compare.Compare(expectedSoilProfile, actualSoilProfile); @@ -243,16 +281,16 @@ private void CompareSoilModel(SoilList expectedSoils, SoilList actualSoils) { - Assert.AreEqual(expectedSoils.Soils.Count, actualSoils.Soils.Count, "Soil Count does not match"); - foreach (Soil expectedSoil in expectedSoils.Soils) - { - var actualSoil = actualSoils.Soils.First(soil => soil.Name.Equals(expectedSoil.Name)); - Assert.IsNotNull(actualSoil, string.Format("Soil {0} not found", expectedSoil.Name)); - var compare = new CompareLogic { Config = { MaxDifferences = 100 } }; - compare.Config.MembersToIgnore = SoilParametersToIgnore; - var result = compare.Compare(expectedSoil, actualSoil); - Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilModel"); - } + Assert.AreEqual(expectedSoils.Soils.Count, actualSoils.Soils.Count, "Soil Count does not match"); + foreach (Soil expectedSoil in expectedSoils.Soils) + { + var actualSoil = actualSoils.Soils.First(soil => soil.Name.Equals(expectedSoil.Name)); + Assert.IsNotNull(actualSoil, string.Format("Soil {0} not found", expectedSoil.Name)); + var compare = new CompareLogic {Config = {MaxDifferences = 100}}; + compare.Config.MembersToIgnore = SoilParametersToIgnore; + var result = compare.Compare(expectedSoil, actualSoil); + Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilModel"); + } } private void CompareStabilityModel(FailureMechanismParametersMStab expectedStabilityModel, FailureMechanismParametersMStab actualStabilityModel) @@ -266,6 +304,5 @@ { return FactoryForDamProjectData.CreateExampleDamProjectData(); } - } -} +} \ No newline at end of file