Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/ConversionHelperTests.cs
===================================================================
diff -u -r2904 -r2907
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 2904)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/KernelWrappers/MacroStabilityCommon/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 2907)
@@ -20,12 +20,9 @@
 // All rights reserved.
 
 using System;
-using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo;
 using Deltares.DamEngine.Data.General;
 using Deltares.DamEngine.TestHelpers;
-using Deltares.MacroStability.Data;
-using Deltares.MacroStability.Geometry;
-using Deltares.MacroStability.Standard;
+using Deltares.MacroStability.CSharpWrapper.Input;
 using KellermanSoftware.CompareNetObjects;
 using NUnit.Framework;
 using CharacteristicPointType = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType;
@@ -69,17 +66,16 @@
 
         #region ModelType
         [Test]
-        [TestCase(ModelOptions.Bishop, MStabModelType.BishopWti)]
-        [TestCase(ModelOptions.UpliftVan, MStabModelType.UpliftVanWti)]
-        [TestCase(ModelOptions.UpliftSpencer, MStabModelType.UpliftSpencerWti)]
-        public void CanConvertToMStabModelType(ModelOptions modelOption, MStabModelType mStabModelType)
+        [TestCase(MacroStability.CSharpWrapper.Output.StabilityModelOption.Bishop, MStabModelType.BishopWti)]
+        [TestCase(MacroStability.CSharpWrapper.Output.StabilityModelOption.UpliftVan, MStabModelType.UpliftVanWti)]
+        public void CanConvertToMStabModelType(MacroStability.CSharpWrapper.Output.StabilityModelOption modelOption, MStabModelType mStabModelType)
         {
             Assert.AreEqual(mStabModelType, ConversionHelper.ConvertToMStabModelType(modelOption));
         }
 
         [Test]
-        [TestCase(MStabModelType.UpliftVanWti, ModelOptions.UpliftVan)]
-        public void CanConvertToModelOptions(MStabModelType mStabModelType, ModelOptions modelOption)
+        [TestCase(MStabModelType.UpliftVanWti, MacroStability.CSharpWrapper.Output.StabilityModelOption.UpliftVan)]
+        public void CanConvertToModelOptions(MStabModelType mStabModelType, MacroStability.CSharpWrapper.Output.StabilityModelOption modelOption)
         {
             Assert.AreEqual(modelOption, ConversionHelper.ConvertToModelOptions(mStabModelType));
         }
@@ -105,15 +101,15 @@
         #endregion
 
         #region GridOrientation
-        [TestCase(GridOrientation.Outwards, MStabGridPosition.Left)]
-        [TestCase(GridOrientation.Inwards, MStabGridPosition.Right)]
-        public static void CanConvertToMStabGridPosition(GridOrientation gridOrientation, MStabGridPosition mStabGridPosition)
+        [TestCase(Orientation.Outwards, MStabGridPosition.Left)]
+        [TestCase(Orientation.Inwards, MStabGridPosition.Right)]
+        public static void CanConvertToMStabGridPosition(Orientation gridOrientation, MStabGridPosition mStabGridPosition)
         {
             Assert.AreEqual(mStabGridPosition, ConversionHelper.ConvertToMStabGridPosition(gridOrientation));
         }
-        [TestCase(MStabGridPosition.Left, GridOrientation.Outwards)]
-        [TestCase(MStabGridPosition.Right, GridOrientation.Inwards)]
-        public static void CanConvertToGridOrientation(MStabGridPosition mStabGridPosition, GridOrientation gridOrientation)
+        [TestCase(MStabGridPosition.Left, Orientation.Outwards)]
+        [TestCase(MStabGridPosition.Right, Orientation.Inwards)]
+        public static void CanConvertToGridOrientation(MStabGridPosition mStabGridPosition, Orientation gridOrientation)
         {
             Assert.AreEqual(gridOrientation, ConversionHelper.ConvertToGridOrientation(mStabGridPosition));
         }
