Index: DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs
===================================================================
diff -u -r6157 -r6196
--- DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 6157)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 6196)
@@ -181,53 +181,53 @@
     }
 
     [Test]
-    [TestCase(SoilProfileType.ProfileType1D, 0)]
-    [TestCase(SoilProfileType.ProfileType2D, 1)]
-    public void CanConvertToInputSoilGeometryType(SoilProfileType soilProfileType, int inputSoilGeometryType)
+    [TestCase(SoilProfileType.ProfileType1D, SegmentSoilGeometryProbabilitySoilProfileType.ProfileType1D)]
+    [TestCase(SoilProfileType.ProfileType2D, SegmentSoilGeometryProbabilitySoilProfileType.ProfileType2D)]
+    public void CanConvertToInputSoilGeometryType(SoilProfileType soilProfileType, SegmentSoilGeometryProbabilitySoilProfileType inputSoilGeometryType)
     {
         Assert.That(ConversionHelper.ConvertToInputSoilGeometryType(soilProfileType), Is.EqualTo(inputSoilGeometryType));
     }
 
     [Test]
-    [TestCase(0, SoilProfileType.ProfileType1D)]
-    [TestCase(1, SoilProfileType.ProfileType2D)]
-    public void CanConvertToSoilGeometryType(int inputSoilGeometryType, SoilProfileType soilProfileType)
+    [TestCase(SegmentSoilGeometryProbabilitySoilProfileType.ProfileType1D, SoilProfileType.ProfileType1D)]
+    [TestCase(SegmentSoilGeometryProbabilitySoilProfileType.ProfileType2D, SoilProfileType.ProfileType2D)]
+    public void CanConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilProfileType inputSoilGeometryType, SoilProfileType soilProfileType)
     {
         Assert.That(ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryType), Is.EqualTo(soilProfileType));
     }
 
     [Test]
-    [TestCase(FailureMechanismSystemType.StabilityInside, ConversionHelper.InputFailureMechanismStabilityInside)]
-    [TestCase(FailureMechanismSystemType.StabilityOutside, ConversionHelper.InputFailureMechanismStabilityOutside)]
-    [TestCase(FailureMechanismSystemType.Piping, ConversionHelper.InputFailureMechanismPiping)]
-    public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, int inputFailureMechanismSystemType)
+    [TestCase(FailureMechanismSystemType.StabilityInside, InputFailureMechanismSystemType.StabilityInside)]
+    [TestCase(FailureMechanismSystemType.StabilityOutside, InputFailureMechanismSystemType.StabilityOutside)]
+    [TestCase(FailureMechanismSystemType.Piping, InputFailureMechanismSystemType.Piping)]
+    public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, InputFailureMechanismSystemType inputFailureMechanismSystemType)
     {
         Assert.That(ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType), Is.EqualTo(inputFailureMechanismSystemType));
     }
 
     [Test]
