//-----------------------------------------------------------------------
// <copyright file="Scenario.cs" company="Deltares">
//  Copyright (c) 2010 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T. The</author>
// <email>tom.the@deltares.nl</email>
// <date>04-11-2010</date>
// <summary>Calculation scenario class</summary>
//-----------------------------------------------------------------------

using System.ComponentModel;
using System.Globalization;
using System.Xml.Serialization;
using Deltares.Geotechnics;
using Deltares.Standard;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Language;
using System.Collections.Generic;
using System;
using System.Collections.Specialized;
using System.Linq.Expressions;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.Attributes;
using Deltares.Standard.Units;
using Deltares.Standard.Validation;

namespace Deltares.Dam.Data
{

    /// <summary>
    /// Does uplift occur or not
    /// </summary>
    public struct UpliftSituation
    {
        public bool IsUplift;
        public double Pl3MinUplift;
        public double Pl3HeadAdjusted;
        public double Pl3LocationXMinUplift;
        public double Pl4MinUplift;
        public double Pl4HeadAdjusted;
        public double Pl4LocationXMinUplift;
    }

    [Serializable]
    public class ScenarioException : Exception
    {
        public ScenarioException(string message) : base(message)
        {
        }
    }

    /// <summary>
    /// Calculation scenario class
    /// </summary>
    public class Scenario : IVisibleEnabled, IRepairer
    {
        #region Performance optimization: Extract expression so it only has to be generated once.

        private static readonly Expression<Func<Scenario, object>> ExpressionLocationScenarioId = x => x.LocationScenarioID;
        private static readonly Expression<Func<Scenario, object>> ExpressionRiverLevel = x => x.RiverLevel;
        private static readonly Expression<Func<Scenario, object>> ExpressionRiverLevelLow = x => x.RiverLevelLow;
        private static readonly Expression<Func<Scenario, object>> ExpressionDikeTableHeight = x => x.DikeTableHeight;
        private static readonly Expression<Func<Scenario, object>> ExpressionRequiredSafetyFactorStabilityInnerSlope = x => x.RequiredSafetyFactorStabilityInnerSlope;
        private static readonly Expression<Func<Scenario, object>> ExpressionRequiredSafetyFactorStabilityOuterSlope = x => x.RequiredSafetyFactorStabilityOuterSlope;
        private static readonly Expression<Func<Scenario, object>> ExpressionRequiredSafetyFactorPiping = x => x.RequiredSafetyFactorPiping;
        private static readonly Expression<Func<Scenario, object>> ExpressionRequiredProbabilityOfFailurePiping = x => x.RequiredProbabilityOfFailurePiping;
        private static readonly Expression<Func<Scenario, object>> ExpressionUpliftCriterionPiping = x => x.UpliftCriterionPiping;
        private static readonly Expression<Func<Scenario, object>> ExpressionUpliftCriterionStability = x => x.UpliftCriterionStability;
        private static readonly Expression<Func<Scenario, object>> ExpressionPlLineOffsetBelowDikeTopAtRiver = x => x.PlLineOffsetBelowDikeTopAtRiver;
        private static readonly Expression<Func<Scenario, object>> ExpressionPlLineOffsetBelowDikeTopAtPolder = x => x.PlLineOffsetBelowDikeTopAtPolder;
        private static readonly Expression<Func<Scenario, object>> ExpressionPlLineOffsetBelowShoulderBaseInside = x => x.PlLineOffsetBelowShoulderBaseInside;
        private static readonly Expression<Func<Scenario, object>> ExpressionPlLineOffsetBelowDikeToeAtPolder = x => x.PlLineOffsetBelowDikeToeAtPolder;
        private static readonly Expression<Func<Scenario, object>> ExpressionUsePlLineOffsetBelowDikeCrestMiddle = x => x.UsePlLineOffsetBelowDikeCrestMiddle;
        private static readonly Expression<Func<Scenario, object>> ExpressionPlLineOffsetBelowDikeCrestMiddle = x => x.PlLineOffsetBelowDikeCrestMiddle;
        private static readonly Expression<Func<Scenario, object>> ExpressionUsePlLineOffsetFactorBelowShoulderCrest = x => x.UsePlLineOffsetFactorBelowShoulderCrest;
        private static readonly Expression<Func<Scenario, object>> ExpressionPlLineOffsetFactorBelowShoulderCrest = x => x.PlLineOffsetFactorBelowShoulderCrest;
        private static readonly Expression<Func<Scenario, object>> ExpressionHeadPl3 = x => x.HeadPl3;
        private static readonly Expression<Func<Scenario, object>> ExpressionHeadPl4 = x => x.HeadPl4;
        private static readonly Expression<Func<Scenario, object>> ExpressionWaterHeightDecimeringsHoogte = x => x.WaterHeightDecimeringsHoogte;
        private static readonly Expression<Func<Scenario, object>> ExpressionMaxWaterLevel = x => x.MaxWaterLevel;
        
        #endregion

        private CalculationResult calculationResult = CalculationResult.NoRun;
        private Location location = null;
        private readonly List<CsvExportData> calculationResults = new List<CsvExportData>();

        private Dictionary<Object, UpliftSituation?> stabilityUpliftSituations;
        private Dictionary<Object, PipingResults?> pipingResults;
        private Dictionary<Object, MStabResults?> mStabResults;
        private Dictionary<Object, double?> failureProbabilitiesStability;
        private Dictionary<Object, double?> safetyFactorsPiping;
        private Dictionary<Object, double?> failureProbabilitiesPiping;
        private Dictionary<Object, SurfaceLine2> redesignedSurfaceLines;
        private Dictionary<Object, string> resultMessages;
        private Dictionary<Object, double?> safetyFactorsFlowSlide;

        private string locationScenarioId;
        private double riverLevel;
        private double? riverLevelLow;
        private double? dikeTableHeight;
        private double? plLineOffsetBelowDikeTopAtRiver;
        private double? plLineOffsetBelowDikeTopAtPolder;
        private double? plLineOffsetBelowShoulderBaseInside;
        private double? plLineOffsetBelowDikeToeAtPolder;
        private bool? usePlLineOffsetBelowDikeCrestMiddle;
        private double? plLineOffsetBelowDikeCrestMiddle;
        private bool? usePlLineOffsetFactorBelowShoulderCrest;
        private double? plLineOffsetFactorBelowShoulderCrest;
        private double? headPl3;
        private double? headPl4;
        private double? waterHeightDecimeringsHoogte;
        private double? maxWaterLevel;

        [Browsable(false)]
        public CalculationResult CalculationResult
        {
            get { return calculationResult; }
            set { calculationResult = value; }
        }