@@ -125,7 +121,7 @@
         public void GivenMacroStabilitySoilWhenConvertingToDamSoilAndBackThenResultEqualsOriginal()
         {
             // Given MacroStability Soil
-            var macroStabilitySoil = new MacroStability.Geometry.Soil()
+            var macroStabilitySoil = new MacroStability.CSharpWrapper.Input.Soil()
             {
                 Name = "MacroStabilitySoil",
                 AbovePhreaticLevel = 1.01,
@@ -136,9 +132,9 @@
                 RRatio = 1.05,
                 RatioCuPc  = 1.06,
                 RheologicalCoefficient = 1.07,
-                ShearStrengthModel = MacroStability.Geometry.ShearStrengthModel.CPhiOrCuCalculated,
+                ShearStrengthModel = MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhiOrCuCalculated,
                 StrengthIncreaseExponent = 1.08,
-                UseSoilType = true,
+                UseSoilClassification = true,
                 BondStressCurve = null
             };
 
@@ -157,100 +153,98 @@
         #endregion
 
         #region ShearStrengthModel
-        [TestCase(MacroStability.Geometry.ShearStrengthModel.CPhi, ShearStrengthModel.CPhi)]
-        [TestCase(MacroStability.Geometry.ShearStrengthModel.CPhiOrCuCalculated, ShearStrengthModel.CPhiOrSuCalculated)]
-        [TestCase(MacroStability.Geometry.ShearStrengthModel.CuCalculated, ShearStrengthModel.SuCalculated)]
-        [TestCase(MacroStability.Geometry.ShearStrengthModel.None, ShearStrengthModel.None)]
+        [TestCase(MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhi, ShearStrengthModel.CPhi)]
+        [TestCase(MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhiOrCuCalculated, ShearStrengthModel.CPhiOrSuCalculated)]
+        [TestCase(MacroStability.CSharpWrapper.Input.ShearStrengthModel.CuCalculated, ShearStrengthModel.SuCalculated)]
         public static void CanConvertToConvertToDamShearStrengthModel(
-            MacroStability.Geometry.ShearStrengthModel kernelShearStrengthModel, ShearStrengthModel damShearStrengthModel)
+            MacroStability.CSharpWrapper.Input.ShearStrengthModel kernelShearStrengthModel, ShearStrengthModel damShearStrengthModel)
         {
             Assert.AreEqual(damShearStrengthModel, ConversionHelper.ConvertToDamShearStrengthModel(kernelShearStrengthModel));
         }
 
-        [TestCase(ShearStrengthModel.CPhi, MacroStability.Geometry.ShearStrengthModel.CPhi)]
-        [TestCase(ShearStrengthModel.CPhiOrSuCalculated, MacroStability.Geometry.ShearStrengthModel.CPhiOrCuCalculated)]
-        [TestCase(ShearStrengthModel.None, MacroStability.Geometry.ShearStrengthModel.None)]
-        [TestCase(ShearStrengthModel.SuCalculated, MacroStability.Geometry.ShearStrengthModel.CuCalculated)]
+        [TestCase(ShearStrengthModel.CPhi, MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhi)]
+        [TestCase(ShearStrengthModel.CPhiOrSuCalculated, MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhiOrCuCalculated)]
+        [TestCase(ShearStrengthModel.SuCalculated, MacroStability.CSharpWrapper.Input.ShearStrengthModel.CuCalculated)]
         public static void CanConvertToConvertToMacroStabilityShearStrengthModel(
-            ShearStrengthModel damShearStrengthModel, MacroStability.Geometry.ShearStrengthModel kernelShearStrengthModel)
+            ShearStrengthModel damShearStrengthModel, MacroStability.CSharpWrapper.Input.ShearStrengthModel kernelShearStrengthModel)
         {
             Assert.AreEqual(kernelShearStrengthModel, ConversionHelper.ConvertToMacroStabilityShearStrengthModel(damShearStrengthModel));
         }
         #endregion
 
         #region WaterpressureInterpolationModel
-        [TestCase(Data.Geotechnics.WaterpressureInterpolationModel.Automatic, WaterpressureInterpolationModel.Automatic)]
-        [TestCase(Data.Geotechnics.WaterpressureInterpolationModel.Hydrostatic, WaterpressureInterpolationModel.Hydrostatic)]
+        [TestCase(Data.Geotechnics.WaterpressureInterpolationModel.Automatic, WaterPressureInterpolationModel.Automatic)]
+        [TestCase(Data.Geotechnics.WaterpressureInterpolationModel.Hydrostatic, WaterPressureInterpolationModel.Hydrostatic)]
         public static void CanConvertToMacroStabilityWaterpressureInterpolationModel(
-            Data.Geotechnics.WaterpressureInterpolationModel damWaterpressureInterpolationModel, WaterpressureInterpolationModel waterpressureInterpolationModel)
+            Data.Geotechnics.WaterpressureInterpolationModel damWaterpressureInterpolationModel, WaterPressureInterpolationModel waterpressureInterpolationModel)
         {
             Assert.AreEqual(waterpressureInterpolationModel, ConversionHelper.ConvertToMacroStabilityWaterpressureInterpolationModel(damWaterpressureInterpolationModel));
         }
 
