// Copyright (C) Stichting Deltares 2025. All rights reserved.
// 
// This file is part of the application DAM - UI.
// 
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
// 
// You should have received a copy of the GNU 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;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Globalization;
using System.Linq.Expressions;
using Deltares.DamEngine.Data.Standard;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Language;
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
{
    private Dictionary<Object, UpliftSituation?> stabilityUpliftSituations;
    private Dictionary<Object, PipingResults?> pipingResults;
    private Dictionary<Object, double?> safetyFactorsPiping;
    private Dictionary<Object, SurfaceLine2> redesignedSurfaceLines;
    private Dictionary<Object, string> resultMessages;

    private string locationScenarioId;
    private double? riverLevel;
    private double? riverLevelLow;
    private double? dikeTableHeight;
    private double plLineOffsetBelowDikeTopAtRiver = 0.5;
    private double plLineOffsetBelowDikeTopAtPolder = 1.5;
    private double plLineOffsetBelowShoulderBaseInside = 0.1;
    private double plLineOffsetBelowDikeToeAtPolder = 0.1;
    private bool? usePlLineOffsetBelowDikeCrestMiddle;
    private double? plLineOffsetBelowDikeCrestMiddle;
    private bool? usePlLineOffsetFactorBelowShoulderCrest;
    private double? plLineOffsetFactorBelowShoulderCrest;
    private double? headPl2;
    private double? headPl3;
    private double? headPl4;
    private double polderLevel;

    /// <summary>
    /// Constructor
    /// </summary>
    public Scenario()
    {
        ClearResults();
        ClearErrors();
        ClearstabilityUpliftSituations();
        ModelFactors = new ModelFactors();
    }

    [Browsable(false)] public CalculationResult CalculationResult { get; set; } = CalculationResult.NoRun;

    [Browsable(false)] public List<CsvExportData> CalculationResults { get; } = new List<CsvExportData>();

    /// <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 polder level.
    /// </summary>
    /// <value>
    /// The polder level.
    /// </value>
    [PropertyOrder(1, 4)]
    [Unit(UnitType.Length)]
    [Format("F2")]
    public double PolderLevel
    {
        get
        {
            return polderLevel;
        }
        set
        {
            DataEventPublisher.BeforeChange(this, ExpressionPolderLevel);
            polderLevel = value;
            DataEventPublisher.AfterChange(this, ExpressionPolderLevel);
        }
    }

    /// <summary>
    /// Gets or sets the uplift criterion piping.
    /// </summary>
    /// <value>
    /// The uplift criterion piping.
    /// </value>
    [PropertyOrder(1, 5)]
    [Unit(UnitType.None)]
    [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, 6)]
    [Unit(UnitType.None)]
    [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);
        }
    }

    /// <summary>
    /// Gets or sets the pl line offset below dike top at river side.
    /// </summary>
    /// <value>
    /// The pl line offset below dike top at river side.
    /// </value>
    [PropertyOrder(1, 7)]
    [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, 8)]
    [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, 9)]
    [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, 10)]
    [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, 11)]
    [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, 12)]
    [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, 13)]
    [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, 14)]
    [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 PL2.
    /// </summary>
    /// <value>
    /// The head PL2.
    /// </value>
    [PropertyOrder(1, 15)]
    [Unit(UnitType.Length)]
    [Format("F2")]
    public double? HeadPl2
    {
        get
        {
            return headPl2;
        }
        set
        {
            DataEventPublisher.BeforeChange(this, ExpressionHeadPl2);
            headPl2 = value;
            DataEventPublisher.AfterChange(this, ExpressionHeadPl2);
        }
    }

    /// <summary>
    /// Gets or sets the head PL3.
    /// </summary>
    /// <value>
    /// The head PL3.
    /// </value>
    [PropertyOrder(1, 16)]
    [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, 17)]
    [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 required safety factor stability inner slope.
    /// </summary>
    /// <value>
    /// The required safety factor stability inner slope.
    /// </value>
    [PropertyOrder(1, 18)]
    [Unit(UnitType.None)]
    [Format("F2")]
    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, 19)]
    [Unit(UnitType.None)]
    [Format("F2")]
    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, 20)]
    [Unit(UnitType.None)]
    [Format("F2")]
    public double RequiredSafetyFactorPiping
    {
        get
        {
            return ModelFactors.RequiredSafetyFactorPiping;
        }
        set
        {
            DataEventPublisher.BeforeChange(this, ExpressionRequiredSafetyFactorPiping);
            ModelFactors.RequiredSafetyFactorPiping = value;
            DataEventPublisher.AfterChange(this, ExpressionRequiredSafetyFactorPiping);
        }
    }

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

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

    /// <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?>();
        safetyFactorsPiping = new Dictionary<Object, double?>();
        resultMessages = new Dictionary<Object, string>();
        redesignedSurfaceLines = new Dictionary<Object, SurfaceLine2>();
        CalculationResults.Clear();
    }

    /// <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.IsNearEqual(0))
        {
            throw new ScenarioException(String.Format(LocalizationManager.GetTranslatedText(this, "NoUpliftCriterionForStability"), Location.Name, ToString()));
        }

        return (ModelFactors.UpliftCriterionStability.IsNearEqual(0)
                    ? defaultUpliftCriterionStability.Value
                    : ModelFactors.UpliftCriterionStability);
    }

    /// <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.IsNearEqual(0)))
        {
            throw new ScenarioException(String.Format(LocalizationManager.GetTranslatedText(this, "NoUpliftCriterionForPiping"), Location.Name, ToString()));
        }

        return (ModelFactors.UpliftCriterionPiping.IsNearEqual(0) ? defaultUpliftCriterionPiping.Value : ModelFactors.UpliftCriterionPiping);
    }

    /// <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.IsNearEqual(0)))
        {
            throw new ScenarioException(String.Format(LocalizationManager.GetTranslatedText(this, "NoRequiredSafetyFactorPiping"), Location.Name, ToString()));
        }

        return (ModelFactors.RequiredSafetyFactorPiping.IsNearEqual(0) ? defaultRequiredSafetyFactorPiping.Value : ModelFactors.RequiredSafetyFactorPiping);
    }

    /// <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", this)
                };
            }

            if (PlLineOffsetFactorBelowShoulderCrest.Value > DamGlobalConstants.PlLineOffsetFactorBelowShoulderCrestMaxValue)
            {
                return new[]
                {
                    new ValidationResult(ValidationResultType.Error,
                                         LocalizationManager.GetTranslatedText(this, "PlLineOffsetFactorBelowShoulderCrestTooLarge"),
                                         this, "PlLineOffsetFactorBelowShoulderCrest", "AssignMaxValue", this)
                };
            }
        }

        return new ValidationResult[0];
    }

    /// <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="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="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="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 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>
    /// 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="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>
    /// 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="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="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);
    }

    public Dictionary<string, string> GetParametersAsNameValuePairs()
    {
        var numberFormatInfo = new NumberFormatInfo();
        numberFormatInfo.NumberDecimalSeparator = ".";
        var nameValuePairs = new Dictionary<string, string>();
        nameValuePairs.Add(ScenarioParameterNames.LocationScenarioId, LocationScenarioID);
        if (RiverLevel != null)
        {
            nameValuePairs.Add(ScenarioParameterNames.RiverLevel, RiverLevel.Value.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 (ModelFactors != null)
        {
            nameValuePairs.Add(ScenarioParameterNames.RequiredSafetyFactorStabilityInnerSlope, ModelFactors.RequiredSafetyFactorStabilityInnerSlope.ToString(numberFormatInfo));
            nameValuePairs.Add(ScenarioParameterNames.RequiredSafetyFactorStabilityOuterSlope, ModelFactors.RequiredSafetyFactorStabilityOuterSlope.ToString(numberFormatInfo));
            nameValuePairs.Add(ScenarioParameterNames.RequiredSafetyFactorPiping, ModelFactors.RequiredSafetyFactorPiping.ToString(numberFormatInfo));
            nameValuePairs.Add(ScenarioParameterNames.UpliftCriterionPiping, ModelFactors.UpliftCriterionPiping.ToString(numberFormatInfo));
            nameValuePairs.Add(ScenarioParameterNames.UpliftCriterionStability, ModelFactors.UpliftCriterionStability.ToString(numberFormatInfo));
        }

        nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowDikeTopAtRiver, PlLineOffsetBelowDikeTopAtRiver.ToString(numberFormatInfo));
        nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowDikeTopAtPolder, PlLineOffsetBelowDikeTopAtPolder.ToString(numberFormatInfo));
        nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowShoulderBaseInside, PlLineOffsetBelowShoulderBaseInside.ToString(numberFormatInfo));
        nameValuePairs.Add(ScenarioParameterNames.PlLineOffsetBelowDikeToeAtPolder, PlLineOffsetBelowDikeToeAtPolder.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));
        }

        nameValuePairs.Add(ScenarioParameterNames.PolderLevel, PolderLevel.ToString(numberFormatInfo));

        if (HeadPl2 != null)
        {
            nameValuePairs.Add(ScenarioParameterNames.HeadPl2, HeadPl2.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.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.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);
        }

        if (parameterName.Equals(ScenarioParameterNames.PolderLevel))
        {
            PolderLevel = Convert.ToDouble(parameterValue, numberFormatInfo);
        }

        if (parameterName.Equals(ScenarioParameterNames.HeadPl2))
        {
            HeadPl2 = Convert.ToDouble(parameterValue, numberFormatInfo);
        }
    }

    /// <summary>
    /// Implementation of ToString
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return $"Location={Location.Name}, " +
               $"ID={LocationScenarioID} " +
               $"RiverLevel={RiverLevel} " +
               $"RiverLevelLow={(RiverLevelLow.HasValue ? RiverLevelLow.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"DikeTableHeight={(DikeTableHeight.HasValue ? DikeTableHeight.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"RequiredSafetyFactorStabilityInnerSlope={ModelFactors.RequiredSafetyFactorStabilityInnerSlope.ToString(CultureInfo.InvariantCulture)} " +
               $"RequiredSafetyFactorStabilityOuterSlope={ModelFactors.RequiredSafetyFactorStabilityOuterSlope.ToString(CultureInfo.InvariantCulture)} " +
               $"PlLineOffsetBelowDikeTopAtRiver={PlLineOffsetBelowDikeTopAtRiver.ToString(CultureInfo.InvariantCulture)} " +
               $"PlLineOffsetBelowDikeToeAtPolder={PlLineOffsetBelowDikeToeAtPolder.ToString(CultureInfo.InvariantCulture)} " +
               $"PlLineOffsetBelowDikeTopAtPolder={PlLineOffsetBelowDikeTopAtPolder.ToString(CultureInfo.InvariantCulture)} " +
               $"PlLineOffsetBelowShoulderBaseInside={PlLineOffsetBelowShoulderBaseInside.ToString(CultureInfo.InvariantCulture)} " +
               $"UsePlLineOffsetBelowDikeCrestMiddle {(UsePlLineOffsetBelowDikeCrestMiddle.HasValue ? UsePlLineOffsetBelowDikeCrestMiddle.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"PlLineOffsetBelowDikeCrestMiddle {(PlLineOffsetBelowDikeCrestMiddle.HasValue ? PlLineOffsetBelowDikeCrestMiddle.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"UsePlLineOffsetFactorBelowShoulderCrest {(UsePlLineOffsetFactorBelowShoulderCrest.HasValue ? UsePlLineOffsetFactorBelowShoulderCrest.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"PlLineOffsetFactorBelowShoulderCrest {(PlLineOffsetFactorBelowShoulderCrest.HasValue ? PlLineOffsetFactorBelowShoulderCrest.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"HeadPl3={(HeadPl3.HasValue ? HeadPl3.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"HeadPl4={(HeadPl4.HasValue ? HeadPl4.Value.ToString(CultureInfo.InvariantCulture) : "?")} " +
               $"PolderLevel={PolderLevel.ToString(CultureInfo.InvariantCulture)} " +
               $"HeadPl2={(HeadPl2.HasValue ? HeadPl2.Value.ToString(CultureInfo.InvariantCulture) : "?")}";
    }

    /// <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 bool IsVisible(string property)
    {
        switch (property)
        {
            default: return true;
        }
    }

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

    /// <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>
    ///  Set stability uplift situation
    /// </summary>
    /// <param name="objectAsKey"></param>
    /// <param name="upliftSituation"></param>
    private void SetStabilityUpliftSituation(Object objectAsKey, UpliftSituation upliftSituation)
    {
        stabilityUpliftSituations[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>
    /// Set PipingResults
    /// </summary>
    /// <param name="objectAsKey"></param>
    /// <param name="pipingResults"></param>
    private void SetPipingResults(Object objectAsKey, PipingResults? pipingResults)
    {
        this.pipingResults[objectAsKey] = pipingResults;
    }

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

    /// <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>
    /// Set Redesigned surfaceline
    /// </summary>
    /// <param name="objectAsKey"></param>
    /// <param name="surfaceLine"></param>
    private void SetRedesignedSurfaceLine(Object objectAsKey, SurfaceLine2 surfaceLine)
    {
        redesignedSurfaceLines[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>
    /// 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;
    }

    #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>> 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>> ExpressionPolderLevel = x => x.PolderLevel;
    private static readonly Expression<Func<Scenario, object>> ExpressionHeadPl2 = x => x.HeadPl2;

    #endregion
}

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 RequiredSafetyFactorStabilityInnerSlope = "RequiredSafetyFactorStabilityInnerSlope";
    public const string RequiredSafetyFactorStabilityOuterSlope = "RequiredSafetyFactorStabilityOuterSlope";
    public const string RequiredSafetyFactorPiping = "RequiredSafetyFactorPiping";
    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";
    public const string PolderLevel = "PolderLevel";
    public const string HeadPl2 = "HeadPL2";
}