Index: DamEngine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs
===================================================================
diff -u -r941 -r1062
--- DamEngine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 941)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs	(.../ConversionHelper.cs)	(revision 1062)
@@ -779,5 +779,282 @@
             return translationTable[stabilityDesignMethod];
         }
 
+        /// <summary>
+        /// Converts to Load Situation.
+        /// </summary>
+        /// <param name="inputLoadSituation">The input Load Situation.</param>
+        /// <returns></returns>
+        public static LoadSituation ConvertToLoadSituation(int inputLoadSituation)
+        {
+            var translationTable = new Dictionary<int, LoadSituation>()
+            {
+                {0, LoadSituation.Dry},
+                {1, LoadSituation.Wet}
+            };
+            return translationTable[inputLoadSituation];
+        }
+
+        /// <summary>
+        /// Converts to output LoadSituation.
+        /// </summary>
+        /// <param name="loadSituation">The Load Situation.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputLoadSituation(LoadSituation loadSituation)
+        {
+            var translationTable = new Dictionary<LoadSituation, int>()
+            {
+                {LoadSituation.Dry, 0},
+                {LoadSituation.Wet, 1}
+            };
+            return translationTable[loadSituation];
+        }
+
+        /// <summary>
+        /// Converts to Dike Dry Sensitivity.
+        /// </summary>
+        /// <param name="inputDikeDrySensitivity">The input DikeDrySensitivity.</param>
+        /// <returns></returns>
+        public static DikeDrySensitivity ConvertToDikeDrySensitivity(int inputDikeDrySensitivity)
+        {
+            var translationTable = new Dictionary<int, DikeDrySensitivity>()
+            {
+                {0, DikeDrySensitivity.None},
+                {1, DikeDrySensitivity.Dry}
+            };
+            return translationTable[inputDikeDrySensitivity];
+        }
+
+        /// <summary>
+        /// Converts to output Dike Dry Sensitivity.
+        /// </summary>
+        /// <param name="dikeDrySensitivity">The DikeDrySensitivity.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputDikeDrySensitivity(DikeDrySensitivity dikeDrySensitivity)
+        {
+            var translationTable = new Dictionary<DikeDrySensitivity, int>()
+            {
+                {DikeDrySensitivity.None, 0},
+                {DikeDrySensitivity.Dry, 1}
+            };
+            return translationTable[dikeDrySensitivity];
+        }
+
+        /// <summary>
+        /// Converts to Hydraulic Shortcut Type.
+        /// </summary>
+        /// <param name="inputHydraulicShortcutType">The input HydraulicShortcutType.</param>
+        /// <returns></returns>
+        public static HydraulicShortcutType ConvertToHydraulicShortcutType(int inputHydraulicShortcutType)
+        {
+            var translationTable = new Dictionary<int, HydraulicShortcutType>()
+            {
+                {0, HydraulicShortcutType.HydraulicShortcut},
+                {1, HydraulicShortcutType.NoHydraulicShortcut}
+            };
+            return translationTable[inputHydraulicShortcutType];
+        }
+
+        /// <summary>
+        /// Converts to output Hydraulic Shortcut Type.
+        /// </summary>
+        /// <param name="hydraulicShortcutType">The HydraulicShortcutType.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputHydraulicShortcutType(HydraulicShortcutType hydraulicShortcutType)
+        {
+            var translationTable = new Dictionary<HydraulicShortcutType, int>()
+            {
+                {HydraulicShortcutType.HydraulicShortcut, 0},
+                {HydraulicShortcutType.NoHydraulicShortcut, 1}
+            };
+            return translationTable[hydraulicShortcutType];
+        }
+
+        /// <summary>
+        /// Converts to Uplift Type.
+        /// </summary>
+        /// <param name="inputUpliftType">The input UpliftType.</param>
+        /// <returns></returns>
+        public static UpliftType ConvertToUpliftType(int inputUpliftType)
+        {
+            var translationTable = new Dictionary<int, UpliftType>()
+            {
+                {0, UpliftType.Uplift},
+                {1, UpliftType.NoUplift}
+            };
+            return translationTable[inputUpliftType];
+        }
+
+        /// <summary>
+        /// Converts to output Uplift Type.
+        /// </summary>
+        /// <param name="upliftType">The UpliftType.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputUpliftType(UpliftType upliftType)
+        {
+            var translationTable = new Dictionary<UpliftType, int>()
+            {
+                {UpliftType.Uplift, 0},
+                {UpliftType.NoUplift, 1}
+            };
+            return translationTable[upliftType];
+        }
+
+        /// <summary>
+        /// Converts to MStab Model Type.
+        /// </summary>
+        /// <param name="inputMStabModelType">The input MStabModelType.</param>
+        /// <returns></returns>
+        public static MStabModelType ConvertToMStabModelType(int inputMStabModelType)
+        {
+            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}                
+            };
+            return translationTable[inputMStabModelType];
+        }
+        
+        /// <summary>
+        /// Converts to output MStabModelType.
+        /// </summary>
+        /// <param name="mStabModelType">The UpliftType.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputMStabModelType(MStabModelType mStabModelType)
+        {
+            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}
+            };
+            return translationTable[mStabModelType];
+        }
+
+        /// <summary>
+        /// Converts to Scenario Type.
+        /// </summary>
+        /// <param name="inputScenarioType">The input ScenarioType.</param>
+        /// <returns></returns>
+        public static ScenarioType ConvertToScenarioType(int inputScenarioType)
+        {
+            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}
+            };
+            return translationTable[inputScenarioType];
+        }
+
+        /// <summary>
+        /// Converts to output Scenario Type.
+        /// </summary>
+        /// <param name="scenarioType">The ScenarioType.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputScenarioType(ScenarioType scenarioType)
+        {
+            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}
+            };
+            return translationTable[scenarioType];
+        }
+
+        /// <summary>
+        /// Converts to Piping Model Type.
+        /// </summary>
+        /// <param name="inputPipingModelType">The input PipingModelType.</param>
+        /// <returns></returns>
+        public static PipingModelType ConvertToPipingModelType(int inputPipingModelType)
+        {
+            var translationTable = new Dictionary<int, PipingModelType>()
+            {
+                {0, PipingModelType.Bligh},
+                {1, PipingModelType.SellmeijerVnk},
+                {2, PipingModelType.Sellmeijer4Forces},
+                {3, PipingModelType.Wti2017}
+            };
+            return translationTable[inputPipingModelType];
+        }
+
+        /// <summary>
+        /// Converts to output PipingModelType.
+        /// </summary>
+        /// <param name="PipingModelType">The UpliftType.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputPipingModelType(PipingModelType PipingModelType)
+        {
+            var translationTable = new Dictionary<PipingModelType, int>()
+            {
+                {PipingModelType.Bligh, 0},
+                {PipingModelType.SellmeijerVnk, 1},
+                {PipingModelType.Sellmeijer4Forces, 2},
+                {PipingModelType.Wti2017, 3}
+            };
+            return translationTable[PipingModelType];
+        }
+
+        /// <summary>
+        /// Converts to RegionalResult Type.
+        /// </summary>
+        /// <param name="inputRegionalResultType">The input RegionalResultType.</param>
+        /// <returns></returns>
+        public static RegionalResultType ConvertToRegionalResultType(int inputRegionalResultType)
+        {
+            var translationTable = new Dictionary<int, RegionalResultType>()
+            {
+                {0, RegionalResultType.ProbabilityOfFailure},
+                {1, RegionalResultType.SafetyFactor}
+            };
+            return translationTable[inputRegionalResultType];
+        }
+
+        /// <summary>
+        /// Converts to output RegionalResult Type.
+        /// </summary>
+        /// <param name="RegionalResultType">The RegionalResultType.</param>
+        /// <returns></returns>
+        public static int ConvertToOutputRegionalResultType(RegionalResultType RegionalResultType)
+        {
+            var translationTable = new Dictionary<RegionalResultType, int>()
+            {
+                {RegionalResultType.ProbabilityOfFailure, 0},
+                {RegionalResultType.SafetyFactor, 1}
+            };
+            return translationTable[RegionalResultType];
+        }
     }
 }
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesAssessmentRegional/RWScenariosCalculation.cs
===================================================================
diff -u -r962 -r1062
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesAssessmentRegional/RWScenariosCalculation.cs	(.../RWScenariosCalculation.cs)	(revision 962)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesAssessmentRegional/RWScenariosCalculation.cs	(.../RWScenariosCalculation.cs)	(revision 1062)
@@ -333,13 +333,13 @@
 //                double? pipingFactor = calculator.CalculatePipingFactor(job.Location, job.Location.LocalXZSurfaceLine2, job.SoilGeometryProbability.SoilProfile1D, waterLevel);
 //                job.BaseFileName = calculator.FilenameCalculation;
 //