        [Browsable(false)]
        [XmlIgnore]
        public IList<NonWaterRetainingObjectResults> NwoResults { get; set; }

        [Browsable(false)]
        public List<CsvExportData> CalculationResults
        {
            get { return calculationResults; }
        }
        
        /// <summary>
        /// Constructor
        /// </summary>
        public Scenario()
        {
            ClearResults();
            ClearErrors();
            ClearstabilityUpliftSituations();
            ModelFactors = new ModelFactors();
        }

        /// <summary>
        /// Clears the results
        /// </summary>
        public void ClearstabilityUpliftSituations()
        {
            stabilityUpliftSituations = new Dictionary<Object, UpliftSituation?>();
        }

        /// <summary>
        /// Clears the errors.
        /// </summary>
        public void ClearErrors()
        {
            Errors = new StringCollection();
        }
        /// <summary>
        /// Clears the results
        /// </summary>
        public void ClearResults()
        {
            calculationResult = CalculationResult.NoRun;
            pipingResults = new Dictionary<Object, PipingResults?>();
            mStabResults = new Dictionary<Object, MStabResults?>();
            safetyFactorsPiping = new Dictionary<Object, double?>();
            safetyFactorsFlowSlide = new Dictionary<Object, double?>();
            resultMessages = new Dictionary<Object, string>();
            failureProbabilitiesStability = new Dictionary<Object, double?>();
            failureProbabilitiesPiping = new Dictionary<Object, double?>();
            redesignedSurfaceLines = new Dictionary<Object, SurfaceLine2>();
            NwoResults = new List<NonWaterRetainingObjectResults>();
            calculationResults.Clear(); 
        }

        /// <summary>
        /// Gets or sets the location scenario identifier.
        /// </summary>
        /// <value>
        /// The location scenario identifier.
        /// </value>
        [Browsable(true)]
        [PropertyOrder(0, 1)]
        [ReadOnly(true)]
        public string LocationScenarioID 
        {
            get
            {
                return locationScenarioId;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionLocationScenarioId);
                locationScenarioId = value;
                DataEventPublisher.AfterChange(this, ExpressionLocationScenarioId);
            }
        }

        [Browsable(false)]
        public StringCollection Errors { get; private set; }

        /// <summary>
        /// Gets or sets the river level.
        /// </summary>
        /// <value>
        /// The river level.
        /// </value>
        [PropertyOrder(1, 1)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        [Label("River level")]
        [Description("River level")]
        public double RiverLevel
        {
            get
            {
                return riverLevel;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionRiverLevel);
                riverLevel = value;
                DataEventPublisher.AfterChange(this, ExpressionRiverLevel);
            }
        }

        /// <summary>
        /// Gets or sets the river level low.
        /// </summary>
        /// <value>
        /// The river level low.
        /// </value>
        [PropertyOrder(1, 2)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        [Label("River level low")]
        [Description("River level low")]
        public double? RiverLevelLow
        {
            get
            {
                return riverLevelLow;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionRiverLevelLow);
                riverLevelLow = value;
                DataEventPublisher.AfterChange(this, ExpressionRiverLevelLow);
            }
        }

        /// <summary>
        /// Gets or sets the height of the dike table.
        /// </summary>
        /// <value>
        /// The height of the dike table.
        /// </value>
        [PropertyOrder(1, 3)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        [Label("Dike table height")]
        [Description("Dike table height")]
        public double? DikeTableHeight
        {
            get
            {
                return dikeTableHeight;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionDikeTableHeight);
                dikeTableHeight = value;
                DataEventPublisher.AfterChange(this, ExpressionDikeTableHeight);
            }
        }

