Index: DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs
===================================================================
diff -u -r1223 -r1231
--- DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 1223)
+++ DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 1231)
@@ -407,7 +407,174 @@
Assert.AreEqual(dikeSoilType, ConversionHelper.ConvertToInputSoilType(soilType));
}
+
[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.Sellmeijer, 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.Sellmeijer)]
+ [TestCase(2, PipingModelType.Sellmeijer4Forces)]
+ [TestCase(3, PipingModelType.Wti2017)]
+ public void CanConvertToPipingModelType(int outputPipingModelType, PipingModelType pipingModelType)
+ {
+ Assert.AreEqual(pipingModelType, ConversionHelper.ConvertToPipingModelType(outputPipingModelType));
+ }
+
+ [Test]
+ [TestCase(RWResultType.ProbabilityOfFailure, 0)]
+ [TestCase(RWResultType.SafetyFactor, 1)]
+ public void CanConvertToOutputRegionalResultType(RWResultType regionalResultType, int outputRegionalResultType)
+ {
+ Assert.AreEqual(outputRegionalResultType, ConversionHelper.ConvertToOutputRegionalResultType(regionalResultType));
+ }
+
+ [Test]
+ [TestCase(0, RWResultType.ProbabilityOfFailure)]
+ [TestCase(1, RWResultType.SafetyFactor)]
+ public void CanConvertToRegionalResultType(int outputRegionalResultType, RWResultType regionalResultType)
+ {
+ Assert.AreEqual(regionalResultType, ConversionHelper.ConvertToRegionalResultType(outputRegionalResultType));
+ }
+ [Test]
[TestCase(DesignResultStabilityDesignResultsStabilityModelType.Bishop, MStabModelType.Bishop)]
[TestCase(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan, MStabModelType.UpliftVan)]
[TestCase(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan, MStabModelType.BishopUpliftVan)]
Index: DamClients/DamUI/trunk/src/Dam/Data/DamEngineIo/FillDamUiFromXmlOutput.cs
===================================================================
diff -u -r1180 -r1231
--- DamClients/DamUI/trunk/src/Dam/Data/DamEngineIo/FillDamUiFromXmlOutput.cs (.../FillDamUiFromXmlOutput.cs) (revision 1180)
+++ DamClients/DamUI/trunk/src/Dam/Data/DamEngineIo/FillDamUiFromXmlOutput.cs (.../FillDamUiFromXmlOutput.cs) (revision 1231)
@@ -20,12 +20,15 @@
// All rights reserved.
using System.Collections.Generic;
+using System.Linq;
+using Deltares.DamEngine.Data.RegionalAssessmentResults;
using Deltares.DamEngine.Io.XmlOutput;
using Deltares.Geometry;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.EventPublisher;
+using Deltares.Standard.Extensions;
using SurfaceLine = Deltares.DamEngine.Io.XmlOutput.SurfaceLine;
namespace Deltares.Dam.Data.DamEngineIo
@@ -44,16 +47,27 @@
///
public static DamProjectData AddOutputToDamProjectData(DamProjectData damProjectData, Output output)
{
- if (output != null && output.Results != null && output.Results.CalculationResults != null &&
- output.Results.CalculationResults.DesignResults != null)
+ if (output != null && output.Results != null && output.Results.CalculationResults != null)
{
- DataEventPublisher.InvokeWithoutPublishingEvents(() =>
- {
- CreateDesignResultsFromOutput(output, damProjectData);
- }
- );
+ if (output.Results.CalculationResults.DesignResults != null)
+ {
+ DataEventPublisher.InvokeWithoutPublishingEvents(() =>
+ {
+ CreateDesignResultsFromOutput(output, damProjectData);
+ }
+ );
+ }
+ if (output.Results.CalculationResults.LocationResults != null)
+ {
+ DataEventPublisher.InvokeWithoutPublishingEvents(() =>
+ {
+ CreateLocationResultsOutput(output, damProjectData);
+ damProjectData.UpdateCalculations();
+ }
+ );
+ }
}
-
+
// Transfer calculation messages
if (output != null && output.Results != null && output.Results.CalculationMessages != null)
{
@@ -241,5 +255,82 @@
desResult.Pl4LocalLocationXMinUplift = uplift.Pl4LocationXMinUplift;
}
}
+
+ private static void CreateLocationResultsOutput(Output output, DamProjectData damProjectData)
+ {
+ // Calculation results (per location)
+ //damProjectData.LocationJobs = new List();
+ //var wj = damProjectData.WaterBoardJob;
+ //var lj = damProjectData.LocationJobs;
+ foreach (var outputLocationResult in output.Results.CalculationResults.LocationResults)
+ {
+ var locationJob = new LocationJob(null)
+ {
+ LocationResult = new LocationResult()
+ };
+ //locationJob.LocationResult.RWScenariosResult.RWScenarioResults[0].RWScenarioProfileResults[0].BaseFileName;
+ Location location = null;
+ if (outputLocationResult.RegionalScenariosResult != null)
+ {
+ locationJob.LocationResult.RWScenariosResult = new RWScenariosResult
+ {
+ CalculationResult = ConversionHelper.ConvertToCalculationResult(outputLocationResult.RegionalScenariosResult.CalculationResult),
+ SafetyFactor = outputLocationResult.RegionalScenariosResult.SafetyFactor
+ };
+ var regionalScenarioResults = new List();
+ foreach (var outPutRegionalScenarioResult in outputLocationResult.RegionalScenariosResult.RegionalScenarioResult)
+ {
+ var regionalScenarioResult = new RWScenarioResult
+ {
+ CalculationResult = ConversionHelper.ConvertToCalculationResult(outPutRegionalScenarioResult.CalculationResult),
+ DikeDrySensitivity = ConversionHelper.ConvertToDikeDrySensitivity(outPutRegionalScenarioResult.DikeDrySensitivity),
+ HydraulicShortcutType = ConversionHelper.ConvertToHydraulicShortcutType(outPutRegionalScenarioResult.HydraulicShortcutType),
+ LoadSituation = ConversionHelper.ConvertToLoadSituation(outPutRegionalScenarioResult.LoadSituation),
+ ModelOption = ConversionHelper.ConvertToMStabModelType(outPutRegionalScenarioResult.ModelOption),
+ SafetyFactor = outPutRegionalScenarioResult.SafetyFactor,
+ ScenarioType = ConversionHelper.ConvertToScenarioType(outPutRegionalScenarioResult.ScenarioType),
+ UpliftType = ConversionHelper.ConvertToUpliftType(outPutRegionalScenarioResult.UpliftType)
+ };
+ var regionalScenarioProfileResults = new List();
+ foreach (var outPutRegionalScenarioProfileResult in outPutRegionalScenarioResult.RegionalScenarioProfileResults)
+ {
+
+ var locationName = outPutRegionalScenarioProfileResult.LocationName;
+ location = damProjectData.WaterBoard.Dikes[0].Locations.FirstOrDefault(x => x.Name == locationName);
+ var spName = outPutRegionalScenarioProfileResult.SoilProfileName;
+ var soilGeometryProbability = location.Segment.SoilProfileProbabilities.FirstOrDefault(s => ((s.SegmentFailureMechanismType == null) ||
+ (s.SegmentFailureMechanismType.Value == FailureMechanismSystemType.StabilityInside)) &&
+ (s.SoilGeometryName == spName));
+ var regionalScenarioProfileResult = new RWScenarioProfileResult()
+ {
+ Location = location,
+ SoilGeometryProbability = soilGeometryProbability,
+ LoadSituation = ConversionHelper.ConvertToLoadSituation(outPutRegionalScenarioProfileResult.LoadSituation),
+ DikeDrySensitivity = ConversionHelper.ConvertToDikeDrySensitivity(outPutRegionalScenarioProfileResult.DikeDrySensitivity),
+ HydraulicShortcutType = ConversionHelper.ConvertToHydraulicShortcutType(outPutRegionalScenarioProfileResult.HydraulicShortcutType),
+ UpliftType = ConversionHelper.ConvertToUpliftType(outPutRegionalScenarioProfileResult.UpliftType),
+ MstabModelOption = ConversionHelper.ConvertToMStabModelType(outPutRegionalScenarioProfileResult.MStabModelOption),
+ PipingModelOption = ConversionHelper.ConvertToPipingModelType(outPutRegionalScenarioProfileResult.PipingModelOption),
+ ScenarioType = ConversionHelper.ConvertToScenarioType(outPutRegionalScenarioProfileResult.ScenarioType),
+ FailureMechanismType = ConversionHelper.ConvertToFailureMechanismSystemType(outPutRegionalScenarioProfileResult.FailureMechanismType),
+ BaseFileName = outPutRegionalScenarioProfileResult.BaseFileName,
+ RwResultType = ConversionHelper.ConvertToRegionalResultType(outPutRegionalScenarioProfileResult.RegionalResult.RegionalResultType),
+ SafetyFactor = outPutRegionalScenarioProfileResult.RegionalResult.SafetyFactor,
+ ProbabilityOfFailure = outPutRegionalScenarioProfileResult.RegionalResult.ProbabilityOfFailure,
+ CalculationResult = ConversionHelper.ConvertToCalculationResult(outPutRegionalScenarioProfileResult.RegionalResult.CalculationResult)
+ };
+ regionalScenarioProfileResults.Add(regionalScenarioProfileResult);
+ }
+ regionalScenarioResult.RWScenarioProfileResults.AddRange(regionalScenarioProfileResults);
+ regionalScenarioResults.Add(regionalScenarioResult);
+ }
+ locationJob.LocationResult.RWScenariosResult.RWScenarioResults.AddRange(regionalScenarioResults);
+ }
+ //locationJob.Location = location;
+ var curjob = damProjectData.LocationJobs.FirstOrDefault(x => x.Location.Name == location.Name);
+ curjob.LocationResult = locationJob.LocationResult;
+ //damProjectData.LocationJobs.Add(locationJob);
+ }
+ }
}
}
Index: DamClients/DamUI/trunk/src/Dam/Data/DamEngineIo/ConversionHelper.cs
===================================================================
diff -u -r1223 -r1231
--- DamClients/DamUI/trunk/src/Dam/Data/DamEngineIo/ConversionHelper.cs (.../ConversionHelper.cs) (revision 1223)
+++ DamClients/DamUI/trunk/src/Dam/Data/DamEngineIo/ConversionHelper.cs (.../ConversionHelper.cs) (revision 1231)
@@ -858,5 +858,283 @@
};
return translationTable[soilType];
}
+
+ ///
+ /// Converts to Load Situation.
+ ///
+ /// The input Load Situation.
+ ///
+ public static LoadSituation ConvertToLoadSituation(int inputLoadSituation)
+ {
+ var translationTable = new Dictionary()
+ {
+ {0, LoadSituation.Dry},
+ {1, LoadSituation.Wet}
+ };
+ return translationTable[inputLoadSituation];
+ }
+
+ ///
+ /// Converts to output LoadSituation.
+ ///
+ /// The Load Situation.
+ ///
+ public static int ConvertToOutputLoadSituation(LoadSituation loadSituation)
+ {
+ var translationTable = new Dictionary()
+ {
+ {LoadSituation.Dry, 0},
+ {LoadSituation.Wet, 1}
+ };
+ return translationTable[loadSituation];
+ }
+
+ ///
+ /// Converts to Dike Dry Sensitivity.
+ ///
+ /// The input DikeDrySensitivity.
+ ///
+ public static DikeDrySensitivity ConvertToDikeDrySensitivity(int inputDikeDrySensitivity)
+ {
+ var translationTable = new Dictionary()
+ {
+ {0, DikeDrySensitivity.None},
+ {1, DikeDrySensitivity.Dry}
+ };
+ return translationTable[inputDikeDrySensitivity];
+ }
+
+ ///
+ /// Converts to output Dike Dry Sensitivity.
+ ///
+ /// The DikeDrySensitivity.
+ ///
+ public static int ConvertToOutputDikeDrySensitivity(DikeDrySensitivity dikeDrySensitivity)
+ {
+ var translationTable = new Dictionary()
+ {
+ {DikeDrySensitivity.None, 0},
+ {DikeDrySensitivity.Dry, 1}
+ };
+ return translationTable[dikeDrySensitivity];
+ }
+
+ ///
+ /// Converts to Hydraulic Shortcut Type.
+ ///
+ /// The input HydraulicShortcutType.
+ ///
+ public static HydraulicShortcutType ConvertToHydraulicShortcutType(int inputHydraulicShortcutType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {0, HydraulicShortcutType.HydraulicShortcut},
+ {1, HydraulicShortcutType.NoHydraulicShortcut}
+ };
+ return translationTable[inputHydraulicShortcutType];
+ }
+
+ ///
+ /// Converts to output Hydraulic Shortcut Type.
+ ///
+ /// The HydraulicShortcutType.
+ ///
+ public static int ConvertToOutputHydraulicShortcutType(HydraulicShortcutType hydraulicShortcutType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {HydraulicShortcutType.HydraulicShortcut, 0},
+ {HydraulicShortcutType.NoHydraulicShortcut, 1}
+ };
+ return translationTable[hydraulicShortcutType];
+ }
+
+ ///
+ /// Converts to Uplift Type.
+ ///
+ /// The input UpliftType.
+ ///
+ public static UpliftType ConvertToUpliftType(int inputUpliftType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {0, UpliftType.Uplift},
+ {1, UpliftType.NoUplift}
+ };
+ return translationTable[inputUpliftType];
+ }
+
+ ///
+ /// Converts to output Uplift Type.
+ ///
+ /// The UpliftType.
+ ///
+ public static int ConvertToOutputUpliftType(UpliftType upliftType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {UpliftType.Uplift, 0},
+ {UpliftType.NoUplift, 1}
+ };
+ return translationTable[upliftType];
+ }
+
+ ///
+ /// Converts to MStab Model Type.
+ ///
+ /// The input MStabModelType.
+ ///
+ public static MStabModelType ConvertToMStabModelType(int inputMStabModelType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {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];
+ }
+
+ ///
+ /// Converts to output MStabModelType.
+ ///
+ /// The UpliftType.
+ ///
+ public static int ConvertToOutputMStabModelType(MStabModelType mStabModelType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {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];
+ }
+
+ ///
+ /// Converts to Scenario Type.
+ ///
+ /// The input ScenarioType.
+ ///
+ public static ScenarioType ConvertToScenarioType(int inputScenarioType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {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];
+ }
+
+ ///
+ /// Converts to output Scenario Type.
+ ///
+ /// The ScenarioType.
+ ///
+ public static int ConvertToOutputScenarioType(ScenarioType scenarioType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {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];
+ }
+
+ ///
+ /// Converts to Piping Model Type.
+ ///
+ /// The input PipingModelType.
+ ///
+ public static PipingModelType ConvertToPipingModelType(int inputPipingModelType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {0, PipingModelType.Bligh},
+ {1, PipingModelType.Sellmeijer},
+ {2, PipingModelType.Sellmeijer4Forces},
+ {3, PipingModelType.Wti2017}
+ };
+ return translationTable[inputPipingModelType];
+ }
+
+ ///
+ /// Converts to output PipingModelType.
+ ///
+ /// The UpliftType.
+ ///
+ public static int ConvertToOutputPipingModelType(PipingModelType pipingModelType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {PipingModelType.Bligh, 0},
+ {PipingModelType.Sellmeijer, 1},
+ {PipingModelType.Sellmeijer4Forces, 2},
+ {PipingModelType.Wti2017, 3}
+ };
+ return translationTable[pipingModelType];
+ }
+
+ ///
+ /// Converts to RegionalResult Type.
+ ///
+ /// The input RegionalResultType.
+ ///
+ public static RWResultType ConvertToRegionalResultType(int inputRegionalResultType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {0, RWResultType.ProbabilityOfFailure},
+ {1, RWResultType.SafetyFactor}
+ };
+ return translationTable[inputRegionalResultType];
+ }
+
+ ///
+ /// Converts to output RegionalResult Type.
+ ///
+ /// The RegionalResultType.
+ ///
+ public static int ConvertToOutputRegionalResultType(RWResultType regionalResultType)
+ {
+ var translationTable = new Dictionary()
+ {
+ {RWResultType.ProbabilityOfFailure, 0},
+ {RWResultType.SafetyFactor, 1}
+ };
+ return translationTable[regionalResultType];
+ }
}
}