Index: DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs
===================================================================
diff -u -r1618 -r1723
--- DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 1618)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 1723)
@@ -387,151 +387,151 @@
         }
 
         [Test]
-        [TestCase(LoadSituation.Dry, 0)]
-        [TestCase(LoadSituation.Wet, 1)]
+        [TestCase(LoadSituation.Dry, ConversionHelper.LoadSituationDry)]
+        [TestCase(LoadSituation.Wet, ConversionHelper.LoadSituationWet)]
         public void CanConvertToOutputLoadSituation(LoadSituation loadSituation, int outputLoadSituation)
         {
             Assert.AreEqual(outputLoadSituation, ConversionHelper.ConvertToOutputLoadSituation(loadSituation));
         }
 
         [Test]
-        [TestCase(0, LoadSituation.Dry)]
-        [TestCase(1, LoadSituation.Wet)]
+        [TestCase(ConversionHelper.LoadSituationDry, LoadSituation.Dry)]
+        [TestCase(ConversionHelper.LoadSituationWet, LoadSituation.Wet)]
         public void CanConvertToLoadSituation(int outputLoadSituation, LoadSituation loadSituation)
         {
             Assert.AreEqual(loadSituation, ConversionHelper.ConvertToLoadSituation(outputLoadSituation));
         }
 
         [Test]
-        [TestCase(DikeDrySensitivity.None, 0)]
-        [TestCase(DikeDrySensitivity.Dry, 1)]
+        [TestCase(DikeDrySensitivity.None, ConversionHelper.DikeDrySensitivityNone)]
+        [TestCase(DikeDrySensitivity.Dry, ConversionHelper.DikeDrySensitivityDry)]
         public void CanConvertToOutputDikeDrySensitivity(DikeDrySensitivity dikeDrySensitivity, int outputDikeDrySensitivity)
         {
             Assert.AreEqual(outputDikeDrySensitivity, ConversionHelper.ConvertToOutputDikeDrySensitivity(dikeDrySensitivity));
         }
 
         [Test]
-        [TestCase(0, DikeDrySensitivity.None)]
-        [TestCase(1, DikeDrySensitivity.Dry)]
+        [TestCase(ConversionHelper.DikeDrySensitivityNone, DikeDrySensitivity.None)]
+        [TestCase(ConversionHelper.DikeDrySensitivityDry, DikeDrySensitivity.Dry)]
         public void CanConvertToDikeDrySensitivity(int outputDikeDrySensitivity, DikeDrySensitivity dikeDrySensitivity)
         {
             Assert.AreEqual(dikeDrySensitivity, ConversionHelper.ConvertToDikeDrySensitivity(outputDikeDrySensitivity));
         }
 
 
         [Test]
-        [TestCase(HydraulicShortcutType.HydraulicShortcut, 0)]
-        [TestCase(HydraulicShortcutType.NoHydraulicShortcut, 1)]
+        [TestCase(HydraulicShortcutType.HydraulicShortcut, ConversionHelper.HydraulicShortcutTypeHydraulicShortcut)]
+        [TestCase(HydraulicShortcutType.NoHydraulicShortcut, ConversionHelper.HydraulicShortcutTypeNoHydraulicShortcut)]
         public void CanConvertToOutputHydraulicShortcutType(HydraulicShortcutType hydraulicShortcutType, int outputHydraulicShortcutType)
         {
             Assert.AreEqual(outputHydraulicShortcutType, ConversionHelper.ConvertToOutputHydraulicShortcutType(hydraulicShortcutType));
         }
 
         [Test]
-        [TestCase(0, HydraulicShortcutType.HydraulicShortcut)]
-        [TestCase(1, HydraulicShortcutType.NoHydraulicShortcut)]
+        [TestCase(ConversionHelper.HydraulicShortcutTypeHydraulicShortcut, HydraulicShortcutType.HydraulicShortcut)]
+        [TestCase(ConversionHelper.HydraulicShortcutTypeNoHydraulicShortcut, HydraulicShortcutType.NoHydraulicShortcut)]
         public void CanConvertToHydraulicShortcutType(int outputHydraulicShortcutType, HydraulicShortcutType hydraulicShortcutType)
         {
             Assert.AreEqual(hydraulicShortcutType, ConversionHelper.ConvertToHydraulicShortcutType(outputHydraulicShortcutType));
         }
 
         [Test]