-        [TestCase(WaterpressureInterpolationModel.Automatic, Data.Geotechnics.WaterpressureInterpolationModel.Automatic)]
-        [TestCase(WaterpressureInterpolationModel.Hydrostatic, Data.Geotechnics.WaterpressureInterpolationModel.Hydrostatic)]
+        [TestCase(WaterPressureInterpolationModel.Automatic, Data.Geotechnics.WaterpressureInterpolationModel.Automatic)]
+        [TestCase(WaterPressureInterpolationModel.Hydrostatic, Data.Geotechnics.WaterpressureInterpolationModel.Hydrostatic)]
         public static void CanConvertToDamWaterpressureInterpolationModel(
-            WaterpressureInterpolationModel waterpressureInterpolationModel, Data.Geotechnics.WaterpressureInterpolationModel damWaterpressureInterpolationModel)
+            WaterPressureInterpolationModel waterpressureInterpolationModel, Data.Geotechnics.WaterpressureInterpolationModel damWaterpressureInterpolationModel)
         {
             Assert.AreEqual(damWaterpressureInterpolationModel, ConversionHelper.ConvertToDamWaterpressureInterpolationModel(waterpressureInterpolationModel));
         }
         #endregion
 
         #region CharacteristicPointType
-        [TestCase(CharacteristicPointType.BottomDitchPolderSide, MacroStability.Geometry.CharacteristicPointType.BottomDitchPolderSide)]
-        [TestCase(CharacteristicPointType.BottomDitchDikeSide, MacroStability.Geometry.CharacteristicPointType.BottomDitchDikeSide)]
-        [TestCase(CharacteristicPointType.DikeLine, MacroStability.Geometry.CharacteristicPointType.DikeLine)]
-        [TestCase(CharacteristicPointType.DikeToeAtPolder, MacroStability.Geometry.CharacteristicPointType.DikeToeAtPolder)]
-        [TestCase(CharacteristicPointType.DikeToeAtRiver, MacroStability.Geometry.CharacteristicPointType.DikeToeAtRiver)]
-        [TestCase(CharacteristicPointType.DikeTopAtPolder, MacroStability.Geometry.CharacteristicPointType.DikeTopAtPolder)]
-        [TestCase(CharacteristicPointType.DikeTopAtRiver, MacroStability.Geometry.CharacteristicPointType.DikeTopAtRiver)]
-        [TestCase(CharacteristicPointType.DitchDikeSide, MacroStability.Geometry.CharacteristicPointType.DitchDikeSide)]
-        [TestCase(CharacteristicPointType.DitchPolderSide, MacroStability.Geometry.CharacteristicPointType.DitchPolderSide)]
-        [TestCase(CharacteristicPointType.None, MacroStability.Geometry.CharacteristicPointType.None)]
-        [TestCase(CharacteristicPointType.ShoulderBaseInside, MacroStability.Geometry.CharacteristicPointType.ShoulderBaseInside)]
-        [TestCase(CharacteristicPointType.ShoulderBaseOutside, MacroStability.Geometry.CharacteristicPointType.ShoulderBaseOutside)]
-        [TestCase(CharacteristicPointType.ShoulderTopInside, MacroStability.Geometry.CharacteristicPointType.ShoulderTopInside)]
-        [TestCase(CharacteristicPointType.ShoulderTopOutside, MacroStability.Geometry.CharacteristicPointType.ShoulderTopOutside)]
-        [TestCase(CharacteristicPointType.SurfaceLevelInside, MacroStability.Geometry.CharacteristicPointType.SurfaceLevelInside)]
-        [TestCase(CharacteristicPointType.SurfaceLevelOutside, MacroStability.Geometry.CharacteristicPointType.SurfaceLevelOutside)]
-        [TestCase(CharacteristicPointType.TrafficLoadInside, MacroStability.Geometry.CharacteristicPointType.TrafficLoadInside)]
-        [TestCase(CharacteristicPointType.TrafficLoadOutside, MacroStability.Geometry.CharacteristicPointType.TrafficLoadOutside)]
+        [TestCase(CharacteristicPointType.BottomDitchPolderSide, CharacteristicPoint.BottomDitchPolderSide)]
+        [TestCase(CharacteristicPointType.BottomDitchDikeSide, CharacteristicPoint.BottomDitchDikeSide)]
+        //[TestCase(CharacteristicPointType.DikeLine, CharacteristicPoint.DikeLine)]
+        [TestCase(CharacteristicPointType.DikeToeAtPolder, CharacteristicPoint.DikeToeAtPolder)]
+        [TestCase(CharacteristicPointType.DikeToeAtRiver, CharacteristicPoint.DikeToeAtRiver)]
+        [TestCase(CharacteristicPointType.DikeTopAtPolder, CharacteristicPoint.DikeTopAtPolder)]
+        [TestCase(CharacteristicPointType.DikeTopAtRiver, CharacteristicPoint.DikeTopAtRiver)]
+        [TestCase(CharacteristicPointType.DitchDikeSide, CharacteristicPoint.DitchDikeSide)]
+        [TestCase(CharacteristicPointType.DitchPolderSide, CharacteristicPoint.DitchPolderSide)]
+        [TestCase(CharacteristicPointType.None, CharacteristicPoint.None)]
+        [TestCase(CharacteristicPointType.ShoulderBaseInside, CharacteristicPoint.ShoulderBaseInside)]
+        [TestCase(CharacteristicPointType.ShoulderBaseOutside, CharacteristicPoint.ShoulderBaseOutside)]
+        [TestCase(CharacteristicPointType.ShoulderTopInside, CharacteristicPoint.ShoulderTopInside)]
+        [TestCase(CharacteristicPointType.ShoulderTopOutside, CharacteristicPoint.ShoulderTopOutside)]
+        [TestCase(CharacteristicPointType.SurfaceLevelInside, CharacteristicPoint.SurfaceLevelInside)]
+        [TestCase(CharacteristicPointType.SurfaceLevelOutside, CharacteristicPoint.SurfaceLevelOutside)]
+        [TestCase(CharacteristicPointType.TrafficLoadInside, CharacteristicPoint.TrafficLoadInside)]
+        [TestCase(CharacteristicPointType.TrafficLoadOutside, CharacteristicPoint.TrafficLoadOutside)]
         public static void CanConvertToMacroStabilityWaterpressureInterpolationModel(
-            CharacteristicPointType damCharacteristicPointType, MacroStability.Geometry.CharacteristicPointType kernelCharacteristicPointType)
+            CharacteristicPointType damCharacteristicPointType, CharacteristicPoint kernelCharacteristicPointType)
         {
             Assert.AreEqual(kernelCharacteristicPointType, ConversionHelper.ConvertToMacroStabilityCharacteristicPointType(damCharacteristicPointType));
         }
 
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.DikeLine, CharacteristicPointType.DikeLine)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.DitchDikeSide, CharacteristicPointType.DitchDikeSide)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.DitchPolderSide, CharacteristicPointType.DitchPolderSide)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.None, CharacteristicPointType.None)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside)]
-        [TestCase(MacroStability.Geometry.CharacteristicPointType.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside)]
+        [TestCase(CharacteristicPoint.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide)]
+        [TestCase(CharacteristicPoint.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide)]
+       // [TestCase(CharacteristicPoint.DikeLine, CharacteristicPointType.DikeLine)]
+        [TestCase(CharacteristicPoint.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder)]
+        [TestCase(CharacteristicPoint.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver)]
+        [TestCase(CharacteristicPoint.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder)]
+        [TestCase(CharacteristicPoint.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver)]
+        [TestCase(CharacteristicPoint.DitchDikeSide, CharacteristicPointType.DitchDikeSide)]
+        [TestCase(CharacteristicPoint.DitchPolderSide, CharacteristicPointType.DitchPolderSide)]
+        [TestCase(CharacteristicPoint.None, CharacteristicPointType.None)]
+        [TestCase(CharacteristicPoint.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside)]
+        [TestCase(CharacteristicPoint.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside)]
+        [TestCase(CharacteristicPoint.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside)]
+        [TestCase(CharacteristicPoint.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside)]
+        [TestCase(CharacteristicPoint.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside)]
+        [TestCase(CharacteristicPoint.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside)]
+        [TestCase(CharacteristicPoint.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside)]
+        [TestCase(CharacteristicPoint.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside)]
         public static void CanConvertToDamWaterpressureInterpolationModel(
-            MacroStability.Geometry.CharacteristicPointType kernelCharacteristicPointType, CharacteristicPointType damCharacteristicPointType)
+            CharacteristicPoint kernelCharacteristicPointType, CharacteristicPointType damCharacteristicPointType)
         {
             Assert.AreEqual(damCharacteristicPointType, ConversionHelper.ConvertToDamCharacteristicPointType(kernelCharacteristicPointType));
         }
         #endregion
 
         #region LogMessages
