//-----------------------------------------------------------------------
// <copyright file="CsvExportData.cs" company="Deltares">
//  Copyright (c) 2010 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>05-10-2010</date>
// <summary>Data definition for results export to csv</summary>
//-----------------------------------------------------------------------

using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Xml.Serialization;
using Deltares.Geographic;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Converter;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Standard;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Units;
using System;
using System.Collections.Generic;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.Attributes;

namespace Deltares.Dam.Data
{
    /// <summary>
    ///1:"Id":invoer
    ///2:"Dijkringnaam":invoer
    ///3:"RDX":invoer
    ///4:"RDY":invoer
    ///5:"Scenarionummer (waterhoogtenummer, hoeveelste \"entry\" uit tabel; 1, 2, 3, 4 of 5)":invoer
    ///6:"Waterhoogtewaarde":invoer
    ///7:"Dijkhoogte bestaand":invoer
    ///8:"Huidige locatie teen":invoer
    ///9:"Dijktafelhoogte":invoer	
    ///10:"1Dprofiel":invoer
    ///11:"Mechanisme":invoer
    ///12:"1Dprofiel kans":invoer
    ///13:"Berekende lokatie teen":uitvoer	
    ///14:"Bermhoogte":uitvoer
    ///15:"Dijkbasis bestaand":invoer
    ///16:"Dijkbasis nieuw":uitvoer
    /// </summary>
    public class CsvExportData : ICloneable, IVisibleEnabled, IGeographicPoint
    {
        private string id;
        private string baseFileName;
        private string calculationSubDir;
        private Dike dike;
        private AnalysisType analysisType;
        private ProbabilisticType probabilisticType;
        private DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification;
        private Scenario scenario;
        private SoilProfile1D soilProfile;
        private string soilGeometry2DName;
        private double? safetyFactorFlowSlide;
        private double? failureProbabilityPiping;
        private double? localPipingExitPointX;
        private SurfaceLine2 redesignedSurfaceLinePiping;
        private double? safetyFactorStability;
        private double? failureProbabilityStability;
        private double? zone1SafetyFactorStability;
        private double? localZone1EntryPointX;
        private double? localZone1ExitPointX;
        private double? zone2SafetyFactorStability;
        private double? localZone2EntryPointX;
        private double? localZone2ExitPointX;
        private double? upliftFactor;
        private double? heaveFactor;
        private double? blighPipingFactor;
        private double? blighHCritical;
        private double? sellmeijer2ForcesPipingFactor;
        private double? sellmeijer2ForcesHCritical;
        private double? sellmeijer4ForcesPipingFactor;
        private double? sellmeijer4ForcesHCritical;
        private double? sellmeijerPipingFactor;
        private double? sellmeijerHCritical;
        private double? wti2017PipingFactor;
        private double? wti2017HCritical;
        private bool? isUplift;
        private double? pl3MinUplift;
        private double? pl3HeadAdjusted;
        private double? pl3LocalLocationXMinUplift;
        private double? pl4MinUplift;
        private double? pl4HeadAdjusted;
        private double? pl4LocalLocationXMinUplift;
        private string nwoId;
        private int nwoResultIndex;
        private double? locationXrdStart;
        private double? locationYrdStart;
        private double? locationZrdStart;
        private double? locationXrdEnd;
        private double? locationYrdEnd;
        private double? locationZrdEnd;
        private CalculationResult calculationResult = CalculationResult.NoRun;
        private string resultMessage = "";
        private int numberOfIterations;
        private ResultEvaluation resultEvaluation = ResultEvaluation.NotEvaluated;
        private string notes = "";
        private bool dirty = true;
        private List<IGeographicPoint> points = new List<IGeographicPoint>();
        private StabilityKernelType selectedStabilityKernelType = StabilityKernelType.DamClassic;
        private SurfaceLine2 redesignedSurfaceLineStability;

        public CsvExportData()
        {
        }

        public CsvExportData(string id, Dike dike, DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification, Scenario scenario, SoilProfile1D soilProfile,
            string soilGeometry2DName, AnalysisType analysisType, int nwoResultIndex, ProbabilisticType probabilisticType)
        {
            this.id = id;
            this.BaseFileName = "";
            this.CalculationSubDir = "";
            this.dike = dike;
            this.damFailureMechanismeCalculationSpecification = damFailureMechanismeCalculationSpecification;
            this.scenario = scenario;
            this.soilProfile = soilProfile;
            this.SoilGeometry2DName = soilGeometry2DName;
            this.analysisType = analysisType;
            this.failureProbabilityPiping = null;
            this.redesignedSurfaceLinePiping = null;
            this.safetyFactorStability = null;
            this.failureProbabilityStability = null;
            this.redesignedSurfaceLineStability = null;
            this.zone1SafetyFactorStability = null;
            this.LocalZone1EntryPointX = null;
            this.LocalZone1ExitPointX = null;
            this.zone2SafetyFactorStability = null;
            this.LocalZone2EntryPointX = null;
            this.LocalZone2ExitPointX = null;
            this.blighPipingFactor = null;
            this.blighHCritical = null;
            this.sellmeijer2ForcesPipingFactor = null;
            this.sellmeijer2ForcesHCritical = null;
            this.sellmeijer4ForcesPipingFactor = null;
            this.sellmeijer4ForcesHCritical = null;
            this.sellmeijerPipingFactor = null;
            this.sellmeijerHCritical = null;
            this.wti2017PipingFactor = null;
            this.wti2017HCritical = null;
            this.isUplift = null;
            this.pl3MinUplift = null;
            this.pl3HeadAdjusted = null;
            this.pl3LocalLocationXMinUplift = null;
            this.pl4MinUplift = null;
            this.pl4HeadAdjusted = null;
            this.pl4LocalLocationXMinUplift = null;
            this.nwoId = "";
            this.nwoResultIndex = nwoResultIndex;
            this.locationXrdStart = null;
            this.locationXrdEnd = null;
            this.locationYrdStart = null;
            this.locationYrdEnd = null;
            this.locationZrdStart = null;
            this.locationZrdEnd = null;
            this.dirty = true;

            if (damFailureMechanismeCalculationSpecification != null)
            {
                this.probabilisticType = probabilisticType;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityInside:
                    case FailureMechanismSystemType.StabilityOutside:
                    
                        if (analysisType == AnalysisType.AdaptNWO)
                        {
                            // an index of 0 can also indicate an error message. That has no futher data so check if there actualy is any.
                            if (scenario.NwoResults.Count > 0)
                            {
                                this.nwoId = scenario.NwoResults[nwoResultIndex].NwoId;
                                this.locationXrdStart = scenario.NwoResults[nwoResultIndex].LocationXrdStart;
                                this.locationYrdStart = scenario.NwoResults[nwoResultIndex].LocationYrdStart;
                                this.locationZrdStart = scenario.NwoResults[nwoResultIndex].LocationZrdStart;
                                this.locationXrdEnd = scenario.NwoResults[nwoResultIndex].LocationXrdEnd;
                                this.locationYrdEnd = scenario.NwoResults[nwoResultIndex].LocationYrdEnd;
                                this.locationZrdEnd = scenario.NwoResults[nwoResultIndex].LocationZrdEnd;
                                this.dirty = true;
                                this.BaseFileName = scenario.NwoResults[nwoResultIndex].MStabResults.CalculationName;
                                this.CalculationSubDir =
                                    scenario.NwoResults[nwoResultIndex].MStabResults.CalculationSubDir;
                                this.numberOfIterations =
                                    scenario.NwoResults[nwoResultIndex].MStabResults.IterationNumber;
                                this.safetyFactorStability = scenario.NwoResults[nwoResultIndex].MStabResults.zone1.safetyFactor;
                                this.zone1SafetyFactorStability = scenario.NwoResults[nwoResultIndex].MStabResults.zone1.safetyFactor;
                                this.LocalZone1EntryPointX = scenario.NwoResults[nwoResultIndex].MStabResults.zone1.entryPointXCoordinate;
                                this.LocalZone1ExitPointX = scenario.NwoResults[nwoResultIndex].MStabResults.zone1.exitPointXCoordinate;
                                if (scenario.NwoResults[nwoResultIndex].MStabResults.zone2 != null)
                                {
                                    this.zone2SafetyFactorStability = scenario.NwoResults[nwoResultIndex].MStabResults.zone2.Value.safetyFactor;
                                    this.LocalZone2EntryPointX = scenario.NwoResults[nwoResultIndex].MStabResults.zone2.Value.entryPointXCoordinate;
                                    this.LocalZone2ExitPointX = scenario.NwoResults[nwoResultIndex].MStabResults.zone2.Value.exitPointXCoordinate;
                                }
                            }
                        }
                        else
                        {
                            MStabResults? mstabResults = scenario.GetMStabResults(this.SoilProfile, this.SoilGeometry2DName);
                            this.resultMessage = scenario.GetResultMessage(this.SoilProfile, this.SoilGeometry2DName);
                            calculationResult = DetermineStabilityCalculationResult(this.resultMessage, mstabResults);
                            if (mstabResults != null)
                            {
                                
                                BaseFileName = mstabResults.Value.CalculationName;
                                CalculationSubDir = mstabResults.Value.CalculationSubDir;
                                numberOfIterations = mstabResults.Value.IterationNumber;
                                this.safetyFactorStability = mstabResults.Value.zone1.safetyFactor;
                                this.zone1SafetyFactorStability = mstabResults.Value.zone1.safetyFactor;
                                this.LocalZone1EntryPointX = mstabResults.Value.zone1.entryPointXCoordinate;
                                this.LocalZone1ExitPointX = mstabResults.Value.zone1.exitPointXCoordinate;
                                if (mstabResults.Value.zone2 != null)
                                {
                                    this.zone2SafetyFactorStability = mstabResults.Value.zone2.Value.safetyFactor;
                                    this.LocalZone2EntryPointX = mstabResults.Value.zone2.Value.entryPointXCoordinate;
                                    this.LocalZone2ExitPointX = mstabResults.Value.zone2.Value.exitPointXCoordinate;
                                }
                            }
                        }
                        this.failureProbabilityStability = scenario.GetFailureProbabilityStability(this.SoilProfile, this.SoilGeometry2DName);
                        this.redesignedSurfaceLineStability = scenario.GetRedesignedSurfaceLine(this.SoilProfile, this.SoilGeometry2DName);

                        UpliftSituation? upliftSituation = scenario.GetStabilityUpliftSituation(this.SoilProfile, this.SoilGeometry2DName);
                        if (upliftSituation != null)
                        {
                            SetUpliftSituationResults(upliftSituation.Value);
                        }

                        break;

                    case FailureMechanismSystemType.Piping:
                    
                        this.failureProbabilityPiping = scenario.GetFailureProbabilityPiping(this.SoilProfile, this.SoilGeometry2DName);
                        this.resultMessage = scenario.GetResultMessage(this.SoilProfile, this.SoilGeometry2DName);
                        this.redesignedSurfaceLinePiping = scenario.GetRedesignedSurfaceLine(this.SoilProfile, this.SoilGeometry2DName);
                        UpliftSituation? upliftSituationPiping = scenario.GetStabilityUpliftSituation(this.SoilProfile, this.SoilGeometry2DName);
                        if (upliftSituationPiping != null)
                        {
                            SetUpliftSituationResults(upliftSituationPiping.Value);
                        }
                        PipingResults? pipingResults = scenario.GetPipingResults(this.SoilProfile, this.SoilGeometry2DName);
                        if (pipingResults != null)
                        {
                            BaseFileName = pipingResults.Value.CalculationName;
                            CalculationSubDir = pipingResults.Value.CalculationSubDir;
                            this.blighPipingFactor = pipingResults.Value.BlighPipingFactor;
                            this.blighHCritical = pipingResults.Value.BlighHCritical;
                            this.sellmeijer2ForcesPipingFactor = pipingResults.Value.Sellmeijer2ForcesPipingFactor;
                            this.sellmeijer2ForcesHCritical = pipingResults.Value.Sellmeijer2ForcesHCritical;
                            this.sellmeijer4ForcesPipingFactor = pipingResults.Value.Sellmeijer4ForcesPipingFactor;
                            this.sellmeijer4ForcesHCritical = pipingResults.Value.Sellmeijer4ForcesHCritical;
                            this.sellmeijerPipingFactor = pipingResults.Value.SellmeijerPipingFactor;
                            this.sellmeijerHCritical = pipingResults.Value.SellmeijerHCritical;
                            this.wti2017PipingFactor = pipingResults.Value.Wti2017PipingFactor;
                            this.wti2017HCritical = pipingResults.Value.Wti2017HCritical;
                            this.localPipingExitPointX = pipingResults.Value.PipingExitPointX;
                            this.HeaveFactor = pipingResults.Value.HeaveFactor;
                            this.UpliftFactor = pipingResults.Value.UpliftFactor;
                        }
                        this.calculationResult = (this.PipingFactor == null && this.PipingFailureProbability == null) ? CalculationResult.RunFailed : CalculationResult.Succeeded;
                        break;
                    case FailureMechanismSystemType.FlowSlide:
                        this.safetyFactorFlowSlide = scenario.GetSafetyFactorFlowSlide(this.SoilProfile, this.SoilGeometry2DName);
                        break;
                }
            }
        }