-        [TestCase(UpliftType.Uplift, 0)]
-        [TestCase(UpliftType.NoUplift, 1)]
+        [TestCase(UpliftType.Uplift, ConversionHelper.UpliftTypeUplift)]
+        [TestCase(UpliftType.NoUplift, ConversionHelper.UpliftTypeNoUplift)]
         public void CanConvertToOutputUpliftType(UpliftType upliftType, int outputUpliftType)
         {
             Assert.AreEqual(outputUpliftType, ConversionHelper.ConvertToOutputUpliftType(upliftType));
         }
 
         [Test]
-        [TestCase(0, UpliftType.Uplift)]
-        [TestCase(1, UpliftType.NoUplift)]
+        [TestCase(ConversionHelper.UpliftTypeUplift, UpliftType.Uplift)]
+        [TestCase(ConversionHelper.UpliftTypeNoUplift, UpliftType.NoUplift)]
         public void CanConvertToUpliftType(int outputUpliftType, UpliftType upliftType)
         {
             Assert.AreEqual(upliftType, ConversionHelper.ConvertToUpliftType(outputUpliftType));
         }
 
         [Test]
-        [TestCase(MStabModelType.Bishop, 0)]
-        [TestCase(MStabModelType.Spencer, 1)]
-        [TestCase(MStabModelType.Fellenius, 2)]
-        [TestCase(MStabModelType.UpliftVan, 3)]
-        [TestCase(MStabModelType.UpliftSpencer, 4)]
-        [TestCase(MStabModelType.BishopRandomField, 5)]
-        [TestCase(MStabModelType.HorizontalBalance, 6)]
-        [TestCase(MStabModelType.BishopUpliftVan, 7)]
-        [TestCase(MStabModelType.SpencerHigh, 8)]
-        [TestCase(MStabModelType.SpencerLow, 9)]
+        [TestCase(MStabModelType.Bishop, ConversionHelper.MStabModelTypeBishop)]
+        [TestCase(MStabModelType.Spencer, ConversionHelper.MStabModelTypeSpencer)]
+        [TestCase(MStabModelType.Fellenius, ConversionHelper.MStabModelTypeFellenius)]
+        [TestCase(MStabModelType.UpliftVan, ConversionHelper.MStabModelTypeUpliftVan)]
+        [TestCase(MStabModelType.UpliftSpencer, ConversionHelper.MStabModelTypeUpliftSpencer)]
+        [TestCase(MStabModelType.BishopRandomField, ConversionHelper.MStabModelTypeBishopRandomField)]
+        [TestCase(MStabModelType.HorizontalBalance, ConversionHelper.MStabModelTypeHorizontalBalance)]
+        [TestCase(MStabModelType.BishopUpliftVan, ConversionHelper.MStabModelTypeBishopUpliftVan)]
+        [TestCase(MStabModelType.SpencerHigh, ConversionHelper.MStabModelTypeSpencerHigh)]
+        [TestCase(MStabModelType.SpencerLow, ConversionHelper.MStabModelTypeSpencerLow)]
         public void CanConvertToOutputMStabModelType(MStabModelType mStabModelType, int outputMStabModelType)
         {
             Assert.AreEqual(outputMStabModelType, ConversionHelper.ConvertToOutputMStabModelType(mStabModelType));
         }
 
         [Test]
-        [TestCase(0, MStabModelType.Bishop)]
-        [TestCase(1, MStabModelType.Spencer)]
-        [TestCase(2, MStabModelType.Fellenius)]
-        [TestCase(3, MStabModelType.UpliftVan)]
-        [TestCase(4, MStabModelType.UpliftSpencer)]
-        [TestCase(5, MStabModelType.BishopRandomField)]
-        [TestCase(6, MStabModelType.HorizontalBalance)]
-        [TestCase(7, MStabModelType.BishopUpliftVan)]
-        [TestCase(8, MStabModelType.SpencerHigh)]
-        [TestCase(9, MStabModelType.SpencerLow)]
+        [TestCase(ConversionHelper.MStabModelTypeBishop, MStabModelType.Bishop)]
+        [TestCase(ConversionHelper.MStabModelTypeSpencer, MStabModelType.Spencer)]
+        [TestCase(ConversionHelper.MStabModelTypeFellenius, MStabModelType.Fellenius)]
+        [TestCase(ConversionHelper.MStabModelTypeUpliftVan, MStabModelType.UpliftVan)]
+        [TestCase(ConversionHelper.MStabModelTypeUpliftSpencer, MStabModelType.UpliftSpencer)]
+        [TestCase(ConversionHelper.MStabModelTypeBishopRandomField, MStabModelType.BishopRandomField)]
+        [TestCase(ConversionHelper.MStabModelTypeHorizontalBalance, MStabModelType.HorizontalBalance)]
+        [TestCase(ConversionHelper.MStabModelTypeBishopUpliftVan, MStabModelType.BishopUpliftVan)]
+        [TestCase(ConversionHelper.MStabModelTypeSpencerHigh, MStabModelType.SpencerHigh)]
+        [TestCase(ConversionHelper.MStabModelTypeSpencerLow, MStabModelType.SpencerLow)]
         public void CanConvertToMStabModelType(int outputMStabModelType, MStabModelType mStabModelType)
         {
             Assert.AreEqual(mStabModelType, ConversionHelper.ConvertToMStabModelType(outputMStabModelType));
         }
 
         [Test]