-    [TestCase(ConversionHelper.InputFailureMechanismStabilityInside, FailureMechanismSystemType.StabilityInside)]
-    [TestCase(ConversionHelper.InputFailureMechanismStabilityOutside, FailureMechanismSystemType.StabilityOutside)]
-    [TestCase(ConversionHelper.InputFailureMechanismPiping, FailureMechanismSystemType.Piping)]
-    public void CanConvertToFailureMechanismSystemType(int inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
+    [TestCase(InputFailureMechanismSystemType.StabilityInside, FailureMechanismSystemType.StabilityInside)]
+    [TestCase(InputFailureMechanismSystemType.StabilityOutside, FailureMechanismSystemType.StabilityOutside)]
+    [TestCase(InputFailureMechanismSystemType.Piping, FailureMechanismSystemType.Piping)]
+    public void CanConvertToFailureMechanismSystemType(InputFailureMechanismSystemType inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
     {
         Assert.That(ConversionHelper.ConvertToFailureMechanismSystemType(inputFailureMechanismSystemType), Is.EqualTo(failureMechanismSystemType));
     }
 
     [Test]
-    [TestCase(SegmentFailureMechanismType.All, ConversionHelper.InputSegmentFailureMechanismAll)]
-    [TestCase(SegmentFailureMechanismType.Stability, ConversionHelper.InputSegmentFailureMechanismStability)]
-    [TestCase(SegmentFailureMechanismType.Piping, ConversionHelper.InputSegmentFailureMechanismPiping)]
-    public void CanConvertToInputFailureMechanismSystemType(SegmentFailureMechanismType failureMechanismSystemType, int inputFailureMechanismSystemType)
+    [TestCase(SegmentFailureMechanismType.All, SegmentSoilGeometryProbabilitySegmentFailureMechanismType.All)]
+    [TestCase(SegmentFailureMechanismType.Stability, SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Stability)]
+    [TestCase(SegmentFailureMechanismType.Piping, SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Piping)]
+    public void CanConvertToInputFailureMechanismSystemType(SegmentFailureMechanismType failureMechanismSystemType, SegmentSoilGeometryProbabilitySegmentFailureMechanismType inputFailureMechanismSystemType)
     {
         Assert.That(ConversionHelper.ConvertToInputSegmentFailureMechanismSystemType(failureMechanismSystemType), Is.EqualTo(inputFailureMechanismSystemType));
     }
 
     [Test]
-    [TestCase(ConversionHelper.InputSegmentFailureMechanismAll, SegmentFailureMechanismType.All)]
-    [TestCase(ConversionHelper.InputSegmentFailureMechanismStability, SegmentFailureMechanismType.Stability)]
-    [TestCase(ConversionHelper.InputSegmentFailureMechanismPiping, SegmentFailureMechanismType.Piping)]
-    public void CanConvertToFailureMechanismSystemType(int inputFailureMechanismSystemType, SegmentFailureMechanismType failureMechanismSystemType)
+    [TestCase(SegmentSoilGeometryProbabilitySegmentFailureMechanismType.All, SegmentFailureMechanismType.All)]
+    [TestCase(SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Stability, SegmentFailureMechanismType.Stability)]
+    [TestCase(SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Piping, SegmentFailureMechanismType.Piping)]
+    public void CanConvertToFailureMechanismSystemType(SegmentSoilGeometryProbabilitySegmentFailureMechanismType inputFailureMechanismSystemType, SegmentFailureMechanismType failureMechanismSystemType)
     {
         Assert.That(ConversionHelper.ConvertToSegmentFailureMechanismSystemType(inputFailureMechanismSystemType), Is.EqualTo(failureMechanismSystemType));
     }
@@ -269,34 +269,33 @@
     }
 
     [Test]
-    [TestCase(MStabZonesType.NoZones, ConversionHelper.InputZoneTypeNoZones)]
-    [TestCase(MStabZonesType.ForbiddenZone, ConversionHelper.InputZoneTypesForbiddenZones)]
-    public void CanConvertToInputZoneType(MStabZonesType zoneType, int inputZoneType)
+    [TestCase(MStabZonesType.NoZones, LocationStabilityOptionsZoneType.NoZones)]
+    [TestCase(MStabZonesType.ForbiddenZone, LocationStabilityOptionsZoneType.ForbiddenZones)]
+    public void CanConvertToInputZoneType(MStabZonesType zoneType, LocationStabilityOptionsZoneType inputZoneType)
     {
         Assert.That(ConversionHelper.ConvertToInputZoneType(zoneType), Is.EqualTo(inputZoneType));
     }
 
     [Test]
-    [TestCase(ConversionHelper.InputZoneTypeNoZones, MStabZonesType.NoZones)]
-    [TestCase(ConversionHelper.InputZoneTypeOldZoneArea, MStabZonesType.NoZones)]
-    [TestCase(ConversionHelper.InputZoneTypesForbiddenZones, MStabZonesType.ForbiddenZone)]
-    public void CanConvertToZoneType(int inputZoneType, MStabZonesType zoneType)
+    [TestCase(LocationStabilityOptionsZoneType.NoZones, MStabZonesType.NoZones)]
+    [TestCase(LocationStabilityOptionsZoneType.ForbiddenZones, MStabZonesType.ForbiddenZone)]
+    public void CanConvertToZoneType(LocationStabilityOptionsZoneType inputZoneType, MStabZonesType zoneType)
     {
         Assert.That(ConversionHelper.ConvertToZoneType(inputZoneType), Is.EqualTo(zoneType));
     }
 
     [Test]
-    [TestCase(MStabSearchMethod.Grid, ConversionHelper.InputSearchMethodGrid)]
-    [TestCase(MStabSearchMethod.BeeSwarm, ConversionHelper.InputSearchMethodBeeSwarm)]
-    public void CanConvertToInputSearchMethod(MStabSearchMethod searchMethod, int inputSearchMethod)
+    [TestCase(MStabSearchMethod.Grid, StabilityParametersSearchMethod.CalculationGrid)]
+    [TestCase(MStabSearchMethod.BeeSwarm, StabilityParametersSearchMethod.BeeSwarm)]
+    public void CanConvertToInputSearchMethod(MStabSearchMethod searchMethod, StabilityParametersSearchMethod inputSearchMethod)
     {
         Assert.That(ConversionHelper.ConvertToInputSearchMethod(searchMethod), Is.EqualTo(inputSearchMethod));
     }
 
     [Test]
-    [TestCase(ConversionHelper.InputSearchMethodGrid, MStabSearchMethod.Grid)]
-    [TestCase(ConversionHelper.InputSearchMethodBeeSwarm, MStabSearchMethod.BeeSwarm)]
-    public void CanConvertToSearchMethod(int inputSearchMethod, MStabSearchMethod searchMethod)
+    [TestCase(StabilityParametersSearchMethod.CalculationGrid, MStabSearchMethod.Grid)]
+    [TestCase(StabilityParametersSearchMethod.BeeSwarm, MStabSearchMethod.BeeSwarm)]
+    public void CanConvertToSearchMethod(StabilityParametersSearchMethod inputSearchMethod, MStabSearchMethod searchMethod)
     {
         Assert.That(ConversionHelper.ConvertToSearchMethod(inputSearchMethod), Is.EqualTo(searchMethod));
     }
@@ -332,22 +331,38 @@
     }
 
     [Test]