        /// <summary>
        /// Determines the global point coordinates based on global surface line.
        /// </summary>
        /// <param name="localPoint">The local point.</param>
        /// <param name="globalSurfaceLine">The global surface line.</param>
        /// <returns></returns>
        private GeometryPoint DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(GeometryPoint localPoint, SurfaceLine2 globalSurfaceLine)
        {
            CoordinateSystemConverter coordinateSystemConverter = new CoordinateSystemConverter();
            coordinateSystemConverter.DefineGlobalXYZBasedOnLine(globalSurfaceLine.Geometry);

            coordinateSystemConverter.ConvertLocalXZToGlobalXYZ(localPoint);
            return localPoint;
        }

        /// <summary>
        /// Determines the stability calculation run result.
        /// </summary>
        /// <param name="message">The result message.</param>
        /// <param name="mstabResults">The mstab results.</param>
        /// <returns></returns>
        private CalculationResult DetermineStabilityCalculationResult(string message, MStabResults? mstabResults)
        {
            CalculationResult result;
            if ((message != null) && this.resultMessage.Contains("FAIL"))
            {
                result = CalculationResult.UnexpectedError;
            }
            else
            {
                // If no failure and no results, then no run has been made
                result = mstabResults != null ? CalculationResult.Succeeded : CalculationResult.NoRun;
            }
            return result;
        }

        /// <summary>
        /// Sets the uplift situation results.
        /// </summary>
        /// <param name="upliftSituation">The uplift situation.</param>
        private void SetUpliftSituationResults(UpliftSituation upliftSituation)
        {
            this.isUplift = upliftSituation.IsUplift;
            if (upliftSituation.Pl3MinUplift < double.MaxValue)
            {
                this.pl3MinUplift = upliftSituation.Pl3MinUplift;
            }
            if (upliftSituation.Pl3HeadAdjusted < double.MaxValue)
            {
                this.pl3HeadAdjusted = upliftSituation.Pl3HeadAdjusted;
            }
            if (upliftSituation.Pl3LocationXMinUplift < double.MaxValue)
            {
                this.pl3LocalLocationXMinUplift = upliftSituation.Pl3LocationXMinUplift;
            }
            if (upliftSituation.Pl4MinUplift < double.MaxValue)
            {
                this.pl4MinUplift = upliftSituation.Pl4MinUplift;
            }
            if (upliftSituation.Pl4HeadAdjusted < double.MaxValue)
            {
                this.pl4HeadAdjusted = upliftSituation.Pl4HeadAdjusted;
            }
            if (upliftSituation.Pl4LocationXMinUplift < double.MaxValue)
            {
                this.pl4LocalLocationXMinUplift = upliftSituation.Pl4LocationXMinUplift;
            }
        }

        [Browsable(false)]
        public StabilityKernelType SelectedStabilityKernelType
        {
            get { return selectedStabilityKernelType; } 
            set { selectedStabilityKernelType = value; }
        }

        [Label("Number of iterations")]
        [ReadOnly(true)]
        public int NumberOfIterations
        {
            get { return numberOfIterations; }
            set { numberOfIterations = value; }
        }

        [Browsable(false)]
        [Label("Image file")]
        public string ResultFile
        {
            get
            {
                if (!String.IsNullOrEmpty(BaseFileName))
                {
                    const string wmfExtension = ".wmf";
                    string fullBaseFilename = DamProject.ProjectWorkingPath;
                    if (CalculationSubDir !=  "")
                    {
                        fullBaseFilename = Path.Combine(fullBaseFilename, CalculationSubDir);
                    }
                    fullBaseFilename = fullBaseFilename + Path.DirectorySeparatorChar + BaseFileName;
                    string fullFilename = fullBaseFilename + wmfExtension;
                    if (!File.Exists(fullFilename))
                    {
                        fullFilename = fullBaseFilename + "z1" + wmfExtension;
                    }
                    if (!File.Exists(fullFilename))
                    {
                        fullFilename = fullBaseFilename + "z2" + wmfExtension;
                    }
                    return fullFilename;
                }
                return "";
            }
        }

        [Browsable(false)]
        [Label("Input file")]
        public string InputFile
        {
            get
            {
                if (!String.IsNullOrEmpty(BaseFileName))
                {
                    string fileExtension = ".sti";
                    if (selectedStabilityKernelType != StabilityKernelType.DamClassic)
                    {
                        fileExtension = ".dsx";
                    }
                    string fullBaseFilename = DamProject.ProjectWorkingPath;
                    if (CalculationSubDir != "")
                    {
                        fullBaseFilename = Path.Combine(fullBaseFilename, CalculationSubDir);
                    }
                    fullBaseFilename = fullBaseFilename + Path.DirectorySeparatorChar + BaseFileName;
                    string fullFilename = fullBaseFilename + fileExtension;
                    return fullFilename;
                }
                return "";
            }
        }

