Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/FileIdentificationDefinition.xsd =================================================================== diff -u --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/FileIdentificationDefinition.xsd (revision 0) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/FileIdentificationDefinition.xsd (revision 927) @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/DamMStabInputDefinition.xsd =================================================================== diff -u --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/DamMStabInputDefinition.xsd (revision 0) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/DamMStabInputDefinition.xsd (revision 927) @@ -0,0 +1,249 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityInwards/DamMacroStabilityInwardsKernelWrapperTests.cs =================================================================== diff -u -r926 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityInwards/DamMacroStabilityInwardsKernelWrapperTests.cs (.../DamMacroStabilityInwardsKernelWrapperTests.cs) (revision 926) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityInwards/DamMacroStabilityInwardsKernelWrapperTests.cs (.../DamMacroStabilityInwardsKernelWrapperTests.cs) (revision 927) @@ -77,11 +77,11 @@ subSoilScenario.SoilProfileType = SoilProfileType.ProfileTypeStiFile; subSoilScenario.SegmentFailureMechanismType = FailureMechanismSystemType.StabilityInside; - var failureMechanismeParamatersMStab = new FailureMechanismParametersMStab(); - failureMechanismeParamatersMStab.MStabParameters.GridPosition = MStabGridPosition.Right; - failureMechanismeParamatersMStab.MStabParameters.SearchMethod = MStabSearchMethod.GeneticAlgorithm; - failureMechanismeParamatersMStab.MStabParameters.CalculationOptions.MinimalCircleDepth = 1.0; - failureMechanismeParamatersMStab.MStabParameters.Model = MStabModelType.Bishop; + var FailureMechanismParametersMStab = new FailureMechanismParametersMStab(); + FailureMechanismParametersMStab.MStabParameters.GridPosition = MStabGridPosition.Right; + FailureMechanismParametersMStab.MStabParameters.SearchMethod = MStabSearchMethod.GeneticAlgorithm; + FailureMechanismParametersMStab.MStabParameters.CalculationOptions.MinimalCircleDepth = 1.0; + FailureMechanismParametersMStab.MStabParameters.Model = MStabModelType.Bishop; var damKernelInput = new DamKernelInput(); damKernelInput.Location = location; @@ -90,7 +90,7 @@ damKernelInput.WorkingDir = workingDir; var kernelWrapper = new DamMacroStabilityInwardsKernelWrapper(); - kernelWrapper.FailureMechanismParametersMStab = failureMechanismeParamatersMStab; + kernelWrapper.FailureMechanismParametersMStab = FailureMechanismParametersMStab; // Prepare the wrapper. Result is input for the calculation dll IKernelDataInput damStabilityInput; @@ -115,7 +115,7 @@ Assert.AreEqual(1.5570, results[0].StabilityDesignResults.SafetyFactor, diff); } - public XDocument ModifiedXmlDocument(string stiFileName) + private XDocument ModifiedXmlDocument(string stiFileName) { var xmlFileName = Path.Combine(TestFolder, "test.xml"); var geometryFileName = Path.Combine(TestFolder, "DWP_1.sti"); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/MStabXmlDocTests.cs =================================================================== diff -u -r926 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/MStabXmlDocTests.cs (.../MStabXmlDocTests.cs) (revision 926) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/MStabXmlDocTests.cs (.../MStabXmlDocTests.cs) (revision 927) @@ -73,14 +73,14 @@ subSoilScenario.SoilProfileType = SoilProfileType.ProfileTypeStiFile; subSoilScenario.SegmentFailureMechanismType = FailureMechanismSystemType.StabilityInside; - var failureMechanismeParamatersMStab = new FailureMechanismParametersMStab(); - failureMechanismeParamatersMStab.MStabParameters.GridPosition = MStabGridPosition.Right; - failureMechanismeParamatersMStab.MStabParameters.SearchMethod = MStabSearchMethod.GeneticAlgorithm; + var FailureMechanismParametersMStab = new FailureMechanismParametersMStab(); + FailureMechanismParametersMStab.MStabParameters.GridPosition = MStabGridPosition.Right; + FailureMechanismParametersMStab.MStabParameters.SearchMethod = MStabSearchMethod.GeneticAlgorithm; MStabDesignEmbankment mStabDesignEmbankment = null; XDocument mstabXml = MStabXmlDoc.CreateMStabXmlDoc(stabilityProjectFilename, scenario, subSoilScenario, - mStabDesignEmbankment, requiredSafetyFactor, failureMechanismeParamatersMStab, + mStabDesignEmbankment, requiredSafetyFactor, FailureMechanismParametersMStab, out errorMessages); mstabXml.Save(xmlFileName); @@ -95,7 +95,7 @@ Assert.AreEqual(expectedText, testedText); } - public XDocument ModifiedXmlDocument(string xmlFileName) + private XDocument ModifiedXmlDocument(string xmlFileName) { XDocument xDocument = XDocument.Load(xmlFileName); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj =================================================================== diff -u -r915 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj (.../Deltares.DamEngine.Calculators.csproj) (revision 915) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/Deltares.DamEngine.Calculators.csproj (.../Deltares.DamEngine.Calculators.csproj) (revision 927) @@ -170,6 +170,15 @@ Designer + + Designer + + + Designer + + + Designer + Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs =================================================================== diff -u -r877 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs (.../PLLinesCreator.cs) (revision 877) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs (.../PLLinesCreator.cs) (revision 927) @@ -445,13 +445,7 @@ throw new PLLinesCreatorException("Damping factor < 0.0"); } - // ToDo bka #zant: Is this change correct? actualSoilProfile is null for ProfileTypeStiFile - SoilLayer1D relevantAquiferLayer = null; - if (actualSoilProfile != null) - { - relevantAquiferLayer = GetRelevantAquiferLayer(plLineType, actualSoilProfile); - } - + var relevantAquiferLayer = GetRelevantAquiferLayer(plLineType, actualSoilProfile); if (relevantAquiferLayer != null) { double referenceLevel = (this.HeadInPLLine2 != null) ? this.HeadInPLLine2.Value : this.waterLevelPolder; @@ -528,7 +522,7 @@ string message = "Soil profile (" + actualSoilProfile.Name + ") contains no aquifer layers at all."; throw new PLLinesCreatorException(message); } - SoilLayer1D relevantAquiferLayer = null; + SoilLayer1D relevantAquiferLayer; switch (type) { case PLLineType.PL3: Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Assemblers/DamMStabAssembler.cs =================================================================== diff -u -r877 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Assemblers/DamMStabAssembler.cs (.../DamMStabAssembler.cs) (revision 877) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Assemblers/DamMStabAssembler.cs (.../DamMStabAssembler.cs) (revision 927) @@ -44,7 +44,7 @@ /// /// Holds the common part of the path to the embedded resource /// - private const string EmbeddedResourcePath = "Deltares.Dam.Data.Xsd"; + private const string EmbeddedResourcePath = "Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStabilityCommon.Xsd"; public const string XmlAttributeBottomLevel = "BottomLevel"; public const string XmlAttributeBoundaryLayer = "BoundaryLayer"; @@ -291,6 +291,22 @@ inputElement.Add(designElement); } + // Profile + SoilProfile1D profile = failureMechanismParametersMStab.SoilProfile; + if (profile != null) + { + var soilProfileAssembler = new SoilProfileAssembler(); + XNamespace tnsa = soilProfileAssembler.ElementNamespace; + doc.Root.Add(new XAttribute(XNamespace.Xmlns + "tnsa", tnsa.NamespaceName)); + + + //TODO: Remove duplicate code. The method GetProfileElement should call the SoilProfileAssembler already defined in another namespace + XElement profileElement = GetProfileElement(profile, tns, tnsa); + // XElement profileElement = soilProfileAssembler.CreateDataTransferObject(profile); //GetProfileElement(profile, tns, tnsa); + // profileElement.Name = tns.GetName(profileElement.Name.LocalName);// .SetNamespace(DamMStabAssembler.XmlElementProfile, tns.NamespaceName); + doc.Root.Add(profileElement); + } + return doc; } @@ -640,9 +656,9 @@ // DAMMStabDefinition XmlSchemaSet schemas = new XmlSchemaSet(); - Stream xsdStream = DamMacroStabilityCommon.Assemblers.Common.GetEmbeddedFile(Assembly.GetExecutingAssembly(), XsdEmbeddedResourcePath); + Stream xsdStream = Common.GetEmbeddedFile(Assembly.GetExecutingAssembly(), XsdEmbeddedResourcePath); schemas.Add(XmlElementNamespace, XmlReader.Create(xsdStream)); - xsdStream = DamMacroStabilityCommon.Assemblers.Common.GetEmbeddedFile(Assembly.GetExecutingAssembly(), XsdEmbeddedResourcePathInput); + xsdStream = Common.GetEmbeddedFile(Assembly.GetExecutingAssembly(), XsdEmbeddedResourcePathInput); schemas.Add(XmlElementNamespaceInput, XmlReader.Create(xsdStream)); Assembly assembly; @@ -660,18 +676,30 @@ (from string name in assembly.GetManifestResourceNames() where name.EndsWith(schemaFileName) select name).Single(); - xsdStream = DamMacroStabilityCommon.Assemblers.Common.GetEmbeddedFile(assembly, resourceName); + xsdStream = Common.GetEmbeddedFile(assembly, resourceName); schemas.Add(fileIdentificationAssembler.ElementNamespace, XmlReader.Create(xsdStream)); } + // ProfileDefinition + var soilProfileAssembler = + new SoilProfileAssembler(); + assembly = soilProfileAssembler.GetType().Assembly; + schemaName = Path.GetFileName(soilProfileAssembler.ElementNamespace); + resourceName = + (from string name in assembly.GetManifestResourceNames() + where name.EndsWith(schemaName + ".xsd") + select name).Single(); + xsdStream = Common.GetEmbeddedFile(assembly, resourceName); + schemas.Add(soilProfileAssembler.ElementNamespace, XmlReader.Create(xsdStream)); doc.Validate(schemas, (o, e) => - { - result = false; - errorMessage = e.Message; - }, true); + { + result = false; + errorMessage = e.Message; + }, true); message = errorMessage; + return result; } Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/MStabXmlDoc.cs =================================================================== diff -u -r916 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/MStabXmlDoc.cs (.../MStabXmlDoc.cs) (revision 916) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/MStabXmlDoc.cs (.../MStabXmlDoc.cs) (revision 927) @@ -194,7 +194,7 @@ if (failureMechanismParametersMStab.MStabParameters.Model == MStabModelType.UpliftVan) { // Determine right side of slip plane grid (right grid) - // This is the location with the lowest uplift factor or, if present, the second NWO point + // This is the location with the lowest uplift factor var upliftLocationAndResult = CalculationHelper.GetLocationWithLowestUpliftFactor(currentSurfaceLine, subSoilScenario.SoilProfile1D, soilGeometry2DName, failureMechanismParametersMStab.PLLines, scenario.Location); @@ -222,7 +222,7 @@ return mstabXML; } - public static MStabForbiddenZone CreateForbiddenZone(DesignScenario scenario, SurfaceLine2 surfaceLine) + private static MStabForbiddenZone CreateForbiddenZone(DesignScenario scenario, SurfaceLine2 surfaceLine) { var dikeTopAtPolder = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder); // Zonestype is ForbiddenZone; TODO: Combine with code in StabilityCalculator? @@ -242,13 +242,7 @@ }; } - /// - /// - /// - /// - /// - /// - public static void ConsistencyCheck(DesignScenario scenario, SoilProfile1D soilProfile, string soilGeometry2DName) + private static void ConsistencyCheck(DesignScenario scenario, SoilProfile1D soilProfile, string soilGeometry2DName) { if (soilProfile != null) { Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj =================================================================== diff -u -r925 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj (.../Deltares.DamEngine.Calculators.Tests.csproj) (revision 925) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/Deltares.DamEngine.Calculators.Tests.csproj (.../Deltares.DamEngine.Calculators.Tests.csproj) (revision 927) @@ -48,6 +48,7 @@ + Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/DamMStabDocDefinition.xsd =================================================================== diff -u --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/DamMStabDocDefinition.xsd (revision 0) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStabilityCommon/Xsd/DamMStabDocDefinition.xsd (revision 927) @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityOutwards/DamMacroStabilityOutwardsKernelWrapperTests.cs =================================================================== diff -u -r926 -r927 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityOutwards/DamMacroStabilityOutwardsKernelWrapperTests.cs (.../DamMacroStabilityOutwardsKernelWrapperTests.cs) (revision 926) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityOutwards/DamMacroStabilityOutwardsKernelWrapperTests.cs (.../DamMacroStabilityOutwardsKernelWrapperTests.cs) (revision 927) @@ -62,7 +62,7 @@ var damKernelInput = CreateDamKernelInput(); - var failureMechanismeParamatersMStab = new FailureMechanismParametersMStab + var FailureMechanismParametersMStab = new FailureMechanismParametersMStab { MStabParameters = { @@ -78,7 +78,7 @@ var kernelWrapper = new DamMacroStabilityOutwardsKernelWrapper { - FailureMechanismParametersMStab = failureMechanismeParamatersMStab + FailureMechanismParametersMStab = FailureMechanismParametersMStab }; // Prepare the wrapper. Result is input for the calculation dll @@ -125,7 +125,7 @@ damKernelInput.DesignScenario.Location.DikeEmbankmentMaterial = "Del_Ppp"; damKernelInput.DesignScenario.Location.ShoulderEmbankmentMaterial = "Del_Ppp"; damKernelInput.DesignScenario.Location.StabilityOptions.MinimalCircleDepth = 1.0; - var failureMechanismeParamatersMStab = new FailureMechanismParametersMStab + var FailureMechanismParametersMStab = new FailureMechanismParametersMStab { MStabParameters = { @@ -144,7 +144,7 @@ var kernelWrapper = new DamMacroStabilityOutwardsKernelWrapper { - FailureMechanismParametersMStab = failureMechanismeParamatersMStab + FailureMechanismParametersMStab = FailureMechanismParametersMStab }; // Prepare the wrapper. Result is input for the calculation dll @@ -430,7 +430,7 @@ SegmentFailureMechanismType = FailureMechanismSystemType.StabilityOutside }; - var failureMechanismeParamatersMStab = new FailureMechanismParametersMStab + var FailureMechanismParametersMStab = new FailureMechanismParametersMStab { MStabParameters = { @@ -453,7 +453,7 @@ var kernelWrapper = new DamMacroStabilityOutwardsKernelWrapper { - FailureMechanismParametersMStab = failureMechanismeParamatersMStab + FailureMechanismParametersMStab = FailureMechanismParametersMStab }; // Prepare the wrapper. Result is input for the calculation dll Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/DamMStabAssemblerTest.cs =================================================================== diff -u --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/DamMStabAssemblerTest.cs (revision 0) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/DamMacroStabilityCommon/DamMStabAssemblerTest.cs (revision 927) @@ -0,0 +1,935 @@ +// Copyright (C) Stichting Deltares 2018. All rights reserved. +// +// This file is part of the Dam Engine. +// +// The Dam Engine is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Xml.Linq; +using Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStabilityCommon.Assemblers; +using Deltares.DamEngine.Calculators.PlLinesCreator; +using Deltares.DamEngine.Data.General; +using Deltares.DamEngine.Data.General.PlLines; +using Deltares.DamEngine.Data.Geometry; +using Deltares.DamEngine.Data.Geotechnics; +using NUnit.Framework; + +namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.DamMacroStabilityCommon +{ + [TestFixture] + public class DamMStabAssemblerTest + { + #region Setup/Teardown + + [SetUp] + public void TestSetup() + { + assembler = new DamMStabAssembler(); + + // Dike + dike = new Dike(); + dike.Name = "Dike"; + + // Segments + segment1 = new Segment(); + segment1.Name = "Segment1"; + + // Locations + location1 = new Location(); + location1.Name = "Location1"; + location1.Segment = segment1; + dike.Locations.Add(location1); + + // Surface lines + surfaceLine1 = new SurfaceLine2 + { + Name = "SurfaceLine1", + CharacteristicPoints = { GeometryMustContainPoint = true }, + Geometry = new GeometryPointString() + }; + dike.SurfaceLines2.Add(surfaceLine1); + surfaceLine2 = new SurfaceLine2 + { + Name = "SurfaceLine2", + CharacteristicPoints = { GeometryMustContainPoint = true }, + Geometry = new GeometryPointString() + }; + dike.SurfaceLines2.Add(surfaceLine2); + + // Soil profiles + soilProfile1 = new SoilProfile1D(); + soilProfile1.Name = "SoilProfile1"; + soilProfile1.BottomLevel = -25.3; + Soil soilClay = new Soil("Clay", 20.0, 20.0); + Soil soilPeat = new Soil("Peat", 20.0, 20.0); + Soil soilSand = new Soil("Sand", 20.0, 20.0); + SoilLayer1D layer = new SoilLayer1D(); + layer.Name = "L1"; + layer.TopLevel = -1.52; + layer.Soil = soilClay; + layer.IsAquifer = false; + soilProfile1.Layers.Add(layer); + layer = new SoilLayer1D(); + layer.Name = "L2"; + layer.TopLevel = -3.18; + layer.Soil = soilPeat; + layer.IsAquifer = false; + soilProfile1.Layers.Add(layer); + layer = new SoilLayer1D(); + layer.Name = "L3"; + layer.TopLevel = -7.37; + layer.Soil = soilSand; + layer.IsAquifer = true; + soilProfile1.Layers.Add(layer); + layer = new SoilLayer1D(); + layer.Name = "L4"; + layer.TopLevel = -12.28; + layer.Soil = soilPeat; + layer.IsAquifer = false; + soilProfile1.Layers.Add(layer); + layer = new SoilLayer1D(); + layer.Name = "L5"; + layer.TopLevel = -15.62; + layer.Soil = soilClay; + layer.IsAquifer = false; + soilProfile1.Layers.Add(layer); + layer = new SoilLayer1D(); + layer.Name = "L6"; + layer.TopLevel = -18.39; + layer.Soil = soilSand; + layer.IsAquifer = true; + soilProfile1.Layers.Add(layer); + dike.SoilProfiles.Add(soilProfile1); + + // Locations' Segments + location1.Segment = segment1; + + // Locations' surface lines + location1.SurfaceLine = surfaceLine1; + + // Segments' Soil profile probabilities +// segment1.AddSoilProfileProbability(soilProfile1, 100.0, FailureMechanismSystemType.StabilityInside); + + // Surface lines' points + surfaceLine1.EnsurePointOfType(15.3, -3.52, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine1.EnsurePointOfType(19.4, -1.46, CharacteristicPointType.DikeToeAtRiver); + surfaceLine1.EnsurePointOfType(27.4, 8.56, CharacteristicPointType.DikeTopAtRiver); + surfaceLine1.EnsurePointOfType(35.2, 8.62, CharacteristicPointType.DikeTopAtPolder); + surfaceLine1.EnsurePointOfType(41.5, -3.76, CharacteristicPointType.DikeToeAtPolder); + surfaceLine1.EnsurePointOfType(85.4, -3.61, CharacteristicPointType.SurfaceLevelInside); + + surfaceLine2.EnsurePointOfType(0.0, -1.46, CharacteristicPointType.SurfaceLevelOutside); + surfaceLine2.EnsurePointOfType(19.4, -1.46, CharacteristicPointType.DikeToeAtRiver); + surfaceLine2.EnsurePointOfType(27.4, 8.56, CharacteristicPointType.DikeTopAtRiver); + surfaceLine2.EnsurePointOfType(35.2, 8.62, CharacteristicPointType.DikeTopAtPolder); + surfaceLine2.EnsurePointOfType(41.5, -3.76, CharacteristicPointType.DikeToeAtPolder); + surfaceLine2.EnsurePoint(46.7, -3.82); + surfaceLine2.EnsurePoint(47.5, -4.78); + surfaceLine2.EnsurePoint(51.2, -4.82); + surfaceLine2.EnsurePoint(53.1, -3.78); + surfaceLine2.EnsurePointOfType(85.4, -3.61, CharacteristicPointType.SurfaceLevelInside); + + // PL Lines + peelLines = new PLLines(); + peelLine1 = new PLLine(); + peelLine1.Name = "PLLine1"; + peelLine1.IsPhreatic = false; + peelLine1.BoundaryLayer = 2; + peelLine1.Points.Add(new PLLinePoint(35.2, -7.56)); + peelLine1.Points.Add(new PLLinePoint(42.5, -6.12)); + peelLine1.Points.Add(new PLLinePoint(45.3, -8.73)); + peelLines.Lines[PLLineType.PL1] = peelLine1; + peelLine2 = new PLLine(); + peelLine2.Name = "PLLine2"; + peelLine2.IsPhreatic = true; + peelLine2.BoundaryLayer = 5; + peelLine2.Points.Add(new PLLinePoint(16.2, 3.23)); + peelLine2.Points.Add(new PLLinePoint(18.4, 1.19)); + peelLine2.Points.Add(new PLLinePoint(21.8, -0.45)); + peelLine2.Points.Add(new PLLinePoint(22.5, -1.73)); + peelLines.Lines[PLLineType.PL1] = peelLine2; + + // Calculation options + calculationOptions = new MStabCalculationOptions(); + calculationOptions.MinimalCircleDepth = 1.1; + + // Zone areas + zoneAreas = new MStabZoneAreas(); + zoneAreas.DikeTableHeight = 12.0; + zoneAreas.DikeTableWidth = 1.5; + zoneAreas.XCoordinateDikeTopAtRiver = 10.0; + zoneAreas.XCoordinateDikeTopAtPolder = 18.0; + zoneAreas.XCoordinateStartRestProfile = 20.0; + zoneAreas.SafetyFactorZone1A = 1.2; + zoneAreas.SafetyFactorZone1B = 1.3; + + // Geometry creation options + geometryCreationOptions = new MStabGeometryCreationOptions(); + geometryCreationOptions.SoilProfileType = SoilProfileType.ProfileType2D; + geometryCreationOptions.SoilGeometry2DFilename = "geometry2D filename"; + geometryCreationOptions.XOffsetSoilGeometry2DOrigin = 12.0; + geometryCreationOptions.MaterialForDike = "clay dike"; + geometryCreationOptions.MaterialForShoulder = "sand shoulder"; + geometryCreationOptions.IsUseOriginalPLLineAssignments = true; + geometryCreationOptions.IsUseOriginalCalculationOptions = true; + geometryCreationOptions.IsDrySituation = true; + geometryCreationOptions.IsDesign = true; + + // MStabDesignEmbankment design + design = new MStabDesignEmbankment(); + design.EmbankmentMaterialname = "soiltest"; + design.PreviousGeometry2DFilename = "soilname/Path/testFileNameWithPLLines.sti"; + + // Sheetpiling + sheetPiling = new SheetPiling(); + sheetPiling.XCoordinate = 11.11; + sheetPiling.YCoordinate = 22.22; + sheetPiling.ZCoordinate = 33.33; + sheetPiling.Length = 20.0; + + // Horizontal Balance Area + horizontalBalanceArea = new HorizontalBalanceArea(); + horizontalBalanceArea.XLeft = 13.11; + horizontalBalanceArea.XRight = 14.11; + horizontalBalanceArea.YTop = 15.11; + horizontalBalanceArea.YBottom = 16.11; + horizontalBalanceArea.PlaneCount = 17; + + // Slip Circle Definition + slipCircleDefinition = new SlipCircleDefinition(); + slipCircleDefinition.XCoordinateLastUpliftPoint = 18.11; + slipCircleDefinition.UpliftVanTangentLinesDefinition = TangentLinesDefinition.Specified; + slipCircleDefinition.GridSizeDetermination = GridSizeDetermination.Specified; + slipCircleDefinition.UpliftVanLeftGridVerticalPointCount = 19; + slipCircleDefinition.UpliftVanLeftGridVerticalPointDistance = 20.11; + slipCircleDefinition.UpliftVanLeftGridHorizontalPointCount = 21; + slipCircleDefinition.UpliftVanLeftGridHorizontalPointDistance = 22.11; + slipCircleDefinition.UpliftVanRightGridVerticalPointCount = 23; + slipCircleDefinition.UpliftVanRightGridVerticalPointDistance = 24.11; + slipCircleDefinition.UpliftVanRightGridHorizontalPointCount = 25; + slipCircleDefinition.UpliftVanRightGridHorizontalPointDistance = 26.11; + slipCircleDefinition.BishopGridVerticalPointCount = 27; + slipCircleDefinition.BishopGridVerticalPointDistance = 28.11; + slipCircleDefinition.BishopGridHorizontalPointCount = 29; + slipCircleDefinition.BishopGridHorizontalPointDistance = 30.11; + + // DAMMStab (class containing all) + damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification + { + FailureMechanismParametersMStab = new FailureMechanismParametersMStab() + { + Location = location1, + SurfaceLine = location1.SurfaceLine, + PLLines = peelLines, + SoilProfile = soilProfile1, + Design = design, + MStabParameters = new MStabParameters() + { + SoilDatabaseName = @"X:\GeoData\Soils\TestDatabase.mdb", + Model = MStabModelType.UpliftVan, + ShearStrength = MStabShearStrength.CPhi, + ProjectFileName = @"X:\MStab\Demo.sti", + ZoneAreas = zoneAreas, + GeometryCreationOptions = geometryCreationOptions, + SheetPiling = sheetPiling, + HorizontalBalanceArea = horizontalBalanceArea, + SlipCircleDefinition = slipCircleDefinition, + CalculationOptions = calculationOptions + + } + } + }; + } + + [TearDown] + public void TearDown() + { + } + + #endregion + + private const string TestDirectory = "TestResults"; + private const string TestFileName = "DikeMStabAssemblerTest.xml"; + private const string TestFileNameWithPlLines = "DikeMStabAssemblerTestWithPLLines.xml"; + + private const double Precision = 1e-8; + + private DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification; + private DamMStabAssembler assembler; + + private Dike dike; + private Segment segment1; + private Location location1; + private SurfaceLine2 surfaceLine1; + private SurfaceLine2 surfaceLine2; + private SoilProfile1D soilProfile1; + + private PLLines peelLines; + private PLLine peelLine1; + private PLLine peelLine2; + + private MStabZoneAreas zoneAreas; + private MStabCalculationOptions calculationOptions; + private MStabGeometryCreationOptions geometryCreationOptions; + private SheetPiling sheetPiling; + private HorizontalBalanceArea horizontalBalanceArea; + private MStabDesignEmbankment design; + private SlipCircleDefinition slipCircleDefinition; + + [TestFixtureSetUp] + public void TestFixtureSetup() + { + } + + [Test] + public void CanCreateAndValidateMStabInputXML() + { + // Do the thing: create XML element from SoilProfile + geometryCreationOptions.IntrusionVerticalWaterPressureType = IntrusionVerticalWaterPressureType.HydroStatic; + geometryCreationOptions.PenetrationLength = 1.4; + XDocument doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + + Directory.CreateDirectory(TestDirectory); + doc.Save(Path.Combine(TestDirectory, TestFileName)); + + // Validate against schema + string message; + if (!assembler.ValidateSchema(doc, out message)) + { + Assert.Fail("SCHEMA VALIDATION: " + message); + } + + // Compare resulting XML to original object + + // Input + XElement inputElement = (from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementNameInput + select element).Single(); + + // Database + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ProjectFileName, inputElement.AttributeAs(DamMStabAssembler.XmlAttributeMStabFileName), "SoilDB Name"); + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SoilDatabaseName, inputElement.AttributeAs(DamMStabAssembler.XmlAttributeSoilDBName), "SoilDB Name"); + + // Surface lines + XElement surfaceLineElement = (from element in inputElement.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementSurfaceLine + select element).Single(); + + // Surface points + IEnumerable surfacePointElements = from element in surfaceLineElement.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementSurfacePoint + select element; + + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Count, surfacePointElements.Count(), "Number of surface line points"); + + IEnumerator surfacePointElementEnumerator = surfacePointElements.GetEnumerator(); + foreach (GeometryPoint point in damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Points) + { + surfacePointElementEnumerator.MoveNext(); + XElement surfaceLinePointElement = surfacePointElementEnumerator.Current; + Assert.AreEqual(point.X, surfaceLinePointElement.AttributeAs(DamMStabAssembler.XmlAttributeXCoord), Precision, String.Format("X of GeometryPoint #{0}", + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Points.IndexOf(point))); + Assert.AreEqual(point.Z, surfaceLinePointElement.AttributeAs(DamMStabAssembler.XmlAttributeYCoord), Precision, String.Format("Z of GeometryPoint #{0}", + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Points.IndexOf(point))); + } + + // External PL lines + IEnumerable externalPLLineCollectionElements = from element in inputElement.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementExternalPLLines + select element; + + Assert.AreEqual(1, externalPLLineCollectionElements.Count(), String.Format("There should be exactly one {0} tag", DamMStabAssembler.XmlElementExternalPLLines)); + + XElement externalPLLineCollectionElement = externalPLLineCollectionElements.Single(); + + IEnumerable peelLineCollectionElements = from element in externalPLLineCollectionElement.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementPLLine + select element; + + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.PLLines.PLLineCount, peelLineCollectionElements.Count(), "Number of PL lines"); + IEnumerator peelLineElementEnumerator = peelLineCollectionElements.GetEnumerator(); + foreach (PLLineType plLineType in Enum.GetValues(typeof(PLLineType))) + { + PLLine line = damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.PLLines.Lines[plLineType]; + peelLineElementEnumerator.MoveNext(); + XElement peelLineElement = peelLineElementEnumerator.Current; + + Assert.AreEqual(line.IsPhreatic, peelLineElement.AttributeAs(DamMStabAssembler.XmlAttributeIsPhreatic), String.Format("{0}", DamMStabAssembler.XmlAttributeIsPhreatic)); + Assert.AreEqual(line.BoundaryLayer, peelLineElement.AttributeAs(DamMStabAssembler.XmlAttributeBoundaryLayer), String.Format("{0}", DamMStabAssembler.XmlAttributeBoundaryLayer)); + + IEnumerable peelPointCollectionElements = from element in peelLineElement.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementPLPoint + select element; + Assert.AreEqual(line.Points.Count, peelPointCollectionElements.Count(), "Number of PL line Points"); + IEnumerator peelPointElementEnumerator = peelPointCollectionElements.GetEnumerator(); + foreach (PLLinePoint point in line.Points) + { + peelPointElementEnumerator.MoveNext(); + XElement peelPointElement = peelPointElementEnumerator.Current; + Assert.AreEqual(point.X, peelPointElement.AttributeAs(DamMStabAssembler.XmlAttributeXCoord), Precision, String.Format("X of GeometryPoint #{0}", line.Points.IndexOf(point))); + Assert.AreEqual(point.Z, peelPointElement.AttributeAs(DamMStabAssembler.XmlAttributeYCoord), Precision, String.Format("Z of GeometryPoint #{0}", line.Points.IndexOf(point))); + } + } + + // Model + XElement modelElement = (from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementModel + select element).Single(); + Assert.AreEqual(MStabModelType.UpliftVan.ToString(), modelElement.AttributeAs(DamMStabAssembler.XmlAttributeCalculationModel), DamMStabAssembler.XmlAttributeCalculationModel); + Assert.AreEqual(MStabShearStrength.CPhi.ToString(), modelElement.AttributeAs(DamMStabAssembler.XmlAttributeShearStrength), DamMStabAssembler.XmlAttributeShearStrength); + Assert.AreEqual(false, modelElement.AttributeAs(DamMStabAssembler.XmlAttributeProbabilistic), DamMStabAssembler.XmlAttributeProbabilistic); + + // Zone Areas + XElement zoneAreasElement = (from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementZoneAreas + select element).Single(); + Assert.AreEqual(zoneAreas.DikeTableHeight, zoneAreasElement.AttributeAs("DikeTableHeight"), "DikeTableHeight"); + Assert.AreEqual(zoneAreas.DikeTableWidth, zoneAreasElement.AttributeAs("DikeTableWidth"), "DikeTableWidth"); + Assert.AreEqual(zoneAreas.XCoordinateDikeTopAtRiver, zoneAreasElement.AttributeAs("XCoordinateDikeTopAtRiver"), "XCoordinateDikeTopAtRiver"); + Assert.AreEqual(zoneAreas.XCoordinateDikeTopAtPolder, zoneAreasElement.AttributeAs("XCoordinateDikeTopAtPolder"), "XCoordinateDikeTopAtPolder"); + Assert.AreEqual(zoneAreas.XCoordinateStartRestProfile, zoneAreasElement.AttributeAs("XCoordinateStartRestProfile"), "XCoordinateStartRestProfile"); + Assert.AreEqual(zoneAreas.SafetyFactorZone1A, zoneAreasElement.AttributeAs("SafetyFactorZone1A"), "SafetyFactorZone1A"); + Assert.AreEqual(zoneAreas.SafetyFactorZone1B, zoneAreasElement.AttributeAs("SafetyFactorZone1B"), "SafetyFactorZone1B"); + + // Calculation options + XElement calculationOptionsElement = (from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementCalculationOptions + select element).Single(); + Assert.AreEqual(calculationOptions.MinimalCircleDepth, calculationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeMinimalCircleDepth), DamMStabAssembler.XmlAttributeMinimalCircleDepth); + + // GeometryCreationOptions + XElement geometryCreationOptionsElement = (from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementGeometryCreationOptions + select element).Single(); + Assert.AreEqual("SoilGeometry2D", geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeSoilGeometryType), DamMStabAssembler.XmlAttributeSoilGeometryType); + Assert.AreEqual(geometryCreationOptions.SoilGeometry2DFilename, + geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeSoilGeometry2DFilename), DamMStabAssembler.XmlAttributeSoilGeometry2DFilename); + Assert.AreEqual(geometryCreationOptions.MaterialForDike, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeMaterialForDike), DamMStabAssembler.XmlAttributeMaterialForDike); + Assert.AreEqual(geometryCreationOptions.MaterialForShoulder, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeMaterialForShoulder), DamMStabAssembler.XmlAttributeMaterialForShoulder); + Assert.AreEqual(geometryCreationOptions.IsUseOriginalPLLineAssignments, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments), DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments); + Assert.AreEqual(geometryCreationOptions.IsUseOriginalCalculationOptions, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions), DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions); + Assert.AreEqual(geometryCreationOptions.IsDrySituation, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeIsDrySituation), DamMStabAssembler.XmlAttributeIsDrySituation); + Assert.AreEqual(geometryCreationOptions.IsDesign, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeIsDesign), DamMStabAssembler.XmlAttributeIsDesign); + Assert.AreEqual(geometryCreationOptions.PLLineAssignment, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributePLLineAssignment), DamMStabAssembler.XmlAttributePLLineAssignment); + Assert.AreEqual(geometryCreationOptions.IntrusionVerticalWaterPressureType, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributeIntrusionVerticalWaterPressure), DamMStabAssembler.XmlAttributeIntrusionVerticalWaterPressure); + Assert.AreEqual(geometryCreationOptions.PenetrationLength, geometryCreationOptionsElement.AttributeAs(DamMStabAssembler.XmlAttributePenetrationLength), DamMStabAssembler.XmlAttributePenetrationLength); + + XElement designElement = (from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementDesign + select element).Single(); + + Assert.AreEqual(design.EmbankmentMaterialname.ToString(), + designElement.AttributeAs(DamMStabAssembler.XmlAttributeEmbankmentMaterialName), + DamMStabAssembler.XmlAttributeEmbankmentMaterialName); + Assert.AreEqual(design.PreviousGeometry2DFilename.ToString(), + designElement.AttributeAs( + DamMStabAssembler.XmlAttributePreviousGeometry2DFilename), + DamMStabAssembler.XmlAttributePreviousGeometry2DFilename); + + + // Profile + IEnumerable soilProfileCollectionElements = from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementProfile + select element; + + Assert.AreEqual(1, soilProfileCollectionElements.Count(), "Number of profiles"); + + XElement soilProfileElement = soilProfileCollectionElements.Single(); + + Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeName), String.Format("{0}", DamMStabAssembler.XmlAttributeName)); + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Name, soilProfileElement.AttributeAs(DamMStabAssembler.XmlAttributeName), String.Format("{0}", DamMStabAssembler.XmlAttributeName)); + Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomLevel), String.Format("{0}", DamMStabAssembler.XmlAttributeBottomLevel)); + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.BottomLevel, soilProfileElement.AttributeAs(DamMStabAssembler.XmlAttributeBottomLevel), Precision, String.Format("{0}", DamMStabAssembler.XmlAttributeBottomLevel)); + // Created no PL line so characteristic layers are unassigned + Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomSandLayerID), DamMStabAssembler.XmlAttributeBottomSandLayerID); + Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInBetweenSandLayerID), DamMStabAssembler.XmlAttributeInBetweenSandLayerID); + Assert.IsNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInfiltrationLayerID), DamMStabAssembler.XmlAttributeInfiltrationLayerID); + + // Profile layers + IEnumerable layersCollectionElements = from element in soilProfileElement.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementLayers + select element; + + Assert.AreEqual(1, layersCollectionElements.Count(), "profile layer collection tag"); + + IEnumerable layerCollectionElements = from element in layersCollectionElements.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementLayer + select element; + + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.Count, layerCollectionElements.Count(), "Number of profile layers"); + + IEnumerator layerElementEnumerator = layerCollectionElements.GetEnumerator(); + foreach (SoilLayer1D layer in damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers) + { + layerElementEnumerator.MoveNext(); + XElement layerElement = layerElementEnumerator.Current; + Assert.IsNotNull(layerElement.Attribute(DamMStabAssembler.XmlAttributeID), String.Format("{0}", String.Format("ID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer)))); + Assert.AreEqual(layer.Name, layerElement.AttributeAs(DamMStabAssembler.XmlAttributeID), String.Format("ID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer))); + Assert.IsNotNull(layerElement.Attribute(DamMStabAssembler.XmlAttributeSoilID), String.Format("{0}", String.Format("SoilID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer)))); + Assert.AreEqual(layer.Soil.Name, layerElement.AttributeAs(DamMStabAssembler.XmlAttributeSoilID), String.Format("SoilID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer))); + Assert.IsNotNull(layerElement.Attribute(DamMStabAssembler.XmlAttributeTopLevel), String.Format("{0}", String.Format("TopLevel of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer)))); + Assert.AreEqual(layer.TopLevel, layerElement.AttributeAs(DamMStabAssembler.XmlAttributeTopLevel), String.Format("TopLevel of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer))); + } + + } + + [Test] + public void CanCreateAndValidateMStabInputXMLWithPLLines() + { + // Create PL lines + var location = new Location {DamType = DamType.Regional}; + PLLinesCreator plLineCreator = new PLLinesCreator(); + plLineCreator.SoilProfile = soilProfile1; + plLineCreator.SurfaceLine = surfaceLine1; + plLineCreator.WaterLevelRiverHigh = 4.0; + plLineCreator.WaterLevelPolder = -4.5; + plLineCreator.ModelParametersForPLLines.DampingFactorPL3 = 0.3; + plLineCreator.ModelParametersForPLLines.DampingFactorPL4 = 0.4; + plLineCreator.ModelParametersForPLLines.PenetrationLength = 1.5; + plLineCreator.HeadInPLLine2 = 0.0; + plLineCreator.CreateAllPLLines(location); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + Directory.CreateDirectory(TestDirectory); + doc.Save(Path.Combine(TestDirectory, TestFileNameWithPlLines)); + string message; + if (!assembler.ValidateSchema(doc, out message)) + { + Assert.Fail("SCHEMA VALIDATION: " + message); + } + var soilProfileCollectionElements = from element in doc.Root.Descendants() + where element.Name.LocalName == DamMStabAssembler.XmlElementProfile + select element; + Assert.AreEqual(1, soilProfileCollectionElements.Count(), "Number of profiles"); + var soilProfileElement = soilProfileCollectionElements.Single(); + Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomSandLayerID), DamMStabAssembler.XmlAttributeBottomSandLayerID); + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.BottomAquiferLayer.Name, soilProfileElement.AttributeAs(DamMStabAssembler.XmlAttributeBottomSandLayerID), + DamMStabAssembler.XmlAttributeBottomSandLayerID); + Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInBetweenSandLayerID), DamMStabAssembler.XmlAttributeInBetweenSandLayerID); + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.InBetweenAquiferLayer.Name, soilProfileElement.AttributeAs(DamMStabAssembler.XmlAttributeInBetweenSandLayerID), + DamMStabAssembler.XmlAttributeInBetweenSandLayerID); + Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInfiltrationLayerID), DamMStabAssembler.XmlAttributeInfiltrationLayerID); + Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.InfiltrationLayer.Name, soilProfileElement.AttributeAs(DamMStabAssembler.XmlAttributeInfiltrationLayerID), + DamMStabAssembler.XmlAttributeInfiltrationLayerID); + } + + + /// + /// SearchMethod test + /// The default key value pair for the attribute: SearchMethod="Grid" + /// + [Test] + public void VerifyThatTheDefaultKeyValuePairSearchMethodIsWritten() + { + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementModel); + Assert.IsNotNull(modelElement); + + const string expectedValue = "Grid"; + Assert.AreEqual(expectedValue, modelElement.AttributeAs(DamMStabAssembler.XmlAttributeSearchMethod)); + } + + /// + /// SearchMethod test + /// The key value pair for the attribute should be: SearchMethod="GeneticAlgorithm" + /// + [Test] + public void VerifyThatTheAssemblerCorrectlyWritesTheSearchMethodAttributeValueWhenSetToGrid() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SearchMethod = MStabSearchMethod.Grid; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementModel); + Assert.IsNotNull(modelElement); + + const string expectedValue = "Grid"; + Assert.AreEqual(expectedValue, modelElement.AttributeAs(DamMStabAssembler.XmlAttributeSearchMethod)); + } + + /// + /// UseZones + /// + [Test] + public void VerifyThatTheAttributeZonesTypeIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.CalculationOptions.ZonesType = MStabZonesType.ZoneAreas; + + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCalculationOptions); + Assert.IsNotNull(element); + + Assert.AreEqual(MStabZonesType.ZoneAreas, element.AttributeAs(DamMStabAssembler.XmlAttributeZonesType)); + } + + /// + /// ZoneAreas + /// + [Test] + public void VerifyThatElementZoneAreasIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ZoneAreas = new MStabZoneAreas { }; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementZoneAreas); + Assert.IsNotNull(element); + + const int expectedValue = 1; + Assert.AreEqual(expectedValue, element.Attributes("DikeTableHeight").Count()); + Assert.AreEqual(expectedValue, element.Attributes("DikeTableWidth").Count()); + Assert.AreEqual(expectedValue, element.Attributes("XCoordinateDikeTopAtRiver").Count()); + Assert.AreEqual(expectedValue, element.Attributes("XCoordinateStartRestProfile").Count()); + Assert.AreEqual(7, element.Attributes().Count()); + } + + /// + /// ZoneAreas test + /// + [Test] + public void VerifyThatElementZoneAreasIsNotWrittenByDefault() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ZoneAreas = null; + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementZoneAreas); + Assert.IsNull(modelElement); + } + + /// + /// ZoneAreas + /// + [Test] + public void VerifyThatElementForbiddenZoneIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ForbiddenZone = new MStabForbiddenZone() { }; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementForbiddenZone); + Assert.IsNotNull(element); + + const int expectedValue = 1; + Assert.AreEqual(expectedValue, element.Attributes("IsXEntryMinUsed").Count()); + Assert.AreEqual(expectedValue, element.Attributes("IsXEntryMaxUsed").Count()); + Assert.AreEqual(expectedValue, element.Attributes("XEntryMin").Count()); + Assert.AreEqual(expectedValue, element.Attributes("XEntryMax").Count()); + Assert.AreEqual(4, element.Attributes().Count()); + } + + /// + /// ZoneAreas test + /// + [Test] + public void VerifyThatElementForbiddenZoneIsNotWrittenByDefault() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ZoneAreas = null; + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementForbiddenZone); + Assert.IsNull(modelElement); + } + + /// + /// Traffic Load + /// + [Test] + public void VerifyThatElementTrafficLoadIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + surfaceLine1.EnsurePointOfType(30.1, 8.56, CharacteristicPointType.TrafficLoadOutside); + surfaceLine1.EnsurePointOfType(31.2, 8.62, CharacteristicPointType.TrafficLoadInside); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementTrafficLoad); + Assert.IsNotNull(element); + + Assert.AreEqual(1, element.Attributes("XCoordinateAtRiver").Count()); + Assert.AreEqual(1, element.Attributes("XCoordinateAtPolder").Count()); + Assert.AreEqual(1, element.Attributes("Load").Count()); + } + + /// + /// Traffic load + /// + [Test] + public void VerifyThatElementTrafficLoadIsNotWrittenByDefault() + { + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var trafficLoadElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementTrafficLoad); + Assert.IsNull(trafficLoadElement); + } + + /// + /// Calculation options + /// + [Test] + public void VerifyThatElementCalculationOptionsIsWrittenWhenSet() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.CalculationOptions = new MStabCalculationOptions(); + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCalculationOptions); + Assert.IsNotNull(element); + Assert.AreEqual(1, element.Attributes("MinimalCircleDepth").Count()); + Assert.AreEqual(1, element.Attributes("ZonesType").Count()); + } + + /// + /// Calculation options + /// + [Test] + public void VerifyThatElementCalculationOptionsIsNotWrittenByDefault() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.CalculationOptions = null; + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var calculationOptionsElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCalculationOptions); + Assert.IsNull(calculationOptionsElement); + } + + /// + /// Geometry Creation Options + /// + [Test] + public void VerifyThatElementGeometryCreationOptionsIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions = geometryCreationOptions; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions); + Assert.IsNotNull(element); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeSoilGeometryType).Count()); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeXOffsetSoilGeometry2DOrigin).Count()); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeMaterialForDike).Count()); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeMaterialForShoulder).Count()); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments).Count()); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions).Count()); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsDrySituation).Count()); + Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsDesign).Count()); + } + + /// + /// Geometry Creation Options + /// + [Test] + public void VerifyThatElementGeometryCreationOptionsIsNotWrittenByDefault() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions = null; + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var geometryCreationOptionsElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions); + Assert.IsNull(geometryCreationOptionsElement); + } + + /// + /// IsUseOriginalPLLineAssignments test + /// The key value pair for the attribute should be: IsUseOriginalPLLineAssignments="true" + /// + [Test] + public void VerifyThatTheAssemblerCorrectlyWritesTheIsUseOriginalPLLineAssignmentsAttributeValueWhenSetToTrue() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsUseOriginalPLLineAssignments = true; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions); + Assert.IsNotNull(modelElement); + + const string expectedValue = "true"; + Assert.AreEqual(expectedValue, modelElement.AttributeAs(DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments)); + } + + /// + /// IsUseOriginalCalculationOptions test + /// The key value pair for the attribute should be: IsUseOriginalCalculationOptions="true" + /// + [Test] + public void VerifyThatTheAssemblerCorrectlyWritesTheIsUseOriginalCalculationOptionsAttributeValueWhenSetToTrue() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsUseOriginalCalculationOptions = true; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions); + Assert.IsNotNull(modelElement); + + const string expectedValue = "true"; + Assert.AreEqual(expectedValue, modelElement.AttributeAs(DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions)); + } + + /// + /// IsDrySituation test + /// The key value pair for the attribute should be: IsDrySituation="true" + /// + [Test] + public void VerifyThatTheAssemblerCorrectlyWritesTheIsDrySituationAttributeValueWhenSetToTrue() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsDrySituation = true; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions); + Assert.IsNotNull(modelElement); + + const string expectedValue = "true"; + Assert.AreEqual(expectedValue, modelElement.AttributeAs(DamMStabAssembler.XmlAttributeIsDrySituation)); + } + + /// + /// IsDesign test + /// The key value pair for the attribute should be: IsDesign="true" + /// + [Test] + public void VerifyThatTheAssemblerCorrectlyWritesTheIsDesignAttributeValueWhenSetToTrue() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsDesign = true; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions); + Assert.IsNotNull(modelElement); + + const string expectedValue = "true"; + Assert.AreEqual(expectedValue, modelElement.AttributeAs(DamMStabAssembler.XmlAttributeIsDesign)); + } + + + /// + /// Sheetpiling + /// + [Test] + public void VerifyThatElementSheetPilingIsNotWrittenByDefault() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SheetPiling = null; + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var sheetPilingElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSheetPiling); + Assert.IsNull(sheetPilingElement); + } + + /// + /// Sheetpiling + /// + [Test] + public void VerifyThatElementSheetPilingIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SheetPiling = sheetPiling; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSheetPiling); + Assert.IsNotNull(element); + Assert.AreEqual(1, element.Attributes("XCoordinate").Count()); + Assert.AreEqual(1, element.Attributes("YCoordinate").Count()); + Assert.AreEqual(1, element.Attributes("ZCoordinate").Count()); + Assert.AreEqual(1, element.Attributes("Length").Count()); + } + + /// + /// Horizontal Balance Area + /// + [Test] + public void VerifyThatElementHorizontalBalanceAreaIsNotWrittenByDefault() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.HorizontalBalanceArea = null; + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var horizontalBalanceAreaElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementHorizontalBalanceArea); + Assert.IsNull(horizontalBalanceAreaElement); + } + + /// + /// Horizontal Balance Area + /// + [Test] + public void VerifyThatElementHorizontalBalanceAreaIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.HorizontalBalanceArea = horizontalBalanceArea; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementHorizontalBalanceArea); + Assert.IsNotNull(element); + Assert.AreEqual(1, element.Attributes("XLeft").Count()); + Assert.AreEqual(1, element.Attributes("XRight").Count()); + Assert.AreEqual(1, element.Attributes("YTop").Count()); + Assert.AreEqual(1, element.Attributes("YBottom").Count()); + Assert.AreEqual(1, element.Attributes("PlaneCount").Count()); + } + + /// + /// SlipCircleDefinition + /// + [Test] + public void VerifyThatElementSlipCircleDefinitionIsNotWrittenByDefault() + { + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SlipCircleDefinition = null; + assembler = new DamMStabAssembler(); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var slipCircledefinitionElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSlipCircleDefinition); + Assert.IsNull(slipCircledefinitionElement); + } + + /// + /// SlipCircleDefinition + /// + [Test] + public void VerifyThatElementSlipCircleDefinitionIsWrittenWhenSet() + { + assembler = new DamMStabAssembler(); + damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SlipCircleDefinition = slipCircleDefinition; + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSlipCircleDefinition); + Assert.IsNotNull(element); + Assert.AreEqual(1, element.Attributes("XCoordinateLastUpliftPoint").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanTangentLinesDefinition").Count()); + Assert.AreEqual(1, element.Attributes("GridSizeDetermination").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridVerticalPointCount").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridVerticalPointDistance").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridHorizontalPointCount").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridHorizontalPointDistance").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanRightGridVerticalPointCount").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanRightGridVerticalPointDistance").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanRightGridHorizontalPointCount").Count()); + Assert.AreEqual(1, element.Attributes("UpliftVanRightGridHorizontalPointDistance").Count()); + Assert.AreEqual(1, element.Attributes("BishopGridVerticalPointCount").Count()); + Assert.AreEqual(1, element.Attributes("BishopGridVerticalPointDistance").Count()); + Assert.AreEqual(1, element.Attributes("BishopGridHorizontalPointCount").Count()); + Assert.AreEqual(1, element.Attributes("BishopGridHorizontalPointDistance").Count()); + } + + /// + /// Characteristic points + /// + [Test] + public void VerifyThatCharacteristicPointsAreWritten() + { + assembler = new DamMStabAssembler(); + surfaceLine1.EnsurePointOfType(30, 1.0, CharacteristicPointType.DikeToeAtRiver); + surfaceLine1.EnsurePointOfType(35, 11.0, CharacteristicPointType.DikeTopAtRiver); + surfaceLine1.EnsurePointOfType(40, 12.0, CharacteristicPointType.DikeTopAtPolder); + surfaceLine1.EnsurePointOfType(45, 2.0, CharacteristicPointType.DikeToeAtPolder); + var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab); + var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCharacteristicPoints); + Assert.IsNotNull(element); + + element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCharacteristicPoint); + Assert.IsNotNull(element); + Assert.AreEqual(1, element.Attributes("XCoord").Count()); + Assert.AreEqual(1, element.Attributes("YCoord").Count()); + Assert.AreEqual(1, element.Attributes("CharacteristicPointType").Count()); + } + + } +} \ No newline at end of file