// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System.Collections.Generic;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.Io.XmlInput;
using Deltares.DamEngine.Io.XmlOutput;

namespace Deltares.DamEngine.Interface
{
    /// <summary>
    /// Converts types from Dam class to Input serializer class and vice versa
    /// </summary>
    public static class ConversionHelper
    {
        /// <summary>
        /// Converts the type DamProjectType from input object type to Dam Engine type.
        /// </summary>
        /// <param name="inputDamProjectType">Type of the input object.</param>
        /// <returns>Dam Engine type</returns>
        public static DamProjectType ConvertToDamProjectType(InputDamProjectType inputDamProjectType)
        {
            var translationTable = new Dictionary<InputDamProjectType, DamProjectType>()
            {
                {InputDamProjectType.AssessmentRegional, DamProjectType.AssessmentRegional},
                {InputDamProjectType.Design, DamProjectType.Design},
                {InputDamProjectType.Operational, DamProjectType.Operational}
            };
            return translationTable[inputDamProjectType];
        }

        /// <summary>
        /// Converts the type DamProjectType from Dam Engine type to input object type.
        /// </summary>
        /// <param name="damProjectType">Type of the dam project.</param>
        /// <returns>Type of the input object.</returns>
        public static InputDamProjectType ConvertToInputDamProjectType(DamProjectType damProjectType)
        {
            var translationTable = new Dictionary<DamProjectType, InputDamProjectType>()
            {
                {DamProjectType.AssessmentRegional, InputDamProjectType.AssessmentRegional},
                {DamProjectType.Design, InputDamProjectType.Design},
                {DamProjectType.Operational, InputDamProjectType.Operational}
            };
            return translationTable[damProjectType];
        }

        /// <summary>
        /// Converts the type PLLineCreationMethod from Dam Engine type to input object type.
        /// </summary>
        /// <param name="plLineCreationMethod">Type of the dam project.</param>
        /// <returns>
        /// Type of the input object.
        /// </returns>
        public static LocationWaternetOptionsPhreaticLineCreationMethod ConvertToInputPhreaticLineCreationMethod(PlLineCreationMethod plLineCreationMethod)
        {
            var translationTable = new Dictionary<PlLineCreationMethod, LocationWaternetOptionsPhreaticLineCreationMethod>()
            {
                {PlLineCreationMethod.ExpertKnowledgeLinearInDike, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike},
                {PlLineCreationMethod.ExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD},
                {PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD},
                {PlLineCreationMethod.Sensors, LocationWaternetOptionsPhreaticLineCreationMethod.Sensors},
                {PlLineCreationMethod.None, LocationWaternetOptionsPhreaticLineCreationMethod.None}
            };
            return translationTable[plLineCreationMethod];
        }

        /// <summary>
        /// Converts the type PLLineCreationMethod from input object type to Dam Engine type.
        /// </summary>
        /// <param name="inputPhreaticLineCreationMethod">Type of the input object.</param>
        /// <returns>
        /// Type of the dam object.
        /// </returns>
        public static PlLineCreationMethod ConvertToPhreaticLineCreationMethod(LocationWaternetOptionsPhreaticLineCreationMethod inputPhreaticLineCreationMethod)
        {
            var translationTable = new Dictionary<LocationWaternetOptionsPhreaticLineCreationMethod, PlLineCreationMethod>()
            {
                {LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike, PlLineCreationMethod.ExpertKnowledgeLinearInDike},
                {LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD, PlLineCreationMethod.ExpertKnowledgeRRD},
                {LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD},
                {LocationWaternetOptionsPhreaticLineCreationMethod.Sensors, PlLineCreationMethod.Sensors},
                {LocationWaternetOptionsPhreaticLineCreationMethod.None, PlLineCreationMethod.None}
            };
            return translationTable[inputPhreaticLineCreationMethod];
        }

        /// <summary>
        /// Converts the type IntrusionVerticalWaterPressureType from Dam Engine type to input object type.
        /// </summary>
        /// <param name="intrusionVerticalWaterPressureType">Type of the dam project.</param>
        /// <returns>
        /// Type of the input object.
        /// </returns>
        public static LocationWaternetOptionsIntrusionVerticalWaterPressure ConvertToInputIntrusionVerticalWaterPressure(IntrusionVerticalWaterPressureType intrusionVerticalWaterPressureType)
        {
            var translationTable = new Dictionary<IntrusionVerticalWaterPressureType, LocationWaternetOptionsIntrusionVerticalWaterPressure>()
            {
                {IntrusionVerticalWaterPressureType.FullHydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic},
                {IntrusionVerticalWaterPressureType.HydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic},
                {IntrusionVerticalWaterPressureType.Linear, LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear},
                {IntrusionVerticalWaterPressureType.SemiTimeDependent, LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent},
                {IntrusionVerticalWaterPressureType.Standard, LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard}
            };
            return translationTable[intrusionVerticalWaterPressureType];
        }

        /// <summary>
        /// Converts the type IntrusionVerticalWaterPressureType from input object type to Dam Engine type.
        /// </summary>
        /// <param name="inputIntrusionVerticalWaterPressure">Type of the input object.</param>
        /// <returns>
        /// Type of the dam object.
        /// </returns>
        public static IntrusionVerticalWaterPressureType ConvertToIntrusionVerticalWaterPressure(LocationWaternetOptionsIntrusionVerticalWaterPressure inputIntrusionVerticalWaterPressure)
        {
            var translationTable = new Dictionary<LocationWaternetOptionsIntrusionVerticalWaterPressure, IntrusionVerticalWaterPressureType>()
            {
                {LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic, IntrusionVerticalWaterPressureType.FullHydroStatic},
                {LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic, IntrusionVerticalWaterPressureType.HydroStatic},
                {LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear, IntrusionVerticalWaterPressureType.Linear},
                {LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent, IntrusionVerticalWaterPressureType.SemiTimeDependent},
                {LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard, IntrusionVerticalWaterPressureType.Standard}
            };
            return translationTable[inputIntrusionVerticalWaterPressure];
        }