        /// <summary>
        /// Gets or sets the required safety factor stability inner slope.
        /// </summary>
        /// <value>
        /// The required safety factor stability inner slope.
        /// </value>
        [PropertyOrder(1, 4)]
        [Format("F2")]
        [Label("Required safety factor stability inner slope")]
        [Description("Required safety factor stability inner slope")]
        public double? RequiredSafetyFactorStabilityInnerSlope
        {
            get { return ModelFactors.RequiredSafetyFactorStabilityInnerSlope; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionRequiredSafetyFactorStabilityInnerSlope);
                ModelFactors.RequiredSafetyFactorStabilityInnerSlope = value;
                DataEventPublisher.AfterChange(this, ExpressionRequiredSafetyFactorStabilityInnerSlope);
            }
        }

        /// <summary>
        /// Gets or sets the required safety factor stability outer slope.
        /// </summary>
        /// <value>
        /// The required safety factor stability outer slope.
        /// </value>
        [PropertyOrder(1, 5)]
        [Format("F2")]
        [Label("Required safety factor stability outer slope")]
        [Description("Required safety factor stability outer slope")]
        public double? RequiredSafetyFactorStabilityOuterSlope
        {
            get { return ModelFactors.RequiredSafetyFactorStabilityOuterSlope; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionRequiredSafetyFactorStabilityOuterSlope);
                ModelFactors.RequiredSafetyFactorStabilityOuterSlope = value;
                DataEventPublisher.AfterChange(this, ExpressionRequiredSafetyFactorStabilityOuterSlope);
            }
        }

        /// <summary>
        /// Gets or sets the required safety factor piping.
        /// </summary>
        /// <value>
        /// The required safety factor piping.
        /// </value>
        [PropertyOrder(1, 6)]
        [Format("F2")]
        [Label("Required safety factor piping")]
        [Description("Required safety factor piping")]
        public double? RequiredSafetyFactorPiping
        {
            get { return ModelFactors.RequiredSafetyFactorPiping; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionRequiredSafetyFactorPiping);
                ModelFactors.RequiredSafetyFactorPiping = value;
                DataEventPublisher.AfterChange(this, ExpressionRequiredSafetyFactorPiping);
            }
        }

        /// <summary>
        /// Gets or sets the required probability of failure piping.
        /// </summary>
        /// <value>
        /// The required probability of failure piping.
        /// </value>
        [PropertyOrder(1, 7)]
        [Format("F6")]
        [Label("Required probability of failure piping")]
        [Description("Required probability of failure piping")]
        public double? RequiredProbabilityOfFailurePiping
        {
            get { return ModelFactors.RequiredProbabilityOfFailurePiping; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionRequiredProbabilityOfFailurePiping);
                ModelFactors.RequiredProbabilityOfFailurePiping = value;
                DataEventPublisher.AfterChange(this, ExpressionRequiredProbabilityOfFailurePiping);
            }
        }

        /// <summary>
        /// Gets or sets the uplift criterion piping.
        /// </summary>
        /// <value>
        /// The uplift criterion piping.
        /// </value>
        [PropertyOrder(1, 8)]
        [Format("F2")]
        [Label("Uplift criterion piping")]
        [Description("Uplift criterion piping")]
        public double? UpliftCriterionPiping
        {
            get { return ModelFactors.UpliftCriterionPiping; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionUpliftCriterionPiping);
                ModelFactors.UpliftCriterionPiping = value;
                DataEventPublisher.AfterChange(this, ExpressionUpliftCriterionPiping);
            }
        }

        /// <summary>
        /// Gets or sets the uplift criterion stability.
        /// </summary>
        /// <value>
        /// The uplift criterion stability.
        /// </value>
        [PropertyOrder(1, 9)]
        [Format("F2")]
        [Label("Uplift criterion stability")]
        [Description("Uplift criterion stability")]
        public double? UpliftCriterionStability
        {
            get { return ModelFactors.UpliftCriterionStability; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionUpliftCriterionStability);
                ModelFactors.UpliftCriterionStability = value;
                DataEventPublisher.AfterChange(this, ExpressionUpliftCriterionStability);
            }
        }

        [PropertyOrder(1, 10)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        public double? PlLineOffsetBelowDikeTopAtRiver
        {
            get
            {
                return plLineOffsetBelowDikeTopAtRiver;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionPlLineOffsetBelowDikeTopAtRiver);
                plLineOffsetBelowDikeTopAtRiver = value;
                DataEventPublisher.AfterChange(this, ExpressionPlLineOffsetBelowDikeTopAtRiver);
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below dike top at polder.
        /// </summary>
        /// <value>
        /// The pl line offset below dike top at polder.
        /// </value>
        [PropertyOrder(1, 11)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        public double? PlLineOffsetBelowDikeTopAtPolder
        {
            get
            {
                return plLineOffsetBelowDikeTopAtPolder;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionPlLineOffsetBelowDikeTopAtPolder);
                plLineOffsetBelowDikeTopAtPolder = value;
                DataEventPublisher.AfterChange(this, ExpressionPlLineOffsetBelowDikeTopAtPolder);
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below shoulder base inside.
        /// </summary>
        /// <value>
        /// The pl line offset below shoulder base inside.
        /// </value>
        [PropertyOrder(1, 12)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        public double? PlLineOffsetBelowShoulderBaseInside
        {
            get
            {
                return plLineOffsetBelowShoulderBaseInside;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionPlLineOffsetBelowShoulderBaseInside);
                plLineOffsetBelowShoulderBaseInside = value;
                DataEventPublisher.AfterChange(this, ExpressionPlLineOffsetBelowShoulderBaseInside);
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below dike toe at polder.
        /// </summary>
        /// <value>
        /// The pl line offset below dike toe at polder.
        /// </value>
        [PropertyOrder(1, 13)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        public double? PlLineOffsetBelowDikeToeAtPolder
        {
            get
            {
                return plLineOffsetBelowDikeToeAtPolder;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionPlLineOffsetBelowDikeToeAtPolder);
                plLineOffsetBelowDikeToeAtPolder = value;
                DataEventPublisher.AfterChange(this, ExpressionPlLineOffsetBelowDikeToeAtPolder);
            }
        }

        /// <summary>
        /// Gets or sets the use pl line offset below dike crest middle.
        /// </summary>
        /// <value>
        /// The use pl line offset below dike crest middle.
        /// </value>
        [PropertyOrder(1, 14)]
        [Unit(UnitType.None)]
        [Clearable]
        public bool? UsePlLineOffsetBelowDikeCrestMiddle
        {
            get
            {
                return usePlLineOffsetBelowDikeCrestMiddle;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionUsePlLineOffsetBelowDikeCrestMiddle);
                usePlLineOffsetBelowDikeCrestMiddle = value;
                DataEventPublisher.AfterChange(this, ExpressionUsePlLineOffsetBelowDikeCrestMiddle);
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset below dike crest middle.
        /// </summary>
        /// <value>
        /// The pl line offset below dike crest middle.
        /// </value>
        [PropertyOrder(1, 15)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        public double? PlLineOffsetBelowDikeCrestMiddle
        {
            get { return plLineOffsetBelowDikeCrestMiddle; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionPlLineOffsetBelowDikeCrestMiddle);
                plLineOffsetBelowDikeCrestMiddle = value;
                DataEventPublisher.AfterChange(this, ExpressionPlLineOffsetBelowDikeCrestMiddle);
            }
        }

        /// <summary>
        /// Gets or sets the use pl line offset factor below shoulder crest.
        /// </summary>
        /// <value>
        /// The use pl line offset factor below shoulder crest.
        /// </value>
        [PropertyOrder(1, 16)]
        [Unit(UnitType.None)]
        [Clearable]
        public bool? UsePlLineOffsetFactorBelowShoulderCrest
        {
            get
            {
                return usePlLineOffsetFactorBelowShoulderCrest;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionUsePlLineOffsetFactorBelowShoulderCrest);
                usePlLineOffsetFactorBelowShoulderCrest = value;
                DataEventPublisher.AfterChange(this, ExpressionUsePlLineOffsetFactorBelowShoulderCrest);
            }
        }

        /// <summary>
        /// Gets or sets the pl line offset factor below shoulder crest.
        /// </summary>
        /// <value>
        /// The pl line offset factor below shoulder crest.
        /// </value>
        [PropertyOrder(1, 17)]
        [Unit(UnitType.Fractions)]
        [Format("F2")]
        public double? PlLineOffsetFactorBelowShoulderCrest
        {
            get { return plLineOffsetFactorBelowShoulderCrest; }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionPlLineOffsetFactorBelowShoulderCrest);
                plLineOffsetFactorBelowShoulderCrest = value;
                DataEventPublisher.AfterChange(this, ExpressionPlLineOffsetFactorBelowShoulderCrest);
            }
        }

        /// <summary>
        /// Gets or sets the head PL3.
        /// </summary>
        /// <value>
        /// The head PL3.
        /// </value>
        [PropertyOrder(1, 18)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        public double? HeadPl3
        {
            get
            {
                return headPl3;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionHeadPl3);
                headPl3 = value;
                DataEventPublisher.AfterChange(this, ExpressionHeadPl3);
            }
        }

        /// <summary>
        /// Gets or sets the head PL4.
        /// </summary>
        /// <value>
        /// The head PL4.
        /// </value>
        [PropertyOrder(1, 19)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        public double? HeadPl4
        {
            get
            {
                return headPl4;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionHeadPl4);
                headPl4 = value;
                DataEventPublisher.AfterChange(this, ExpressionHeadPl4);
            }
        }

        /// <summary>
        /// Gets or sets the water height decimerings hoogte.
        /// </summary>
        /// <value>
        /// The water height decimerings hoogte.
        /// </value>
        [Browsable(false)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        [Label("Water height decimerings height")]
        public double? WaterHeightDecimeringsHoogte
        {
            get
            {
                return waterHeightDecimeringsHoogte;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionWaterHeightDecimeringsHoogte);
                waterHeightDecimeringsHoogte = value;
                DataEventPublisher.AfterChange(this, ExpressionWaterHeightDecimeringsHoogte);
            }
        }

        /// <summary>
        /// Gets or sets the maximum water level.
        /// </summary>
        /// <value>
        /// The maximum water level.
        /// </value>
        [Browsable(false)]
        [Unit(UnitType.Length)]
        [Format("F2")]
        [Label("Max water level")]
        public double? MaxWaterLevel
        {
            get
            {
                return maxWaterLevel;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, ExpressionMaxWaterLevel);
                maxWaterLevel = value;
                DataEventPublisher.AfterChange(this, ExpressionMaxWaterLevel);
            }
        }

        [Browsable(false)]
        public ModelFactors ModelFactors { get; set; }

        /// <remarks>Aggregation relationship.</remarks>
        [Browsable(false)]
        public Location Location
        {
            get { return location; }
            set { location = value; }
        }

        /// <summary>
        /// Get uplift criterion for this scenario; return default value if not available
        /// </summary>
        /// <param name="defaultUpliftCriterionStability">default value if not available</param>
        /// <returns>uplift criterion for this scenario</returns>
        public double GetUpliftCriterionStability(double? defaultUpliftCriterionStability)
        {
            if ((defaultUpliftCriterionStability == null) && (ModelFactors.UpliftCriterionStability == null))
            {
                throw new ScenarioException(String.Format(LocalizationManager.GetTranslatedText(typeof(SurfaceLineAdapter), "NoUpliftCriterionForStability"), Location.Name, ToString()));
                
            }
            return (ModelFactors.UpliftCriterionStability == null ? defaultUpliftCriterionStability.Value
                        : ModelFactors.UpliftCriterionStability.Value);
        }

        /// <summary>
        /// Get uplift criterion for this scenario; return default value if not available
        /// </summary>
        /// <param name="defaultUpliftCriterionPiping">default value if not available</param>
        /// <returns>uplift criterion for this scenario</returns>
        public double GetUpliftCriterionPiping(double? defaultUpliftCriterionPiping)
        {
            if ((defaultUpliftCriterionPiping == null) && (ModelFactors.UpliftCriterionPiping == null))
            {
                throw new ScenarioException(String.Format(LocalizationManager.GetTranslatedText(typeof(SurfaceLineAdapter), "NoUpliftCriterionForPiping"), Location.Name, ToString()));
            }
            return (ModelFactors.UpliftCriterionPiping == null ? defaultUpliftCriterionPiping.Value : ModelFactors.UpliftCriterionPiping.Value);
        }

        /// <summary>
        /// Get required safety factor for this scenario; return default value if not available
        /// </summary>
        /// <param name="defaultRequiredSafetyFactorPiping">default value if not available</param>
        /// <returns>uplift criterion for this scenario</returns>
        public double GetRequiredSafetyFactorPiping(double? defaultRequiredSafetyFactorPiping)
        {
            if ((defaultRequiredSafetyFactorPiping == null) && (ModelFactors.RequiredSafetyFactorPiping == null))
            {
                throw new ScenarioException(String.Format(LocalizationManager.GetTranslatedText(typeof(SurfaceLineAdapter), "NoRequiredSafetyFactorPiping"), Location.Name, ToString()));
            }
            return (ModelFactors.RequiredSafetyFactorPiping == null ? defaultRequiredSafetyFactorPiping.Value : ModelFactors.RequiredSafetyFactorPiping.Value);
        }

        /// <summary>
        /// Determines whether [is pl line offset factor below shoulder crest valid].
        /// </summary>
        /// <returns></returns>
        [Validate]
        public ValidationResult[] IsPlLineOffsetFactorBelowShoulderCrestValid()
        {
            if (UsePlLineOffsetFactorBelowShoulderCrest.HasValue && UsePlLineOffsetFactorBelowShoulderCrest.Value &&
                PlLineOffsetFactorBelowShoulderCrest.HasValue)
            {
                if (PlLineOffsetFactorBelowShoulderCrest.Value < DamGlobalConstants.PlLineOffsetFactorBelowShoulderCrestMinValue)
                {
                    return new[]
                        {
                            new ValidationResult(ValidationResultType.Error,
                                                 LocalizationManager.GetTranslatedText(this, "PlLineOffsetFactorBelowShoulderCrestTooSmall"),
                                                 this, "PlLineOffsetFactorBelowShoulderCrest", "AssignMinValue", (IRepairer) this)
                        };
                }
                if (PlLineOffsetFactorBelowShoulderCrest.Value > DamGlobalConstants.PlLineOffsetFactorBelowShoulderCrestMaxValue)
                {
                    return new[]
                        {
                            new ValidationResult(ValidationResultType.Error,
                                                 LocalizationManager.GetTranslatedText(this, "PlLineOffsetFactorBelowShoulderCrestTooLarge"),
                                                 this, "PlLineOffsetFactorBelowShoulderCrest", "AssignMaxValue", (IRepairer) this)
                        };
                }
            }
            return new ValidationResult[0];
        }

        /// <summary>
        /// Get stability uplift situation
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private UpliftSituation? GetStabilityUpliftSituation(Object objectAsKey)
        {
            return objectAsKey != null && stabilityUpliftSituations.ContainsKey(objectAsKey) ? stabilityUpliftSituations[objectAsKey] : null;
        }

        /// <summary>
        /// Get stability uplift situation
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public UpliftSituation? GetStabilityUpliftSituation(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetStabilityUpliftSituation(objectAsKey);
        }

        /// <summary>
        ///  Set stability uplift situation
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="upliftSituation"></param>
        private void SetStabilityUpliftSituation(Object objectAsKey, UpliftSituation upliftSituation)
        {
            stabilityUpliftSituations[objectAsKey] = upliftSituation;
        }

        /// <summary>
        /// Set stability uplift situation
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="upliftSituation"></param>
        public void SetStabilityUpliftSituation(SoilProfile1D soilProfile, string soilGeometry2DName, UpliftSituation upliftSituation)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetStabilityUpliftSituation(objectAsKey, upliftSituation);
        }

        /// <summary>
        /// Get PipingResults
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private PipingResults? GetPipingResults(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return pipingResults.ContainsKey(objectAsKey) ? pipingResults[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        /// Get PipingResults
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public PipingResults? GetPipingResults(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetPipingResults(objectAsKey);
        }

        /// <summary>
        /// Set PipingResults
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="pipingResults"></param>
        private void SetPipingResults(Object objectAsKey, PipingResults? pipingResults)
        {
            this.pipingResults[objectAsKey] = pipingResults;
        }

        /// <summary>
        /// Set PipingResults
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="pipingResults"></param>
        public void SetPipingResults(SoilProfile1D soilProfile, string soilGeometry2DName, PipingResults? pipingResults)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetPipingResults(objectAsKey, pipingResults);
        }

        /// <summary>
        /// Get MStabResults
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private MStabResults? GetMStabResults(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return mStabResults.ContainsKey(objectAsKey) ? mStabResults[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        /// Get MStabResults
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public MStabResults? GetMStabResults(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetMStabResults(objectAsKey);
        }

        /// <summary>
        /// Set MStabResults
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="mStabResults"></param>
        private void SetMStabResults(Object objectAsKey, MStabResults? mStabResults)
        {
            this.mStabResults[objectAsKey] = mStabResults;
        }

        /// <summary>
        /// Set MStabResults
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="mStabResults"></param>
        public void SetMStabResults(SoilProfile1D soilProfile, string soilGeometry2DName, MStabResults? mStabResults)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetMStabResults(objectAsKey, mStabResults);
        }

        /// <summary>
        /// Get Safety Factor Piping
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private double? GetSafetyFactorPiping(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return safetyFactorsPiping.ContainsKey(objectAsKey) ? safetyFactorsPiping[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        ///  Get Safety Factor Piping
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public double? GetSafetyFactorPiping(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetSafetyFactorPiping(objectAsKey);
        }

        /// <summary>
        ///  Set Safety Factor Piping
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="safetyFactor"></param>
        private void SetSafetyFactorPiping(Object objectAsKey, double? safetyFactor)
        {
            safetyFactorsPiping[objectAsKey] = safetyFactor;
        }

        /// <summary>
        /// Set Safety Factor Piping
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="safetyFactor"></param>
        public void SetSafetyFactorPiping(SoilProfile1D soilProfile, string soilGeometry2DName, double? safetyFactor)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetSafetyFactorPiping(objectAsKey, safetyFactor);
        }

        /// <summary>
        /// Get Failure Probability piping 
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private double? GetFailureProbabilityPiping(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return failureProbabilitiesPiping.ContainsKey(objectAsKey) ? failureProbabilitiesPiping[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        /// Get Failure Probability piping 
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public double? GetFailureProbabilityPiping(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetFailureProbabilityPiping(objectAsKey);
        }

        /// <summary>
        /// Set Failure Probability piping 
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="failureProbability"></param>
        public void SetFailureProbabilityPiping(SoilProfile1D soilProfile, string soilGeometry2DName, double? failureProbability)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetFailureProbabilityPiping(objectAsKey, failureProbability);
        }

        /// <summary>
        /// Set Failure Probability piping  
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="failureProbability"></param>
        private void SetFailureProbabilityPiping(Object objectAsKey, double? failureProbability)
        {
            failureProbabilitiesPiping[objectAsKey] = failureProbability;
        }

        /// <summary>
        ///  Get Safety Factor Piping
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public double? GetSafetyFactorFlowSlide(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetSafetyFactorFlowSlide(objectAsKey);
        }

        /// <summary>
        /// Get Safety Factor FlowSlide
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private double? GetSafetyFactorFlowSlide(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return safetyFactorsFlowSlide.ContainsKey(objectAsKey) ? safetyFactorsFlowSlide[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        ///  Set Safety Factor FlowSlide
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="safetyFactor"></param>
        private void SetSafetyFactorFlowSlide(Object objectAsKey, double? safetyFactor)
        {
            safetyFactorsFlowSlide[objectAsKey] = safetyFactor;
        }

        /// <summary>
        /// Set Safety Factor FlowSlide
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="safetyFactor"></param>
        public void SetSafetyFactorFlowSlide(SoilProfile1D soilProfile, string soilGeometry2DName, double? safetyFactor)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetSafetyFactorFlowSlide(objectAsKey, safetyFactor);
        }

        /// <summary>
        /// Get Result Message
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private string GetResultMessage(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return resultMessages.ContainsKey(objectAsKey) ? resultMessages[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        /// Get Result Message
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public string GetResultMessage(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetResultMessage(objectAsKey);
        }

        /// <summary>
        /// Set Result Message
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="resultMessage"></param>
        private void SetResultMessage(Object objectAsKey, string resultMessage)
        {
            resultMessages[objectAsKey] = resultMessage;
        }

        /// <summary>
        /// Set Result Message
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="resultMessage"></param>
        public void SetResultMessage(SoilProfile1D soilProfile, string soilGeometry2DName, string resultMessage)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetResultMessage(objectAsKey, resultMessage);
        }

        /// <summary>
        /// Return the safety factor for calculation type of most probable soil profile
        /// </summary>
        /// <param name="failureMechanismType"></param>
        /// <returns></returns>
        public double? GetMostProbableSafetyFactor(FailureMechanismSystemType? failureMechanismType)
        {
            SoilProfile1D soilProfile = Location.Segment.GetMostProbableProfile(failureMechanismType);
            string soilGeometry2DName = Location.Segment.GetMostProbableGeometry2DName(failureMechanismType);
            switch (failureMechanismType)
            {
                case FailureMechanismSystemType.Piping:
                    return GetSafetyFactorPiping(soilProfile, soilGeometry2DName);
                case FailureMechanismSystemType.StabilityInside:
                case FailureMechanismSystemType.StabilityOutside:
                    MStabResults? mstabResults = GetMStabResults(soilProfile, soilGeometry2DName);
                    double? safetyFactor = null;
                    if (mstabResults != null)
                    {
                        safetyFactor = mstabResults.Value.zone1.safetyFactor;
                    }
                    return safetyFactor;
            }
            return null;
        }

        /// <summary>
        /// Return probability stability
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private double? GetFailureProbabilityStability(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return failureProbabilitiesStability.ContainsKey(objectAsKey) ? failureProbabilitiesStability[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        /// Return probability stability
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public double? GetFailureProbabilityStability(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetFailureProbabilityStability(objectAsKey);
        }

        /// <summary>
        /// Set probability stability
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="failureProbability"></param>
        private void SetFailureProbabilityStability(Object objectAsKey, double? failureProbability)
        {
            failureProbabilitiesStability[objectAsKey] = failureProbability;
        }

        /// <summary>
        /// Set probability stability
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="failureProbability"></param>
        public void SetFailureProbabilityStability(SoilProfile1D soilProfile, string soilGeometry2DName, double? failureProbability)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetFailureProbabilityStability(objectAsKey, failureProbability);
        }

        /// <summary>
        /// Get Redesigned surfaceline
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private SurfaceLine2 GetRedesignedSurfaceLine(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return redesignedSurfaceLines.ContainsKey(objectAsKey) ? redesignedSurfaceLines[objectAsKey] : null;
            }
            return null;
        }

        /// <summary>
        /// Get Redesigned surfaceline
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public SurfaceLine2 GetRedesignedSurfaceLine(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            return GetRedesignedSurfaceLine(objectAsKey);
        }

        /// <summary>
        /// Set Redesigned surfaceline
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <param name="surfaceLine"></param>
        private void SetRedesignedSurfaceLine(Object objectAsKey, SurfaceLine2 surfaceLine)
        {
            redesignedSurfaceLines[objectAsKey] = surfaceLine;
        }

        /// <summary>
        /// Set Redesigned surfaceline
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="surfaceLine"></param>
        public void SetRedesignedSurfaceLine(SoilProfile1D soilProfile, string soilGeometry2DName, SurfaceLine2 surfaceLine)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetRedesignedSurfaceLine(objectAsKey, surfaceLine);
        }

        /// <summary>
        /// Get Most recent surfaceline
        /// </summary>
        /// <param name="objectAsKey"></param>
        /// <returns></returns>
        private SurfaceLine2 GetMostRecentSurfaceLine(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return redesignedSurfaceLines.ContainsKey(objectAsKey) ? redesignedSurfaceLines[objectAsKey] ?? Location.LocalXZSurfaceLine2 : Location.LocalXZSurfaceLine2;
            }
            return null;
        }

        /// <summary>
        /// Get Most recent surfaceline
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        public SurfaceLine2 GetMostRecentSurfaceLine(SoilProfile soilProfile, string soilGeometry2DName)
        {
            var profile1D = soilProfile as SoilProfile1D;
            Object objectAsKey = GetObjectAsKey(profile1D, soilGeometry2DName);
            return GetMostRecentSurfaceLine(objectAsKey);
        }

        /// <summary>
        /// Determine object key based on either 1d-soilprofile or 2d-geometry
        /// 
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <returns></returns>
        private Object GetObjectAsKey(SoilProfile1D soilProfile, string soilGeometry2DName)
        {
            if (soilProfile != null)
            {
                return soilProfile;
            }
            return soilGeometry2DName;
        }

        /// <summary>
        /// Implementation of ToString
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return String.Format("Location={0}, ID={1} RiverLevel={2} RiverLevelLow={3} DikeTableHeight={4} SafetyFactorStabilityInnerSlope={5} RequiredSafetyFactorStabilityOuterSlope={6} WaterHeightDecimeringsHoogte= {7} MaxWaterheight={8} ProbabilityOfFailureStabilityInnerslope={9} ProbabilityOfFailurePiping={10} PlLineOffsetBelowDikeTopAtRiver={11} PlLineOffsetBelowDikeToeAtPolder={12} PlLineOffsetBelowDikeTopAtPolder={13} PlLineOffsetBelowShoulderBaseInside={14} UsePlLineOffsetBelowDikeCrestMiddle {15} PlLineOffsetBelowDikeCrestMiddle {16} UsePlLineOffsetFactorBelowShoulderCrest {17} PlLineOffsetFactorBelowShoulderCrest {18} HeadPl3={19} HeadPl4={20}",
                                 Location.Name, LocationScenarioID, RiverLevel,
                                 RiverLevelLow.HasValue ? RiverLevelLow.ToString() : "?",
                                 DikeTableHeight.HasValue ? DikeTableHeight.ToString() : "?",
                                 ModelFactors.RequiredSafetyFactorStabilityInnerSlope.HasValue ? ModelFactors.RequiredSafetyFactorStabilityInnerSlope.ToString() : "?",
                                 ModelFactors.RequiredSafetyFactorStabilityOuterSlope.HasValue ? ModelFactors.RequiredSafetyFactorStabilityOuterSlope.ToString() : "?",
                                 WaterHeightDecimeringsHoogte.HasValue ? WaterHeightDecimeringsHoogte.ToString() : "?",
                                 MaxWaterLevel.HasValue ? MaxWaterLevel.ToString() : "?",
                                 ModelFactors.RequiredProbabilityOfFailureStabilityInnerslope.HasValue ? ModelFactors.RequiredProbabilityOfFailureStabilityInnerslope.ToString() : "?",
                                 ModelFactors.RequiredProbabilityOfFailurePiping.HasValue ? ModelFactors.RequiredProbabilityOfFailurePiping.ToString() : "?",
                                 PlLineOffsetBelowDikeTopAtRiver.HasValue ? PlLineOffsetBelowDikeToeAtPolder.ToString() : "?",
                                 PlLineOffsetBelowDikeToeAtPolder.HasValue ? MaxWaterLevel.ToString() : "?",
                                 PlLineOffsetBelowDikeTopAtPolder.HasValue ? PlLineOffsetBelowDikeTopAtPolder.ToString() : "?",
                                 PlLineOffsetBelowShoulderBaseInside.HasValue ? PlLineOffsetBelowShoulderBaseInside.ToString() : "?",
                                 UsePlLineOffsetBelowDikeCrestMiddle.HasValue ? UsePlLineOffsetBelowDikeCrestMiddle.ToString() : "?",
                                 PlLineOffsetBelowDikeCrestMiddle.HasValue ? PlLineOffsetBelowDikeCrestMiddle.ToString() : "?",
                                 UsePlLineOffsetFactorBelowShoulderCrest.HasValue ? UsePlLineOffsetFactorBelowShoulderCrest.ToString() : "?",
                                 PlLineOffsetFactorBelowShoulderCrest.HasValue ? PlLineOffsetFactorBelowShoulderCrest.ToString() : "?",
                                 HeadPl3.HasValue ? HeadPl3.ToString() : "?",
                                 HeadPl4.HasValue ? HeadPl4.ToString() : "?");
        }

        /// <summary>
        /// Determine waterlevels based on waterlevel, max waterlevel and decimeringshoogte
        /// </summary>
        /// <returns></returns>
        public double[] DetermineProperWaterlevelsForProbabilisticAdvanced()
        {
            double[] waterLevels = new double[3];

            waterLevels[0] = (double)MaxWaterLevel;
            waterLevels[1] = (double)MaxWaterLevel;
            waterLevels[2] = (double)MaxWaterLevel;

            if (MaxWaterLevel > RiverLevel + WaterHeightDecimeringsHoogte)
            {
                waterLevels[0] = (double)(RiverLevel + WaterHeightDecimeringsHoogte);
                waterLevels[1] = (double)RiverLevel;
                waterLevels[2] = (double)(RiverLevel - WaterHeightDecimeringsHoogte);
            }
            else
            {
                if (MaxWaterLevel > RiverLevel)
                {
                    waterLevels[0] = (double)MaxWaterLevel;
                    waterLevels[1] = (double)RiverLevel;
                    waterLevels[2] = (double)(RiverLevel - WaterHeightDecimeringsHoogte);
                }
                else
                {
                    if (MaxWaterLevel > RiverLevel - WaterHeightDecimeringsHoogte)
                    {
                        waterLevels[0] = (double)MaxWaterLevel;
                        waterLevels[1] = (double)MaxWaterLevel;
                        waterLevels[2] = (double)(RiverLevel - WaterHeightDecimeringsHoogte);
                    }
                }
            }
            return waterLevels;
        }

        public Dictionary<string, string> GetParametersAsNameValuePairs()
        {
            var numberFormatInfo = new NumberFormatInfo();
            numberFormatInfo.NumberDecimalSeparator = ".";
            var nameValuePairs = new Dictionary<string, string>();
            nameValuePairs.Add(ScenarioParameterNames.LocationScenarioId, LocationScenarioID);
            nameValuePairs.Add(ScenarioParameterNames.RiverLevel, RiverLevel.ToString(numberFormatInfo));
            if (RiverLevelLow != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.RiverLevelLow, RiverLevelLow.Value.ToString(numberFormatInfo));
            }
            if (DikeTableHeight != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.DikeTableHeight, DikeTableHeight.Value.ToString(numberFormatInfo));
            }
            if (WaterHeightDecimeringsHoogte != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.WaterHeightDecimeringsHoogte, WaterHeightDecimeringsHoogte.Value.ToString(numberFormatInfo));
            }
            if (MaxWaterLevel != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.MaxWaterLevel, MaxWaterLevel.Value.ToString(numberFormatInfo));
            }
            if (ModelFactors != null)
            {
                if (ModelFactors.RequiredSafetyFactorStabilityInnerSlope != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.RequiredSafetyFactorStabilityInnerSlope, ModelFactors.RequiredSafetyFactorStabilityInnerSlope.Value.ToString(numberFormatInfo));
                }
                if (ModelFactors.RequiredSafetyFactorStabilityOuterSlope != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.RequiredSafetyFactorStabilityOuterSlope, ModelFactors.RequiredSafetyFactorStabilityOuterSlope.Value.ToString(numberFormatInfo));
                }
                if (ModelFactors.RequiredSafetyFactorPiping != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.RequiredSafetyFactorPiping, ModelFactors.RequiredSafetyFactorPiping.Value.ToString(numberFormatInfo));
                }
                if (ModelFactors.RequiredProbabilityOfFailureStabilityInnerslope != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.RequiredProbabilityOfFailureStabilityInnerslope, ModelFactors.RequiredProbabilityOfFailureStabilityInnerslope.Value.ToString(numberFormatInfo));
                }
                if (ModelFactors.RequiredProbabilityOfFailureStabilityOuterslope != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.RequiredProbabilityOfFailureStabilityOuterslope, ModelFactors.RequiredProbabilityOfFailureStabilityOuterslope.Value.ToString(numberFormatInfo));
                }
                if (ModelFactors.RequiredProbabilityOfFailurePiping != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.RequiredProbabilityOfFailurePiping, ModelFactors.RequiredProbabilityOfFailurePiping.Value.ToString(numberFormatInfo));
                }
                if (ModelFactors.UpliftCriterionPiping != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.UpliftCriterionPiping, ModelFactors.UpliftCriterionPiping.Value.ToString(numberFormatInfo));
                }
                if (ModelFactors.UpliftCriterionStability != null)
                {
                    nameValuePairs.Add(ScenarioParameterNames.UpliftCriterionStability, ModelFactors.UpliftCriterionStability.Value.ToString(numberFormatInfo));
                }
            }
            if (PlLineOffsetBelowDikeTopAtRiver != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowDikeTopAtRiver, PlLineOffsetBelowDikeTopAtRiver.Value.ToString(numberFormatInfo));
            }
            if (PlLineOffsetBelowDikeTopAtPolder != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowDikeTopAtPolder, PlLineOffsetBelowDikeTopAtPolder.Value.ToString(numberFormatInfo));
            }
            if (PlLineOffsetBelowShoulderBaseInside != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowShoulderBaseInside, PlLineOffsetBelowShoulderBaseInside.Value.ToString(numberFormatInfo));
            }
            if (PlLineOffsetBelowDikeToeAtPolder != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowDikeToeAtPolder, PlLineOffsetBelowDikeToeAtPolder.Value.ToString(numberFormatInfo));
            }
            if (PlLineOffsetBelowDikeCrestMiddle != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowDikeCrestMiddle, PlLineOffsetBelowDikeCrestMiddle.Value.ToString(numberFormatInfo));
            }
            if (PlLineOffsetFactorBelowShoulderCrest != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetFactorBelowShoulderCrest, PlLineOffsetFactorBelowShoulderCrest.Value.ToString(numberFormatInfo));
            }
            if (UsePlLineOffsetBelowDikeCrestMiddle != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.UsePlLineOffsetBelowDikeCrestMiddle, UsePlLineOffsetBelowDikeCrestMiddle.Value.ToString());
            }
            if (UsePlLineOffsetFactorBelowShoulderCrest != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.UsePlLineOffsetFactorBelowShoulderCrest, UsePlLineOffsetFactorBelowShoulderCrest.Value.ToString());
            }
            if (HeadPl3 != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.HeadPl3, HeadPl3.Value.ToString(numberFormatInfo));
            }
            if (HeadPl4 != null)
            {
                nameValuePairs.Add(ScenarioParameterNames.HeadPl4, HeadPl4.Value.ToString(numberFormatInfo));
            }
            return nameValuePairs;
        }

        public void SetParameterFromNameValuePair(string parameterName, string parameterValue)
        {
            var numberFormatInfo = new NumberFormatInfo();
            numberFormatInfo.NumberDecimalSeparator = ".";
            if (parameterName.Equals(ScenarioParameterNames.LocationScenarioId))
                LocationScenarioID = parameterValue;
            if (parameterName.Equals(ScenarioParameterNames.RiverLevel))
                RiverLevel = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.RiverLevelLow))
                RiverLevelLow = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.DikeTableHeight))
                DikeTableHeight = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.WaterHeightDecimeringsHoogte))
                WaterHeightDecimeringsHoogte = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.MaxWaterLevel))
                MaxWaterLevel = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.RequiredSafetyFactorStabilityInnerSlope))
                ModelFactors.RequiredSafetyFactorStabilityInnerSlope = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.RequiredSafetyFactorStabilityOuterSlope))
                ModelFactors.RequiredSafetyFactorStabilityOuterSlope = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.RequiredSafetyFactorPiping))
                ModelFactors.RequiredSafetyFactorPiping = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.RequiredProbabilityOfFailureStabilityInnerslope))
                ModelFactors.RequiredProbabilityOfFailureStabilityInnerslope = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.RequiredProbabilityOfFailureStabilityOuterslope))
                ModelFactors.RequiredProbabilityOfFailureStabilityOuterslope = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.RequiredProbabilityOfFailurePiping))
                ModelFactors.RequiredProbabilityOfFailurePiping = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.UpliftCriterionPiping))
                ModelFactors.UpliftCriterionPiping = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.UpliftCriterionStability))
                ModelFactors.UpliftCriterionStability = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.PlLineOffsetBelowDikeTopAtRiver))
                PlLineOffsetBelowDikeTopAtRiver = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.PlLineOffsetBelowDikeTopAtPolder))
                PlLineOffsetBelowDikeTopAtPolder = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.PlLineOffsetBelowShoulderBaseInside))
                PlLineOffsetBelowShoulderBaseInside = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.PlLineOffsetBelowDikeToeAtPolder))
                PlLineOffsetBelowDikeToeAtPolder = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.PlLineOffsetBelowDikeCrestMiddle))
                PlLineOffsetBelowDikeCrestMiddle = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.PlLineOffsetFactorBelowShoulderCrest))
                PlLineOffsetFactorBelowShoulderCrest = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.UsePlLineOffsetBelowDikeCrestMiddle))
                UsePlLineOffsetBelowDikeCrestMiddle = Convert.ToBoolean(parameterValue);
            if (parameterName.Equals(ScenarioParameterNames.UsePlLineOffsetFactorBelowShoulderCrest))
                UsePlLineOffsetFactorBelowShoulderCrest = Convert.ToBoolean(parameterValue);
            if (parameterName.Equals(ScenarioParameterNames.HeadPl3))
                HeadPl3 = Convert.ToDouble(parameterValue, numberFormatInfo);
            if (parameterName.Equals(ScenarioParameterNames.HeadPl4))
                HeadPl4 = Convert.ToDouble(parameterValue, numberFormatInfo);
        }

        public bool IsVisible(string property)
        {
            switch (property)
            {
                case "RequiredProbabilityOfFailurePiping": return calculationResults != null && calculationResults.Count > 0 &&
                    calculationResults[0].ProbabilisticType != ProbabilisticType.Deterministic;                
                default: return true;
            }
        }

        public bool IsEnabled(string property)
        {
            return true;
        }

        /// <summary>
        /// Repairs the specified subject.
        /// </summary>
        /// <param name="subject">The subject.</param>
        /// <param name="property">The property.</param>
        /// <param name="id">The identifier.</param>
        public void Repair(object subject, string property, string id)
        {
            if (subject is Scenario)
            {
                if (id == "AssignMinValue" && property == "PlLineOffsetFactorBelowShoulderCrest")
                {
                    PlLineOffsetFactorBelowShoulderCrest = DamGlobalConstants.PlLineOffsetFactorBelowShoulderCrestMinValue;
                }
                if (id == "AssignMaxValue" && property == "PlLineOffsetFactorBelowShoulderCrest")
                {
                    PlLineOffsetFactorBelowShoulderCrest = DamGlobalConstants.PlLineOffsetFactorBelowShoulderCrestMaxValue;
                }
            }
        }

        /// <summary>
        /// Gets the repair description.
        /// </summary>
        /// <param name="subject">The subject.</param>
        /// <param name="property">The property.</param>
        /// <param name="id">The identifier.</param>
        /// <returns></returns>
        public string GetRepairDescription(object subject, string property, string id)
        {
            if (id == "AssignMinValue")
            {
                return LocalizationManager.GetTranslatedText(this, "AssignMinValue");
            }
            if (id == "AssignMaxValue")
            {
                return LocalizationManager.GetTranslatedText(this, "AssignMaxValue");
            }
            return "";
        }
    }

    public static class ScenarioParameterNames
    {
        public const string LocationScenarioId = "LocationScenarioId";
        public const string RiverLevel = "RiverLevel";
        public const string RiverLevelLow = "RiverLevelLow";
        public const string DikeTableHeight = "DikeTableHeight";
        public const string WaterHeightDecimeringsHoogte = "WaterHeightDecimeringsHoogte";
        public const string MaxWaterLevel = "MaxWaterLevel";

        public const string RequiredSafetyFactorStabilityInnerSlope = "RequiredSafetyFactorStabilityInnerSlope";
        public const string RequiredSafetyFactorStabilityOuterSlope = "RequiredSafetyFactorStabilityOuterSlope";
        public const string RequiredSafetyFactorPiping = "RequiredSafetyFactorPiping";
        public const string RequiredProbabilityOfFailureStabilityInnerslope = "RequiredProbabilityOfFailureStabilityInnerslope";
        public const string RequiredProbabilityOfFailureStabilityOuterslope = "RequiredProbabilityOfFailureStabilityOuterslope";
        public const string RequiredProbabilityOfFailurePiping = "RequiredProbabilityOfFailurePiping";
        public const string UpliftCriterionPiping = "UpliftCriterionPiping";
        public const string UpliftCriterionStability = "UpliftCriterionStability";
        public const string PlLineOffsetBelowDikeTopAtRiver = "PLLineOffsetBelowDikeTopAtRiver";
        public const string PlLineOffsetBelowDikeTopAtPolder = "PLLineOffsetBelowDikeTopAtPolder";
        public const string PlLineOffsetBelowShoulderBaseInside = "PLLineOffsetBelowShoulderBaseInside";
        public const string PlLineOffsetBelowDikeToeAtPolder = "PLLineOffsetBelowDikeToeAtPolder";
        public const string PlLineOffsetBelowDikeCrestMiddle = "PlLineOffsetBelowDikeCrestMiddle";
        public const string PlLineOffsetFactorBelowShoulderCrest = "PlLineOffsetFactorBelowShoulderCrest";
        public const string UsePlLineOffsetBelowDikeCrestMiddle = "UsePlLineOffsetBelowDikeCrestMiddle";
        public const string UsePlLineOffsetFactorBelowShoulderCrest = "UsePlLineOffsetFactorBelowShoulderCrest";
        public const string HeadPl3 = "HeadPL3";
        public const string HeadPl4 = "HeadPL4";
    }
}