-        [TestCase(ScenarioType.Scenario01, 0)]
-        [TestCase(ScenarioType.Scenario02, 1)]
-        [TestCase(ScenarioType.Scenario03, 2)]
-        [TestCase(ScenarioType.Scenario04, 3)]
-        [TestCase(ScenarioType.Scenario05, 4)]
-        [TestCase(ScenarioType.Scenario06, 5)]
-        [TestCase(ScenarioType.Scenario07, 6)]
-        [TestCase(ScenarioType.Scenario08, 7)]
-        [TestCase(ScenarioType.Scenario09, 8)]
-        [TestCase(ScenarioType.Scenario10, 9)]
-        [TestCase(ScenarioType.Scenario11, 10)]
+        [TestCase(ScenarioType.Scenario01, ConversionHelper.ScenarioTypeScenario01)]
+        [TestCase(ScenarioType.Scenario02, ConversionHelper.ScenarioTypeScenario02)]
+        [TestCase(ScenarioType.Scenario03, ConversionHelper.ScenarioTypeScenario03)]
+        [TestCase(ScenarioType.Scenario04, ConversionHelper.ScenarioTypeScenario04)]
+        [TestCase(ScenarioType.Scenario05, ConversionHelper.ScenarioTypeScenario05)]
+        [TestCase(ScenarioType.Scenario06, ConversionHelper.ScenarioTypeScenario06)]
+        [TestCase(ScenarioType.Scenario07, ConversionHelper.ScenarioTypeScenario07)]
+        [TestCase(ScenarioType.Scenario08, ConversionHelper.ScenarioTypeScenario08)]
+        [TestCase(ScenarioType.Scenario09, ConversionHelper.ScenarioTypeScenario09)]
+        [TestCase(ScenarioType.Scenario10, ConversionHelper.ScenarioTypeScenario10)]
+        [TestCase(ScenarioType.Scenario11, ConversionHelper.ScenarioTypeScenario11)]
         public void CanConvertToOutputScenarioType(ScenarioType scenarioType, int outputScenarioType)
         {
             Assert.AreEqual(outputScenarioType, ConversionHelper.ConvertToOutputScenarioType(scenarioType));
         }
 
         [Test]
-        [TestCase(0, ScenarioType.Scenario01)]
-        [TestCase(1, ScenarioType.Scenario02)]
-        [TestCase(2, ScenarioType.Scenario03)]
-        [TestCase(3, ScenarioType.Scenario04)]
-        [TestCase(4, ScenarioType.Scenario05)]
-        [TestCase(5, ScenarioType.Scenario06)]
-        [TestCase(6, ScenarioType.Scenario07)]
-        [TestCase(7, ScenarioType.Scenario08)]
-        [TestCase(8, ScenarioType.Scenario09)]
-        [TestCase(9, ScenarioType.Scenario10)]
-        [TestCase(10, ScenarioType.Scenario11)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario01, ScenarioType.Scenario01)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario02, ScenarioType.Scenario02)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario03, ScenarioType.Scenario03)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario04, ScenarioType.Scenario04)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario05, ScenarioType.Scenario05)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario06, ScenarioType.Scenario06)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario07, ScenarioType.Scenario07)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario08, ScenarioType.Scenario08)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario09, ScenarioType.Scenario09)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario10, ScenarioType.Scenario10)]
+        [TestCase(ConversionHelper.ScenarioTypeScenario11, ScenarioType.Scenario11)]
         public void CanConvertToScenarioType(int outputScenarioType, ScenarioType scenarioType)
         {
             Assert.AreEqual(scenarioType, ConversionHelper.ConvertToScenarioType(outputScenarioType));
         }
 
         [Test]