-    [TestCase(GridSizeDetermination.Automatic, ConversionHelper.InputGridTypeAutomatic)]
-    [TestCase(GridSizeDetermination.Specified, ConversionHelper.InputGridTypeSpecified)]
-    public void CanConvertToInputGridSizeDetermination(GridSizeDetermination gridDetermination, int inputGridDetermination)
+    [TestCase(GridSizeDetermination.Automatic, StabilityParametersBishopSearchAreaDetermination.Automatic)]
+    [TestCase(GridSizeDetermination.Specified, StabilityParametersBishopSearchAreaDetermination.Specified)]
+    public void CanConvertToInputBishopSearchAreaDetermination(GridSizeDetermination gridDetermination, StabilityParametersBishopSearchAreaDetermination inputGridDetermination)
     {
-        Assert.That(ConversionHelper.ConvertToInputGridDetermination(gridDetermination), Is.EqualTo(inputGridDetermination));
+        Assert.That(ConversionHelper.ConvertToInputBishopSearchAreaDetermination(gridDetermination), Is.EqualTo(inputGridDetermination));
     }
 
     [Test]
-    [TestCase(ConversionHelper.InputGridTypeAutomatic, GridSizeDetermination.Automatic)]
-    [TestCase(ConversionHelper.InputGridTypeSpecified, GridSizeDetermination.Specified)]
-    public void CanConvertToGridSizeDetermination(int inputGridDetermination, GridSizeDetermination gridDetermination)
+    [TestCase(StabilityParametersBishopSearchAreaDetermination.Automatic, GridSizeDetermination.Automatic)]
+    [TestCase(StabilityParametersBishopSearchAreaDetermination.Specified, GridSizeDetermination.Specified)]
+    public void CanConvertToBishopSearchAreaDetermination(StabilityParametersBishopSearchAreaDetermination inputGridDetermination, GridSizeDetermination gridDetermination)
     {
-        Assert.That(ConversionHelper.ConvertToGridDetermination(inputGridDetermination), Is.EqualTo(gridDetermination));
+        Assert.That(ConversionHelper.ConvertToBishopSearchAreaDetermination(inputGridDetermination), Is.EqualTo(gridDetermination));
     }
