Fisheye: Tag 6380 refers to a dead (removed) revision in file `DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/InterfaceConversionHelper.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/InputConversionHelper.cs =================================================================== diff -u --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/InputConversionHelper.cs (revision 0) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/InputConversionHelper.cs (revision 6380) @@ -0,0 +1,462 @@ +// Copyright (C) Stichting Deltares 2024. 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 Deltares.DamEngine.Data.General; +using Deltares.DamEngine.Data.Geotechnics; +using Deltares.MacroStability.Io.XmlInput; +using CharacteristicPointType = Deltares.MacroStability.Io.XmlInput.CharacteristicPointType; + +namespace Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo; + +public static class InputConversionHelper +{ + /// Converts SearchAlgorithm to Dam SearchMethod. + /// The MacroStability search algorithm. + /// StabilitySearchMethod + /// + public static StabilitySearchMethod ConvertToDamSearchMethod(SearchAlgorithmType searchAlgorithm) + { + if (searchAlgorithm != SearchAlgorithmType.Grid && searchAlgorithm != SearchAlgorithmType.Genetic && searchAlgorithm != SearchAlgorithmType.BeeswarmAndLevenbergMarquardt) + { + throw new ArgumentException($"Unsupported search algorithm: {searchAlgorithm}"); + } + + var translationTable = new Dictionary + { + { + SearchAlgorithmType.Grid, StabilitySearchMethod.Grid + }, + { + SearchAlgorithmType.BeeswarmAndLevenbergMarquardt, StabilitySearchMethod.BeeSwarm + } + }; + return translationTable[searchAlgorithm]; + } + + /// Converts Dam SearchMethod to Macro Stability SearchAlgorithm. + /// The Dam search algorithm. + /// SearchAlgorithmType + /// + public static SearchAlgorithmType ConvertToMacroStabilitySearchMethod(StabilitySearchMethod stabilitySearchMethod) + { + var translationTable = new Dictionary + { + { + StabilitySearchMethod.Grid, SearchAlgorithmType.Grid + }, + { + StabilitySearchMethod.BeeSwarm, SearchAlgorithmType.BeeswarmAndLevenbergMarquardt + } + }; + return translationTable[stabilitySearchMethod]; + } + + /// Converts to ModelOptions type. + /// the Dam StabilityModelType. + /// the MacroStability ModelOption + /// + public static StabilityModelOption ConvertToMacroStabilityModelOption(StabilityModelType stabilityModelType) + { + // For the Macrostability kernel, the only supported options for now are Bishop and UpliftVan. + if (stabilityModelType != StabilityModelType.UpliftVan && stabilityModelType != StabilityModelType.Bishop) + { + throw new ArgumentException($"Unsupported MStabModelType: {stabilityModelType}"); + } + + var translationTable = new Dictionary + { + { + StabilityModelType.UpliftVan, StabilityModelOption.UpliftVan + }, + { + StabilityModelType.Bishop, StabilityModelOption.Bishop + } + }; + return translationTable[stabilityModelType]; + } + + /// Converts ModelOption to the DamModelType. + /// This comes back from the kernel side so any model that can be matched is OK. + /// The model option. + /// the Dam MStabModelType + public static StabilityModelType ConvertToDamStabilityModelType(StabilityModelOption stabilityModelOption) + { + var translationTable = new Dictionary + { + { + StabilityModelOption.Bishop, StabilityModelType.Bishop + }, + { + StabilityModelOption.UpliftVan, StabilityModelType.UpliftVan + } + }; + return translationTable[stabilityModelOption]; + } + + /// Converts to MacroStability GridOrientation. + /// The Dam GridPosition. + /// OrientationType + public static OrientationType ConvertToMacroStabilityGridOrientation(StabilityGridPosition stabilityGridPosition) + { + var translationTable = new Dictionary + { + { + StabilityGridPosition.Right, OrientationType.Inwards + }, + { + StabilityGridPosition.Left, OrientationType.Outwards + } + }; + return translationTable[stabilityGridPosition]; + } + + /// Converts to Dam GridPosition. + /// The grid orientation. + /// StabilityGridPosition + public static StabilityGridPosition ConvertToDamGridPosition(OrientationType gridOrientation) + { + var translationTable = new Dictionary + { + { + OrientationType.Inwards, StabilityGridPosition.Right + }, + { + OrientationType.Outwards, StabilityGridPosition.Left + } + }; + return translationTable[gridOrientation]; + } + + /// Converts the type of to macro stability characteristic point. + /// Type of the dam characteristic point. + /// CharacteristicPointType (Macro stability) + public static CharacteristicPointType ConvertToMacroStabilityCharacteristicPointType(Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType damCharacteristicPointType) + { + var translationTable = new Dictionary + { + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DitchDikeSide, CharacteristicPointType.DitchDikeSide + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DitchPolderSide, CharacteristicPointType.DitchPolderSide + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.None, CharacteristicPointType.None + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside + }, + { + Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside + } + }; + return translationTable[damCharacteristicPointType]; + } + + /// Converts the type of macro stability characteristic point to dam type. + /// Type of the dam characteristic point. + /// CharacteristicPointType (DamEngine) + public static Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType ConvertToDamCharacteristicPointType(CharacteristicPointType kernelCharacteristicPointType) + { + var translationTable = new Dictionary + { + { + CharacteristicPointType.BottomDitchPolderSide, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.BottomDitchPolderSide + }, + { + CharacteristicPointType.BottomDitchDikeSide, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.BottomDitchDikeSide + }, + { + CharacteristicPointType.DikeToeAtPolder, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeToeAtPolder + }, + { + CharacteristicPointType.DikeToeAtRiver, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeToeAtRiver + }, + { + CharacteristicPointType.DikeTopAtPolder, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeTopAtPolder + }, + { + CharacteristicPointType.DikeTopAtRiver, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DikeTopAtRiver + }, + { + CharacteristicPointType.DitchDikeSide, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DitchDikeSide + }, + { + CharacteristicPointType.DitchPolderSide, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.DitchPolderSide + }, + { + CharacteristicPointType.None, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.None + }, + { + CharacteristicPointType.ShoulderBaseInside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderBaseInside + }, + { + CharacteristicPointType.ShoulderBaseOutside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderBaseOutside + }, + { + CharacteristicPointType.ShoulderTopInside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderTopInside + }, + { + CharacteristicPointType.ShoulderTopOutside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.ShoulderTopOutside + }, + { + CharacteristicPointType.SurfaceLevelInside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.SurfaceLevelInside + }, + { + CharacteristicPointType.SurfaceLevelOutside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.SurfaceLevelOutside + }, + { + CharacteristicPointType.TrafficLoadInside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.TrafficLoadInside + }, + { + CharacteristicPointType.TrafficLoadOutside, Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType.TrafficLoadOutside + } + }; + return translationTable[kernelCharacteristicPointType]; + } + + /// Converts to MacroStability soil. + /// The Dam soil. + /// The MacroStability Soil. + public static SoilType ConvertToMacroStabilitySoil(Soil soil) + { + var macroStabilitySoil = new SoilType + { + Name = soil.Name, + AbovePhreaticLevel = soil.AbovePhreaticLevel, + BelowPhreaticLevel = soil.BelowPhreaticLevel, + Cohesion = soil.Cohesion, + FrictionAngle = soil.FrictionAngle, + Dilatancy = soil.FrictionAngle, + RatioCuPc = soil.RatioCuPc, + StrengthIncreaseExponent = soil.ShearStrengthModel == ShearStrengthModel.SuTable && double.IsNaN(soil.StrengthIncreaseExponent) ? 1.0 : soil.StrengthIncreaseExponent, // can't be NaN in MAC kernel because used for multi-stages + UseSoilClassification = false, // Soil type is not given so make sure it is not used. + BondStressCurve = null, // these are not supported in DAM so set to null. + SigmaTauTable = new SoilTypeSigmaTauTablePoint[soil.SigmaTauCurve.Points.Count], + SuTable = new SoilTypeSuTablePoint[soil.SuTableCurve.Points.Count] + }; + + if (soil.ShearStrengthModel != null) + { + macroStabilitySoil.ShearStrengthAbovePhreaticLevelModel = ConvertToMacroStabilityShearStrengthModel(soil.ShearStrengthModel.Value); + macroStabilitySoil.ShearStrengthBelowPhreaticLevelModel = ConvertToMacroStabilityShearStrengthModel(soil.ShearStrengthModel.Value); + } + + if (soil.SigmaTauCurve != null) + { + int i = 0; + foreach (SigmaTauPoint point in soil.SigmaTauCurve.Points) + { + SoilTypeSigmaTauTablePoint tablePoint = new SoilTypeSigmaTauTablePoint + { + Sigma = point.Sigma, + Tau = point.Tau + }; + macroStabilitySoil.SigmaTauTable[i] = tablePoint; + i++; + } + } + + if (soil.SuTableCurve != null) + { + int i = 0; + foreach (SigmaSuPoint point in soil.SuTableCurve.Points) + { + SoilTypeSuTablePoint tablePoint = new SoilTypeSuTablePoint + { + Su = point.Su, + EffectiveStress = point.Sigma + }; + macroStabilitySoil.SuTable[i] = tablePoint; + i++; + } + } + + return macroStabilitySoil; + } + + /// Converts to Dam soil. + /// The MacroStability soil. + /// The Dam soil. + /// + public static Soil ConvertToDamSoil(SoilType soil) + { + var damSoil = new Soil + { + Name = soil.Name, + AbovePhreaticLevel = soil.AbovePhreaticLevel, + BelowPhreaticLevel = soil.BelowPhreaticLevel, + Cohesion = soil.Cohesion, + FrictionAngle = soil.FrictionAngle, + RatioCuPc = soil.RatioCuPc, + StrengthIncreaseExponent = soil.StrengthIncreaseExponent, + //Todo #Bka We keep this as "truth" for now. But maybe Dam should become above/below too + ShearStrengthModel = ConvertToDamShearStrengthModel(soil.ShearStrengthAbovePhreaticLevelModel) + }; + + if (soil.SigmaTauTable != null) + { + damSoil.SigmaTauCurve = new SigmaTauCurve(); + foreach (SoilTypeSigmaTauTablePoint point in soil.SigmaTauTable) + { + damSoil.SigmaTauCurve.Points.Add(new SigmaTauPoint + { + Sigma = point.Sigma, + Tau = point.Tau + }); + } + } + + if (soil.SuTable != null) + { + damSoil.SuTableCurve = new SuTableCurve(); + foreach (SoilTypeSuTablePoint point in soil.SuTable) + { + damSoil.SuTableCurve.Points.Add(new SigmaSuPoint() + { + Sigma = point.EffectiveStress, + Su = point.Su + }); + } + } + + return damSoil; + } + + /// Converts to macro stability ShearStrengthModel. + /// The dam ShearStrengthModel. + /// ShearStrengthModelType + /// + private static ShearStrengthModelType ConvertToMacroStabilityShearStrengthModel(ShearStrengthModel damShearStrengthModel) + { + var translationTable = new Dictionary + { + { + ShearStrengthModel.CPhi, ShearStrengthModelType.MohrCoulomb + }, + { + ShearStrengthModel.SuCalculated, ShearStrengthModelType.Shansep + }, + { + ShearStrengthModel.SigmaTauCurve, ShearStrengthModelType.SigmaTauTable + }, + { + ShearStrengthModel.SuTable, ShearStrengthModelType.SuTable + } + }; + return translationTable[damShearStrengthModel]; + } + + /// Converts to dam ShearStrengthModel. + /// The kernel ShearStrengthModel. + /// ShearStrengthModel + private static ShearStrengthModel ConvertToDamShearStrengthModel(ShearStrengthModelType kernelShearStrengthModel) + { + var translationTable = new Dictionary + { + { + ShearStrengthModelType.MohrCoulomb, ShearStrengthModel.CPhi + }, + { + ShearStrengthModelType.Shansep, ShearStrengthModel.SuCalculated + }, + { + ShearStrengthModelType.SigmaTauTable, ShearStrengthModel.SigmaTauCurve + }, + { + ShearStrengthModelType.SuTable, ShearStrengthModel.SuTable + } + }; + return translationTable[kernelShearStrengthModel]; + } + + /// Converts to macro stability water pressure interpolation model. + /// The water pressure interpolation model. + /// WaterPressureInterpolationModelType + public static WaterPressureInterpolationModelType ConvertToMacroStabilityWaterPressureInterpolationModel(WaterpressureInterpolationModel waterPressureInterpolationModel) + { + var translationTable = new Dictionary + { + { + WaterpressureInterpolationModel.Automatic, WaterPressureInterpolationModelType.Automatic + }, + { + WaterpressureInterpolationModel.Hydrostatic, WaterPressureInterpolationModelType.Hydrostatic + } + }; + return translationTable[waterPressureInterpolationModel]; + } + + /// Converts to dam water pressure interpolation model. + /// The water pressure interpolation model. + /// WaterpressureInterpolationModel + public static WaterpressureInterpolationModel ConvertToDamWaterPressureInterpolationModel(WaterPressureInterpolationModelType waterpressureInterpolationModel) + { + var translationTable = new Dictionary + { + { + WaterPressureInterpolationModelType.Automatic, WaterpressureInterpolationModel.Automatic + }, + { + WaterPressureInterpolationModelType.Hydrostatic, WaterpressureInterpolationModel.Hydrostatic + } + }; + return translationTable[waterpressureInterpolationModel]; + } +} \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityKernelInputFromEngine.cs =================================================================== diff -u -r6366 -r6380 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityKernelInputFromEngine.cs (.../FillMacroStabilityKernelInputFromEngine.cs) (revision 6366) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/FillMacroStabilityKernelInputFromEngine.cs (.../FillMacroStabilityKernelInputFromEngine.cs) (revision 6380) @@ -20,10 +20,12 @@ // All rights reserved. using System; +using System.Collections.Generic; using System.Linq; using Deltares.DamEngine.Calculators.KernelWrappers.Common; using Deltares.DamEngine.Data.General; using Deltares.DamEngine.Data.Geotechnics; +using Deltares.DamEngine.Data.Standard; using Deltares.MacroStability.Io.XmlInput; using CharacteristicPoint = Deltares.DamEngine.Data.Geotechnics.CharacteristicPoint; using CharacteristicPointSet = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointSet; @@ -58,7 +60,7 @@ public FullInputModelType CreateFullInputModel(DamKernelInput damKernelInput, MStabParameters mStabParameters, Waternet waterNet) { - // The objectregistry is to be used to keep track of all keys of some of the referenced objects, see the C#wrapper for where and when to use it (Creators) + // The objectRegistry is to be used to keep track of all keys of some of the referenced objects var objectRegistry = new ObjectRegistry(); var fullInputModelType = new FullInputModelType { @@ -117,11 +119,9 @@ { case StabilityModelType.Bishop: TransferBishopSearchAreaSettings(preprocessingSearchAreaConditions); - //BishopCalculationCircle = TransferBishopCalculationGrid(); #Bka, moet naar TransferStabilityModel want geen deel van TransferPreprocessingInput break; case StabilityModelType.UpliftVan: TransferUpliftVanSearchAreaSettings(preprocessingSearchAreaConditions); - //UpliftVanCalculationGrid = TransferUpliftVanCalculationGrid(); #Bka, toevoegen en moet naar TransferStabilityModel want geen deel van TransferPreprocessingInput break; default: throw new NotImplementedException(nameof(mStabParameters.Model)); @@ -180,7 +180,44 @@ return kernelBishopCalculationCircle; } + + private UpliftVanCalculationGridType TransferUpliftVanCalculationGrid() + { + if (UpliftVanCalculationGrid == null) + { + throw new ArgumentNullException(nameof(UpliftVanCalculationGrid)); + } + var kernelUpliftVanCalculationGrid = new UpliftVanCalculationGridType + { + LeftGrid = new CalculationGridType + { + GridXNumber = UpliftVanCalculationGrid.LeftGridXCount, + GridXLeft = UpliftVanCalculationGrid.LeftGridXLeft, + GridXRight = UpliftVanCalculationGrid.LeftGridXRight, + GridZNumber = UpliftVanCalculationGrid.LeftGridZCount, + GridZTop = UpliftVanCalculationGrid.LeftGridZTop, + GridZBottom = UpliftVanCalculationGrid.LeftGridZBottom + }, + RightGrid = new CalculationGridType + { + GridXNumber = UpliftVanCalculationGrid.RightGridXCount, + GridXLeft = UpliftVanCalculationGrid.RightGridXLeft, + GridXRight = UpliftVanCalculationGrid.RightGridXRight, + GridZNumber = UpliftVanCalculationGrid.RightGridZCount, + GridZTop = UpliftVanCalculationGrid.RightGridZTop, + GridZBottom = UpliftVanCalculationGrid.RightGridZBottom + } + }; + + if (UpliftVanCalculationGrid.TangentLinesCreationMethod == TangentLinesDefinition.Specified) + { + kernelUpliftVanCalculationGrid.TangentLines = UpliftVanCalculationGrid.TangentLineLevels.ToArray(); + } + + return kernelUpliftVanCalculationGrid; + } + private void TransferSurfaceLine(SurfaceLine2 surfaceLineInput, SurfaceLineType surfaceLine) { surfaceLine.CharacteristicPoints = new SurfaceLineTypeCharacteristicPoint[surfaceLineInput.CharacteristicPoints.Count]; @@ -189,7 +226,7 @@ { var kernelCharPoint = new SurfaceLineTypeCharacteristicPoint { - CharacteristicPointType = InterfaceConversionHelper.ConvertToMacroStabilityCharacteristicPointType(damCharPoint.CharacteristicPointType), + CharacteristicPointType = InputConversionHelper.ConvertToMacroStabilityCharacteristicPointType(damCharPoint.CharacteristicPointType), GeometryPoint = new Point2DType { X = damCharPoint.Point.X, @@ -210,19 +247,36 @@ var stabilityInputType = new StabilityInputType { - UpliftVanCalculationGrid = new UpliftVanCalculationGridType(), ConstructionStages = new ConstructionStageInputType[1], SlipPlaneConstraints = new SlipPlaneConstraintsType() }; + switch (mStabParameters.Model) + { + case StabilityModelType.Bishop: + stabilityInputType.BishopCalculationCircle = TransferBishopCalculationGrid(); + break; + case StabilityModelType.UpliftVan: + stabilityInputType.UpliftVanCalculationGrid = TransferUpliftVanCalculationGrid(); + break; + default: + throw new NotImplementedException(nameof(mStabParameters.Model)); + } + + TransferSlipPlaneConstraints(damKernelInput.Location, stabilityInputType.SlipPlaneConstraints); + TransferStabilityModelProperties(mStabParameters, stabilityInputType); + stabilityInputType.ConstructionStages[0] = new ConstructionStageInputType(); ConstructionStageInputType lastStage = stabilityInputType.ConstructionStages.Last(); - - TransferStabilityModelProperties(mStabParameters, stabilityInputType); - TransferSlipPlaneConstraints(damKernelInput.Location, stabilityInputType.SlipPlaneConstraints); + stabilityInputType.Soils = new SoilType[damKernelInput.Location.SoilList.Soils.Count]; lastStage.FixedSoilStresses = new FixedSoilStressType[damKernelInput.Location.SoilList.Soils.Count]; TransferSoils(damKernelInput.Location.SoilList, stabilityInputType.Soils, lastStage.FixedSoilStresses, objectRegistry); + lastStage.UniformLoads = new UniformLoadType[1]; + TransferUniformLoads(TrafficLoad, lastStage.UniformLoads, objectRegistry); + TransferTrafficLoadDegreeOfConsolidation(TrafficLoad, damKernelInput.SubSoilScenario.SoilProfile2D, + damKernelInput.Location.TrafficLoadDegreeOfConsolidations, lastStage, objectRegistry); + lastStage.SoilProfile = new SoilProfileType(); lastStage.PreconsolidationStresses = new PreconsolidationStressType[damKernelInput.SubSoilScenario.SoilProfile2D.PreconsolidationStresses.Count]; lastStage.WaterDefinition = WaterDefinitionType.WaterNet; @@ -244,18 +298,34 @@ private void TransferStabilityModelProperties(MStabParameters mStabParameters, StabilityInputType kernelStabilityInput) { - kernelStabilityInput.MoveGrid = true; // is not in DamEngine but MUST be true as we use the brute force approach. - kernelStabilityInput.MaximumSliceWidth = 1.0; // is not in DamEngine datamodel + kernelStabilityInput.Orientation = InputConversionHelper.ConvertToMacroStabilityGridOrientation(mStabParameters.GridPosition); + kernelStabilityInput.ModelOption = InputConversionHelper.ConvertToMacroStabilityModelOption(mStabParameters.Model); // For Bishop, only Grid is possible however if Bishop/UpliftVan was selected, then the SearchAlgorithm concerns only Uplift-Van - kernelStabilityInput.SearchAlgorithm = mStabParameters.Model == StabilityModelType.Bishop ? SearchAlgorithmType.Grid : InterfaceConversionHelper.ConvertToMacroStabilitySearchMethod(mStabParameters.SearchMethod); + kernelStabilityInput.SearchAlgorithm = mStabParameters.Model == StabilityModelType.Bishop ? SearchAlgorithmType.Grid : InputConversionHelper.ConvertToMacroStabilitySearchMethod(mStabParameters.SearchMethod); if (kernelStabilityInput.SearchAlgorithm == SearchAlgorithmType.BeeswarmAndLevenbergMarquardt) { CreateDefaultBeeSwarmOptions(kernelStabilityInput); } + kernelStabilityInput.GeneticAlgorithmOptions = null; + kernelStabilityInput.LevenbergMarquardtOptions = null; - kernelStabilityInput.ModelOption = InterfaceConversionHelper.ConvertToMacroStabilityModelOption(mStabParameters.Model); - kernelStabilityInput.Orientation = InterfaceConversionHelper.ConvertToMacroStabilityGridOrientation(mStabParameters.GridPosition); + kernelStabilityInput.MaximumSliceWidthSpecified = true; + kernelStabilityInput.MaximumSliceWidth = 1.0; + kernelStabilityInput.MoveGridSpecified = true; + kernelStabilityInput.MoveGrid = true; // Is not in DamEngine but MUST be true as we use the brute force approach. + kernelStabilityInput.MaxAllowedAngleBetweenSlicesSpecified = true; + kernelStabilityInput.MaxAllowedAngleBetweenSlices = 0; + kernelStabilityInput.RequiredForcePointsInSlicesSpecified = true; + kernelStabilityInput.RequiredForcePointsInSlices = 0; + kernelStabilityInput.TraversalGridPointsSpecified = true; + kernelStabilityInput.TraversalGridPoints = 2; + kernelStabilityInput.TraversalRefinementsSpecified = true; + kernelStabilityInput.TraversalRefinements = 0; + kernelStabilityInput.MaxGridMovesSpecified = true; + kernelStabilityInput.MaxGridMoves = 50; + kernelStabilityInput.NumberOfRefinementsGridSpecified = true; kernelStabilityInput.NumberOfRefinementsGrid = 2; + kernelStabilityInput.NumberOfRefinementsTangentLinesSpecified = true; kernelStabilityInput.NumberOfRefinementsTangentLines = 2; } @@ -304,9 +374,11 @@ { SoilType kernelSoil = CreateSoil(damSoil, registry); kernelSoils[i] = kernelSoil; - var kernelFixedSoilStressType = new FixedSoilStressType(); - kernelFixedSoilStressType.POP = damSoil.PoP; - kernelFixedSoilStressType.Soil = kernelSoil.Key; + var kernelFixedSoilStressType = new FixedSoilStressType + { + POP = damSoil.PoP, + Soil = kernelSoil.Key + }; kernelFixedSoilStresses[i] = kernelFixedSoilStressType; i++; } @@ -315,7 +387,7 @@ private static SoilType CreateSoil(Soil soil, ObjectRegistry registry) { - SoilType soilType = InterfaceConversionHelper.ConvertToMacroStabilitySoil(soil); + SoilType soilType = InputConversionHelper.ConvertToMacroStabilitySoil(soil); soilType.Key = registry.GetId(soil); return soilType; } @@ -378,7 +450,7 @@ GeometrySurface = registry.GetId(damSoilLayer2D.GeometrySurface), Soil = registry.GetId(damSoilLayer2D.Soil), WaterPressureInterpolationModelSpecified = true, - WaterPressureInterpolationModel = InterfaceConversionHelper.ConvertToMacroStabilityWaterPressureInterpolationModel(damSoilLayer2D + WaterPressureInterpolationModel = InputConversionHelper.ConvertToMacroStabilityWaterPressureInterpolationModel(damSoilLayer2D .WaterpressureInterpolationModel) }; kernelSoilProfile.SoilSurfaces[i] = kernelSoilLayer2D; @@ -469,4 +541,37 @@ i++; } } + + private void TransferUniformLoads(TrafficLoad damTrafficLoad, UniformLoadType[] kernelUniformLoads, ObjectRegistry registry) + { + if (damTrafficLoad != null) + { + kernelUniformLoads[0].XStart = damTrafficLoad.XStart; + kernelUniformLoads[0].XEnd = damTrafficLoad.XEnd; + kernelUniformLoads[0].Pressure = damTrafficLoad.Pressure; + kernelUniformLoads[0].DistributionAngle = 0.0; + kernelUniformLoads[0].Key = registry.GetId(damTrafficLoad); + }; + } + + private static void TransferTrafficLoadDegreeOfConsolidation(TrafficLoad damTrafficLoad, SoilProfile2D soilProfile, + IList damDegreeOfConsolidations, + ConstructionStageInputType stage, ObjectRegistry registry) + { + if (damDegreeOfConsolidations != null && stage.UniformLoads.Length == 1) + { + int i = 0; + stage.ConsolidationValues = new ConsolidationValuesTypeConsolidationValue[damDegreeOfConsolidations.Count]; + foreach (SoilLayer2D surface in soilProfile.Surfaces) + { + stage.ConsolidationValues[i] = new ConsolidationValuesTypeConsolidationValue + { + Consolidator = registry.GetId(damTrafficLoad), + Consolidated = registry.GetId(surface), + Value = damDegreeOfConsolidations.Find(t => t.SoilName == surface.Soil.Name).DegreeOfConsolidation + }; + i++; + } + } + } } \ No newline at end of file Fisheye: Tag 6380 refers to a dead (removed) revision in file `DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/InterfaceConversionHelperTests.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/InputConversionHelperTests.cs =================================================================== diff -u --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/InputConversionHelperTests.cs (revision 0) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/InputConversionHelperTests.cs (revision 6380) @@ -0,0 +1,255 @@ +// Copyright (C) Stichting Deltares 2024. 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 Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo; +using Deltares.DamEngine.Data.General; +using Deltares.DamEngine.Data.Geotechnics; +using Deltares.MacroStability.Io.XmlInput; +using KellermanSoftware.CompareNetObjects; +using NUnit.Framework; +using CharacteristicPointType = Deltares.MacroStability.Io.XmlInput.CharacteristicPointType; +using ConversionHelper = Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo.ConversionHelper; + +namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon; + +[TestFixture] +public class InputConversionHelperTests +{ + [Test] + public void GivenMacroStabilitySoilWhenConvertingToDamSoilAndBackThenResultEqualsOriginal() + { + // Given MacroStability Soil + var macroStabilitySoil = new SoilType() + { + Name = "MacroStabilitySoil", + AbovePhreaticLevel = 1.01, + BelowPhreaticLevel = 1.02, + Cohesion = 1.03, + FrictionAngle = 1.04, + Dilatancy = 1.04, + RatioCuPc = 1.06, + ShearStrengthAbovePhreaticLevelModel = ShearStrengthModelType.MohrCoulomb, + ShearStrengthBelowPhreaticLevelModel = ShearStrengthModelType.MohrCoulomb, + StrengthIncreaseExponent = 1.08, + UseSoilClassification = false, // must be false + SigmaTauTable = [], + SuTable = [], + BondStressCurve = null // must be null + }; + + // When Converting to DamSoil and back + Data.Geotechnics.Soil damSoil = InputConversionHelper.ConvertToDamSoil(macroStabilitySoil); + SoilType actualMacroStabilitySoil = InputConversionHelper.ConvertToMacroStabilitySoil(damSoil); + + // Then result equals original + var compare = new CompareLogic + { + Config = + { + MaxDifferences = 100 + } + }; + ComparisonResult result = compare.Compare(macroStabilitySoil, actualMacroStabilitySoil); + Assert.That(result.Differences, Is.Empty, "Differences found converting/reconverting Soil but this ok now if diff = 3"); + } + + [Test] + public void GivenMacroStabilitySoilWithSuAndSigmaTauTableWhenConvertingToDamSoilAndBackThenResultEqualsOriginal() + { + // Given MacroStability Soil with filled Su and SigmaTau table + var sigmaTauTable = new SoilTypeSigmaTauTablePoint[2]; + sigmaTauTable[0] = new SoilTypeSigmaTauTablePoint + { + Sigma = 1.1, + Tau = 2.1 + }; + sigmaTauTable[1] = new SoilTypeSigmaTauTablePoint + { + Sigma = 2.1, + Tau = 3.1 + }; + var suTable = new SoilTypeSuTablePoint[2]; + suTable[0] = new SoilTypeSuTablePoint + { + Su = 0.1, + EffectiveStress = 10.1 + }; + suTable[1] = new SoilTypeSuTablePoint + { + Su = 1.21, + EffectiveStress = 13.4 + }; + var macroStabilitySoil = new SoilType() + { + Name = "MacroStabilitySoil", + AbovePhreaticLevel = 1.01, + BelowPhreaticLevel = 1.02, + Cohesion = 1.03, + FrictionAngle = 1.04, + Dilatancy = 1.04, + RatioCuPc = 1.06, + ShearStrengthAbovePhreaticLevelModel = ShearStrengthModelType.MohrCoulomb, + ShearStrengthBelowPhreaticLevelModel = ShearStrengthModelType.MohrCoulomb, + StrengthIncreaseExponent = 1.08, + UseSoilClassification = false, // must be false + SigmaTauTable = sigmaTauTable, + SuTable = suTable, + BondStressCurve = null // must be null + }; + + // When Converting to DamSoil and back + Data.Geotechnics.Soil damSoil = InputConversionHelper.ConvertToDamSoil(macroStabilitySoil); + SoilType actualMacroStabilitySoil = InputConversionHelper.ConvertToMacroStabilitySoil(damSoil); + + // Then result equals original + var compare = new CompareLogic + { + Config = + { + MaxDifferences = 100 + } + }; + ComparisonResult result = compare.Compare(macroStabilitySoil, actualMacroStabilitySoil); + Assert.That(result.Differences, Is.Empty, "Differences found converting/reconverting Soil but this ok now if diff = 3"); + } + + [TestCase(WaterpressureInterpolationModel.Automatic, WaterPressureInterpolationModelType.Automatic)] + [TestCase(WaterpressureInterpolationModel.Hydrostatic, WaterPressureInterpolationModelType.Hydrostatic)] + public static void CanConvertToMacroStabilityWaterPressureInterpolationModel( + WaterpressureInterpolationModel damWaterPressureInterpolationModel, WaterPressureInterpolationModelType waterPressureInterpolationModel) + { + Assert.That(InputConversionHelper.ConvertToMacroStabilityWaterPressureInterpolationModel(damWaterPressureInterpolationModel), Is.EqualTo(waterPressureInterpolationModel)); + } + + [TestCase(WaterPressureInterpolationModelType.Automatic, WaterpressureInterpolationModel.Automatic)] + [TestCase(WaterPressureInterpolationModelType.Hydrostatic, WaterpressureInterpolationModel.Hydrostatic)] + public static void CanConvertToDamWaterPressureInterpolationModel( + WaterPressureInterpolationModelType waterPressureInterpolationModel, WaterpressureInterpolationModel damWaterPressureInterpolationModel) + { + Assert.That(InputConversionHelper.ConvertToDamWaterPressureInterpolationModel(waterPressureInterpolationModel), Is.EqualTo(damWaterPressureInterpolationModel)); + } + + [TestCase(Data.Geotechnics.CharacteristicPointType.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide)] + [TestCase(Data.Geotechnics.CharacteristicPointType.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide)] + [TestCase(Data.Geotechnics.CharacteristicPointType.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder)] + [TestCase(Data.Geotechnics.CharacteristicPointType.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver)] + [TestCase(Data.Geotechnics.CharacteristicPointType.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder)] + [TestCase(Data.Geotechnics.CharacteristicPointType.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver)] + [TestCase(Data.Geotechnics.CharacteristicPointType.DitchDikeSide, CharacteristicPointType.DitchDikeSide)] + [TestCase(Data.Geotechnics.CharacteristicPointType.DitchPolderSide, CharacteristicPointType.DitchPolderSide)] + [TestCase(Data.Geotechnics.CharacteristicPointType.None, CharacteristicPointType.None)] + [TestCase(Data.Geotechnics.CharacteristicPointType.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside)] + [TestCase(Data.Geotechnics.CharacteristicPointType.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside)] + [TestCase(Data.Geotechnics.CharacteristicPointType.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside)] + [TestCase(Data.Geotechnics.CharacteristicPointType.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside)] + [TestCase(Data.Geotechnics.CharacteristicPointType.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside)] + [TestCase(Data.Geotechnics.CharacteristicPointType.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside)] + [TestCase(Data.Geotechnics.CharacteristicPointType.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside)] + [TestCase(Data.Geotechnics.CharacteristicPointType.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside)] + public static void CanConvertToMacroStabilityCharacteristicPointType( + Data.Geotechnics.CharacteristicPointType damCharacteristicPointType, CharacteristicPointType kernelCharacteristicPointType) + { + Assert.That(InputConversionHelper.ConvertToMacroStabilityCharacteristicPointType(damCharacteristicPointType), Is.EqualTo(kernelCharacteristicPointType)); + } + + [TestCase(CharacteristicPointType.BottomDitchDikeSide, Data.Geotechnics.CharacteristicPointType.BottomDitchDikeSide)] + [TestCase(CharacteristicPointType.BottomDitchPolderSide, Data.Geotechnics.CharacteristicPointType.BottomDitchPolderSide)] + [TestCase(CharacteristicPointType.DikeToeAtPolder, Data.Geotechnics.CharacteristicPointType.DikeToeAtPolder)] + [TestCase(CharacteristicPointType.DikeToeAtRiver, Data.Geotechnics.CharacteristicPointType.DikeToeAtRiver)] + [TestCase(CharacteristicPointType.DikeTopAtPolder, Data.Geotechnics.CharacteristicPointType.DikeTopAtPolder)] + [TestCase(CharacteristicPointType.DikeTopAtRiver, Data.Geotechnics.CharacteristicPointType.DikeTopAtRiver)] + [TestCase(CharacteristicPointType.DitchDikeSide, Data.Geotechnics.CharacteristicPointType.DitchDikeSide)] + [TestCase(CharacteristicPointType.DitchPolderSide, Data.Geotechnics.CharacteristicPointType.DitchPolderSide)] + [TestCase(CharacteristicPointType.None, Data.Geotechnics.CharacteristicPointType.None)] + [TestCase(CharacteristicPointType.ShoulderBaseInside, Data.Geotechnics.CharacteristicPointType.ShoulderBaseInside)] + [TestCase(CharacteristicPointType.ShoulderBaseOutside, Data.Geotechnics.CharacteristicPointType.ShoulderBaseOutside)] + [TestCase(CharacteristicPointType.ShoulderTopInside, Data.Geotechnics.CharacteristicPointType.ShoulderTopInside)] + [TestCase(CharacteristicPointType.ShoulderTopOutside, Data.Geotechnics.CharacteristicPointType.ShoulderTopOutside)] + [TestCase(CharacteristicPointType.SurfaceLevelInside, Data.Geotechnics.CharacteristicPointType.SurfaceLevelInside)] + [TestCase(CharacteristicPointType.SurfaceLevelOutside, Data.Geotechnics.CharacteristicPointType.SurfaceLevelOutside)] + [TestCase(CharacteristicPointType.TrafficLoadInside, Data.Geotechnics.CharacteristicPointType.TrafficLoadInside)] + [TestCase(CharacteristicPointType.TrafficLoadOutside, Data.Geotechnics.CharacteristicPointType.TrafficLoadOutside)] + public static void CanConvertToDamCharacteristicPointType( + CharacteristicPointType kernelCharacteristicPointType, Data.Geotechnics.CharacteristicPointType damCharacteristicPointType) + { + Assert.That(InputConversionHelper.ConvertToDamCharacteristicPointType(kernelCharacteristicPointType), Is.EqualTo(damCharacteristicPointType)); + } + + [Test] + [TestCase(SearchAlgorithmType.Grid, StabilitySearchMethod.Grid)] + [TestCase(SearchAlgorithmType.BeeswarmAndLevenbergMarquardt, StabilitySearchMethod.BeeSwarm)] + public void CanConvertToDamSearchMethod(SearchAlgorithmType searchAlgorithm, StabilitySearchMethod stabilitySearchMethod) + { + Assert.That(InputConversionHelper.ConvertToDamSearchMethod(searchAlgorithm), Is.EqualTo(stabilitySearchMethod)); + } + + [TestCase(SearchAlgorithmType.Beeswarm)] + [TestCase(SearchAlgorithmType.LevenbergMarquardt)] + [TestCase(SearchAlgorithmType.Single)] + public void CanConvertToDamSearchMethodHandleException(SearchAlgorithmType searchAlgorithm) + { + Assert.That(() => InputConversionHelper.ConvertToDamSearchMethod(searchAlgorithm), Throws.InstanceOf()); + } + + [Test] + [TestCase(StabilitySearchMethod.Grid, SearchAlgorithmType.Grid)] + [TestCase(StabilitySearchMethod.BeeSwarm, SearchAlgorithmType.BeeswarmAndLevenbergMarquardt)] + public void ConvertToMacroStabilitySearchMethod(StabilitySearchMethod stabilitySearchMethod, SearchAlgorithmType searchAlgorithm) + { + Assert.That(InputConversionHelper.ConvertToMacroStabilitySearchMethod(stabilitySearchMethod), Is.EqualTo(searchAlgorithm)); + } + + [Test] + [TestCase(StabilityModelOption.Bishop, StabilityModelType.Bishop)] + [TestCase(StabilityModelOption.UpliftVan, StabilityModelType.UpliftVan)] + public void CanConvertToMStabModelType(StabilityModelOption modelOption, StabilityModelType stabilityModelType) + { + Assert.That(InputConversionHelper.ConvertToDamStabilityModelType(modelOption), Is.EqualTo(stabilityModelType)); + } + + [Test] + [TestCase(StabilityModelType.UpliftVan, StabilityModelOption.UpliftVan)] + public void CanConvertToModelOptions(StabilityModelType stabilityModelType, StabilityModelOption modelOption) + { + Assert.That(InputConversionHelper.ConvertToMacroStabilityModelOption(stabilityModelType), Is.EqualTo(modelOption)); + } + + [TestCase(StabilityModelType.BishopUpliftVan)] + public void CanConvertToModelOptionsHandleException(StabilityModelType stabilityModelType) + { + Assert.That(() => InputConversionHelper.ConvertToMacroStabilityModelOption(stabilityModelType), Throws.InstanceOf()); + } + + [TestCase(OrientationType.Outwards, StabilityGridPosition.Left)] + [TestCase(OrientationType.Inwards, StabilityGridPosition.Right)] + public static void CanConvertToMStabGridPosition(OrientationType gridOrientation, StabilityGridPosition stabilityGridPosition) + { + Assert.That(InputConversionHelper.ConvertToDamGridPosition(gridOrientation), Is.EqualTo(stabilityGridPosition)); + } + + [TestCase(StabilityGridPosition.Left, OrientationType.Outwards)] + [TestCase(StabilityGridPosition.Right, OrientationType.Inwards)] + public static void CanConvertToGridOrientation(StabilityGridPosition stabilityGridPosition, OrientationType gridOrientation) + { + Assert.That(InputConversionHelper.ConvertToMacroStabilityGridOrientation(stabilityGridPosition), Is.EqualTo(gridOrientation)); + } +} \ No newline at end of file