        /// <summary>
        /// Converts to output calculation result.
        /// </summary>
        /// <param name="calculationResult">Type of the dam project.</param>
        /// <returns></returns>
        public static int ConvertToOutputCalculationResult(CalculationResult calculationResult)
        {
            var translationTable = new Dictionary<CalculationResult, int>()
            {
                {CalculationResult.NoRun, 0},
                {CalculationResult.Succeeded, 1},
                {CalculationResult.NoInput, 2},
                {CalculationResult.NoLicense, 3},
                {CalculationResult.UserAbort, 4},
                {CalculationResult.InvalidInputStructure, 5},
                {CalculationResult.InvalidInputData, 6},
                {CalculationResult.RunFailed, 7},
                {CalculationResult.UnexpectedError, 8}
            };
            return translationTable[calculationResult];
        }

        /// <summary>
        /// Converts to calculation result.
        /// </summary>
        /// <param name="calculationResult">The calculation result.</param>
        /// <returns></returns>
        public static CalculationResult ConvertToCalculationResult(int calculationResult)
        {
            var translationTable = new Dictionary<int, CalculationResult>()
            {
                {0, CalculationResult.NoRun},
                {1, CalculationResult.Succeeded},
                {2, CalculationResult.NoInput},
                {3, CalculationResult.NoLicense},
                {4, CalculationResult.UserAbort},
                {5, CalculationResult.InvalidInputStructure},
                {6, CalculationResult.InvalidInputData},
                {7, CalculationResult.RunFailed},
                {8, CalculationResult.UnexpectedError}
            };
            return translationTable[calculationResult];
        }

        public const int CpNone = 0; //
        public const int CpSurfaceLevelOutside = 1; // Maaiveld buitenwaarts
        public const int CpDikeToeAtRiver = 5; // Teen dijk buitenwaarts
        public const int CpShoulderTopOutside = 6; // Kruin buitenberm
        public const int CpShoulderBaseOutside = 7; // Insteek buitenberm
        public const int CpDikeTopAtRiver = 8; // Kruin buitentalud
        public const int CpDikeLine = 9; // referentielijn
        public const int CpTrafficLoadOutside = 10; // Verkeersbelasting kant buitenwaarts
        public const int CpTrafficLoadInside = 11; // Verkeersbelasting kant binnenwaarts
        public const int CpDikeTopAtPolder = 12; // Kruin binnentalud
        public const int CpShoulderBaseInside = 13; // Insteek binnenberm
        public const int CpShoulderTopInside = 14; // Kruin binnenberm
        public const int CpDikeToeAtPolder = 15; // Teen dijk binnenwaarts
        public const int CpDitchDikeSide = 16; // Insteek sloot dijkzijde
        public const int CpBottomDitchDikeSide = 17; // Slootbodem dijkzijde
        public const int CpBottomDitchPolderSide = 18; // Slootbodem polderzijde
        public const int CpDitchPolderSide = 19; // Insteek sloot polderzijde
        public const int CpSurfaceLevelInside = 25; // Maaiveld binnenwaarts        

        /// <summary>
        /// Converts the input characteristic point type to the Dam characteristic point type
        /// </summary>
        /// <param name="inputPointType">Type of the input point.</param>
        /// <returns></returns>
        public static CharacteristicPointType ConvertToDamPointType(int inputPointType)
        {
            var translationTable = new Dictionary<int, CharacteristicPointType>()
            {
                {CpNone, CharacteristicPointType.None},
                {CpSurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside},
                {CpDikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver},
                {CpShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside},
                {CpShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside},
                {CpDikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver},
                {CpDikeLine, CharacteristicPointType.DikeLine},
                {CpTrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside},
                {CpTrafficLoadInside, CharacteristicPointType.TrafficLoadInside},
                {CpDikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder},
                {CpShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside},
                {CpShoulderTopInside, CharacteristicPointType.ShoulderTopInside},
                {CpDikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder},
                {CpDitchDikeSide, CharacteristicPointType.DitchDikeSide},
                {CpBottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide},
                {CpBottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide},
                {CpDitchPolderSide, CharacteristicPointType.DitchPolderSide},
                {CpSurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside}
            };
            return translationTable[inputPointType];
        }

        /// <summary>
        /// Converts the Dam characteristic point type to the input characteristic point type
        /// </summary>
        /// <param name="characteristicPointType">Type of the characteristic point.</param>
        /// <returns></returns>
        public static int ConvertToInputPointType(CharacteristicPointType characteristicPointType)
        {
            var translationTable = new Dictionary<CharacteristicPointType, int>()
            {
                {CharacteristicPointType.None, CpNone},
                {CharacteristicPointType.SurfaceLevelOutside, CpSurfaceLevelOutside},
                {CharacteristicPointType.DikeToeAtRiver, CpDikeToeAtRiver},
                {CharacteristicPointType.ShoulderTopOutside, CpShoulderTopOutside},
                {CharacteristicPointType.ShoulderBaseOutside, CpShoulderBaseOutside},
                {CharacteristicPointType.DikeTopAtRiver, CpDikeTopAtRiver},
                {CharacteristicPointType.DikeLine, CpDikeLine},
                {CharacteristicPointType.TrafficLoadOutside, CpTrafficLoadOutside},
                {CharacteristicPointType.TrafficLoadInside, CpTrafficLoadInside},
                {CharacteristicPointType.DikeTopAtPolder, CpDikeTopAtPolder},
                {CharacteristicPointType.ShoulderBaseInside, CpShoulderBaseInside},
                {CharacteristicPointType.ShoulderTopInside, CpShoulderTopInside},
                {CharacteristicPointType.DikeToeAtPolder, CpDikeToeAtPolder},
                {CharacteristicPointType.DitchDikeSide, CpDitchDikeSide},
                {CharacteristicPointType.BottomDitchDikeSide, CpBottomDitchDikeSide},
                {CharacteristicPointType.BottomDitchPolderSide, CpBottomDitchPolderSide},
                {CharacteristicPointType.DitchPolderSide, CpDitchPolderSide},
                {CharacteristicPointType.SurfaceLevelInside, CpSurfaceLevelInside}
            };
            return translationTable[characteristicPointType];
        }