-        [TestCase(ValidationResultType.Info, Data.Standard.Logging.LogMessageType.Info)]
-        [TestCase(ValidationResultType.Warning, Data.Standard.Logging.LogMessageType.Warning)]
-        [TestCase(ValidationResultType.Error, Data.Standard.Logging.LogMessageType.Error)]
-        public void TestConvertKernelValidationResultTypeToLogMessageType(ValidationResultType validationResultType, LogMessageType logMessageType)
+        [TestCase(MacroStability.CSharpWrapper.Output.MessageType.Info, Data.Standard.Logging.LogMessageType.Info)]
+        [TestCase(MacroStability.CSharpWrapper.Output.MessageType.Warning, Data.Standard.Logging.LogMessageType.Warning)]
+        [TestCase(MacroStability.CSharpWrapper.Output.MessageType.Error, Data.Standard.Logging.LogMessageType.Error)]
+        public void TestConvertKernelValidationResultTypeToLogMessageType(MacroStability.CSharpWrapper.Output.MessageType validationResultType, LogMessageType logMessageType)
         {
             Assert.AreEqual(logMessageType,
                 ConversionHelper.ConvertKernelValidationResultTypeToLogMessageType(validationResultType));
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/ConversionHelper.cs
===================================================================
diff -u -r2904 -r2907
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 2904)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/MacroStabilityCommon/MacroStabilityIo/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 2907)
@@ -23,15 +23,14 @@
 using System.Collections.Generic;
 using Deltares.DamEngine.Data.General;
 using Deltares.DamEngine.Data.Geotechnics;