        [Browsable(false)]
        [Label("Input file")]
        public string PipingResultFile
        {
            // Path of piping is not based on the working dir but on assembly (Assembly.GetExecutingAssembly().Location)
            get
            {
                if (!String.IsNullOrEmpty(BaseFileName))
                {
                    const string txtExtension = ".txt";
                    string fullBaseFilename = DamProject.ProjectWorkingPath;
                    if (CalculationSubDir != "")
                    {
                        fullBaseFilename = Path.Combine(fullBaseFilename, CalculationSubDir);
                    }
                    fullBaseFilename = fullBaseFilename + Path.DirectorySeparatorChar + BaseFileName;
                    string fullFilename = fullBaseFilename + txtExtension;
                    return fullFilename;
                }
                return "";
            }
        }

        [Label("Analysis")]
        [PropertyOrder(1, 2)]
        [ReadOnly(true)]
        public AnalysisType AnalysisType
        {
            get { return analysisType; }
            set { analysisType = value; }
        }

        [Label("Probabilistic")]
        [PropertyOrder(1, 3)]
        [ReadOnly(true)]
        public ProbabilisticType ProbabilisticType
        {
            get { return probabilisticType; }
            set { probabilisticType = value; }
        }

        [Browsable(false)]
        public DamFailureMechanismeCalculationSpecification DamFailureMechanismeCalculation
        {
            get { return damFailureMechanismeCalculationSpecification; }
            set { damFailureMechanismeCalculationSpecification = value; }
        }

        [CsvExportColumn("id", 1)]
        [Browsable(false)]
        public string ID
        {
            get { return this.id; }
        }

        [CsvExportColumn("DikeName", 2)]
        [Browsable(false)]
        [Label("Dike")]
        public string DikeName
        {
            get { return dike.Name; }
        }

        [CsvExportColumn("Calculation", 3)]
        [Browsable(false)]
        public string Calculation
        {
            get { return this.damFailureMechanismeCalculationSpecification != null ? this.damFailureMechanismeCalculationSpecification.ToString() : ""; }
        }

        [CsvExportColumn("Scenario", 4)]
        [Browsable(false)]
        public string ScenarioName
        {
            get { return this.Scenario.LocationScenarioID; }
        }

        [CsvExportColumn("LocationName", 5)]
        [Label("Location")]
        [PropertyOrder(0, 1)]
        [ReadOnly(true)]
        public string LocationName
        {
            get { return this.Scenario.Location.Name; }
        }

        [Browsable(false)]
        public int LocationScenarioCount
        {
            get { return this.Scenario.Location.Scenarios.Count; }
        }

        [Label("Scenario")]
        [PropertyOrder(0, 2)]
        [ReadOnly(true)]
        public string ScenarioDefinitionName
        {
            get { return this.Scenario.LocationScenarioID + " of " + this.LocationScenarioCount.ToString(); }
        }

        [Label("Calculation result")]
        [PropertyOrder(0, 3)]
        public CalculationResult CalculationResult
        {
            get
            {
                return calculationResult;
            }
            set
            {
                calculationResult = value;
            }
        }

        [Label("Message")]
        [PropertyOrder(7,1)]
        [ReadOnly(true)]
        public string ResultMessage
        {
            get { return resultMessage; }
            set { resultMessage = value; }
        }

        [CsvExportColumn("X", 6)]
        [Label("Global X-coordinate")]
        [Format("F3")]
        [PropertyOrder(1, 0)]
        [Unit(UnitType.Length)]
        [XmlIgnore]
        [ReadOnly(true)]
        public double X
        {
            get
            {
                return (this.Scenario != null) ? this.Scenario.Location.XRd : 0.0;
            }
            set
            {
                if (this.Scenario != null)
                {
                    this.Scenario.Location.XRd = value;
                } 
            }
        }

        [CsvExportColumn("Y", 7)]
        [Label("Global Y-coordinate")]
        [Format("F3")]
        [PropertyOrder(1, 1)]
        [Unit(UnitType.Length)]
        [XmlIgnore]
        [ReadOnly(true)]
        public double Y
        {
            get
            {
                return (this.Scenario != null) ? this.Scenario.Location.YRd : 0.0;
            }
            set
            {
                if (this.Scenario != null)
                {
                    this.Scenario.Location.YRd = value;
                }
            }
        }

        [CsvExportColumn("LocationScenarioId", 8)]
        [Browsable(false)]
        public string LocationScenarioId
        {
            get { return this.Scenario.LocationScenarioID; }
        }

        [Label("River level")]
        [CsvExportColumn("RiverLevel", 9)]
        [PropertyOrder(2, 12)]
        [Format("F3")]
        [ReadOnly(true)]
        public double? RiverLevel
        {
            get { return this.Scenario.RiverLevel; }
        }

        [Label("River level low")]
        [CsvExportColumn("RiverLevelLow", 10)]
        [PropertyOrder(2, 13)]
        [Format("F3")]
        [ReadOnly(true)]
        public double? RiverLevelLow
        {
            get { return this.Scenario.RiverLevelLow; }
        }

        [Label("Dike table height")]
        [CsvExportColumn("DikeTableHeight", 11)]
        [PropertyOrder(2, 14)]
        [Format("F3")]
        [ReadOnly(true)]
        public double? DikeTableHeight
        {
            get { return this.Scenario.DikeTableHeight; }
        }

        [Label("Slope damping factor")]
        [CsvExportColumn("DikeTableHeight", 12)]
        [PropertyOrder(2, 15)]
        [Format("F3")]
        [ReadOnly(true)]
        public double? SlopeDampingPiezometricHeightPolderSide
        {
            get { return this.Scenario.Location.SlopeDampingPiezometricHeightPolderSide; }
        }

        [CsvExportColumn("CurrentDikeHeight", 13)]
        [Browsable(false)]
        public double? CurrentDikeHeight
        {
            get { return this.Scenario.Location.SurfaceLine2.GetDikeHeight(); }
        }

        [CsvExportColumn("CurrentDikeToeAtPolderX", 14)]
        [Browsable(false)]
        public double? CurrentDikeToeAtPolderX
        {
            get
            {
                double? x = null;
                GeometryPoint point = this.Scenario.Location.SurfaceLine2.GetDikeToeInward();
                if (point != null)
                    x = point.X;
                return x;
            }
        }

        [CsvExportColumn("CurrentDikeToeAtPolderZ", 15)]
        [Browsable(false)]
        public double? CurrentDikeToeAtPolderZ
        {
            get
            {
                double? z = null;
                GeometryPoint point = this.Scenario.Location.SurfaceLine2.GetDikeToeInward();
                if (point != null)
                    z = point.Z;
                return z;
            }
        }

        private string GetSoilProfileName(FailureMechanismSystemType failureMechanismType)
        {
            string soilprofilename = "";
            if (this.SoilProfile != null)
            {
                soilprofilename = this.SoilProfile.Name;
            }
            else
            {
                if (this.SoilGeometry2DName != null)
                {
                    soilprofilename = this.SoilGeometry2DName;
                }
            }
            return failureMechanismType == this.damFailureMechanismeCalculationSpecification.FailureMechanismSystemType ? soilprofilename : "";
        }

        private double? GetSoilProfileProbability(FailureMechanismSystemType? failureMechanismType)
        {
            return this.Scenario.Location.GetSoilProfileProbability(this.SoilProfile, failureMechanismType);
        }

        [CsvExportColumn("StabilityProfileName", 16)]
        [Label("Stability profile")]
        [Browsable(false)]
        public string StabilityProfileName
        {
            get { return GetSoilProfileName(FailureMechanismSystemType.StabilityInside); }
        }

        [CsvExportColumn("StabilityProfileProbability", 17)]
        [Label("Stability probability")]
        [Format("F3")]
        [Unit(UnitType.Fractions)]
        [Browsable(false)]
        public double? StabilityProfileProbability
        {
            get { return GetSoilProfileProbability(FailureMechanismSystemType.StabilityInside); }
        }

        [CsvExportColumn("PipingProfileName", 18)]
        [Label("Piping profile")]
        [Browsable(false)]
        public string PipingProfileName
        {
            get { return GetSoilProfileName(FailureMechanismSystemType.Piping); }
        }

        [CsvExportColumn("PipingProfileProbability", 19)]
        [Label("Piping probability")]
        [Format("F3")]
        [Unit(UnitType.Fractions)]
        [Browsable(false)]
        public double? PipingProfileProbability
        {
            get { return GetSoilProfileProbability(FailureMechanismSystemType.Piping); }
        }

        [CsvExportColumn("CurrentDikeLength", 20)]
        [Browsable(false)]
        public double? CurrentDikeLength
        {
            get { return this.Scenario.Location.SurfaceLine2.GetDikeLength(); }
        }