-        [TestCase(PipingModelType.Bligh, 0)]
-        [TestCase(PipingModelType.SellmeijerVnk, 1)]
-        [TestCase(PipingModelType.Sellmeijer4Forces, 2)]
-        [TestCase(PipingModelType.Wti2017, 3)]        
+        [TestCase(PipingModelType.Bligh, ConversionHelper.PipingModelTypeBligh)]
+        [TestCase(PipingModelType.SellmeijerVnk, ConversionHelper.PipingModelTypeSellmeijer)]
+        [TestCase(PipingModelType.Sellmeijer4Forces, ConversionHelper.PipingModelTypeSellmeijer4Forces)]
+        [TestCase(PipingModelType.Wti2017, ConversionHelper.PipingModelTypeWti2017)]
         public void CanConvertToOutputPipingModelType(PipingModelType pipingModelType, int outputPipingModelType)
         {
             Assert.AreEqual(outputPipingModelType, ConversionHelper.ConvertToOutputPipingModelType(pipingModelType));
         }
 
         [Test]
-        [TestCase(0, PipingModelType.Bligh)]
-        [TestCase(1, PipingModelType.SellmeijerVnk)]
-        [TestCase(2, PipingModelType.Sellmeijer4Forces)]
-        [TestCase(3, PipingModelType.Wti2017)]
+        [TestCase(ConversionHelper.PipingModelTypeBligh, PipingModelType.Bligh)]
+        [TestCase(ConversionHelper.PipingModelTypeSellmeijer, PipingModelType.SellmeijerVnk)]
+        [TestCase(ConversionHelper.PipingModelTypeSellmeijer4Forces, PipingModelType.Sellmeijer4Forces)]
+        [TestCase(ConversionHelper.PipingModelTypeWti2017, PipingModelType.Wti2017)]
         public void CanConvertToPipingModelType(int outputPipingModelType, PipingModelType pipingModelType)
         {
             Assert.AreEqual(pipingModelType, ConversionHelper.ConvertToPipingModelType(outputPipingModelType));
@@ -558,16 +558,16 @@
         }
 
         [Test]
-        [TestCase(RegionalResultType.ProbabilityOfFailure, 0)]
-        [TestCase(RegionalResultType.SafetyFactor, 1)]
+        [TestCase(RegionalResultType.ProbabilityOfFailure, ConversionHelper.RwResultTypeProbabilityOfFailure)]
+        [TestCase(RegionalResultType.SafetyFactor, ConversionHelper.RwResultTypeSafetyFactor)]
         public void CanConvertToOutputRegionalResultType(RegionalResultType regionalResultType, int outputRegionalResultType)
         {
             Assert.AreEqual(outputRegionalResultType, ConversionHelper.ConvertToOutputRegionalResultType(regionalResultType));
         }
 
         [Test]
-        [TestCase(0, RegionalResultType.ProbabilityOfFailure)]
-        [TestCase(1, RegionalResultType.SafetyFactor)]
+        [TestCase(ConversionHelper.RwResultTypeProbabilityOfFailure, RegionalResultType.ProbabilityOfFailure)]
+        [TestCase(ConversionHelper.RwResultTypeSafetyFactor, RegionalResultType.SafetyFactor)]
         public void CanConvertToRegionalResultType(int outputRegionalResultType, RegionalResultType regionalResultType)
         {
             Assert.AreEqual(regionalResultType, ConversionHelper.ConvertToRegionalResultType(outputRegionalResultType));
Index: DamEngine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs
===================================================================
diff -u -r1686 -r1723
--- DamEngine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 1686)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 1723)
@@ -810,6 +810,16 @@
         }
 
         /// <summary>
+        /// The load situation dry
+        /// </summary>
+        public const int LoadSituationDry = 0;
+
+        /// <summary>
+        /// The load situation wet
+        /// </summary>
+        public const int LoadSituationWet = 1;
+
+        /// <summary>
         /// Converts to Load Situation.
         /// </summary>
         /// <param name="inputLoadSituation">The input Load Situation.</param>
@@ -818,8 +828,8 @@
         {
             var translationTable = new Dictionary<int, LoadSituation>()
             {
-                {0, LoadSituation.Dry},
-                {1, LoadSituation.Wet}
+                {LoadSituationDry, LoadSituation.Dry},
+                {LoadSituationWet, LoadSituation.Wet}
             };
             return translationTable[inputLoadSituation];
         }