        /// <summary>
        /// Converts to waterpressure interpolation model.
        /// </summary>
        /// <param name="inputWaterpressureInterpolationModel">The input waterpressure interpolation model.</param>
        /// <returns></returns>
        public static WaterpressureInterpolationModel ConvertToWaterpressureInterpolationModel(int inputWaterpressureInterpolationModel)
        {
            var translationTable = new Dictionary<int, WaterpressureInterpolationModel>()
            {
                {0, WaterpressureInterpolationModel.Automatic},
                {1, WaterpressureInterpolationModel.Hydrostatic}
            };
            return translationTable[inputWaterpressureInterpolationModel];
        }

        /// <summary>
        /// Converts to input waterpressure interpolation model.
        /// </summary>
        /// <param name="waterpressureInterpolationModel">The waterpressure interpolation model.</param>
        /// <returns></returns>
        public static int ConvertToInputWaterpressureInterpolationModel(WaterpressureInterpolationModel waterpressureInterpolationModel)
        {
            var translationTable = new Dictionary<WaterpressureInterpolationModel, int>()
            {
                {WaterpressureInterpolationModel.Automatic, 0},
                {WaterpressureInterpolationModel.Hydrostatic, 1}
            };
            return translationTable[waterpressureInterpolationModel];
        }

        /// <summary>
        /// Converts the Dam profile type to the input profile type
        /// </summary>
        /// <param name="soilProfileType">Type of the soil geometry.</param>
        /// <returns></returns>
        public static int ConvertToInputSoilGeometryType(SoilProfileType soilProfileType)
        {
            var translationTable = new Dictionary<SoilProfileType, int>()
            {
                {SoilProfileType.ProfileType1D, 0},
                {SoilProfileType.ProfileType2D, 1},
                {SoilProfileType.ProfileTypeStiFile, 2}
            };
            return translationTable[soilProfileType];
        }

        /// <summary>
        /// Converts the input profile type to the Dam profile type
        /// </summary>
        /// <param name="soilGeometryType">Type of the soil geometry.</param>
        /// <returns></returns>
        public static SoilProfileType ConvertToSoilGeometryType(int soilGeometryType)
        {
            var translationTable = new Dictionary<int, SoilProfileType>()
            {
                {0, SoilProfileType.ProfileType1D},
                {1, SoilProfileType.ProfileType2D},
                {2, SoilProfileType.ProfileTypeStiFile}
            };
            return translationTable[soilGeometryType];
        }

        public const int InputFailureMechanismStabilityInside = 0;
        public const int InputFailureMechanismStabilityOutside = 1;
        public const int InputFailureMechanismPiping = 2;
        public const int InputFailureMechanismHorizontalBalance = 3;

        /// <summary>
        /// Converts the Dam failure mechanism type to the input failure mechanism type .
        /// </summary>
        /// <param name="segmentFailureMechanismType">Type of the segment failure mechanism.</param>
        /// <returns></returns>
        public static int ConvertToInputFailureMechanismSystemType(FailureMechanismSystemType segmentFailureMechanismType)
        {
            var translationTable = new Dictionary<FailureMechanismSystemType, int>()
            {
                {FailureMechanismSystemType.StabilityInside, InputFailureMechanismStabilityInside},
                {FailureMechanismSystemType.StabilityOutside, InputFailureMechanismStabilityOutside},
                {FailureMechanismSystemType.Piping, InputFailureMechanismPiping},
                {FailureMechanismSystemType.HorizontalBalance, InputFailureMechanismHorizontalBalance}
            };
            return translationTable[segmentFailureMechanismType];
        }

        /// <summary>
        /// Converts the input failure mechanism type to the Dam failure mechanism type .
        /// </summary>
        /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
        /// <returns></returns>
        public static FailureMechanismSystemType ConvertToFailureMechanismSystemType(int failureMechanismSystemType)
        {
            var translationTable = new Dictionary<int, FailureMechanismSystemType>()
            {
                {InputFailureMechanismStabilityInside, FailureMechanismSystemType.StabilityInside},
                {InputFailureMechanismStabilityOutside, FailureMechanismSystemType.StabilityOutside},
                {InputFailureMechanismPiping, FailureMechanismSystemType.Piping},
                {InputFailureMechanismHorizontalBalance, FailureMechanismSystemType.HorizontalBalance}
            };
            return translationTable[failureMechanismSystemType];
        }

        /// <summary>
        /// Converts the Dam piping model to the input piping model.
        /// </summary>
        /// <param name="pipingModelType">Type of the piping model.</param>
        /// <returns></returns>
        public static InputPipingModelType ConvertToInputPipingModelType(PipingModelType pipingModelType)
        {
            var translationTable = new Dictionary<PipingModelType, InputPipingModelType>()
            {
                {PipingModelType.Bligh, InputPipingModelType.Bligh},
                {PipingModelType.SellmeijerVnk, InputPipingModelType.SellmeijerVnk},
                {PipingModelType.Sellmeijer4Forces, InputPipingModelType.Sellmeijer4Forces},
                {PipingModelType.Wti2017, InputPipingModelType.WbiSellmeijerRevised}
            };
            return translationTable[pipingModelType];
        }

