Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs =================================================================== diff -u -r1686 -r1721 --- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs (.../ConversionHelper.cs) (revision 1686) +++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/DamEngineIo/ConversionHelper.cs (.../ConversionHelper.cs) (revision 1721) @@ -50,6 +50,7 @@ }; return translationTable[inputDamProjectType]; } + /// /// Converts the type DamProjectType from Dam Engine type to input object type. /// @@ -145,6 +146,7 @@ }; return translationTable[inputIntrusionVerticalWaterPressure]; } + public const int CpNone = 0;// public const int CpSurfaceLevelOutside = 1; // Maaiveld buitenwaarts public const int CpDikeToeAtRiver = 5; // Teen dijk buitenwaarts @@ -163,6 +165,12 @@ public const int CpBottomDitchPolderSide = 18; // Slootbodem polderzijde public const int CpDitchPolderSide = 19; // Insteek sloot polderzijde public const int CpSurfaceLevelInside = 25; // Maaiveld binnenwaarts + + /// + /// Converts the type of to dam point. + /// + /// Type of the input point. + /// public static CharacteristicPointType ConvertToDamPointType(int inputPointType) { var translationTable = new Dictionary() @@ -189,6 +197,11 @@ return translationTable[inputPointType]; } + /// + /// Converts the type of to input point. + /// + /// Type of the characteristic point. + /// public static int ConvertToInputPointType(CharacteristicPointType characteristicPointType) { var translationTable = new Dictionary() @@ -330,6 +343,7 @@ public const int InputFailureMechanismStabilityOutside = 1; public const int InputFailureMechanismPiping = 2; public const int InputFailureMechanismHorizontalBalance = 3; + /// /// Converts the Dam failure mechanism type to the input failure mechanism type . /// @@ -363,6 +377,7 @@ }; return translationTable[failureMechanismSystemType]; } + /// /// Converts the Dam piping model to the input piping model. /// @@ -412,6 +427,7 @@ }; return translationTable[stabilityModelType]; } + /// /// Converts the input stability model to the Dam stability model. /// @@ -474,6 +490,7 @@ }; return translationTable[analysisType]; } + /// /// Converts the input analysis type to the Dam analysis type. /// @@ -533,6 +550,7 @@ }; return translationTable[inputZoneType]; } + /// /// Converts the Dam message type to the input message type. /// @@ -862,6 +880,16 @@ } /// + /// The load situation dry + /// + public const int LoadSituationDry = 0; + + /// + /// The load situation wet + /// + public const int LoadSituationWet = 1; + + /// /// Converts to Load Situation. /// /// The input Load Situation. @@ -870,8 +898,8 @@ { var translationTable = new Dictionary() { - {0, LoadSituation.Dry}, - {1, LoadSituation.Wet} + {LoadSituationDry, LoadSituation.Dry}, + {LoadSituationWet, LoadSituation.Wet} }; return translationTable[inputLoadSituation]; } @@ -885,13 +913,23 @@ { var translationTable = new Dictionary() { - {LoadSituation.Dry, 0}, - {LoadSituation.Wet, 1} + {LoadSituation.Dry, LoadSituationDry}, + {LoadSituation.Wet, LoadSituationWet} }; return translationTable[loadSituation]; } /// + /// The dike dry sensitivity none + /// + public const int DikeDrySensitivityNone = 0; + + /// + /// The dike dry sensitivity dry + /// + public const int DikeDrySensitivityDry = 1; + + /// /// Converts to Dike Dry Sensitivity. /// /// The input DikeDrySensitivity. @@ -900,8 +938,8 @@ { var translationTable = new Dictionary() { - {0, DikeDrySensitivity.None}, - {1, DikeDrySensitivity.Dry} + {DikeDrySensitivityNone, DikeDrySensitivity.None}, + {DikeDrySensitivityDry, DikeDrySensitivity.Dry} }; return translationTable[inputDikeDrySensitivity]; } @@ -915,13 +953,23 @@ { var translationTable = new Dictionary() { - {DikeDrySensitivity.None, 0}, - {DikeDrySensitivity.Dry, 1} + {DikeDrySensitivity.None, DikeDrySensitivityNone}, + {DikeDrySensitivity.Dry, DikeDrySensitivityDry} }; return translationTable[dikeDrySensitivity]; } /// + /// The hydraulic shortcut type hydraulic shortcut + /// + public const int HydraulicShortcutTypeHydraulicShortcut = 0; + + /// + /// The hydraulic shortcut type no hydraulic shortcut + /// + public const int HydraulicShortcutTypeNoHydraulicShortcut = 1; + + /// /// Converts to Hydraulic Shortcut Type. /// /// The input HydraulicShortcutType. @@ -930,8 +978,8 @@ { var translationTable = new Dictionary() { - {0, HydraulicShortcutType.HydraulicShortcut}, - {1, HydraulicShortcutType.NoHydraulicShortcut} + {HydraulicShortcutTypeHydraulicShortcut, HydraulicShortcutType.HydraulicShortcut}, + {HydraulicShortcutTypeNoHydraulicShortcut, HydraulicShortcutType.NoHydraulicShortcut} }; return translationTable[inputHydraulicShortcutType]; } @@ -945,13 +993,23 @@ { var translationTable = new Dictionary() { - {HydraulicShortcutType.HydraulicShortcut, 0}, - {HydraulicShortcutType.NoHydraulicShortcut, 1} + {HydraulicShortcutType.HydraulicShortcut, HydraulicShortcutTypeHydraulicShortcut}, + {HydraulicShortcutType.NoHydraulicShortcut, HydraulicShortcutTypeNoHydraulicShortcut} }; return translationTable[hydraulicShortcutType]; } /// + /// The uplift type uplift + /// + public const int UpliftTypeUplift = 0; + + /// + /// The uplift type no uplift + /// + public const int UpliftTypeNoUplift = 1; + + /// /// Converts to Uplift Type. /// /// The input UpliftType. @@ -960,8 +1018,8 @@ { var translationTable = new Dictionary() { - {0, UpliftType.Uplift}, - {1, UpliftType.NoUplift} + {UpliftTypeUplift, UpliftType.Uplift}, + {UpliftTypeNoUplift, UpliftType.NoUplift} }; return translationTable[inputUpliftType]; } @@ -975,13 +1033,63 @@ { var translationTable = new Dictionary() { - {UpliftType.Uplift, 0}, - {UpliftType.NoUplift, 1} + {UpliftType.Uplift, UpliftTypeUplift}, + {UpliftType.NoUplift, UpliftTypeNoUplift} }; return translationTable[upliftType]; } /// + /// The m stab model type bishop + /// + public const int MStabModelTypeBishop = 0; + + /// + /// The m stab model type spencer + /// + public const int MStabModelTypeSpencer = 1; + + /// + /// The m stab model type fellenius + /// + public const int MStabModelTypeFellenius = 2; + + /// + /// The m stab model type uplift van + /// + public const int MStabModelTypeUpliftVan = 3; + + /// + /// The m stab model type uplift spencer + /// + public const int MStabModelTypeUpliftSpencer = 4; + + /// + /// The m stab model type bishop random field + /// + public const int MStabModelTypeBishopRandomField = 5; + + /// + /// The m stab model type horizontal balance + /// + public const int MStabModelTypeHorizontalBalance = 6; + + /// + /// The m stab model type bishop uplift van + /// + public const int MStabModelTypeBishopUpliftVan = 7; + + /// + /// The m stab model type spencer high + /// + public const int MStabModelTypeSpencerHigh = 8; + + /// + /// The m stab model type spencer low + /// + public const int MStabModelTypeSpencerLow = 9; + + /// /// Converts to MStab Model Type. /// /// The input MStabModelType. @@ -990,16 +1098,16 @@ { 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} + {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]; } @@ -1013,21 +1121,76 @@ { 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} + {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]; } /// + /// The scenario type scenario01 + /// + public const int ScenarioTypeScenario01 = 0; + + /// + /// The scenario type scenario02 + /// + public const int ScenarioTypeScenario02 = 1; + + /// + /// The scenario type scenario03 + /// + public const int ScenarioTypeScenario03 = 2; + + /// + /// The scenario type scenario04 + /// + public const int ScenarioTypeScenario04 = 3; + + /// + /// The scenario type scenario05 + /// + public const int ScenarioTypeScenario05 = 4; + + /// + /// The scenario type scenario06 + /// + public const int ScenarioTypeScenario06 = 5; + + /// + /// The scenario type scenario07 + /// + public const int ScenarioTypeScenario07 = 6; + + /// + /// The scenario type scenario08 + /// + public const int ScenarioTypeScenario08 = 7; + + /// + /// The scenario type scenario09 + /// + public const int ScenarioTypeScenario09 = 8; + + /// + /// The scenario type scenario10 + /// + public const int ScenarioTypeScenario10 = 9; + + /// + /// The scenario type scenario11 + /// + public const int ScenarioTypeScenario11 = 10; + + /// /// Converts to Scenario Type. /// /// The input ScenarioType. @@ -1036,17 +1199,17 @@ { 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} + {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]; } @@ -1060,22 +1223,42 @@ { 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} + {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]; } /// + /// The piping model type bligh + /// + public const int PipingModelTypeBligh = 0; + + /// + /// The piping model type sellmeijer + /// + public const int PipingModelTypeSellmeijer = 1; + + /// + /// The piping model type sellmeijer4 forces + /// + public const int PipingModelTypeSellmeijer4Forces = 2; + + /// + /// The piping model type wti2017 + /// + public const int PipingModelTypeWti2017 = 3; + + /// /// Converts to Piping Model Type. /// /// The input PipingModelType. @@ -1084,10 +1267,10 @@ { var translationTable = new Dictionary() { - {0, PipingModelType.Bligh}, - {1, PipingModelType.Sellmeijer}, - {2, PipingModelType.Sellmeijer4Forces}, - {3, PipingModelType.Wti2017} + {PipingModelTypeBligh, PipingModelType.Bligh}, + {PipingModelTypeSellmeijer, PipingModelType.Sellmeijer}, + {PipingModelTypeSellmeijer4Forces, PipingModelType.Sellmeijer4Forces}, + {PipingModelTypeWti2017, PipingModelType.Wti2017} }; return translationTable[inputPipingModelType]; } @@ -1101,15 +1284,25 @@ { var translationTable = new Dictionary() { - {PipingModelType.Bligh, 0}, - {PipingModelType.Sellmeijer, 1}, - {PipingModelType.Sellmeijer4Forces, 2}, - {PipingModelType.Wti2017, 3} + {PipingModelType.Bligh, PipingModelTypeBligh}, + {PipingModelType.Sellmeijer, PipingModelTypeSellmeijer}, + {PipingModelType.Sellmeijer4Forces, PipingModelTypeSellmeijer4Forces}, + {PipingModelType.Wti2017, PipingModelTypeWti2017} }; return translationTable[pipingModelType]; } /// + /// The rw result type probability of failure + /// + public const int RwResultTypeProbabilityOfFailure = 0; + + /// + /// The rw result type safety factor + /// + public const int RwResultTypeSafetyFactor = 1; + + /// /// Converts to RegionalResult Type. /// /// The input RegionalResultType. @@ -1118,8 +1311,8 @@ { var translationTable = new Dictionary() { - {0, RWResultType.ProbabilityOfFailure}, - {1, RWResultType.SafetyFactor} + {RwResultTypeProbabilityOfFailure, RWResultType.ProbabilityOfFailure}, + {RwResultTypeSafetyFactor, RWResultType.SafetyFactor} }; return translationTable[inputRegionalResultType]; } @@ -1133,8 +1326,8 @@ { var translationTable = new Dictionary() { - {RWResultType.ProbabilityOfFailure, 0}, - {RWResultType.SafetyFactor, 1} + {RWResultType.ProbabilityOfFailure, RwResultTypeProbabilityOfFailure}, + {RWResultType.SafetyFactor, RwResultTypeSafetyFactor} }; return translationTable[regionalResultType]; } Index: DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs =================================================================== diff -u -r1624 -r1721 --- DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 1624) +++ DamClients/DamUI/trunk/src/Dam/Tests/DamEngineIo/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 1721) @@ -409,167 +409,167 @@ [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.Sellmeijer, 1)] - [TestCase(PipingModelType.Sellmeijer4Forces, 2)] - [TestCase(PipingModelType.Wti2017, 3)] + [TestCase(PipingModelType.Bligh, ConversionHelper.PipingModelTypeBligh)] + [TestCase(PipingModelType.Sellmeijer, 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.Sellmeijer)] - [TestCase(2, PipingModelType.Sellmeijer4Forces)] - [TestCase(3, PipingModelType.Wti2017)] + [TestCase(ConversionHelper.PipingModelTypeBligh, PipingModelType.Bligh)] + [TestCase(ConversionHelper.PipingModelTypeSellmeijer, PipingModelType.Sellmeijer)] + [TestCase(ConversionHelper.PipingModelTypeSellmeijer4Forces, PipingModelType.Sellmeijer4Forces)] + [TestCase(ConversionHelper.PipingModelTypeWti2017, PipingModelType.Wti2017)] public void CanConvertToPipingModelType(int outputPipingModelType, PipingModelType pipingModelType) { Assert.AreEqual(pipingModelType, ConversionHelper.ConvertToPipingModelType(outputPipingModelType)); } [Test] - [TestCase(RWResultType.ProbabilityOfFailure, 0)] - [TestCase(RWResultType.SafetyFactor, 1)] + [TestCase(RWResultType.ProbabilityOfFailure, ConversionHelper.RwResultTypeProbabilityOfFailure)] + [TestCase(RWResultType.SafetyFactor, ConversionHelper.RwResultTypeSafetyFactor)] public void CanConvertToOutputRegionalResultType(RWResultType regionalResultType, int outputRegionalResultType) { Assert.AreEqual(outputRegionalResultType, ConversionHelper.ConvertToOutputRegionalResultType(regionalResultType)); } [Test] - [TestCase(0, RWResultType.ProbabilityOfFailure)] - [TestCase(1, RWResultType.SafetyFactor)] + [TestCase(ConversionHelper.RwResultTypeProbabilityOfFailure, RWResultType.ProbabilityOfFailure)] + [TestCase(ConversionHelper.RwResultTypeSafetyFactor, RWResultType.SafetyFactor)] public void CanConvertToRegionalResultType(int outputRegionalResultType, RWResultType regionalResultType) { Assert.AreEqual(regionalResultType, ConversionHelper.ConvertToRegionalResultType(outputRegionalResultType)); Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/RWScenarios/EvaluationJob.cs =================================================================== diff -u -r1545 -r1721 --- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/RWScenarios/EvaluationJob.cs (.../EvaluationJob.cs) (revision 1545) +++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/RWScenarios/EvaluationJob.cs (.../EvaluationJob.cs) (revision 1721) @@ -27,6 +27,9 @@ namespace Deltares.Dam.Data { + /// + /// Class holding evaluation job (a calculation task with input and results) + /// public class EvaluationJob { private string dikeName = ""; @@ -35,120 +38,40 @@ private List results = new List(); private List schematizationFactorResults = new List(); + /// + /// Gets or sets the name of the dike. + /// + /// + /// The name of the dike. + /// public string DikeName { get { return dikeName; } set { dikeName = value; } } + /// + /// Gets or sets the locations. + /// + /// + /// The locations. + /// public List Locations { get { return locations; } set { locations = value; } } + /// + /// Gets or sets the results. + /// + /// + /// The results. + /// public List Results { get { return results; } set { results = value; } - } - - public List SchematizationFactorResults - { - get { return schematizationFactorResults; } - set { schematizationFactorResults = value; } - } - - [XmlIgnore] - public string XML - { - get - { - XmlSerializer serializer = new XmlSerializer(); - return serializer.SerializeToString(this); - } - set - { - XmlDeserializer deserializer = new XmlDeserializer(); - EvaluationJob job = (EvaluationJob)deserializer.XmlDeserializeFromString(value, typeof(EvaluationJob)); - - this.DikeName = job.DikeName; - - this.Locations.Clear(); - this.Locations.AddRange(job.Locations); - - this.Results.Clear(); - this.Results.AddRange(job.Results); - this.schematizationFactorResults.Clear(); - this.schematizationFactorResults.AddRange(job.schematizationFactorResults); - } - } - - public List FailedEvaluatedLocations - { - get { return failedEvaluatedLocations; } - set { failedEvaluatedLocations = value; } - } - - public void AttachResults(IEnumerable locationJobs) - { - foreach (LocationJob locationJob in locationJobs) - { - foreach (Location location in this.locations) - { - if (locationJob.Location.Name.Equals(location.Name)) - { - if (locationJob.LocationResult == null) - { - locationJob.LocationResult = new LocationResult(); - } - - if ((this.locations.IndexOf(location) < 0) || (this.locations.IndexOf(location) >= this.results.Count)) - { - var failedRes = new RWScenariosResult(); - failedRes.CalculationResult = CalculationResult.UnexpectedError; - locationJob.LocationResult.RWScenariosResult = failedRes; - } - else - { - locationJob.LocationResult.RWScenariosResult = this.results[this.locations.IndexOf(location)]; - } - - - foreach (RWScenarioResult scenarioResult in locationJob.LocationResult.RWScenariosResult.RWScenarioResults) - { - foreach (RWScenarioProfileResult scenarioProfileResult in scenarioResult.RWScenarioProfileResults) - { - scenarioProfileResult.Location = locationJob.Location; - } - } - - - if ((this.locations.IndexOf(location) < 0) || (this.locations.IndexOf(location) >= this.results.Count)) - { - // var failedRes = new RWSchematizationFactorsResult(); - // failedRes.SchematizationFactorResults. = CalculationResult.UnexpectedError; - // locationJob.LocationResult.RWScenariosResult = failedRes; - } - else - { - if (schematizationFactorResults.Count > this.locations.IndexOf(location)) - { - locationJob.LocationResult.SchematizationFactorsResult = - schematizationFactorResults[this.locations.IndexOf(location)]; - } - } - - if (locationJob.LocationResult.SchematizationFactorsResult != null) - { - foreach (var schematizationFactorResult in locationJob.LocationResult.SchematizationFactorsResult.SchematizationFactorResults) - { - schematizationFactorResult.Location = locationJob.Location; - } - } - } - } - } - } + } } }