@@ -833,13 +843,23 @@
         {
             var translationTable = new Dictionary<LoadSituation, int>()
             {
-                {LoadSituation.Dry, 0},
-                {LoadSituation.Wet, 1}
+                {LoadSituation.Dry, LoadSituationDry},
+                {LoadSituation.Wet, LoadSituationWet}
             };
             return translationTable[loadSituation];
         }
 
         /// <summary>
+        /// The dike dry sensitivity none
+        /// </summary>
+        public const int DikeDrySensitivityNone = 0;
+
+        /// <summary>
+        /// The dike dry sensitivity dry
+        /// </summary>
+        public const int DikeDrySensitivityDry = 1;
+
+        /// <summary>
         /// Converts to Dike Dry Sensitivity.
         /// </summary>
         /// <param name="inputDikeDrySensitivity">The input DikeDrySensitivity.</param>
@@ -848,8 +868,8 @@
         {
             var translationTable = new Dictionary<int, DikeDrySensitivity>()
             {
-                {0, DikeDrySensitivity.None},
-                {1, DikeDrySensitivity.Dry}
+                {DikeDrySensitivityNone, DikeDrySensitivity.None},
+                {DikeDrySensitivityDry, DikeDrySensitivity.Dry}
             };
             return translationTable[inputDikeDrySensitivity];
         }
@@ -863,13 +883,23 @@
         {
             var translationTable = new Dictionary<DikeDrySensitivity, int>()
             {
-                {DikeDrySensitivity.None, 0},
-                {DikeDrySensitivity.Dry, 1}
+                {DikeDrySensitivity.None, DikeDrySensitivityNone},
+                {DikeDrySensitivity.Dry, DikeDrySensitivityDry}
             };
             return translationTable[dikeDrySensitivity];
         }
 
         /// <summary>
+        /// The hydraulic shortcut type hydraulic shortcut
+        /// </summary>
+        public const int HydraulicShortcutTypeHydraulicShortcut = 0;
+
+        /// <summary>
+        /// The hydraulic shortcut type no hydraulic shortcut
+        /// </summary>
+        public const int HydraulicShortcutTypeNoHydraulicShortcut = 1;
+
+        /// <summary>
         /// Converts to Hydraulic Shortcut Type.
         /// </summary>
         /// <param name="inputHydraulicShortcutType">The input HydraulicShortcutType.</param>
@@ -878,8 +908,8 @@
         {
             var translationTable = new Dictionary<int, HydraulicShortcutType>()
             {
-                {0, HydraulicShortcutType.HydraulicShortcut},
-                {1, HydraulicShortcutType.NoHydraulicShortcut}
+                {HydraulicShortcutTypeHydraulicShortcut, HydraulicShortcutType.HydraulicShortcut},
+                {HydraulicShortcutTypeNoHydraulicShortcut, HydraulicShortcutType.NoHydraulicShortcut}
             };
             return translationTable[inputHydraulicShortcutType];
         }
@@ -893,13 +923,23 @@
         {
             var translationTable = new Dictionary<HydraulicShortcutType, int>()
             {
-                {HydraulicShortcutType.HydraulicShortcut, 0},
-                {HydraulicShortcutType.NoHydraulicShortcut, 1}
+                {HydraulicShortcutType.HydraulicShortcut, HydraulicShortcutTypeHydraulicShortcut},
+                {HydraulicShortcutType.NoHydraulicShortcut, HydraulicShortcutTypeNoHydraulicShortcut}
             };
             return translationTable[hydraulicShortcutType];
         }
 
         /// <summary>
+        /// The uplift type uplift
+        /// </summary>
+        public const int UpliftTypeUplift = 0;
+
+        /// <summary>
+        /// The uplift type no uplift
+        /// </summary>
+        public const int UpliftTypeNoUplift = 1;
+
+        /// <summary>
         /// Converts to Uplift Type.
         /// </summary>
         /// <param name="inputUpliftType">The input UpliftType.</param>
@@ -908,8 +948,8 @@
         {
             var translationTable = new Dictionary<int, UpliftType>()
             {
-                {0, UpliftType.Uplift},
-                {1, UpliftType.NoUplift}
+                {UpliftTypeUplift, UpliftType.Uplift},
+                {UpliftTypeNoUplift, UpliftType.NoUplift}
             };
             return translationTable[inputUpliftType];
         }
@@ -923,13 +963,63 @@
         {
             var translationTable = new Dictionary<UpliftType, int>()
             {
-                {UpliftType.Uplift, 0},
-                {UpliftType.NoUplift, 1}
+                {UpliftType.Uplift, UpliftTypeUplift},
+                {UpliftType.NoUplift, UpliftTypeNoUplift}
             };
             return translationTable[upliftType];
         }
 
         /// <summary>
