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];
         }