+    
+    [Test]
+    [TestCase(GridSizeDetermination.Automatic, StabilityParametersUpliftVanGridDetermination.Automatic)]
+    [TestCase(GridSizeDetermination.Specified, StabilityParametersUpliftVanGridDetermination.Specified)]
+    public void CanConvertToInputUpliftVanGridSizeDetermination(GridSizeDetermination gridDetermination, StabilityParametersUpliftVanGridDetermination inputGridDetermination)
+    {
+        Assert.That(ConversionHelper.ConvertToInputUpliftVanGridDetermination(gridDetermination), Is.EqualTo(inputGridDetermination));
+    }
 
     [Test]
+    [TestCase(StabilityParametersUpliftVanGridDetermination.Automatic, GridSizeDetermination.Automatic)]
+    [TestCase(StabilityParametersUpliftVanGridDetermination.Specified, GridSizeDetermination.Specified)]
+    public void CanConvertToUpliftVanGridSizeDetermination(StabilityParametersUpliftVanGridDetermination inputGridDetermination, GridSizeDetermination gridDetermination)
+    {
+        Assert.That(ConversionHelper.ConvertToUpliftVanGridDetermination(inputGridDetermination), Is.EqualTo(gridDetermination));
+    }
+
+    [Test]
     [TestCase(SoilShearStrengthModel.CPhi, ShearStrengthModel.CPhi)]
     [TestCase(SoilShearStrengthModel.SuCalculated, ShearStrengthModel.SuCalculated)]
     [TestCase(SoilShearStrengthModel.SigmaTauCurve, ShearStrengthModel.SigmaTauCurve)]
@@ -357,19 +372,19 @@
     }
 
     [Test]
-    [TestCase(TangentLinesDefinition.OnBoundaryLines, ConversionHelper.InputTangentLinesOnBoundaryLines)]
-    [TestCase(TangentLinesDefinition.Specified, ConversionHelper.InputTangentLinesSpecified)]
-    [TestCase(TangentLinesDefinition.Automatic, ConversionHelper.InputTangentLinesAutomatic)]
-    public void CanConvertToInputTangentLinesDefinition(TangentLinesDefinition tangentLineType, int inputTangentLineType)
+    [TestCase(TangentLinesDefinition.OnBoundaryLines, StabilityParametersUpliftVanTangentLinesDefinition.OnBoundaryLines)]
+    [TestCase(TangentLinesDefinition.Specified, StabilityParametersUpliftVanTangentLinesDefinition.Specified)]
+    [TestCase(TangentLinesDefinition.Automatic, StabilityParametersUpliftVanTangentLinesDefinition.Automatic)]
+    public void CanConvertToInputTangentLinesDefinition(TangentLinesDefinition tangentLineType, StabilityParametersUpliftVanTangentLinesDefinition inputTangentLineType)
     {
         Assert.That(ConversionHelper.ConvertToInputTangentLinesDefinition(tangentLineType), Is.EqualTo(inputTangentLineType));
     }
 
     [Test]
-    [TestCase(ConversionHelper.InputTangentLinesOnBoundaryLines, TangentLinesDefinition.OnBoundaryLines)]
-    [TestCase(ConversionHelper.InputTangentLinesSpecified, TangentLinesDefinition.Specified)]
-    [TestCase(ConversionHelper.InputTangentLinesAutomatic, TangentLinesDefinition.Automatic)]
-    public void CanConvertToTangentLinesDefinition(int inputTangentLineType, TangentLinesDefinition tangentLineType)
+    [TestCase(StabilityParametersUpliftVanTangentLinesDefinition.OnBoundaryLines, TangentLinesDefinition.OnBoundaryLines)]
+    [TestCase(StabilityParametersUpliftVanTangentLinesDefinition.Specified, TangentLinesDefinition.Specified)]
+    [TestCase(StabilityParametersUpliftVanTangentLinesDefinition.Automatic, TangentLinesDefinition.Automatic)]
+    public void CanConvertToTangentLinesDefinition(StabilityParametersUpliftVanTangentLinesDefinition inputTangentLineType, TangentLinesDefinition tangentLineType)
     {
         Assert.That(ConversionHelper.ConvertToTangentLinesDefinition(inputTangentLineType), Is.EqualTo(tangentLineType));
     }