+        /// The m stab model type bishop
+        /// </summary>
+        public const int MStabModelTypeBishop = 0;
+
+        /// <summary>
+        /// The m stab model type spencer
+        /// </summary>
+        public const int MStabModelTypeSpencer = 1;
+
+        /// <summary>
+        /// The m stab model type fellenius
+        /// </summary>
+        public const int MStabModelTypeFellenius = 2;
+
+        /// <summary>
+        /// The m stab model type uplift van
+        /// </summary>
+        public const int MStabModelTypeUpliftVan = 3;
+
+        /// <summary>
+        /// The m stab model type uplift spencer
+        /// </summary>
+        public const int MStabModelTypeUpliftSpencer = 4;
+
+        /// <summary>
+        /// The m stab model type bishop random field
+        /// </summary>
+        public const int MStabModelTypeBishopRandomField = 5;
+
+        /// <summary>
+        /// The m stab model type horizontal balance
+        /// </summary>
+        public const int MStabModelTypeHorizontalBalance = 6;
+
+        /// <summary>
+        /// The m stab model type bishop uplift van
+        /// </summary>
+        public const int MStabModelTypeBishopUpliftVan = 7;
+
+        /// <summary>
+        /// The m stab model type spencer high
+        /// </summary>
+        public const int MStabModelTypeSpencerHigh = 8;
+
+        /// <summary>
+        /// The m stab model type spencer low
+        /// </summary>
+        public const int MStabModelTypeSpencerLow = 9;
+
+        /// <summary>
         /// Converts to MStab Model Type.
         /// </summary>
         /// <param name="inputMStabModelType">The input MStabModelType.</param>
@@ -938,16 +1028,16 @@
         {
             var translationTable = new Dictionary<int, MStabModelType>()
             {
-                {0, MStabModelType.Bishop},
-                {1, MStabModelType.Spencer},
-                {2, MStabModelType.Fellenius},
-                {3, MStabModelType.UpliftVan},
-                {4, MStabModelType.UpliftSpencer},
-                {5, MStabModelType.BishopRandomField},
-                {6, MStabModelType.HorizontalBalance},
-                {7, MStabModelType.BishopUpliftVan},
-                {8, MStabModelType.SpencerHigh},
-                {9, MStabModelType.SpencerLow}                
+                {MStabModelTypeBishop, MStabModelType.Bishop},
+                {MStabModelTypeSpencer, MStabModelType.Spencer},
+                {MStabModelTypeFellenius, MStabModelType.Fellenius},
+                {MStabModelTypeUpliftVan, MStabModelType.UpliftVan},
+                {MStabModelTypeUpliftSpencer, MStabModelType.UpliftSpencer},
+                {MStabModelTypeBishopRandomField, MStabModelType.BishopRandomField},
+                {MStabModelTypeHorizontalBalance, MStabModelType.HorizontalBalance},
+                {MStabModelTypeBishopUpliftVan, MStabModelType.BishopUpliftVan},
+                {MStabModelTypeSpencerHigh, MStabModelType.SpencerHigh},
+                {MStabModelTypeSpencerLow, MStabModelType.SpencerLow}
             };
             return translationTable[inputMStabModelType];
         }
@@ -961,21 +1051,76 @@
         {
             var translationTable = new Dictionary<MStabModelType, int>()
             {
-                {MStabModelType.Bishop, 0},
-                {MStabModelType.Spencer, 1},
-                {MStabModelType.Fellenius, 2},
-                {MStabModelType.UpliftVan, 3},
-                {MStabModelType.UpliftSpencer, 4},
-                {MStabModelType.BishopRandomField, 5},
-                {MStabModelType.HorizontalBalance, 6},
-                {MStabModelType.BishopUpliftVan, 7},
-                {MStabModelType.SpencerHigh, 8},
-                {MStabModelType.SpencerLow, 9}
+                {MStabModelType.Bishop, MStabModelTypeBishop},
+                {MStabModelType.Spencer, MStabModelTypeSpencer},
+                {MStabModelType.Fellenius, MStabModelTypeFellenius},
+                {MStabModelType.UpliftVan, MStabModelTypeUpliftVan},
+                {MStabModelType.UpliftSpencer, MStabModelTypeUpliftSpencer},
+                {MStabModelType.BishopRandomField, MStabModelTypeBishopRandomField},
+                {MStabModelType.HorizontalBalance, MStabModelTypeHorizontalBalance},
+                {MStabModelType.BishopUpliftVan, MStabModelTypeBishopUpliftVan},
+                {MStabModelType.SpencerHigh, MStabModelTypeSpencerHigh},
+                {MStabModelType.SpencerLow, MStabModelTypeSpencerLow}
             };
             return translationTable[mStabModelType];
         }
 
         /// <summary>