        /// <summary>
        /// Converts the input piping model to the Dam piping model.
        /// </summary>
        /// <param name="inputPipingModelType">Type of the input piping model.</param>
        /// <returns></returns>
        public static PipingModelType ConvertToPipingModelType(InputPipingModelType inputPipingModelType)
        {
            var translationTable = new Dictionary<InputPipingModelType, PipingModelType>()
            {
                {InputPipingModelType.Bligh, PipingModelType.Bligh},
                {InputPipingModelType.SellmeijerVnk, PipingModelType.SellmeijerVnk},
                {InputPipingModelType.Sellmeijer4Forces, PipingModelType.Sellmeijer4Forces},
                {InputPipingModelType.WbiSellmeijerRevised, PipingModelType.Wti2017}
            };
            return translationTable[inputPipingModelType];
        }

        /// <summary>
        /// Converts the Dam stability model to the input stability model.
        /// </summary>
        /// <param name="stabilityModelType">Type of the stability model.</param>
        /// <returns></returns>
        public static InputStabilityModelType ConvertToInputStabilityModelType(MStabModelType stabilityModelType)
        {
            var translationTable = new Dictionary<MStabModelType, InputStabilityModelType>()
            {
                {MStabModelType.Bishop, InputStabilityModelType.Bishop},
                {MStabModelType.UpliftVan, InputStabilityModelType.UpliftVan},
                {MStabModelType.BishopUpliftVan, InputStabilityModelType.BishopUpliftVan}
            };
            return translationTable[stabilityModelType];
        }

        /// <summary>
        /// Converts the input stability model to the Dam stability model.
        /// </summary>
        /// <param name="inputStabilityModelType">Type of the input stability model.</param>
        /// <returns></returns>
        public static MStabModelType ConvertToStabilityModelType(InputStabilityModelType inputStabilityModelType)
        {
            var translationTable = new Dictionary<InputStabilityModelType, MStabModelType>()
            {
                {InputStabilityModelType.Bishop, MStabModelType.Bishop},
                {InputStabilityModelType.UpliftVan, MStabModelType.UpliftVan},
                {InputStabilityModelType.BishopUpliftVan, MStabModelType.BishopUpliftVan}
            };
            return translationTable[inputStabilityModelType];
        }

        /// <summary>
        /// Converts the Dam stability model to the output stability model.
        /// </summary>
        /// <param name="stabilityModelType">Type of the stability model.</param>
        /// <returns></returns>
        public static DesignResultStabilityDesignResultsStabilityModelType ConvertToOutputStabilityModelType(MStabModelType stabilityModelType)
        {
            var translationTable = new Dictionary<MStabModelType, DesignResultStabilityDesignResultsStabilityModelType>()
            {
                {MStabModelType.Bishop, DesignResultStabilityDesignResultsStabilityModelType.Bishop},
                {MStabModelType.UpliftVan, DesignResultStabilityDesignResultsStabilityModelType.UpliftVan},
                {MStabModelType.BishopUpliftVan, DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan}
            };
            return translationTable[stabilityModelType];
        }

        /// <summary>
        /// Converts the output stability model to the Dam stability model.
        /// </summary>
        /// <param name="outputStabilityModelType">Type of the output stability model.</param>
        /// <returns></returns>
        public static MStabModelType ConvertToStabilityModelType(DesignResultStabilityDesignResultsStabilityModelType outputStabilityModelType)
        {
            var translationTable = new Dictionary<DesignResultStabilityDesignResultsStabilityModelType, MStabModelType>()
            {
                {DesignResultStabilityDesignResultsStabilityModelType.Bishop, MStabModelType.Bishop},
                {DesignResultStabilityDesignResultsStabilityModelType.UpliftVan, MStabModelType.UpliftVan},
                {DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan, MStabModelType.BishopUpliftVan}
            };
            return translationTable[outputStabilityModelType];
        }

        /// <summary>
        /// Converts the Dam analysis type to the input analysis type.
        /// </summary>
        /// <param name="analysisType">Type of the analysis.</param>
        /// <returns></returns>
        public static InputAnalysisType ConvertToInputAnalysisType(AnalysisType analysisType)
        {
            var translationTable = new Dictionary<AnalysisType, InputAnalysisType>()
            {
                {AnalysisType.NoAdaption, InputAnalysisType.NoAdaption},
                {AnalysisType.AdaptGeometry, InputAnalysisType.AdaptGeometry}
            };
            return translationTable[analysisType];
        }

        /// <summary>
        /// Converts the input analysis type to the Dam analysis type.
        /// </summary>
        /// <param name="inputAnalysisType">Type of the input analysis.</param>
        /// <returns></returns>
        public static AnalysisType ConvertToAnalysisType(InputAnalysisType inputAnalysisType)
        {
            var translationTable = new Dictionary<InputAnalysisType, AnalysisType>()
            {
                {InputAnalysisType.NoAdaption, AnalysisType.NoAdaption},
                {InputAnalysisType.AdaptGeometry, AnalysisType.AdaptGeometry}
            };
            return translationTable[inputAnalysisType];
        }

        /// <summary>
        /// The input zone type no zones
        /// </summary>
        public const int InputZoneTypeNoZones = 0;

        /// <summary>
        /// The input zone type zone areas
        /// </summary>
        public const int InputZoneTypeZoneAreas = 1;

        /// <summary>
        /// The input zone types forbidden zones
        /// </summary>
        public const int InputZoneTypesForbiddenZones = 2;

        /// <summary>
        /// Converts the type of to input zone.
        /// </summary>
        /// <param name="zoneType">Type of the zone.</param>
        /// <returns></returns>
        public static int ConvertToInputZoneType(MStabZonesType zoneType)
        {
            var translationTable = new Dictionary<MStabZonesType, int>()
            {
                {MStabZonesType.NoZones, InputZoneTypeNoZones},
                {MStabZonesType.ZoneAreas, InputZoneTypeZoneAreas},
                {MStabZonesType.ForbiddenZone, InputZoneTypesForbiddenZones}
            };
            return translationTable[zoneType];
        }