        [CsvExportColumn("StabilityToeAtPolderX", 21)]
        [Label("Stability toe polder")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [Browsable(false)]
        public double? StabilityToeAtPolderX
        {
            get
            {
                if (this.redesignedSurfaceLineStability == null)
                    return null;

                GeometryPoint point = this.redesignedSurfaceLineStability.GetDikeToeInward();
                if (point != null)
                    return point.X;
                else
                    return null;
            }
        }

        [CsvExportColumn("StabilityToeAtPolderZ", 22)]
        [Label("Height stability toe polder")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [Browsable(false)]
        public double? StabilityToeAtPolderZ
        {
            get
            {
                if (this.redesignedSurfaceLineStability == null)
                    return null;

                GeometryPoint point = this.redesignedSurfaceLineStability.GetDikeToeInward();
                if (point != null)
                    return point.Z;
                else
                    return null;
            }
        }

        [CsvExportColumn("StabilityShoulderHeight", 23)]
        [Label("Stability shoulder height")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [Browsable(false)]
        public double? StabilityShoulderHeight
        {
            get
            {
                if (this.redesignedSurfaceLineStability == null)
                    return null;

                GeometryPoint point = this.redesignedSurfaceLineStability.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
                if (point != null)
                    return point.Z;
                else
                    return null;
            }
        }

        [CsvExportColumn("StabilitySafetyFactor", 24)]
        [Label("Stability safety factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? StabilitySafetyFactor
        {
            get { return this.safetyFactorStability; }
            set { this.safetyFactorStability = value; }
        }

        [CsvExportColumn("StabilityFailureProbability", 25)]
        [Label("Stability failure probability")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? StabilityFailureProbability
        {
            get { return this.failureProbabilityStability; }
            set { this.failureProbabilityStability = value; }
        }

        [CsvExportColumn("RequiredSafetyFactorStabilityInnerSlope", 26)]
        [Label("Required safety factor stability inside")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? RequiredSafetyFactorStabilityInnerSlope
        {
            get { return this.Scenario.RequiredSafetyFactorStabilityInnerSlope;}
        }

        [CsvExportColumn("RequiredSafetyFactorStabilityOuterSlope", 27)]
        [Label("Required safety factor stability outside")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? RequiredSafetyFactorStabilityOuterSlope
        {
            get { return this.Scenario.RequiredSafetyFactorStabilityOuterSlope; }
        }

        [CsvExportColumn("RequiredSafetyFactorPiping", 28)]
        [Label("Required safety factor piping")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? RequiredSafetyFactorPiping
        {
            get { return this.Scenario.RequiredSafetyFactorPiping; }
        }

        [CsvExportColumn("PipingToeAtPolderX", 29)]
        [Label("Piping toe")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [Browsable(false)]
        public double? PipingToeAtPolderX
        {
            get
            {
                if (this.redesignedSurfaceLinePiping == null)
                    return null;

                GeometryPoint point = this.redesignedSurfaceLinePiping.GetDikeToeInward();
                if (point != null)
                    return point.X;
                else
                    return null;
            }
        }

        [CsvExportColumn("PipingToeAtPolderZ", 30)]
        [Label("Height Piping toe")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [Browsable(false)]
        public double? PipingToeAtPolderZ
        {
            get
            {
                if (this.redesignedSurfaceLinePiping == null)
                    return null;

                GeometryPoint point = this.redesignedSurfaceLinePiping.GetDikeToeInward();
                if (point != null)
                    return point.Z;
                else
                    return null;
            }
        }

        [CsvExportColumn("PipingShoulderHeight", 31)]
        [Label("Piping shoulder height")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [Browsable(false)]
        public double? PipingShoulderHeight
        {
            get
            {
                if (this.redesignedSurfaceLinePiping == null)
                    return null;

                GeometryPoint point = redesignedSurfaceLinePiping.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
                if (point != null)
                    return point.Z;
                else
                    return null;
            }
        }

        [CsvExportColumn("PipingFailureProbability", 32)]
        [Label("Piping failure probability")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? PipingFailureProbability
        {
            get { return this.failureProbabilityPiping; }
            set { this.failureProbabilityPiping = value; }
        }

        [Label("Required piping failure probability")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? RequiredFailureProbabilityPiping
        {
            get { return this.Scenario.RequiredProbabilityOfFailurePiping; }            
        }
        
        [CsvExportColumn("DikeLength", 33)]
        [Label("Dike length")]
        [Format("F3")]
        [PropertyOrder(4, 1)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? DikeLength
        {
            get
            {
                double? maxDikeLength = null;
                List<double?> dikeLengths = new List<double?>();
                SurfaceLine2 surfaceLine = this.Scenario.Location.SurfaceLine2;
                if (surfaceLine != null)
                    dikeLengths.Add(surfaceLine.GetDikeLength());
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityInside:
                        if (redesignedSurfaceLineStability != null)
                            dikeLengths.Add(redesignedSurfaceLineStability.GetDikeLength());
                        break;
                    case FailureMechanismSystemType.Piping:
                        if (redesignedSurfaceLinePiping != null)
                            dikeLengths.Add(redesignedSurfaceLinePiping.GetDikeLength());
                        break;
                }
                
                foreach (double? dikeLength in dikeLengths)
                {
                    if (dikeLength.HasValue && (!maxDikeLength.HasValue || maxDikeLength < dikeLength))
                        maxDikeLength = dikeLength;
                }
                return maxDikeLength;
            }
        }

        [CsvExportColumn("Zone1SafetyFactorStability", 34)]
        [Label("Zone 1 safety factor")]
        [Format("F3")]
        [PropertyOrder(3, 1)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        public double? Zone1SafetyFactorStability
        {
            get { return this.zone1SafetyFactorStability; }
            set { this.zone1SafetyFactorStability = value; }
        }

        [Label("Zone 1 entry point (X-local)")]
        [Format("F3")]
        [PropertyOrder(3, 2)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? LocalZone1EntryPointX
        {
            get { return localZone1EntryPointX; }
            set { localZone1EntryPointX = value; }
        }

        [CsvExportColumn("Zone1EntryPointX", 36)]
        [Label("Zone 1 entry point (X-global)")]
        [Format("F3")]
        [PropertyOrder(3, 3)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? Zone1EntryPointX
        {
            get
            {
                if (this.LocalZone1EntryPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone1EntryPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;                
            }
        }

        [CsvExportColumn("Zone1EntryPointY", 37)]
        [Label("Zone 1 entry point (Y-global)")]
        [Format("F3")]
        [PropertyOrder(3, 4)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? Zone1EntryPointY
        {
            get
            {
                if (this.LocalZone1EntryPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone1EntryPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;
            }
        }

        [CsvExportColumn("Zone1EntryPointZ", 38)]
        [Label("Zone 1 entry point (Z)")]
        [Format("F3")]
        [PropertyOrder(3, 5)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? Zone1EntryPointZ
        {
            get
            {
                if (this.LocalZone1EntryPointX == null)
                    return null;
                if (redesignedSurfaceLineStability == null)
                    return null;
                return this.redesignedSurfaceLineStability.Geometry.GetZAtX(this.LocalZone1EntryPointX.Value);
            }
        }

        [CsvExportColumn("LocalZone1ExitPointX", 39)]
        [Label("Zone 1 exit point (X-local)")]
        [Format("F3")]
        [PropertyOrder(3, 6)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? LocalZone1ExitPointX
        {
            get { return localZone1ExitPointX; }
            set { localZone1ExitPointX = value; }
        }

        [CsvExportColumn("Zone1ExitPointX", 40)]
        [Label("Zone 1 exit point (X-global)")]
        [Format("F3")]
        [PropertyOrder(3, 7)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone1ExitPointX
        {
            get
            {
                if (this.LocalZone1ExitPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone1ExitPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;
            }
        }

        [CsvExportColumn("Zone1ExitPointY", 41)]
        [Label("Zone 1 exit point (Y-global)")]
        [Format("F3")]
        [PropertyOrder(3, 8)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone1ExitPointY
        {
            get
            {
                if (this.LocalZone1ExitPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone1ExitPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;
            }
        }

        [CsvExportColumn("Zone1ExitPointZ", 42)]
        [Label("Zone 1 exit point (Z)")]
        [Format("F3")]
        [PropertyOrder(3, 9)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone1ExitPointZ
        {
            get
            {
                if (this.LocalZone1ExitPointX == null)
                    return null;
                if (redesignedSurfaceLineStability == null)
                    return null;
                return this.redesignedSurfaceLineStability.Geometry.GetZAtX(this.LocalZone1ExitPointX.Value);
            }
        }

        [CsvExportColumn("Zone2SafetyFactorStability", 43)]
        [Label("Zone 2 safety factor")]
        [Format("F3")]
        [PropertyOrder(3, 10)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        public double? Zone2SafetyFactorStability
        {
            get { return this.zone2SafetyFactorStability; }
            set { this.zone2SafetyFactorStability = value; }
        }

        [CsvExportColumn("LocalZone2EntryPointX", 44)]
        [Label("Zone 2 entry point (X-local)")]
        [Format("F3")]
        [PropertyOrder(3, 11)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? LocalZone2EntryPointX
        {
            get { return localZone2EntryPointX; }
            set { localZone2EntryPointX = value; }
        }

        [CsvExportColumn("Zone2EntryPointX", 45)]
        [Label("Zone 2 entry point (X-global)")]
        [Format("F3")]
        [PropertyOrder(3, 12)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone2EntryPointX
        {
            get
            {
                if (this.LocalZone2EntryPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone2EntryPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;
                
            }
        }

        [CsvExportColumn("Zone2EntryPointY", 46)]
        [Label("Zone 2 entry point (Y-global)")]
        [Format("F3")]
        [PropertyOrder(3, 13)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone2EntryPointY
        {
            get
            {
                if (this.LocalZone2EntryPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone2EntryPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;

            }
        }

        [CsvExportColumn("Zone2EntryPointZ", 47)]
        [Label("Zone 2 entry point (Z)")]
        [Format("F3")]
        [PropertyOrder(3, 14)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone2EntryPointZ
        {
            get
            {
                if (this.LocalZone2EntryPointX == null)
                    return null;
                if (redesignedSurfaceLineStability == null)
                    return null;
                return this.redesignedSurfaceLineStability.Geometry.GetZAtX(this.LocalZone2EntryPointX.Value);
            }
        }

        [CsvExportColumn("LocalZone2ExitPointX", 48)]
        [Label("Zone 2 exit point (X-local)")]
        [Format("F3")]
        [PropertyOrder(3, 15)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? LocalZone2ExitPointX
        {
            get { return localZone2ExitPointX; }
            set { localZone2ExitPointX = value; }
        }

        [CsvExportColumn("Zone2ExitPointX", 49)]
        [Label("Zone 2 exit point (X-global)")]
        [Format("F3")]
        [PropertyOrder(3, 16)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone2ExitPointX
        {
            get
            {
                if (this.LocalZone2ExitPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone2ExitPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;
            }
        }

        [CsvExportColumn("Zone2ExitPointY", 50)]
        [Label("Zone 2 exit point (Y-global)")]
        [Format("F3")]
        [PropertyOrder(3, 17)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone2ExitPointY
        {
            get
            {
                if (this.LocalZone2ExitPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalZone2ExitPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;
            }
        }

        [CsvExportColumn("Zone2ExitPointZ", 51)]
        [Label("Zone 2 exit point (Z)")]
        [Format("F3")]
        [PropertyOrder(3, 18)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Zone2ExitPointZ
        {
            get
            {
                if (this.LocalZone2ExitPointX == null)
                    return null;
                if (redesignedSurfaceLineStability == null)
                    return null;
                return this.redesignedSurfaceLineStability.Geometry.GetZAtX(this.LocalZone2ExitPointX.Value);
            }
        }

        [CsvExportColumn("IsUplift", 52)]
        [Label("Uplift")]
        [PropertyOrder(1, 4)]
        [ReadOnly(true)]
        public bool? IsUplift
        {
            get { return this.isUplift; }
            set { this.isUplift = value; }
        }

        [CsvExportColumn("Pl3MinUplift", 53)]
        [Label("PL3 Min uplift")]
        [Format("F3")]
        [PropertyOrder(5, 1)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        public double? Pl3MinUplift
        {
            get { return this.pl3MinUplift; }
            set { this.pl3MinUplift = value; }
        }

        [CsvExportColumn("Pl3HeadAdjusted", 54)]
        [Label("PL3 Head adjusted")]
        [Format("F3")]
        [PropertyOrder(5, 2)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Pl3HeadAdjusted
        {
            get { return this.pl3HeadAdjusted; }
            set { this.pl3HeadAdjusted = value; }
        }

        [CsvExportColumn("pl3LocalLocationXMinUplift", 55)]
        [Label("PL3 Min uplift (X-local)")]
        [Format("F3")]
        [PropertyOrder(5, 3)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Pl3LocalLocationXMinUplift
        {
            get { return this.pl3LocalLocationXMinUplift; }
            set { this.pl3LocalLocationXMinUplift = value; }
        }

        [CsvExportColumn("Pl3LocationXMinUplift", 56)]
        [Label("PL3 Min uplift (X-global)")]
        [Format("F3")]
        [PropertyOrder(5, 4)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? Pl3LocationXMinUplift
        {
            get
            {
                if (this.pl3LocalLocationXMinUplift == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.pl3LocalLocationXMinUplift.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;
            }
        }

        [CsvExportColumn("Pl3LocationYMinUplift", 57)]
        [Label("PL3 Min uplift (Y-global)")]
        [Format("F3")]
        [PropertyOrder(5, 5)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? Pl3LocationYMinUplift
        {
            get
            {
                if (this.pl3LocalLocationXMinUplift == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.pl3LocalLocationXMinUplift.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;
            }
        }

        [CsvExportColumn("Pl4MinUplift", 58)]
        [Label("PL4 Min uplift")]
        [Format("F3")]
        [PropertyOrder(5, 6)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        public double? Pl4MinUplift
        {
            get { return this.pl4MinUplift; }
            set { this.pl4MinUplift = value; }
        }

        [CsvExportColumn("Pl4HeadAdjusted", 59)]
        [Label("PL4 Head adjusted")]
        [Format("F3")]
        [PropertyOrder(5, 7)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Pl4HeadAdjusted
        {
            get { return this.pl4HeadAdjusted; }
            set { this.pl4HeadAdjusted = value; }
        }

        [CsvExportColumn("pl4LocalLocationXMinUplift", 60)]
        [Label("PL4 Min uplift (X-local)")]
        [Format("F3")]
        [PropertyOrder(5, 8)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? Pl4LocalLocationXMinUplift
        {
            get { return this.pl4LocalLocationXMinUplift; }
            set { this.pl4LocalLocationXMinUplift = value; }
        }

        [CsvExportColumn("Pl4LocationXMinUplift", 61)]
        [Label("PL4 Min uplift (X-global)")]
        [Format("F3")]
        [PropertyOrder(5, 9)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? Pl4LocationXMinUplift
        {
            get
            {
                if (this.pl4LocalLocationXMinUplift == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.pl4LocalLocationXMinUplift.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;
            }
        }

        [CsvExportColumn("Pl4LocationYMinUplift", 62)]
        [Label("PL4 Min uplift (Y-global)")]
        [Format("F3")]
        [PropertyOrder(5, 10)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? Pl4LocationYMinUplift
        {
            get
            {
                if (this.pl4LocalLocationXMinUplift == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.pl4LocalLocationXMinUplift.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;
            }
        }

        [Label("Uplift Factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        //[Browsable(false)]
        public double? UpliftFactor
        {
            get { return this.upliftFactor; }
            set { this.upliftFactor = value; }
        }

        [Label("Heave Factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        //[Browsable(false)]
        public double? HeaveFactor
        {
            get { return this.heaveFactor; }
            set { this.heaveFactor = value; }
        }

        [CsvExportColumn("BlighPipingFactor", 63)]
        [Label("Bligh piping factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? BlighPipingFactor
        {
            get { return this.blighPipingFactor; }
            set { this.blighPipingFactor = value; }
        }

        [CsvExportColumn("BlighHCritical", 64)]
        [Label("Bligh H critical")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? BlighHCritical
        {
            get { return this.blighHCritical; }
            set { this.blighHCritical = value; }
        }

        [CsvExportColumn("Sellmeijer2ForcesPipingFactor", 65)]
        [Label("Sellmeijer 2 piping factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? Sellmeijer2ForcesPipingFactor
        {
            get { return this.sellmeijer2ForcesPipingFactor; }
            set { this.sellmeijer2ForcesPipingFactor = value; }
        }

        [CsvExportColumn("Sellmeijer2ForcesHCritical", 66)]
        [Label("Sellmeijer 2 H Critical")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? Sellmeijer2ForcesHCritical
        {
            get { return this.sellmeijer2ForcesHCritical; }
            set { this.sellmeijer2ForcesHCritical = value; }
        }

        [CsvExportColumn("Sellmeijer4ForcesPipingFactor", 67)]
        [Label("Sellmeijer 4 piping factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? Sellmeijer4ForcesPipingFactor
        {
            get { return this.sellmeijer4ForcesPipingFactor; }
            set { this.sellmeijer4ForcesPipingFactor = value; }
        }

        [CsvExportColumn("Sellmeijer4ForcesHCritical", 68)]
        [Label("Sellmeijer 4 H Critical")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? Sellmeijer4ForcesHCritical
        {
            get { return this.sellmeijer4ForcesHCritical; }
            set { this.sellmeijer4ForcesHCritical = value; }
        }

        [CsvExportColumn("SellmeijerPipingFactor", 69)]
        [Label("Sellmeijer piping factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? SellmeijerPipingFactor
        {
            get { return this.sellmeijerPipingFactor; }
            set { this.sellmeijerPipingFactor = value; }
        }

        [CsvExportColumn("SellmeijerHCritical", 70)]
        [Label("Sellmeijer H Critical")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? SellmeijerHCritical
        {
            get { return this.sellmeijerHCritical; }
            set { this.sellmeijerHCritical = value; }
        }

        /// <summary>
        /// Gets or sets the wti2017 piping factor.
        /// </summary>
        /// <value>
        /// The wti2017 piping factor.
        /// </value>
        [Label("WTI 2017 piping factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? Wti2017PipingFactor
        {
            get { return wti2017PipingFactor; }
            set { wti2017PipingFactor = value; }
        }

        /// <summary>
        /// Gets or sets the wti2017 h critical.
        /// </summary>
        /// <value>
        /// The wti2017 h critical.
        /// </value>
        [Label("WTI 2017 H Critical")]
        [Format("F3")]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? Wti2017HCritical
        {
            get { return wti2017HCritical; }
            set { wti2017HCritical = value; }
        }

        [CsvExportColumn("NonWaterRetainingObjectId", 71)]
        [Browsable(false)]        
        public string NwoId { get { return this.nwoId; } }

        [CsvExportColumn("NWOResultIndex", 72)]
        [Browsable(false)]
        public int NwoResultIndex
        {
            get { return this.nwoResultIndex; }
        }

        [CsvExportColumn("NWOPoint1Xrd", 73)]
        [Browsable(false)]
        public double? NWOLocationXrdStart
        {
            get { return this.locationXrdStart; }
        }

        [CsvExportColumn("NWOPoint1Yrd", 74)]
        [Browsable(false)]
        public double? NWOLocationYrdStart
        {
            get { return this.locationYrdStart; }
        }

        [CsvExportColumn("NWOPoint1Zrd", 75)]
        [Browsable(false)]
        public double? NWOLocationZrdStart
        {
            get { return this.locationZrdStart; }
        }

        [CsvExportColumn("NWOPoint4Yrd", 76)]
        [Browsable(false)]
        public double? NWOLocationXrdEnd
        {
            get { return this.locationXrdEnd; }
        }

        [CsvExportColumn("NWOPoint4Xrd", 77)]
        [Browsable(false)]
        public double? NWOLocationYrdEnd
        {
            get { return this.locationYrdEnd; }
        }

        [CsvExportColumn("NWOPoint4Zrd", 78)]
        [Browsable(false)]
        public double? NWOLocationZrdEnd { get { return this.locationZrdEnd; } }
        //Note: using SurfaceLine instead of LocalXzSurfaceLine must give the proper RD coors. If this is not the case, error is somewhere else. Do not convert here!

        [CsvExportColumn("DikeToeAtRiverXrd", 79)]
        [Browsable(false)]
        public double? DikeToeAtRiverXrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).X; }
        }

        [CsvExportColumn("DikeToeAtRiverYrd", 80)]
        [Browsable(false)]
        public double? DikeToeAtRiverYrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).Y; }
        }

        [CsvExportColumn("DikeToeAtRiverZrd", 81)]
        [Browsable(false)]
        public double? DikeToeAtRiverZrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).Z; }
        }

        [CsvExportColumn("DikeTopAtRiverXrd", 82)]
        [Browsable(false)]
        public double? DikeTopAtRiverXrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).X; }
        }

        [CsvExportColumn("DikeTopAtRiverYrd", 83)]
        [Browsable(false)]
        public double? DikeTopAtRiverYrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).Y; }
        }

        [CsvExportColumn("DikeTopAtRiverZrd", 84)]
        [Browsable(false)]
        public double? DikeTopAtRiverZrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).Z; }
        }

        [CsvExportColumn("DikeTopAtPolderXrd", 85)]
        [Browsable(false)]
        public double? DikeTopAtPolderXrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).X; }
        }

        [CsvExportColumn("DikeTopAtPolderYrd", 86)]
        [Browsable(false)]
        public double? DikeTopAtPolderYrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Y; }
        }

        [CsvExportColumn("DikeTopAtPolderZrd", 87)]
        [Browsable(false)]
        public double? DikeTopAtPolderZrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z; }
        }

        [CsvExportColumn("DikeToeAtPolderXrd", 88)]
        [Browsable(false)]
        public double? DikeToeAtPolderXrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X; }
        }

        [CsvExportColumn("DikeToeAtPolderYrd", 89)]
        [Browsable(false)]
        public double? DikeToeAtPolderYrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Y; }
        }

        [CsvExportColumn("DikeToeAtPolderZrd", 90)]
        [Browsable(false)]
        public double? DikeToeAtPolderZrd
        {
            get { return this.Scenario.Location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; }
        }

        [CsvExportColumn("FlowSlideSafetyFactor", 91)]
        [Label("Flowslide safety factor")]
        [Format("F3")]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [Browsable(false)]
        public double? FlowSlideSafetyFactor
        {
            get { return this.safetyFactorFlowSlide; }
            set { this.safetyFactorFlowSlide = value; }
        }

        [Browsable(false)]
        public Scenario Scenario
        {
            get { return scenario; }
            set { scenario = value; }
        }

        [Browsable(false)]
        public SoilProfile1D SoilProfile
        {
            get { return soilProfile; }
            set { soilProfile = value; }
        }

        [Browsable(false)]
        public string SoilGeometry2DName
        {
            get { return soilGeometry2DName; }
            set { soilGeometry2DName = value; }
        }

        /// <summary>
        /// Creates a new <see cref="SurfaceLine2"/> instance based on <see cref="RedesignedSurfaceLine2Stability"/>
        /// with global coordinates instead of local coordinates.
        /// </summary>
        [Browsable(false)]
        public SurfaceLine2 CreateRedesignedSurfaceLineStabilityGlobal()
        {
            if (this.RedesignedSurfaceLine2Stability == null)
                return null;

            SurfaceLine2 originalSurfaceLine = this.Scenario.Location.SurfaceLine2;
            var coordinateSystemConverter = new CoordinateSystemConverter();
            coordinateSystemConverter.DefineGlobalXYZBasedOnLine(originalSurfaceLine.Geometry);

            var redesignedSurfaceLineStabilityGlobal = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            };
            redesignedSurfaceLineStabilityGlobal.Assign(this.RedesignedSurfaceLine2Stability);
            coordinateSystemConverter.ConvertLocalXZToGlobalXYZ(redesignedSurfaceLineStabilityGlobal.Geometry);

            return redesignedSurfaceLineStabilityGlobal;
        }

        [Browsable(false)]
        public SurfaceLine2 RedesignedSurfaceLine2Stability
        {
            get { return redesignedSurfaceLineStability; }
            set { redesignedSurfaceLineStability = value; }
        }

        /// <summary>
        /// Creates a new <see cref="SurfaceLine2"/> instance based on <see cref="RedesignedSurfaceLine2Piping"/>
        /// with global coordinates instead of local coordinates.
        /// </summary>
        [Browsable(false)]
        public SurfaceLine2 CreateRedesignedSurfaceLinePipingGlobal()
        {
            if (this.RedesignedSurfaceLine2Piping == null)
                return null;

            SurfaceLine2 originalSurfaceLine = this.Scenario.Location.SurfaceLine2;
            var coordinateSystemConverter = new CoordinateSystemConverter();
            coordinateSystemConverter.DefineGlobalXYZBasedOnLine(originalSurfaceLine.Geometry);

            var redesignedSurfaceLinePipingGlobal = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            };
            redesignedSurfaceLinePipingGlobal.Assign(this.RedesignedSurfaceLine2Piping);
            coordinateSystemConverter.ConvertLocalXZToGlobalXYZ(redesignedSurfaceLinePipingGlobal.Geometry);

            return redesignedSurfaceLinePipingGlobal;
        }

        [Browsable(false)]
        public SurfaceLine2 RedesignedSurfaceLine2Piping
        {
            get { return redesignedSurfaceLinePiping; }
            set { redesignedSurfaceLinePiping = value; }
        }

        [Label("Profile")]
        [PropertyOrder(2, 1)]
        [XmlIgnore]
        [ReadOnly(true)]
        public string ProfileName
        {
            get
            {
                var res = "";
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.HorizontalBalance:
                    case FailureMechanismSystemType.StabilityOutside:
                    case FailureMechanismSystemType.StabilityInside:
                        res = StabilityProfileName;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = PipingProfileName;
                        break;
                }
                return res;
            }
        }

        [Label("Profile probability")]
        [Format("F3")]
        [PropertyOrder(2, 2)]
        [Unit(UnitType.Fractions)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? ProfileProbability
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.HorizontalBalance:
                    case FailureMechanismSystemType.StabilityOutside:
                    case FailureMechanismSystemType.StabilityInside:
                        res = StabilityProfileProbability;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = PipingProfileProbability;
                        break;
                }
                return res;
            }
        }

        [Label("StabilityModel")]
        [Unit(UnitType.None)]
        [PropertyOrder(2, 3)]
        [ReadOnly(true)]
        [XmlIgnore]
        public MStabModelType? StabilityModel
        {
            get
            {
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityOutside:
                    case FailureMechanismSystemType.StabilityInside:
                        return damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.Model;
                    default:
                        return null;                        
                }                
            }
        }

        [Label("SafetyFactor")]
        [Unit(UnitType.None)]
        [Format("F3")]
        [PropertyOrder(2, 4)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? SafetyFactor
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.HorizontalBalance:
                    case FailureMechanismSystemType.StabilityOutside:
                    case FailureMechanismSystemType.StabilityInside:
                        res = StabilitySafetyFactor;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = PipingFactor;
                        break;
                    case FailureMechanismSystemType.FlowSlide:
                        res = FlowSlideSafetyFactor;
                        break;
                }
                return res;
            }
        }

        [Label("Failure probability")]
        [Format("F3")]
        [PropertyOrder(2, 5)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? FailureProbability
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.HorizontalBalance:
                    case FailureMechanismSystemType.StabilityOutside:
                    case FailureMechanismSystemType.StabilityInside:
                        res = StabilityFailureProbability;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = PipingFailureProbability;
                        break;
                }
                return res;
            }            
        }

        [Label("Required failure probability")]
        [Format("F3")]
        [PropertyOrder(2, 9)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? RequiredFailureProbability
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.Piping:
                        res = RequiredFailureProbabilityPiping;
                        break;
                }
                return res;
            }
        }

        [Label("Required safety factor")]
        [Format("F3")]
        [PropertyOrder(2, 10)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? RequiredSafetyFactor
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityOutside:
                        res = RequiredSafetyFactorStabilityOuterSlope;
                        break;
                    case FailureMechanismSystemType.StabilityInside:
                        res = RequiredSafetyFactorStabilityInnerSlope;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = RequiredSafetyFactorPiping;
                        break;
                }
                return res;
            }            
        }

        [Label("Shoulder height")]
        [Format("F3")]
        [PropertyOrder(2, 5)]
        [Unit(UnitType.Length)]
        [XmlIgnore]
        [ReadOnly(true)]
        public double? ShoulderHeight
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityInside:
                        res = StabilityShoulderHeight;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = PipingShoulderHeight;
                        break;
                }
                return res;
            }
        }

        [Label("Toe polder")]
        [Format("F3")]
        [PropertyOrder(2, 7)]
        [Unit(UnitType.Length)]
        [XmlIgnore]
        [ReadOnly(true)]
        public double? ToeAtPolderX
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityInside:
                        res = StabilityToeAtPolderX;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = PipingToeAtPolderX;
                        break;
                }
                return res;
            }
        }

        [Label("Height toe polder")]
        [Format("F3")]
        [PropertyOrder(2, 8)]
        [Unit(UnitType.Length)]
        [XmlIgnore]
        [ReadOnly(true)]
        public double? ToeAtPolderZ
        {
            get
            {
                double? res = null;
                switch (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType)
                {
                    case FailureMechanismSystemType.StabilityInside:
                        res = StabilityToeAtPolderZ;
                        break;
                    case FailureMechanismSystemType.Piping:
                        res = PipingToeAtPolderZ;
                        break;
                }
                return res;
            }
        }

        [Label("Piping model")]
        [PropertyOrder(6, 1)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [XmlIgnore]
        public PipingModelType? PipingModel
        {
            get
            {
                if (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType == FailureMechanismSystemType.Piping)
                {
                    return damFailureMechanismeCalculationSpecification.PipingModelType;                    
                }
                return null;
            }
        }

        [Label("Piping factor")]
        [Format("F3")]
        [PropertyOrder(6, 2)]
        [Unit(UnitType.None)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? PipingFactor
        {
            get
            {
                double? res = null;
                if (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType == FailureMechanismSystemType.Piping)
                {
                    switch (damFailureMechanismeCalculationSpecification.PipingModelType)
                    {
                        case PipingModelType.Bligh:
                            res = BlighPipingFactor;
                            break;
                        case PipingModelType.Sellmeijer:
                            res = SellmeijerPipingFactor;
                            break;
                        case PipingModelType.Sellmeijer2Forces:
                            res = Sellmeijer2ForcesPipingFactor;
                            break;
                        case PipingModelType.Sellmeijer4Forces:
                            res = Sellmeijer4ForcesPipingFactor;
                            break;
                        case PipingModelType.Wti2017:
                            res = Wti2017PipingFactor;
                            break;
                    }
                }
                return res;
            }
        }

        [Label("Piping entry point (X-local)")]
        [Format("F3")]
        [PropertyOrder(6, 3)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? LocalPipingEntryPointX
        {
            get
            {
                GeometryPoint point = null;
                if (this.RedesignedSurfaceLine2Piping != null)
                {
                    point = this.RedesignedSurfaceLine2Piping.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver);
                }
                else
                {
                    point = this.scenario.Location.LocalXZSurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver);
                }
                if (point != null)
                    return point.X;
                else
                    return null;
            }
        }

        [Label("Piping entry point (X-global)")]
        [Format("F3")]
        [PropertyOrder(6, 4)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? PipingEntryPointX
        {
            get
            {
                if (this.LocalPipingEntryPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalPipingEntryPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;
            }
        }

        [Label("Piping entry point (Y-global)")]
        [Format("F3")]
        [PropertyOrder(6, 5)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? PipingEntryPointY
        {
            get
            {
                if (this.LocalPipingEntryPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalPipingEntryPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;
            }
        }

        [Label("Piping exit point (X-local)")]
        [Format("F3")]
        [PropertyOrder(6, 6)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? LocalPipingExitPointX
        {
            get { return localPipingExitPointX; }
            set { localPipingExitPointX = value; }
        }

        [Label("Piping exit point (X-global)")]
        [Format("F3")]
        [PropertyOrder(6, 7)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? PipingExitPointX
        {
            get
            {
                if (this.LocalPipingExitPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalPipingExitPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.X;
            }
        }

        [Label("Piping exit point (Y-global)")]
        [Format("F3")]
        [PropertyOrder(6, 8)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? PipingExitPointY
        {
            get
            {
                if (this.LocalPipingExitPointX == null)
                    return null;

                GeometryPoint point = DetermineGlobalPointCoordinatesBasedOnGlobalSurfaceLine(
                    new GeometryPoint(this.LocalPipingExitPointX.Value, 0.0, 0.0), this.Scenario.Location.SurfaceLine2);

                return point.Y;
            }
        }

        [Format("F3")]
        [PropertyOrder(6, 9)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        public double? SeepageLength
        {
            get { return LocalPipingExitPointX - LocalPipingEntryPointX; }
        }

        [Label("H critical")]
        [Format("F3")]
        [PropertyOrder(6, 10)]
        [Unit(UnitType.Length)]
        [ReadOnly(true)]
        [XmlIgnore]
        public double? HCritical
        {
            get
            {
                double? res = null;
                if (damFailureMechanismeCalculationSpecification.FailureMechanismSystemType == FailureMechanismSystemType.Piping)
                {
                    switch (damFailureMechanismeCalculationSpecification.PipingModelType)
                    {
                        case PipingModelType.Bligh:
                            res = BlighHCritical;
                            break;
                        case PipingModelType.Sellmeijer:
                            res = SellmeijerHCritical;
                            break;
                        case PipingModelType.Sellmeijer2Forces:
                            res = Sellmeijer2ForcesHCritical;
                            break;
                        case PipingModelType.Sellmeijer4Forces:
                            res = Sellmeijer4ForcesHCritical;
                            break;
                        case PipingModelType.Wti2017:
                            res = Wti2017HCritical;
                            break;
                    }
                }
                return res;
            }
        }

        [Browsable(false)]
        public string BaseFileName
        {
            get { return baseFileName; }
            set { baseFileName = value; }
        }

        [Browsable(false)]
        public string CalculationSubDir
        {
            get { return calculationSubDir; }
            set { calculationSubDir = value; }
        }

        [Label("Evaluation")]
        //[Category(ResultCategory)]
        public ResultEvaluation ResultEvaluation
        {
            get { return resultEvaluation; }
            set
            {
                DataEventPublisher.BeforeChange(this, "ResultEvaluation");
                resultEvaluation = value;
                DataEventPublisher.AfterChange(this, "ResultEvaluation");
            }
        }

        [Label("Notes")]
        [Description("Use this area to explain the valuation and for any further remarks")]
        //[Category(ResultCategory)]
        public string Notes
        {
            get { return notes; }
            set
            {
                DataEventPublisher.BeforeChange(this, "Notes");
                notes = value;
                DataEventPublisher.AfterChange(this, "Notes");
            }
        }

        /// <summary>
        /// Returns the begin point and and point as a list
        /// </summary>
        [XmlIgnore]
        public List<IGeographicPoint> Points
        {
            get
            {
                if (dirty)
                {
                    dirty = false;
                    points.Clear();
                    if (this.locationXrdStart.HasValue && this.locationYrdStart.HasValue)
                    {
                        points.Add(new GeographicPoint(this.locationXrdStart.Value, this.locationYrdStart.Value));
                    }
                    if (this.locationXrdEnd.HasValue && this.locationYrdEnd.HasValue)
                    {
                        points.Add(new GeographicPoint(this.locationXrdEnd.Value, this.locationYrdEnd.Value));
                    }
                }
                
                return points;
            }
        }

        /// <summary>
        /// Copy data
        /// </summary>
        /// <param name="csvExportData"></param>
        public void Assign(CsvExportData csvExportData)
        {
            this.id = csvExportData.id;
            this.BaseFileName = csvExportData.BaseFileName;
            this.CalculationSubDir = csvExportData.CalculationSubDir;
            this.NumberOfIterations = csvExportData.NumberOfIterations;
            this.dike = csvExportData.dike;
            this.damFailureMechanismeCalculationSpecification = csvExportData.damFailureMechanismeCalculationSpecification;
            this.Scenario = csvExportData.Scenario;
            this.SoilProfile = csvExportData.SoilProfile;
            this.SoilGeometry2DName = csvExportData.SoilGeometry2DName;
            this.probabilisticType = csvExportData.ProbabilisticType;

            this.failureProbabilityPiping = csvExportData.failureProbabilityPiping;
            this.redesignedSurfaceLinePiping = csvExportData.redesignedSurfaceLinePiping;
            this.safetyFactorStability = csvExportData.safetyFactorStability;
            this.failureProbabilityStability = csvExportData.failureProbabilityStability;
            this.zone1SafetyFactorStability = csvExportData.zone1SafetyFactorStability;
            this.LocalZone1EntryPointX = csvExportData.LocalZone1EntryPointX;
            this.LocalZone1ExitPointX = csvExportData.LocalZone1ExitPointX;
            this.zone2SafetyFactorStability = csvExportData.zone2SafetyFactorStability;
            this.LocalZone2EntryPointX = csvExportData.LocalZone2EntryPointX;
            this.LocalZone2ExitPointX = csvExportData.LocalZone2ExitPointX;
            this.blighPipingFactor = csvExportData.blighPipingFactor;
            this.blighHCritical = csvExportData.blighHCritical;
            this.sellmeijer2ForcesPipingFactor = csvExportData.sellmeijer2ForcesPipingFactor;
            this.sellmeijer2ForcesHCritical = csvExportData.sellmeijer2ForcesHCritical;
            this.sellmeijer4ForcesPipingFactor = csvExportData.sellmeijer4ForcesPipingFactor;
            this.sellmeijer4ForcesHCritical = csvExportData.sellmeijer4ForcesHCritical;
            this.sellmeijerPipingFactor = csvExportData.sellmeijerPipingFactor;
            this.sellmeijerHCritical = csvExportData.sellmeijerHCritical;
            this.wti2017PipingFactor = csvExportData.wti2017PipingFactor;
            this.wti2017HCritical = csvExportData.wti2017HCritical;
            this.redesignedSurfaceLineStability = csvExportData.redesignedSurfaceLineStability;
            this.calculationResult = csvExportData.calculationResult;
        }

        /// <summary>
        /// Copies the result file.
        /// </summary>
        /// <param name="extension">The extension.</param>
        private void CopyResultFile(string extension)
        {
            string copyResFile = Path.GetDirectoryName(InputFile) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(InputFile) + " (copy)" + extension;
            var resFile = Path.ChangeExtension(InputFile, extension);
            File.Copy(resFile, copyResFile, true);
        }

        private string GetCurrentExeForOpenCalculationFile()
        {
            //var exeName = StabilityCalculator.MStabExePath;
            //if (SelectedStabilityKernelType != StabilityKernelType.DamClassic)
            //{
            //    exeName = Path.GetDirectoryName(exeName) + "\\MStab.exe";
            //}
            //return exeName;

            //throw new NotImplementedException("To be implemented");
            return "";
        }

        /// <summary>
        /// Opens the calculation file.
        /// </summary>
        public void OpenCalculationFile()
        {
            if (File.Exists(InputFile))
            {
                string copyFile = Path.GetDirectoryName(InputFile) + Path.DirectorySeparatorChar + 
                    Path.GetFileNameWithoutExtension(InputFile) + " (copy)" + Path.GetExtension(InputFile);
                File.Copy(InputFile, copyFile, true);
                var exeName = GetCurrentExeForOpenCalculationFile();
                if (SelectedStabilityKernelType == StabilityKernelType.DamClassic)
                {
                    const string stdExtension = ".std";
                    CopyResultFile(stdExtension);

                    const string stoExtension = ".sto";
                    CopyResultFile(stoExtension);
                }
                Process process = new Process();
                process.StartInfo.RedirectStandardOutput = false;
                process.StartInfo.FileName = exeName;
                if (SelectedStabilityKernelType == StabilityKernelType.DamClassicWti ||
                    SelectedStabilityKernelType == StabilityKernelType.AdvancedWti)
                {
                    process.StartInfo.Arguments = " -rto " + " \"" + copyFile + "\"";
                }
                else
                {
                    process.StartInfo.Arguments = " \"" + copyFile + "\"";
                }
                process.StartInfo.UseShellExecute = false;
                process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
                process.Start();
            }
            else
            {
                if (File.Exists(PipingResultFile))
                {
                    string copyFile = Path.GetTempPath() + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(PipingResultFile) + " (copy)" +
                        Path.GetExtension(PipingResultFile);

                    File.Copy(PipingResultFile, copyFile, true);
                    System.Diagnostics.Process.Start(copyFile);
                }
            }
        }

        /// <summary>
        /// Make a clone of object
        /// </summary>
        /// <returns></returns>
        public object Clone()
        {
            CsvExportData csvExportData = new CsvExportData(this.id, this.dike, this.damFailureMechanismeCalculationSpecification, this.Scenario,
                this.SoilProfile, this.SoilGeometry2DName, this.analysisType, this.nwoResultIndex, this.probabilisticType);

            csvExportData.Assign(this);

            return csvExportData;
        }

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

        public bool IsVisible(string property)
        {
            switch (property)
            {
                // #Bka note that using FailureMechanismSystemType here is only possible as long as multiple specifications are NOT allowed. Otherwise visibility would
                // have top be set here per line instead for whole column.
                case "Zone1SafetyFactorStability":
                case "Zone1EntryPointX":
                case "Zone1EntryPointZ":
                case "Zone1ExitPointX":
                case "Zone1ExitPointZ":
                case "Zone2SafetyFactorStability":
                case "Zone2EntryPointX":
                case "Zone2EntryPointZ":
                case "Zone2ExitPointX":
                case "Zone2ExitPointZ":
                    return damFailureMechanismeCalculationSpecification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityInside;// &&
                        //(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType == MStabZonesType.ZoneAreas ||
                        //damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ZonesType == MStabZonesType.ForbiddenZone);
                    //#Bka: zones are defined per location so can differ from result to result. Hence using Isvisible is not possible for this as zones should then be made
                    // visible or invisible per line in the table.
                case "StabilityModel":
                    return damFailureMechanismeCalculationSpecification.FailureMechanismSystemType ==
                           FailureMechanismSystemType.StabilityInside ||
                           damFailureMechanismeCalculationSpecification.FailureMechanismSystemType ==
                           FailureMechanismSystemType.StabilityOutside;
                case "RequiredSafetyFactor":
                    return probabilisticType == ProbabilisticType.Deterministic;
                case "SafetyFactor":
                    return probabilisticType == ProbabilisticType.Deterministic;
                case "FailureProbability":
                    return probabilisticType == ProbabilisticType.Probabilistic || probabilisticType == ProbabilisticType.ProbabilisticFragility;
                case "RequiredFailureProbability":
                    return probabilisticType == ProbabilisticType.Probabilistic || probabilisticType == ProbabilisticType.ProbabilisticFragility;
                case "PipingModel":
                    return damFailureMechanismeCalculationSpecification.FailureMechanismSystemType == FailureMechanismSystemType.Piping;
                case "PipingFactor":
                    return damFailureMechanismeCalculationSpecification.FailureMechanismSystemType == FailureMechanismSystemType.Piping;
                case "HCritical":
                    return damFailureMechanismeCalculationSpecification.FailureMechanismSystemType == FailureMechanismSystemType.Piping;
                case "OpenCalculationFile":
                    return File.Exists(GetCurrentExeForOpenCalculationFile());
                case "IsUplift":
                    return !(damFailureMechanismeCalculationSpecification.StabilityKernelType == StabilityKernelType.AdvancedWti || 
                        damFailureMechanismeCalculationSpecification.StabilityKernelType == StabilityKernelType.AdvancedDotNet);
                default:
                    return true;
            }

        }

        #region Backwards compatibility

        [Obsolete("Do not use this method; Only exists for backwards compatibility purposes.", true)]
        [XmlIgnore]
        [Browsable(false)]
        public SurfaceLine RedesignedSurfaceLineStability
        {
            get { return null; }
            set { redesignedSurfaceLineStability = new OldSurfaceLineToNewConverter().Convert(value);}
        }

        [Obsolete("Do not use this method; Only exists for backwards compatibility purposes.", true)]
        [XmlIgnore]
        [Browsable(false)]
        public SurfaceLine RedesignedSurfaceLinePiping
        {
            get { return null; }
            set { redesignedSurfaceLinePiping = new OldSurfaceLineToNewConverter().Convert(value); }
        }

        #endregion

    }
}