-using Deltares.MacroStability.Data;
-using Deltares.MacroStability.Geometry;
-using Deltares.MacroStability.Standard;
+using Deltares.MacroStability.CSharpWrapper.Input;
 using CharacteristicPointType = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType;
 using LogMessageType = Deltares.DamEngine.Data.Standard.Logging.LogMessageType;
 using ObjectExtensions = Deltares.DamEngine.Data.Standard.ObjectExtensions;
+using SearchAlgorithm = Deltares.MacroStability.CSharpWrapper.Input.SearchAlgorithm;
 using ShearStrengthModel = Deltares.DamEngine.Data.Geotechnics.ShearStrengthModel;
-using Soil = Deltares.MacroStability.Geometry.Soil;
-using WaterpressureInterpolationModel = Deltares.MacroStability.Geometry.WaterpressureInterpolationModel;
+using Soil = Deltares.MacroStability.CSharpWrapper.Input.Soil;
+using WaterpressureInterpolationModel = Deltares.MacroStability.CSharpWrapper.Input.WaterPressureInterpolationModel;
 
 namespace Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo
 {
@@ -77,14 +76,14 @@
         /// This comes back from the kernel side so any model that can be matched is OK.
         /// <param name="modelOption">The model option.</param>
         /// <returns>the Dam MStabModelType</returns>
-        public static MStabModelType ConvertToMStabModelType(ModelOptions modelOption)
+        public static MStabModelType ConvertToMStabModelType(Deltares.MacroStability.CSharpWrapper.Output.StabilityModelOption modelOption)
         {
             // For the macrostability kernel, the only really supported option for now is UpliftVan. But the other two could be options in future version
-            var translationTable = new Dictionary<ModelOptions, MStabModelType>()
+            var translationTable = new Dictionary<MacroStability.CSharpWrapper.Output.StabilityModelOption, MStabModelType>()
             {
-                {ModelOptions.Bishop, MStabModelType.BishopWti},
-                {ModelOptions.UpliftVan, MStabModelType.UpliftVanWti },
-                {ModelOptions.UpliftSpencer, MStabModelType.UpliftSpencerWti}
+                {MacroStability.CSharpWrapper.Output.StabilityModelOption.Bishop, MStabModelType.BishopWti},
+                {MacroStability.CSharpWrapper.Output.StabilityModelOption.UpliftVan, MStabModelType.UpliftVanWti },
+                //{MacroStability.CSharpWrapper.Output.StabilityModelOption.Spencer, MStabModelType.UpliftSpencerWti}
             };
             return translationTable[modelOption];
         }
@@ -93,16 +92,16 @@
         /// <param name="mStabModelType">the MStabModelType.</param>
         /// <returns>the MacroStability ModelOption</returns>
         /// <exception cref="System.ArgumentException"></exception>
-        public static ModelOptions ConvertToModelOptions(MStabModelType mStabModelType)
+        public static MacroStability.CSharpWrapper.Output.StabilityModelOption ConvertToModelOptions(MStabModelType mStabModelType)
         {
             // For the macrostability kernel, the only supported option for now is UpliftVan.
             if (mStabModelType != MStabModelType.UpliftVanWti)
             {
                 throw new ArgumentException(String.Format("Unsupported MStabModelType: {0}", mStabModelType));
             }
-            var translationTable = new Dictionary<MStabModelType, ModelOptions>()
+            var translationTable = new Dictionary<MStabModelType, MacroStability.CSharpWrapper.Output.StabilityModelOption>()
             {
-                {MStabModelType.UpliftVanWti, ModelOptions.UpliftVan}
+                {MStabModelType.UpliftVanWti, MacroStability.CSharpWrapper.Output.StabilityModelOption.UpliftVan}
             };
             return translationTable[mStabModelType];
         }
@@ -112,25 +111,25 @@
         /// <summary>Converts to MStabGridPosition.</summary>
         /// <param name="gridOrientation">The grid orientation.</param>
         /// <returns></returns>
-        public static MStabGridPosition ConvertToMStabGridPosition(GridOrientation gridOrientation)
+        public static MStabGridPosition ConvertToMStabGridPosition(Orientation gridOrientation)
         {
-            var translationTable = new Dictionary<GridOrientation, MStabGridPosition>()
+            var translationTable = new Dictionary<Orientation, MStabGridPosition>()
             {
-                {GridOrientation.Inwards, MStabGridPosition.Right},
-                {GridOrientation.Outwards, MStabGridPosition.Left}
+                {Orientation.Inwards, MStabGridPosition.Right},
+                {Orientation.Outwards, MStabGridPosition.Left}
             };
             return translationTable[gridOrientation];
         }
 
         /// <summary>Converts to GridOrientation.</summary>
         /// <param name="mStabGridPosition">The MStabGridPosition.</param>
         /// <returns></returns>
-        public static GridOrientation ConvertToGridOrientation(MStabGridPosition mStabGridPosition)
+        public static Orientation ConvertToGridOrientation(MStabGridPosition mStabGridPosition)
         {
-            var translationTable = new Dictionary<MStabGridPosition, GridOrientation>()
+            var translationTable = new Dictionary<MStabGridPosition, Orientation>()
             {
-                {MStabGridPosition.Right, GridOrientation.Inwards},
-                {MStabGridPosition.Left, GridOrientation.Outwards}
+                {MStabGridPosition.Right, Orientation.Inwards},
+                {MStabGridPosition.Left, Orientation.Outwards}
             };
             return translationTable[mStabGridPosition];
         }
@@ -153,7 +152,7 @@
                 RatioCuPc = soil.RatioCuPc,
                 RheologicalCoefficient = 0.0, // TODO find the correct parameter
                 StrengthIncreaseExponent = 0.0, // TODO find the correct parameter
-                UseSoilType = true, // TODO find the correct parameter
+                UseSoilClassification = true,// TODO find the correct parameter
                 BondStressCurve = null // TODO find the correct parameter
             };
             if (soil.ShearStrengthModel != null)