        /// <summary>
        /// Converts the type of to zone.
        /// </summary>
        /// <param name="inputZoneType">Type of the input zone.</param>
        /// <returns></returns>
        public static MStabZonesType ConvertToZoneType(int inputZoneType)
        {
            var translationTable = new Dictionary<int, MStabZonesType>()
            {
                {InputZoneTypeNoZones, MStabZonesType.NoZones},
                {InputZoneTypeZoneAreas, MStabZonesType.ZoneAreas},
                {InputZoneTypesForbiddenZones, MStabZonesType.ForbiddenZone}
            };
            return translationTable[inputZoneType];
        }

        /// <summary>
        /// The input search method grid
        /// </summary>
        public const int InputSearchMethodGrid = 0;

        /// <summary>
        /// The input search method genetic
        /// </summary>
        public const int InputSearchMethodGenetic = 1;

        /// <summary>
        /// Converts to input search method.
        /// </summary>
        /// <param name="searchMethod">The search method.</param>
        /// <returns></returns>
        public static int ConvertToInputSearchMethod(MStabSearchMethod searchMethod)
        {
            var translationTable = new Dictionary<MStabSearchMethod, int>()
            {
                {MStabSearchMethod.Grid, InputSearchMethodGrid},
                {MStabSearchMethod.GeneticAlgorithm, InputSearchMethodGenetic}
            };
            return translationTable[searchMethod];
        }

        /// <summary>
        /// Converts to search method.
        /// </summary>
        /// <param name="searchMethod">The search method.</param>
        /// <returns></returns>
        public static MStabSearchMethod ConvertToSearchMethod(int searchMethod)
        {
            var translationTable = new Dictionary<int, MStabSearchMethod>()
            {
                {InputSearchMethodGrid, MStabSearchMethod.Grid},
                {InputSearchMethodGenetic, MStabSearchMethod.GeneticAlgorithm}
            };
            return translationTable[searchMethod];
        }

        /// <summary>
        /// Converts the type of to input message.
        /// </summary>
        /// <param name="messageType">Type of the message.</param>
        /// <returns></returns>
        public static MessageMessageType ConvertToInputMessageType(LogMessageType messageType)
        {
            var translationTable = new Dictionary<LogMessageType, MessageMessageType>()
            {
                {LogMessageType.Warning, MessageMessageType.Warning},
                {LogMessageType.Debug, MessageMessageType.Info},
                {LogMessageType.Error, MessageMessageType.Error},
                {LogMessageType.FatalError, MessageMessageType.Error},
                {LogMessageType.Info, MessageMessageType.Info},
                {LogMessageType.Trace, MessageMessageType.Info}
            };
            return translationTable[messageType];
        }

        /// <summary>
        /// Converts the type of to message.
        /// </summary>
        /// <param name="validationResultMessageType">Type of the validation result message.</param>
        /// <returns></returns>
        public static LogMessageType ConvertToLogMessageType(MessageMessageType validationResultMessageType)
        {
            var translationTable = new Dictionary<MessageMessageType, LogMessageType>()
            {
                {MessageMessageType.Warning, LogMessageType.Warning},
                {MessageMessageType.Error, LogMessageType.Error},
                {MessageMessageType.Info, LogMessageType.Info}
            };
            return translationTable[validationResultMessageType];
        }

        /// <summary>
        /// The input grid type automatic
        /// </summary>
        public const int InputGridTypeAutomatic = 0;

        /// <summary>
        /// The input grid type specified
        /// </summary>
        public const int InputGridTypeSpecified = 1;

        /// <summary>
        /// Converts to input grid determination.
        /// </summary>
        /// <param name="gridType">Type of the grid.</param>
        /// <returns></returns>
        public static int ConvertToInputGridDetermination(GridSizeDetermination gridType)
        {
            var translationTable = new Dictionary<GridSizeDetermination, int>()
            {
                {GridSizeDetermination.Automatic, InputGridTypeAutomatic},
                {GridSizeDetermination.Specified, InputGridTypeSpecified}
            };

            return translationTable[gridType];
        }

        /// <summary>
        /// Converts the shear strength model to soil shear strength model.
        /// </summary>
        /// <param name="shearStrengthModel">The shear strength model.</param>
        /// <returns></returns>
        public static SoilShearStrengthModel ConvertToSoilShearStrengthModel(ShearStrengthModel shearStrengthModel)
        {
            var translationTable = new Dictionary<ShearStrengthModel, SoilShearStrengthModel>()
            {
                {ShearStrengthModel.None, SoilShearStrengthModel.None},
                {ShearStrengthModel.CPhi, SoilShearStrengthModel.CPhi},
                {ShearStrengthModel.StressTable, SoilShearStrengthModel.StressTable},
                {ShearStrengthModel.PseudoValues, SoilShearStrengthModel.PseudoValues},
                {ShearStrengthModel.SuMeasured, SoilShearStrengthModel.SuMeasured},
                {ShearStrengthModel.SuCalculated, SoilShearStrengthModel.SuCalculated},
                {ShearStrengthModel.SuGradient, SoilShearStrengthModel.SuGradient},
                {ShearStrengthModel.SuCalculatedWithYield, SoilShearStrengthModel.SuCalculatedWithYield},
                {ShearStrengthModel.CPhiOrSuCalculated, SoilShearStrengthModel.CPhiOrSuCalculated},
            };
            return translationTable[shearStrengthModel];                
        }
            
        /// <summary>
        /// Converts to grid determination.
        /// </summary>
        /// <param name="gridType">Type of the grid.</param>
        /// <returns></returns>
        public static GridSizeDetermination ConvertToGridDetermination(int gridType)
        {
            var translationTable = new Dictionary<int, GridSizeDetermination>()
            {
                {InputGridTypeAutomatic, GridSizeDetermination.Automatic},
                {InputGridTypeSpecified, GridSizeDetermination.Specified}
            };
            return translationTable[gridType];
        }