+        /// The scenario type scenario01
+        /// </summary>
+        public const int ScenarioTypeScenario01 = 0;
+
+        /// <summary>
+        /// The scenario type scenario02
+        /// </summary>
+        public const int ScenarioTypeScenario02 = 1;
+
+        /// <summary>
+        /// The scenario type scenario03
+        /// </summary>
+        public const int ScenarioTypeScenario03 = 2;
+
+        /// <summary>
+        /// The scenario type scenario04
+        /// </summary>
+        public const int ScenarioTypeScenario04 = 3;
+
+        /// <summary>
+        /// The scenario type scenario05
+        /// </summary>
+        public const int ScenarioTypeScenario05 = 4;
+
+        /// <summary>
+        /// The scenario type scenario06
+        /// </summary>
+        public const int ScenarioTypeScenario06 = 5;
+
+        /// <summary>
+        /// The scenario type scenario07
+        /// </summary>
+        public const int ScenarioTypeScenario07 = 6;
+
+        /// <summary>
+        /// The scenario type scenario08
+        /// </summary>
+        public const int ScenarioTypeScenario08 = 7;
+
+        /// <summary>
+        /// The scenario type scenario09
+        /// </summary>
+        public const int ScenarioTypeScenario09 = 8;
+
+        /// <summary>
+        /// The scenario type scenario10
+        /// </summary>
+        public const int ScenarioTypeScenario10 = 9;
+
+        /// <summary>
+        /// The scenario type scenario11
+        /// </summary>
+        public const int ScenarioTypeScenario11 = 10;
+
+        /// <summary>
         /// Converts to Scenario Type.
         /// </summary>
         /// <param name="inputScenarioType">The input ScenarioType.</param>
@@ -984,17 +1129,17 @@
         {
             var translationTable = new Dictionary<int, ScenarioType>()
             {
-                {0, ScenarioType.Scenario01},
-                {1, ScenarioType.Scenario02},
-                {2, ScenarioType.Scenario03},
-                {3, ScenarioType.Scenario04},
-                {4, ScenarioType.Scenario05},
-                {5, ScenarioType.Scenario06},
-                {6, ScenarioType.Scenario07},
-                {7, ScenarioType.Scenario08},
-                {8, ScenarioType.Scenario09},
-                {9, ScenarioType.Scenario10},
-                {10, ScenarioType.Scenario11}
+                {ScenarioTypeScenario01, ScenarioType.Scenario01},
+                {ScenarioTypeScenario02, ScenarioType.Scenario02},
+                {ScenarioTypeScenario03, ScenarioType.Scenario03},
+                {ScenarioTypeScenario04, ScenarioType.Scenario04},
+                {ScenarioTypeScenario05, ScenarioType.Scenario05},
+                {ScenarioTypeScenario06, ScenarioType.Scenario06},
+                {ScenarioTypeScenario07, ScenarioType.Scenario07},
+                {ScenarioTypeScenario08, ScenarioType.Scenario08},
+                {ScenarioTypeScenario09, ScenarioType.Scenario09},
+                {ScenarioTypeScenario10, ScenarioType.Scenario10},
+                {ScenarioTypeScenario11, ScenarioType.Scenario11}
             };
             return translationTable[inputScenarioType];
         }