@@ -162,7 +161,7 @@
             }
             else
             {
-                macroStabilitySoil.ShearStrengthModel = MacroStability.Geometry.ShearStrengthModel.None;
+                macroStabilitySoil.ShearStrengthModel = MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhi;
             }
             switch (soil.DilatancyType)
             {
@@ -237,13 +236,13 @@
         /// <summary>Converts to dam ShearStrengthModel.</summary>
         /// <param name="kernelShearStrengthModel">The kernel ShearStrengthModel.</param>
         /// <returns></returns>
-        public static ShearStrengthModel ConvertToDamShearStrengthModel(MacroStability.Geometry.ShearStrengthModel kernelShearStrengthModel)
+        public static ShearStrengthModel ConvertToDamShearStrengthModel(MacroStability.CSharpWrapper.Input.ShearStrengthModel kernelShearStrengthModel)
         {
-            var translationTable = new Dictionary<MacroStability.Geometry.ShearStrengthModel, ShearStrengthModel>()
+            var translationTable = new Dictionary<MacroStability.CSharpWrapper.Input.ShearStrengthModel, ShearStrengthModel>()
             {
-                {MacroStability.Geometry.ShearStrengthModel.CPhi, ShearStrengthModel.CPhi},
-                {MacroStability.Geometry.ShearStrengthModel.CPhiOrCuCalculated, ShearStrengthModel.CPhiOrSuCalculated},
-                {MacroStability.Geometry.ShearStrengthModel.CuCalculated, ShearStrengthModel.SuCalculated}
+                {MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhi, ShearStrengthModel.CPhi},
+                {MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhiOrCuCalculated, ShearStrengthModel.CPhiOrSuCalculated},
+                {MacroStability.CSharpWrapper.Input.ShearStrengthModel.CuCalculated, ShearStrengthModel.SuCalculated}
             };
             return translationTable[kernelShearStrengthModel];
         }
@@ -252,7 +251,7 @@
         /// <param name="damShearStrengthModel">The dam ShearStrengthModel.</param>
         /// <returns></returns>
         /// <exception cref="System.ArgumentException"></exception>
-        public static MacroStability.Geometry.ShearStrengthModel ConvertToMacroStabilityShearStrengthModel(ShearStrengthModel damShearStrengthModel)
+        public static MacroStability.CSharpWrapper.Input.ShearStrengthModel ConvertToMacroStabilityShearStrengthModel(ShearStrengthModel damShearStrengthModel)
         {
             if (damShearStrengthModel == ShearStrengthModel.SuCalculatedWithYield || damShearStrengthModel == ShearStrengthModel.None ||
                 damShearStrengthModel == ShearStrengthModel.PseudoValues || damShearStrengthModel == ShearStrengthModel.StressTable ||
@@ -261,11 +260,11 @@
                 throw new ArgumentException(string.Format("Cannot convert dam ShearStrengthModel: {0}", damShearStrengthModel));
             }
 
-            var translationTable = new Dictionary<ShearStrengthModel, MacroStability.Geometry.ShearStrengthModel>()
+            var translationTable = new Dictionary<ShearStrengthModel, MacroStability.CSharpWrapper.Input.ShearStrengthModel>()
             {
-                {ShearStrengthModel.CPhi, MacroStability.Geometry.ShearStrengthModel.CPhi},
-                {ShearStrengthModel.CPhiOrSuCalculated, MacroStability.Geometry.ShearStrengthModel.CPhiOrCuCalculated},
-                {ShearStrengthModel.SuCalculated, MacroStability.Geometry.ShearStrengthModel.CuCalculated}
+                {ShearStrengthModel.CPhi, MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhi},
+                {ShearStrengthModel.CPhiOrSuCalculated, MacroStability.CSharpWrapper.Input.ShearStrengthModel.CPhiOrCuCalculated},
+                {ShearStrengthModel.SuCalculated, MacroStability.CSharpWrapper.Input.ShearStrengthModel.CuCalculated}
             };
             return translationTable[damShearStrengthModel];
         }
@@ -304,57 +303,57 @@
         /// <summary>Converts the type of to dam characteristic point.</summary>
         /// <param name="kernelCharacteristicPointType">Type of the kernel characteristic point.</param>
         /// <returns></returns>
-        public static CharacteristicPointType ConvertToDamCharacteristicPointType(MacroStability.Geometry.CharacteristicPointType kernelCharacteristicPointType)
+        public static CharacteristicPointType ConvertToDamCharacteristicPointType(MacroStability.CSharpWrapper.Input.CharacteristicPoint kernelCharacteristicPointType)
         {
-            var translationTable = new Dictionary<MacroStability.Geometry.CharacteristicPointType, CharacteristicPointType>()
+            var translationTable = new Dictionary<MacroStability.CSharpWrapper.Input.CharacteristicPoint, CharacteristicPointType>()
             {
-                {MacroStability.Geometry.CharacteristicPointType.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide},
-                {MacroStability.Geometry.CharacteristicPointType.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide},
-                {MacroStability.Geometry.CharacteristicPointType.DikeLine, CharacteristicPointType.DikeLine},
-                {MacroStability.Geometry.CharacteristicPointType.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder},
-                {MacroStability.Geometry.CharacteristicPointType.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver},
-                {MacroStability.Geometry.CharacteristicPointType.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder},
-                {MacroStability.Geometry.CharacteristicPointType.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver},
-                {MacroStability.Geometry.CharacteristicPointType.DitchDikeSide, CharacteristicPointType.DitchDikeSide},
-                {MacroStability.Geometry.CharacteristicPointType.DitchPolderSide, CharacteristicPointType.DitchPolderSide},
-                {MacroStability.Geometry.CharacteristicPointType.None, CharacteristicPointType.None},
-                {MacroStability.Geometry.CharacteristicPointType.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside},
-                {MacroStability.Geometry.CharacteristicPointType.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside},
-                {MacroStability.Geometry.CharacteristicPointType.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside},
-                {MacroStability.Geometry.CharacteristicPointType.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside},
-                {MacroStability.Geometry.CharacteristicPointType.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside},
-                {MacroStability.Geometry.CharacteristicPointType.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside},
-                {MacroStability.Geometry.CharacteristicPointType.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside},
-                {MacroStability.Geometry.CharacteristicPointType.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside}
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide},
+             //   {MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeLine, CharacteristicPointType.DikeLine},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.DitchDikeSide, CharacteristicPointType.DitchDikeSide},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.DitchPolderSide, CharacteristicPointType.DitchPolderSide},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.None, CharacteristicPointType.None},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside},
+                {MacroStability.CSharpWrapper.Input.CharacteristicPoint.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside}
             };
             return translationTable[kernelCharacteristicPointType];
         }
 
         /// <summary>Converts the type of to macro stability characteristic point.</summary>
         /// <param name="damCharacteristicPointType">Type of the dam characteristic point.</param>
         /// <returns></returns>