        /// <summary>
        /// The input tangent lines on boundaty lines
        /// </summary>
        public const int InputTangentLinesOnBoundatyLines = 0;

        /// <summary>
        /// The input tangent lines specified
        /// </summary>
        public const int InputTangentLinesSpecified = 1;

        /// <summary>
        /// Converts to input tangent lines definition.
        /// </summary>
        /// <param name="tangentLineType">Type of the tangent line.</param>
        /// <returns></returns>
        public static int ConvertToInputTangentLinesDefinition(TangentLinesDefinition tangentLineType)
        {
            var translationTable = new Dictionary<TangentLinesDefinition, int>()
            {
                {TangentLinesDefinition.OnBoundaryLines, InputGridTypeAutomatic},
                {TangentLinesDefinition.Specified, InputGridTypeSpecified}
            };
            return translationTable[tangentLineType];
        }

        /// <summary>
        /// Converts to tangent lines definition.
        /// </summary>
        /// <param name="tangentLineType">Type of the tangent line.</param>
        /// <returns></returns>
        public static TangentLinesDefinition ConvertToTangentLinesDefinition(int tangentLineType)
        {
            var translationTable = new Dictionary<int, TangentLinesDefinition>()
            {
                {InputGridTypeAutomatic, TangentLinesDefinition.OnBoundaryLines},
                {InputGridTypeSpecified, TangentLinesDefinition.Specified}
            };
            return translationTable[tangentLineType];
        }
    
        /// <summary>
        /// Converts the soil shear strength model to shear strength model.
        /// </summary>
        /// <param name="soilShearStrengthModel">The soil shear strength model.</param>
        /// <returns></returns>
        public static ShearStrengthModel ConvertToShearStrengthModel(SoilShearStrengthModel soilShearStrengthModel)
        {
            var translationTable = new Dictionary<SoilShearStrengthModel, ShearStrengthModel>()
            {
                {SoilShearStrengthModel.None, ShearStrengthModel.None},
                {SoilShearStrengthModel.CPhi, ShearStrengthModel.CPhi},
                {SoilShearStrengthModel.StressTable, ShearStrengthModel.StressTable},
                {SoilShearStrengthModel.PseudoValues, ShearStrengthModel.PseudoValues},
                {SoilShearStrengthModel.SuMeasured, ShearStrengthModel.SuMeasured},
                {SoilShearStrengthModel.SuCalculated, ShearStrengthModel.SuCalculated},
                {SoilShearStrengthModel.SuGradient, ShearStrengthModel.SuGradient},
                {SoilShearStrengthModel.SuCalculatedWithYield, ShearStrengthModel.SuCalculatedWithYield},
                {SoilShearStrengthModel.CPhiOrSuCalculated, ShearStrengthModel.CPhiOrSuCalculated},
            };
            return translationTable[soilShearStrengthModel];
        }

        /// <summary>
        /// Converts the dilatancy type to soil dilatancy dilatancy.
        /// </summary>
        /// <param name="dilatancyType">Type of the dilatancy.</param>
        /// <returns></returns>
        public static SoilDilatancyType ConvertToSoilDilatancyType(DilatancyType dilatancyType)
        {
            var translationTable = new Dictionary<DilatancyType, SoilDilatancyType>()
            {
                {DilatancyType.Zero, SoilDilatancyType.Zero},
                {DilatancyType.Phi, SoilDilatancyType.Phi},
                {DilatancyType.MinusPhi, SoilDilatancyType.MinusPhi},
            };
            return translationTable[dilatancyType];
        }

        /// <summary>
        /// Converts the soil dilatancy type to dilatancy type.
        /// </summary>
        /// <param name="soilDilatancyType">Type of the soil dilatancy.</param>
        /// <returns></returns>
        public static DilatancyType ConvertToDilatancyType(SoilDilatancyType soilDilatancyType)
        {
            var translationTable = new Dictionary<SoilDilatancyType, DilatancyType>()
            {
                {SoilDilatancyType.Zero, DilatancyType.Zero},
                {SoilDilatancyType.Phi, DilatancyType.Phi},
                {SoilDilatancyType.MinusPhi, DilatancyType.MinusPhi},
            };
            return translationTable[soilDilatancyType];
        }

        /// <summary>
        /// Converts the input StabilityDesignMethod to the Dam StabilityDesignMethod.
        /// </summary>
        /// <param name="stabilityDesignMethod">The stability design method.</param>
        /// <returns></returns>
        public static StabilityDesignMethod ConvertToDamStabilityDesignMethod(LocationDesignOptionsStabilityDesignMethod stabilityDesignMethod)
        {
            var translationTable = new Dictionary<LocationDesignOptionsStabilityDesignMethod, StabilityDesignMethod>()
            {
                {LocationDesignOptionsStabilityDesignMethod.OptimizedSlopeAndShoulderAdaption, StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption},
                {LocationDesignOptionsStabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption, StabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption}
            };
            return translationTable[stabilityDesignMethod];
        }

        /// <summary>
        /// Converts the Dam StabilityDesignMethod to the input StabilityDesignMethod.
        /// </summary>
        /// <param name="stabilityDesignMethod">The stability design method.</param>
        /// <returns></returns>
        public static LocationDesignOptionsStabilityDesignMethod ConvertToInputStabilityDesignMethod(StabilityDesignMethod stabilityDesignMethod)
        {
            var translationTable = new Dictionary<StabilityDesignMethod, LocationDesignOptionsStabilityDesignMethod>()
            {
                {StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption, LocationDesignOptionsStabilityDesignMethod.OptimizedSlopeAndShoulderAdaption},
                {StabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption, LocationDesignOptionsStabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption}
            };
            return translationTable[stabilityDesignMethod];
        }