-//                job.RwResultType = RWResultType.SafetyFactor;
+//                job.RegionalResultType = RegionalResultType.SafetyFactor;
 //                if (pipingFactor.HasValue)
 //                {
 //                    job.SafetyFactor = pipingFactor.Value;
 //                    job.CalculationResult = CalculationResult.Succeeded;
 //                    job.ProbabilityOfFailure = double.NaN;
-//                    job.RwResultType = RWResultType.SafetyFactor;
+//                    job.RegionalResultType = RegionalResultType.SafetyFactor;
 //                }
 //
 //                else
@@ -443,12 +443,12 @@
 
 //                job.SafetyFactor = result.SafetyFactor;
 //                job.ProbabilityOfFailure = result.ProbabilityOfFailure;
-//                job.RwResultType = result.RwResultType;
+//                job.RegionalResultType = result.RegionalResultType;
 //                job.CalculationResult = result.CalculationResult;
             }
             else
             {
-//                job.RwResultType = (damCalculation.FailureMechanismParametersMStab.MStabParameters.IsProbabilistic ? RWResultType.ProbabilityOfFailure : RWResultType.SafetyFactor);
+//                job.RegionalResultType = (damCalculation.FailureMechanismParametersMStab.MStabParameters.IsProbabilistic ? RegionalResultType.ProbabilityOfFailure : RegionalResultType.SafetyFactor);
                 job.SafetyFactor = double.NaN;
                 job.ProbabilityOfFailure = double.NaN;
             }
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/RWScenarios/RWResult.cs
===================================================================
diff -u -r877 -r1062
--- DamEngine/trunk/src/Deltares.DamEngine.Data/RWScenarios/RWResult.cs	(.../RWResult.cs)	(revision 877)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/RWScenarios/RWResult.cs	(.../RWResult.cs)	(revision 1062)
@@ -27,7 +27,7 @@
 {
     public class RWResult
     {
-        private RWResultType _rwResultType = RWResultType.ProbabilityOfFailure;
+        private RegionalResultType regionalResultType = RegionalResultType.ProbabilityOfFailure;
         private double safetyFactor = -1;
         private double probabilityOfFailure = -1;
         private CalculationResult calculationResult = CalculationResult.NoRun;
@@ -40,10 +40,10 @@
         {
         }
 
-        public virtual RWResultType RwResultType
+        public virtual RegionalResultType RegionalResultType
         {
-            get { return _rwResultType; }
-            set { _rwResultType = value; }
+            get { return regionalResultType; }
+            set { regionalResultType = value; }
         }
 
         public virtual double SafetyFactor
Index: DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs
===================================================================
diff -u -r941 -r1062
--- DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 941)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 1062)
@@ -29,10 +29,10 @@
 
 namespace Deltares.DamEngine.Interface.Tests
 {
-	[TestFixture]
+    [TestFixture]
     public class ConversionHelperTests
     {
-		[Test]
+        [Test]
         [TestCase(InputDamProjectType.Assessment, DamProjectType.Assessment)]
         [TestCase(InputDamProjectType.AssessmentRegional, DamProjectType.AssessmentRegional)]
         [TestCase(InputDamProjectType.Design, DamProjectType.Design)]
@@ -150,6 +150,7 @@
         {
             Assert.AreEqual(characteristicPointType, ConversionHelper.ConvertToDamPointType(inputPointType));
         }
+
         [Test]
         [TestCase(CharacteristicPointType.None, ConversionHelper.CpNone)]
         [TestCase(CharacteristicPointType.SurfaceLevelOutside, ConversionHelper.CpSurfaceLevelOutside)]
@@ -256,7 +257,7 @@
 
         [Test]
         [TestCase(MStabSearchMethod.Grid, ConversionHelper.InputSearchMethodGrid)]
-        [TestCase(MStabSearchMethod.GeneticAlgorithm, ConversionHelper.InputSearchMethodGenetic)]        
+        [TestCase(MStabSearchMethod.GeneticAlgorithm, ConversionHelper.InputSearchMethodGenetic)]
         public void CanConvertToInputSearchMethod(MStabSearchMethod searchMethod, int inputSearchMethod)
         {
             Assert.AreEqual(inputSearchMethod, ConversionHelper.ConvertToInputSearchMethod(searchMethod));
@@ -386,5 +387,172 @@
         {
             Assert.AreEqual(inputStabilityDesignMethod, ConversionHelper.ConvertToInputStabilityDesignMethod(stabilityDesignMethod));
         }
+
+        [Test]
+        [TestCase(LoadSituation.Dry, 0)]
+        [TestCase(LoadSituation.Wet, 1)]
+        public void CanConvertToOutputLoadSituation(LoadSituation loadSituation, int outputLoadSituation)
+        {
+            Assert.AreEqual(outputLoadSituation, ConversionHelper.ConvertToOutputLoadSituation(loadSituation));
+        }
+
+        [Test]
+        [TestCase(0, LoadSituation.Dry)]
+        [TestCase(1, LoadSituation.Wet)]
+        public void CanConvertToLoadSituation(int outputLoadSituation, LoadSituation loadSituation)
+        {
+            Assert.AreEqual(loadSituation, ConversionHelper.ConvertToLoadSituation(outputLoadSituation));
+        }
+
+        [Test]
+        [TestCase(DikeDrySensitivity.None, 0)]
+        [TestCase(DikeDrySensitivity.Dry, 1)]
+        public void CanConvertToOutputDikeDrySensitivity(DikeDrySensitivity dikeDrySensitivity, int outputDikeDrySensitivity)
+        {
+            Assert.AreEqual(outputDikeDrySensitivity, ConversionHelper.ConvertToOutputDikeDrySensitivity(dikeDrySensitivity));
+        }
+
+        [Test]
+        [TestCase(0, DikeDrySensitivity.None)]
+        [TestCase(1, DikeDrySensitivity.Dry)]
+        public void CanConvertToDikeDrySensitivity(int outputDikeDrySensitivity, DikeDrySensitivity dikeDrySensitivity)
+        {
+            Assert.AreEqual(dikeDrySensitivity, ConversionHelper.ConvertToDikeDrySensitivity(outputDikeDrySensitivity));
+        }
+
+
+        [Test]
+        [TestCase(HydraulicShortcutType.HydraulicShortcut, 0)]
+        [TestCase(HydraulicShortcutType.NoHydraulicShortcut, 1)]
+        public void CanConvertToOutputHydraulicShortcutType(HydraulicShortcutType hydraulicShortcutType, int outputHydraulicShortcutType)
+        {
+            Assert.AreEqual(outputHydraulicShortcutType, ConversionHelper.ConvertToOutputHydraulicShortcutType(hydraulicShortcutType));
+        }
+
+        [Test]
+        [TestCase(0, HydraulicShortcutType.HydraulicShortcut)]
+        [TestCase(1, HydraulicShortcutType.NoHydraulicShortcut)]
+        public void CanConvertToHydraulicShortcutType(int outputHydraulicShortcutType, HydraulicShortcutType hydraulicShortcutType)
+        {
+            Assert.AreEqual(hydraulicShortcutType, ConversionHelper.ConvertToHydraulicShortcutType(outputHydraulicShortcutType));
+        }
+
+        [Test]
+        [TestCase(UpliftType.Uplift, 0)]
+        [TestCase(UpliftType.NoUplift, 1)]
+        public void CanConvertToOutputUpliftType(UpliftType upliftType, int outputUpliftType)
+        {
+            Assert.AreEqual(outputUpliftType, ConversionHelper.ConvertToOutputUpliftType(upliftType));
+        }
+
+        [Test]
+        [TestCase(0, UpliftType.Uplift)]
+        [TestCase(1, 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)]
+        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)]
+        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)]
+        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)]
+        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)]        
+        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)]
+        public void CanConvertToPipingModelType(int outputPipingModelType, PipingModelType pipingModelType)
+        {
+            Assert.AreEqual(pipingModelType, ConversionHelper.ConvertToPipingModelType(outputPipingModelType));
+        }
+
+        [Test]
+        [TestCase(RegionalResultType.ProbabilityOfFailure, 0)]
+        [TestCase(RegionalResultType.SafetyFactor, 1)]
+        public void CanConvertToOutputRegionalResultType(RegionalResultType regionalResultType, int outputRegionalResultType)
+        {
+            Assert.AreEqual(outputRegionalResultType, ConversionHelper.ConvertToOutputRegionalResultType(regionalResultType));
+        }
+
+        [Test]
+        [TestCase(0, RegionalResultType.ProbabilityOfFailure)]
+        [TestCase(1, RegionalResultType.SafetyFactor)]
+        public void CanConvertToRegionalResultType(int outputRegionalResultType, RegionalResultType regionalResultType)
+        {
+            Assert.AreEqual(regionalResultType, ConversionHelper.ConvertToRegionalResultType(outputRegionalResultType));
+        }
     }
 }
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/General/DAMEnumerations.cs
===================================================================
diff -u -r877 -r1062
--- DamEngine/trunk/src/Deltares.DamEngine.Data/General/DAMEnumerations.cs	(.../DAMEnumerations.cs)	(revision 877)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/General/DAMEnumerations.cs	(.../DAMEnumerations.cs)	(revision 1062)
@@ -206,7 +206,7 @@
     }
 
     // TODO: RW this is regional specific code and should be moved to its own class
-    public enum RWResultType //RWScenarios
+    public enum RegionalResultType //RWScenarios
     {
         ProbabilityOfFailure,
         SafetyFactor