-        public static MacroStability.Geometry.CharacteristicPointType ConvertToMacroStabilityCharacteristicPointType(CharacteristicPointType damCharacteristicPointType)
+        public static MacroStability.CSharpWrapper.Input.CharacteristicPoint ConvertToMacroStabilityCharacteristicPointType(CharacteristicPointType damCharacteristicPointType)
         {
-            var translationTable = new Dictionary<CharacteristicPointType, MacroStability.Geometry.CharacteristicPointType>()
+            var translationTable = new Dictionary<CharacteristicPointType, MacroStability.CSharpWrapper.Input.CharacteristicPoint>()
             {
-                {CharacteristicPointType.BottomDitchPolderSide, MacroStability.Geometry.CharacteristicPointType.BottomDitchPolderSide},
-                {CharacteristicPointType.BottomDitchDikeSide, MacroStability.Geometry.CharacteristicPointType.BottomDitchDikeSide},
-                {CharacteristicPointType.DikeLine, MacroStability.Geometry.CharacteristicPointType.DikeLine},
-                {CharacteristicPointType.DikeToeAtPolder, MacroStability.Geometry.CharacteristicPointType.DikeToeAtPolder},
-                {CharacteristicPointType.DikeToeAtRiver, MacroStability.Geometry.CharacteristicPointType.DikeToeAtRiver},
-                {CharacteristicPointType.DikeTopAtPolder, MacroStability.Geometry.CharacteristicPointType.DikeTopAtPolder},
-                {CharacteristicPointType.DikeTopAtRiver, MacroStability.Geometry.CharacteristicPointType.DikeTopAtRiver},
-                {CharacteristicPointType.DitchDikeSide, MacroStability.Geometry.CharacteristicPointType.DitchDikeSide},
-                {CharacteristicPointType.DitchPolderSide, MacroStability.Geometry.CharacteristicPointType.DitchPolderSide},
-                {CharacteristicPointType.None, MacroStability.Geometry.CharacteristicPointType.None},
-                {CharacteristicPointType.ShoulderBaseInside, MacroStability.Geometry.CharacteristicPointType.ShoulderBaseInside},
-                {CharacteristicPointType.ShoulderBaseOutside, MacroStability.Geometry.CharacteristicPointType.ShoulderBaseOutside},
-                {CharacteristicPointType.ShoulderTopInside, MacroStability.Geometry.CharacteristicPointType.ShoulderTopInside},
-                {CharacteristicPointType.ShoulderTopOutside, MacroStability.Geometry.CharacteristicPointType.ShoulderTopOutside},
-                {CharacteristicPointType.SurfaceLevelInside, MacroStability.Geometry.CharacteristicPointType.SurfaceLevelInside},
-                {CharacteristicPointType.SurfaceLevelOutside, MacroStability.Geometry.CharacteristicPointType.SurfaceLevelOutside},
-                {CharacteristicPointType.TrafficLoadInside, MacroStability.Geometry.CharacteristicPointType.TrafficLoadInside},
-                {CharacteristicPointType.TrafficLoadOutside, MacroStability.Geometry.CharacteristicPointType.TrafficLoadOutside}
+                {CharacteristicPointType.BottomDitchPolderSide, MacroStability.CSharpWrapper.Input.CharacteristicPoint.BottomDitchPolderSide},
+                {CharacteristicPointType.BottomDitchDikeSide, MacroStability.CSharpWrapper.Input.CharacteristicPoint.BottomDitchDikeSide},
+                //{CharacteristicPointType.DikeLine, MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeLine},
+                {CharacteristicPointType.DikeToeAtPolder, MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeToeAtPolder},
+                {CharacteristicPointType.DikeToeAtRiver, MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeToeAtRiver},
+                {CharacteristicPointType.DikeTopAtPolder, MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeTopAtPolder},
+                {CharacteristicPointType.DikeTopAtRiver, MacroStability.CSharpWrapper.Input.CharacteristicPoint.DikeTopAtRiver},
+                {CharacteristicPointType.DitchDikeSide, MacroStability.CSharpWrapper.Input.CharacteristicPoint.DitchDikeSide},
+                {CharacteristicPointType.DitchPolderSide, MacroStability.CSharpWrapper.Input.CharacteristicPoint.DitchPolderSide},
+                {CharacteristicPointType.None, MacroStability.CSharpWrapper.Input.CharacteristicPoint.None},
+                {CharacteristicPointType.ShoulderBaseInside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderBaseInside},
+                {CharacteristicPointType.ShoulderBaseOutside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderBaseOutside},
+                {CharacteristicPointType.ShoulderTopInside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderTopInside},
+                {CharacteristicPointType.ShoulderTopOutside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.ShoulderTopOutside},
+                {CharacteristicPointType.SurfaceLevelInside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.SurfaceLevelInside},
+                {CharacteristicPointType.SurfaceLevelOutside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.SurfaceLevelOutside},
+                {CharacteristicPointType.TrafficLoadInside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.TrafficLoadInside},
+                {CharacteristicPointType.TrafficLoadOutside, MacroStability.CSharpWrapper.Input.CharacteristicPoint.TrafficLoadOutside}
             };
             return translationTable[damCharacteristicPointType];
         }
@@ -366,13 +365,13 @@
         /// </summary>
         /// <param name="messageType">Type of the message.</param>
         /// <returns></returns>
-        public static LogMessageType ConvertKernelValidationResultTypeToLogMessageType(ValidationResultType messageType)
+        public static LogMessageType ConvertKernelValidationResultTypeToLogMessageType(MacroStability.CSharpWrapper.Output.MessageType messageType)
         {
-            var translationTable = new Dictionary<ValidationResultType, LogMessageType>()
+            var translationTable = new Dictionary<MacroStability.CSharpWrapper.Output.MessageType, LogMessageType>()
             {
-                {ValidationResultType.Info, LogMessageType.Info},
-                {ValidationResultType.Warning, LogMessageType.Warning},
-                {ValidationResultType.Error, LogMessageType.Error}
+                {MacroStability.CSharpWrapper.Output.MessageType.Info, LogMessageType.Info},
+                {MacroStability.CSharpWrapper.Output.MessageType.Warning, LogMessageType.Warning},
+                {MacroStability.CSharpWrapper.Output.MessageType.Error, LogMessageType.Error}
             };
             return translationTable[messageType];
         }