        /// <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>
        /// <returns></returns>
        public static LoadSituation ConvertToLoadSituation(int inputLoadSituation)
        {
            var translationTable = new Dictionary<int, LoadSituation>()
            {
                {LoadSituationDry, LoadSituation.Dry},
                {LoadSituationWet, 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, 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>
        /// <returns></returns>
        public static DikeDrySensitivity ConvertToDikeDrySensitivity(int inputDikeDrySensitivity)
        {
            var translationTable = new Dictionary<int, DikeDrySensitivity>()
            {
                {DikeDrySensitivityNone, DikeDrySensitivity.None},
                {DikeDrySensitivityDry, 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, 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>
        /// <returns></returns>
        public static HydraulicShortcutType ConvertToHydraulicShortcutType(int inputHydraulicShortcutType)
        {
            var translationTable = new Dictionary<int, HydraulicShortcutType>()
            {
                {HydraulicShortcutTypeHydraulicShortcut, HydraulicShortcutType.HydraulicShortcut},
                {HydraulicShortcutTypeNoHydraulicShortcut, 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, 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>
        /// <returns></returns>
        public static UpliftType ConvertToUpliftType(int inputUpliftType)
        {
            var translationTable = new Dictionary<int, UpliftType>()
            {
                {UpliftTypeUplift, UpliftType.Uplift},
                {UpliftTypeNoUplift, 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, 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>
        /// <returns></returns>
        public static MStabModelType ConvertToMStabModelType(int inputMStabModelType)
        {
            var translationTable = new Dictionary<int, MStabModelType>()
            {
                {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];
        }
        
        /// <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, 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>
        /// <returns></returns>
        public static ScenarioType ConvertToScenarioType(int inputScenarioType)
        {
            var translationTable = new Dictionary<int, ScenarioType>()
            {
                {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];
        }

        /// <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, 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>
        /// <returns></returns>
        public static PipingModelType ConvertToPipingModelType(int inputPipingModelType)
        {
            var translationTable = new Dictionary<int, PipingModelType>()
            {
                {PipingModelTypeBligh, PipingModelType.Bligh},
                {PipingModelTypeSellmeijer, PipingModelType.SellmeijerVnk},
                {PipingModelTypeSellmeijer4Forces, PipingModelType.Sellmeijer4Forces},
                {PipingModelTypeWti2017, 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, 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>
        /// <returns></returns>
        public static RegionalResultType ConvertToRegionalResultType(int inputRegionalResultType)
        {
            var translationTable = new Dictionary<int, RegionalResultType>()
            {
                {RwResultTypeProbabilityOfFailure, RegionalResultType.ProbabilityOfFailure},
                {RwResultTypeSafetyFactor, 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, RwResultTypeProbabilityOfFailure},
                {RegionalResultType.SafetyFactor, RwResultTypeSafetyFactor}
            };
            return translationTable[regionalResultType];
        }

        public const int SoilTypeClay = 0; 
        public const int SoilTypeGravel = 1; 
        public const int SoilTypeLoam = 2; 
        public const int SoilTypePeat = 3; 
        public const int SoilTypeSand = 4;

        /// <summary>
        /// Converts the input dikeMaterialType to SoilType.
        /// </summary>
        /// <param name="dikeMaterialType">Type of the dike material.</param>
        /// <returns></returns>
        public static SoilType ConvertToSoilType(int dikeMaterialType)
        {
            var translationTable = new Dictionary<int, SoilType>()
            {
                {SoilTypeClay, SoilType.Clay},
                {SoilTypeGravel, SoilType.Gravel},
                {SoilTypeLoam, SoilType.Loam},
                {SoilTypePeat, SoilType.Peat},
                {SoilTypeSand, SoilType.Sand}
            };
            return translationTable[dikeMaterialType];
        }

        /// <summary>
        /// Converts the SoilType to the input dikeMaterialType.
        /// </summary>
        /// <param name="soilType">Type of the soil.</param>
        /// <returns></returns>
        public static int ConvertToInputSoilType(SoilType soilType)
        {
            var translationTable = new Dictionary<SoilType, int>()
            {
                {SoilType.Clay, SoilTypeClay},
                {SoilType.Gravel, SoilTypeGravel},
                {SoilType.Loam, SoilTypeLoam},
                {SoilType.Peat, SoilTypePeat},
                {SoilType.Sand, SoilTypeSand}
            };
            return translationTable[soilType];
        }

        /// <summary>
        /// Constants for translating to Enums TimeStepUnit
        /// </summary>
        public const uint TimeStepUnitSecond = 0;
        public const uint TimeStepUnitMinute = 1;
        public const uint TimeStepUnitHour = 2;
        public const uint TimeStepUnitDay = 3;
        public const uint TimeStepUnitMonth = 4;
        public const uint TimeStepUnitWeek = 5;
        public const uint TimeStepUnitYear = 6;
        public const uint TimeStepUnitNonequidistant = 7;

        /// <summary>
        /// Converts the input TimeStepUnit to the TimeStepUnit.
        /// </summary>
        /// <param name="timeStepUnit">The time step unit.</param>
        /// <returns></returns>
        public static TimeStepUnit ConvertToTimeStepUnit(uint timeStepUnit)
        {
            var translationTable = new Dictionary<uint, TimeStepUnit>()
            {
                {TimeStepUnitSecond, TimeStepUnit.Second},
                {TimeStepUnitMinute, TimeStepUnit.Minute},
                {TimeStepUnitHour, TimeStepUnit.Hour},
                {TimeStepUnitDay, TimeStepUnit.Day},
                {TimeStepUnitMonth, TimeStepUnit.Month},
                {TimeStepUnitWeek, TimeStepUnit.Week},
                {TimeStepUnitYear, TimeStepUnit.Year},
                {TimeStepUnitNonequidistant, TimeStepUnit.Nonequidistant},
            };
            return translationTable[timeStepUnit];
        }

        /// <summary>
        /// Converts the TimeStepUnit to the input TimeStepUnit.
        /// </summary>
        /// <param name="timeStepUnit">The time step unit.</param>
        /// <returns></returns>
        public static uint ConvertToInputTimeStepUnit(TimeStepUnit timeStepUnit)
        {
            var translationTable = new Dictionary<TimeStepUnit, uint>()
            {
                {TimeStepUnit.Second, TimeStepUnitSecond},
                {TimeStepUnit.Minute, TimeStepUnitMinute},
                {TimeStepUnit.Hour, TimeStepUnitHour},
                {TimeStepUnit.Day, TimeStepUnitDay},
                {TimeStepUnit.Month, TimeStepUnitMonth},
                {TimeStepUnit.Week, TimeStepUnitWeek},
                {TimeStepUnit.Year, TimeStepUnitYear},
                {TimeStepUnit.Nonequidistant, TimeStepUnitNonequidistant},
            };
            return translationTable[timeStepUnit];
        }

        /// <summary>
        /// Constants for translating to Enums PlLineType
        /// </summary>
        public const uint PlLineTypePl1 = 1;
        public const uint PlLineTypePl2 = 2;
        public const uint PlLineTypePl3 = 3;
        public const uint PlLineTypePl4 = 4;

        /// <summary>
        /// Converts the input plLineType to Dam plLineType.
        /// </summary>
        /// <param name="plLineType">Type of the pl line.</param>
        /// <returns>plLineType</returns>
        public static PlLineType ConvertToPlLineType(uint plLineType)
        {
            var translationTable = new Dictionary<uint, PlLineType>()
            {
                {PlLineTypePl1, PlLineType.Pl1},
                {PlLineTypePl2, PlLineType.Pl2},
                {PlLineTypePl3, PlLineType.Pl3},
                {PlLineTypePl4, PlLineType.Pl4}
            };
            return translationTable[plLineType];
        }

        /// <summary>
        /// Converts the Dam plLineType to input plLineType.
        /// </summary>
        /// <param name="plLineType">Type of the pl line.</param>
        /// <returns>plLineType as integer</returns>
        public static uint ConvertToInputPlLineType(PlLineType plLineType)
        {
            var translationTable = new Dictionary<PlLineType, uint>()
            {
                {PlLineType.Pl1, PlLineTypePl1},
                {PlLineType.Pl2, PlLineTypePl2},
                {PlLineType.Pl3, PlLineTypePl3},
                {PlLineType.Pl4, PlLineTypePl4}
            };
            return translationTable[plLineType];
        }

        /// <summary>
        /// Constants for translating to Enums SensorType
        /// </summary>
        public const uint SensorTypePiezometricHead = 0;
        public const uint SensorTypeWaterLevel = 1;
        public const uint SensorTypePolderLevel = 2;

        /// <summary>
        /// Converts the Dam sensorType to input sensorType.
        /// </summary>
        /// <param name="sensorType">Type of the sensor.</param>
        /// <returns>sensorType</returns>
        public static SensorType ConvertToSensorType(uint sensorType)
        {
            var translationTable = new Dictionary<uint, SensorType>()
            {
                {SensorTypePiezometricHead, SensorType.PiezometricHead},
                {SensorTypePolderLevel, SensorType.PolderLevel},
                {SensorTypeWaterLevel, SensorType.WaterLevel}
            };
            return translationTable[sensorType];
        }

        /// <summary>
        /// Converts the Dam sensorType to input sensorType.
        /// </summary>
        /// <param name="sensorType">Type of the sensor.</param>
        /// <returns>sensorType as integer</returns>
        public static uint ConvertToInputSensorType(SensorType sensorType)
        {
            var translationTable = new Dictionary<SensorType, uint>()
            {
                {SensorType.PiezometricHead, SensorTypePiezometricHead},
                {SensorType.PolderLevel, SensorTypePolderLevel},
                {SensorType.WaterLevel, SensorTypeWaterLevel}
            };
            return translationTable[sensorType];
        }

        /// <summary>
        /// Constants for translating to Enums DataSourceTypeSensors
        /// </summary>
        public const uint DataSourceTypeSensorsIgnore = 0;
        public const uint DataSourceTypeSensorsLocationData = 1;
        public const uint DataSourceTypeSensorsSensor = 2;

        /// <summary>
        /// Converts the Dam DataSourceTypeSensors to input DataSourceTypeSensors.
        /// </summary>
        /// <param name="dataSourceTypeSensors">The data source type sensors.</param>
        /// <returns>
        /// DataSourceTypeSensors
        /// </returns>
        public static DataSourceTypeSensors ConvertToDataSourceTypeSensors(uint dataSourceTypeSensors)
        {
            var translationTable = new Dictionary<uint, DataSourceTypeSensors>()
            {
                {DataSourceTypeSensorsIgnore, DataSourceTypeSensors.Ignore},
                {DataSourceTypeSensorsLocationData, DataSourceTypeSensors.LocationData},
                {DataSourceTypeSensorsSensor, DataSourceTypeSensors.Sensor}
            };
            return translationTable[dataSourceTypeSensors];
        }

        /// <summary>
        /// Converts the Dam DataSourceType to input DataSourceType.
        /// </summary>
        /// <param name="dataSourceTypeSensors">The data source type sensors.</param>
        /// <returns>
        /// DataSourceType as integer
        /// </returns>
        public static uint ConvertToInputDataSourceTypeSensors(DataSourceTypeSensors dataSourceTypeSensors)
        {
            var translationTable = new Dictionary<DataSourceTypeSensors, uint>()
            {
                {DataSourceTypeSensors.Ignore, DataSourceTypeSensorsIgnore},
                {DataSourceTypeSensors.LocationData, DataSourceTypeSensorsLocationData},
                {DataSourceTypeSensors.Sensor, DataSourceTypeSensorsSensor}
            };
            return translationTable[dataSourceTypeSensors];
        }
    }
}