@@ -1008,22 +1153,42 @@
         {
             var translationTable = new Dictionary<ScenarioType, int>()
             {
-                {ScenarioType.Scenario01, 0},
-                {ScenarioType.Scenario02, 1},
-                {ScenarioType.Scenario03, 2},
-                {ScenarioType.Scenario04, 3},
-                {ScenarioType.Scenario05, 4},
-                {ScenarioType.Scenario06, 5},
-                {ScenarioType.Scenario07, 6},
-                {ScenarioType.Scenario08, 7},
-                {ScenarioType.Scenario09, 8},
-                {ScenarioType.Scenario10, 9},
-                {ScenarioType.Scenario11, 10}
+                {ScenarioType.Scenario01, ScenarioTypeScenario01},
+                {ScenarioType.Scenario02, ScenarioTypeScenario02},
+                {ScenarioType.Scenario03, ScenarioTypeScenario03},
+                {ScenarioType.Scenario04, ScenarioTypeScenario04},
+                {ScenarioType.Scenario05, ScenarioTypeScenario05},
+                {ScenarioType.Scenario06, ScenarioTypeScenario06},
+                {ScenarioType.Scenario07, ScenarioTypeScenario07},
+                {ScenarioType.Scenario08, ScenarioTypeScenario08},
+                {ScenarioType.Scenario09, ScenarioTypeScenario09},
+                {ScenarioType.Scenario10, ScenarioTypeScenario10},
+                {ScenarioType.Scenario11, ScenarioTypeScenario11}
             };
             return translationTable[scenarioType];
         }
 
         /// <summary>
+        /// The piping model type bligh
+        /// </summary>
+        public const int PipingModelTypeBligh = 0;
+
+        /// <summary>
+        /// The piping model type sellmeijer
+        /// </summary>
+        public const int PipingModelTypeSellmeijer = 1;
+
+        /// <summary>
+        /// The piping model type sellmeijer4 forces
+        /// </summary>
+        public const int PipingModelTypeSellmeijer4Forces = 2;
+
+        /// <summary>
+        /// The piping model type wti2017
+        /// </summary>
+        public const int PipingModelTypeWti2017 = 3;
+
+        /// <summary>
         /// Converts to Piping Model Type.
         /// </summary>
         /// <param name="inputPipingModelType">The input PipingModelType.</param>
@@ -1032,10 +1197,10 @@
         {
             var translationTable = new Dictionary<int, PipingModelType>()
             {
-                {0, PipingModelType.Bligh},
-                {1, PipingModelType.SellmeijerVnk},
-                {2, PipingModelType.Sellmeijer4Forces},
-                {3, PipingModelType.Wti2017}
+                {PipingModelTypeBligh, PipingModelType.Bligh},
+                {PipingModelTypeSellmeijer, PipingModelType.SellmeijerVnk},
+                {PipingModelTypeSellmeijer4Forces, PipingModelType.Sellmeijer4Forces},
+                {PipingModelTypeWti2017, PipingModelType.Wti2017}
             };
             return translationTable[inputPipingModelType];
         }
@@ -1049,15 +1214,25 @@
         {
             var translationTable = new Dictionary<PipingModelType, int>()
             {
-                {PipingModelType.Bligh, 0},
-                {PipingModelType.SellmeijerVnk, 1},
-                {PipingModelType.Sellmeijer4Forces, 2},
-                {PipingModelType.Wti2017, 3}
+                {PipingModelType.Bligh, PipingModelTypeBligh},
+                {PipingModelType.SellmeijerVnk, PipingModelTypeSellmeijer},
+                {PipingModelType.Sellmeijer4Forces, PipingModelTypeSellmeijer4Forces},
+                {PipingModelType.Wti2017, PipingModelTypeWti2017}
             };
             return translationTable[pipingModelType];
         }
 
         /// <summary>
+        /// The rw result type probability of failure
+        /// </summary>
+        public const int RwResultTypeProbabilityOfFailure = 0;
+
+        /// <summary>
+        /// The rw result type safety factor
+        /// </summary>
+        public const int RwResultTypeSafetyFactor = 1;
+
+        /// <summary>
         /// Converts to RegionalResult Type.
         /// </summary>
         /// <param name="inputRegionalResultType">The input RegionalResultType.</param>
@@ -1066,8 +1241,8 @@
         {
             var translationTable = new Dictionary<int, RegionalResultType>()
             {
-                {0, RegionalResultType.ProbabilityOfFailure},
-                {1, RegionalResultType.SafetyFactor}
+                {RwResultTypeProbabilityOfFailure, RegionalResultType.ProbabilityOfFailure},
+                {RwResultTypeSafetyFactor, RegionalResultType.SafetyFactor}
             };
             return translationTable[inputRegionalResultType];
         }
@@ -1081,8 +1256,8 @@
         {
             var translationTable = new Dictionary<RegionalResultType, int>()
             {
-                {RegionalResultType.ProbabilityOfFailure, 0},
-                {RegionalResultType.SafetyFactor, 1}
+                {RegionalResultType.ProbabilityOfFailure, RwResultTypeProbabilityOfFailure},
+                {RegionalResultType.SafetyFactor, RwResultTypeSafetyFactor}
             };
             return translationTable[regionalResultType];
         }