using System;
using System.Collections;
using System.Collections.Generic;
using Deltares.Mathematics;

// =======================================================================================================================
// Class name: TMStabProbabilisticData
//
// Description:
//
// Copyright (c) 2001-2010 Deltares
//
// Date        ID   Modification
// 2010-02-22       Created
// =======================================================================================================================

namespace Deltares.Stability.Calculation.Inner
{
    public class TMStabProbabilisticData
    {
        private List<string> FAParamName = new List<string>();
        private int[][] FAanpasArr = new int[0][];
        private TCalculationOptions FCalculationOptions;
        private string[] FContributionname;
        private double[][] FCorrelArr = new double[0][];
        private double[][] FCovariantie = new double[0][];
        private double[][] FDegreeOfConsolidationSoil;
        private double[][] FEivec = new double[0][];
        private List<double> FEx = new List<double>();
        private TInterfaceData FInterfaceData = null;
        private double FLimitValue = 0;
        private int FLimitVerdeling = 0;
        private double FLimitvalueModel = 0;
        private double FLimitvalueStDev = 0;
        private TModelData FModelData;
        private int FNSlices = 0;
        private TProbabilisticDefaults FProbabilisticDefaults = null;
        private Tslice[] FSlices;
        private TStabSoilData[] FSoilData;
        private TSoilParameterConversion FSoilParameterConversion = null;
        private TStressTable[] FStresstable;
        private List<double> FSx = new List<double>();
        private double[] FU;
        private int[][] FVarArr = new int[0][];
        private List<int> FVerdeling = new List<int>();
        private double[][] FVp = new double[0][];
        private double FWaterlevel = 0;
        private string FWaterlevelname = String.Empty;
        private bool FWithCorrelation = false;
        private List<double> FX = new List<double>();
        private TprobabilisticData FprobabilisticData;

        public string Waterlevelname
        {
            get
            {
                return FWaterlevelname;
            }
            set
            {
                FWaterlevelname = value;
            }
        }

        public double Waterlevel
        {
            get
            {
                return FWaterlevel;
            }
            set
            {
                FWaterlevel = value;
            }
        }

        public TInterfaceData InterfaceData
        {
            get
            {
                return FInterfaceData;
            }
            set
            {
                FInterfaceData = value;
            }
        }

        public int NSlices
        {
            get
            {
                return FNSlices;
            }
            set
            {
                FNSlices = value;
            }
        }

        public Tslice[] Slices
        {
            get
            {
                return FSlices;
            }
            set
            {
                FSlices = value;
            }
        }

        public int NStochastic
        {
            get
            {
                return FEx.Count;
            }
        }

        public int[] Verdeling
        {
            get
            {
                return FVerdeling.ToArray();
            }
        }

        public double[] Ex
        {
            get
            {
                return FEx.ToArray();
            }
        }

        public double[] Sx
        {
            get
            {
                return FSx.ToArray();
            }
        }

        public double[] U
        {
            get
            {
                return FU;
            }
        }

        public double[] X
        {
            get
            {
                return FX.ToArray();
            }
        }

        public double[][] Vp
        {
            get
            {
                return FVp;
            }
            set
            {
                FVp = value;
            }
        }

        public double[][] Covariantie
        {
            get
            {
                return FCovariantie;
            }
            set
            {
                FCovariantie = value;
            }
        }

        public double[][] Eivec
        {
            get
            {
                return FEivec;
            }
        }

        public int[][] VarArr
        {
            get
            {
                return FVarArr;
            }
            set
            {
                FVarArr = value;
            }
        }

        public int[][] AanpasArr
        {
            get
            {
                return FAanpasArr;
            }
            set
            {
                FAanpasArr = value;
            }
        }

        public bool WithCorrelation
        {
            get
            {
                return FWithCorrelation;
            }
            set
            {
                FWithCorrelation = value;
            }
        }

        public string[] AParamName
        {
            get
            {
                return FAParamName.ToArray();
            }
        }

        public double[][] CorrelArr
        {
            get
            {
                return FCorrelArr;
            }
            set
            {
                FCorrelArr = value;
            }
        }

        public TprobabilisticData probabilisticData
        {
            get
            {
                return FprobabilisticData;
            }
            set
            {
                FprobabilisticData = value;
            }
        }

        public double LimitvalueModel
        {
            get
            {
                return FLimitvalueModel;
            }
            set
            {
                FLimitvalueModel = value;
            }
        }

        // =======================================================================================================================
        // Description: Bepaalt de relatieve bijdragen van de basis variabelen
        // en voert ze uit
        // File is lfw ( global textfile (must be open )
        // N   - Aantal variabelen
        // U   - Array met genormeerde ontwerppunten
        // SX   - Standaard afwijking van de basis variabelen
        //
        // Date        ID   Modification
        // -           -    Created
        // 2002-11-25  Dam  Changed StochasticWater.WaterDataUsed in StochasticWaterList.WaterDataUsed
        // 2007-06-07  Vks  Attempted to make MStab work
        // =======================================================================================================================
        public void ProbabilisticResultDump(double ABeta)
        {
            // (NTot: Integer; Beta, AWaterLevel: Double;
            // AWaterLevelName: string;
            // X, U, SX: TDynamic1DDoubleArr;
            // VarArr: TVararrMax; AanpasArr: TAanpasarrMax);
            int next;
            int i;
            int j;
            int LInLayer;
            double som;
            double[] alfa2;
            int LNMaxCphi;
            int LNDim;
            int LNConsContribution;
            CreateSoilContributionName();
            LNMaxCphi = Constants.CMaxStd;
            // if (not MyGlobals.StochasticWaterList.WaterDataUsed) then
            // alphaCor := 1;
            alfa2 = new double[NStochastic];
            som = 0.0;
            for (i = 0; i < NStochastic; i++)
            {
                alfa2[i] = U[i]*U[i]/(ABeta*ABeta);
                som = som + alfa2[i];
            }
            next = 0;
            FprobabilisticData.beta = ABeta;
            FprobabilisticData.Faalkans = MStabDatafunctions.NormalDistribution(-ABeta);
            FprobabilisticData.WaterlevelName = FInterfaceData.CurrentWaternet.WaternetName; //FWaterlevelname;
            FprobabilisticData.WaterLevel = FInterfaceData.CurrentWaternet.ExternalWaterLevel;

            FprobabilisticData.SoilContributions = new List<TContributionRecord>();

            if (FVarArr != null)
            {
                LNDim = FVarArr.Length;
                for (i = 0; i < FVarArr.Length; i ++)
                {
                    var LContribution = new TContributionRecord();

                    //LContribution = FprobabilisticData.SoilContributions[i];
                    LContribution.SoilNumber = VarArr[i][1];
                    LContribution.SoilName = FSoilData[LContribution.SoilNumber].Name;
                    LContribution.IndicationArray = new List<TContributionIndicationRecord>();

                    FprobabilisticData.SoilContributions.Add(LContribution);

                    for (j = 2; j <= LNMaxCphi; j++)
                    {
                        if ((VarArr[i][j] == 1))
                        {
                            next ++;

                            var contributionIndicationRecord = new TContributionIndicationRecord();

                            contributionIndicationRecord.ContributionName = FContributionname[j - 2];
                            contributionIndicationRecord.ContributionValue = next - 1 < alfa2.Length ? alfa2[next - 1]/som : 0;
                            contributionIndicationRecord.Alpha = U[next - 1];

                            LContribution.IndicationArray.Add(contributionIndicationRecord);
                        }
                    }
                }
            }
            // nu voor de aanpassings percentages
            LNConsContribution = 0;
            FprobabilisticData.DegreeofConsolidation = new List<TDegreeOfConsolidationRecord>();

            if ((FProbabilisticDefaults.ConsolidationCoefTotalStdDev > 1.0E-8))
            {
                if (FAanpasArr.Length > 0)
                {
                    for (i = 0; i < FAanpasArr.Length; i ++)
                    {
                        LInLayer = AanpasArr[i][0];
                        for (j = 1; j < AanpasArr[i].Length; j++)
                        {
                            if ((AanpasArr[i][j] == 1))
                            {
                                next ++;
                                LNConsContribution ++;

                                var degreeOfConsolidationRecord = new TDegreeOfConsolidationRecord();

                                degreeOfConsolidationRecord.InLayer = LInLayer;
                                degreeOfConsolidationRecord.FromLayer = j - 1;
                                degreeOfConsolidationRecord.ContributionValue = next - 1 < alfa2.Length ? alfa2[next - 1]/som : 0;
                                degreeOfConsolidationRecord.Alpha = next - 1 < U.Length ? U[next - 1] : 0;

                                FprobabilisticData.DegreeofConsolidation.Add(degreeOfConsolidationRecord);
                            }
                        }
                    }
                }
            }
            if ((FLimitvalueStDev > 1.0E-8))
            {
                next ++;
                FprobabilisticData.ModelFactor.ContributionName = "Model factor ";
                FprobabilisticData.ModelFactor.ContributionValue = next - 1 < alfa2.Length ? alfa2[next - 1]/som : 0;
                FprobabilisticData.ModelFactor.Alpha = next - 1 < U.Length ? U[next - 1] : 0;
            }
        }

        public void CreateandFillProbArrays()
        {
            int LNo1;
            int LNo2;
            // First create shortcutsfrom interface data
            CreateShortCuts();
            FCorrelArr = null;
            // kijk hoveel materialen in de cirkel voorkomen en vul verw waarde en std
            FillFormArrays();
            // (*
            // if (ProbDump) then
            // begin
            // WriteFormArrays(Vararr, LCorrelArr,
            // Ex, Sx, NStochastic, aanpasarr, Verdeling, NSlices, Slices,
            // WithCorrelation);
            // end;
            // *)
            // creer de overige benodigde arrays
            if (FWithCorrelation)
            {
                FCovariantie = ArraySupport.CreateJaggedArray(NStochastic, NStochastic);
                // zet 1 op hoofd diagonal
                FINITCOV();
                for (int i = 0; i <= CorrelArr[0].Length; i ++)
                {
                    LNo1 = Convert.ToInt32(CorrelArr[0][i]) - 1;
                    LNo2 = Convert.ToInt32(CorrelArr[1][i]) - 1;
                    Covariantie[LNo1][LNo2] = CorrelArr[2][i];
                    Covariantie[LNo2][LNo1] = CorrelArr[2][i];
                }
                FEivec = new double[NStochastic][];
                for (int i = 0; i < NStochastic; i++)
                {
                    FEivec[i] = new double[NStochastic];
                }
            }
            else
            {
                FCovariantie = ArraySupport.CreateJaggedArray(1, 1);
                FEivec = new double[1][];
                FEivec[0] = new double[1];
            }
            FVp = ArraySupport.CreateJaggedArray(10, NStochastic);
            FINITVP();
            FU = FEx.ToArray(); //new double[NStochastic];
            FCorrelArr = null;
        }

        public void PutAdjustedParametersInMaterial(double[] X)
        {
            double LFactor;
            int Next;
            int i;
            TStabSoilData LSoil;
            int LSoilNum;
            int InLayer;
            int FromLayer;
            double LReference;
            double LDilatPhiRatio;
            double LLimitvalueStDev;
            // vul de nieuwe sterkte parameters in en anpassingen
            Next = -1;
            for (i = 0; i < FVarArr.Length; i ++)
            {
                LSoilNum = VarArr[i][1];
                LSoil = FSoilData[LSoilNum];
                // ... Cohesion ...
                if ((VarArr[i][2] > 0))
                {
                    Next ++;
                    LSoil.Cohesion = X[Next];
                }
                // ... phi ...
                if ((VarArr[i][3] > 0))
                {
                    Next ++;
                    LDilatPhiRatio = 1;
                    if ((new ArrayList(new TCalculationTypeSet[]
                        {
                            TCalculationTypeSet.csBishop, TCalculationTypeSet.csFellenius
                        }).Contains(FModelData.CalcType)) && (FModelData.HasAlternativeStrength))
                    {
                        if ((LSoil.Dilatancy > 0))
                        {
                            LDilatPhiRatio = LSoil.Phi/LSoil.Dilatancy;
                        }
                        LSoil.Phi = X[Next];
                        if ((LSoil.Dilatancy > 0))
                        {
                            if ((LDilatPhiRatio > 0))
                            {
                                LSoil.Dilatancy = LSoil.Phi/LDilatPhiRatio;
                            }
                        }
                    }
                    else
                    {
                        LSoil.Phi = X[Next];
                        LSoil.Dilatancy = X[Next];
                    }
                }
                if ((VarArr[i][4] > 0))
                {
                    Next ++;
                    LSoil.FormReferencePn = X[Next];
                }
                // ... measured Cu ...
                if ((VarArr[i][5] > 0))
                {
                    Next ++;
                    LFactor = X[Next]/LSoil.CuTop;
                    // ... top ...
                    LSoil.CuTop = LSoil.CuTop*LFactor;
                    LSoil.CuPassiveTop = LSoil.CuPassiveTop*LFactor;
                    LSoil.CuActiveTop = LSoil.CuActiveTop*LFactor;
                    // ... bottom ...
                    LSoil.CuBottom = LSoil.CuBottom*LFactor;
                    LSoil.CuPassiveBottom = LSoil.CuPassiveBottom*LFactor;
                    LSoil.CuActiveBottom = LSoil.CuActiveBottom*LFactor;
                }
                // ... Calculated Cu ...
                if ((VarArr[i][6] > 0))
                {
                    Next ++;
                    LFactor = X[Next]/LSoil.RatioCuPc;
                    // ... top ...
                    LSoil.RatioCuPc = X[Next];
                    LSoil.RatioCuPcPassive = LSoil.RatioCuPcPassive*LFactor;
                    LSoil.RatioCuPcActive = LSoil.RatioCuPcActive*LFactor;
                }
                // ... Stress Tables ...
                if ((VarArr[i][7] > 0))
                {
                    Next ++;
                    LSoil.StresstableFactor = X[Next];
                }
                // ... Cu Gradient ...
                if ((VarArr[i][8] > 0))
                {
                    Next ++;
                    LSoil.CuGradient = X[Next];
                }
                if ((VarArr[i][9] > 0))
                {
                    Next ++;
                    LSoil.RatioCuPcActive = X[Next];
                }
                if ((VarArr[i][10] > 0))
                {
                    Next ++;
                    LSoil.RatioCuPcPassive = X[Next];
                }
                if ((VarArr[i][11] > 0))
                {
                    Next ++;
                    LSoil.POP = X[Next];
                }
            }
            // nu de nieuwe aanpassingen wegschrijven
            LReference = FProbabilisticDefaults.ConsolidationCoefTotalStdDev;
            if ((LReference > 1.0E-8))
            {
                for (i = FAanpasArr.GetLowerBound(0); i <= FAanpasArr.GetUpperBound(0); i ++)
                {
                    InLayer = Convert.ToInt32(AanpasArr[i][0]);
                    for (FromLayer = AanpasArr[i].GetLowerBound(0) + 1; FromLayer <= AanpasArr[i].GetUpperBound(0); FromLayer ++)
                    {
                        if ((AanpasArr[i][FromLayer] > 0))
                        {
                            Next ++;
                            // From layer is 1 higher then the layer involved, the first position in inlayer
                            FDegreeOfConsolidationSoil[FromLayer - 1][InLayer] = X[Next]*100;
                        }
                    }
                }
            }
            switch (FModelData.CalcType)
            {
                case TCalculationTypeSet.csBishop:
                    // Put data from aanpasarray in degree of consolidation
                    LLimitvalueStDev = FProbabilisticDefaults.LimitValueBishopStdDev;
                    break;
                default:
                    // Lift:
                    LLimitvalueStDev = FProbabilisticDefaults.LimitValueVanStdDev;
                    break;
            }
            if ((LLimitvalueStDev > 1.0E-8))
            {
                Next ++;
                FLimitvalueModel = X[Next];
            }
        }

        public void AdjustSliceData(int NSlices, ref Tslice[] Slices)
        {
            int i;
            // LPoreFactor: Double;
            // LExcessPore: Double;
            for (i = 0; i < NSlices; i ++)
            {
                // put adjust degree of consolidation in vertical
                Slices[i].Vertical.DegreeOfConsolidationSoil = FDegreeOfConsolidationSoil;
                // calculate pore pressure due to new degree of consolidation
                Slices[i].AanpasPore = Slices[i].Vertical.DetermineDegreeOfConsolidationSoilStress(Slices[i].ZBottomMid, Slices[i].InLayer);
                // calculate total pore including the change in the pore pressures from pl-lines
                Slices[i].TotalPore = Slices[i].PnLinePore + FSoilData[Slices[i].SoilNumber].FormReferencePn + Slices[i].AanpasPore + Slices[i].SigmaWaterQuake + Slices[i].WaterLoadStress;
                // (*       if (GSTLicenseSettings.IsEvaluationVersion) then
                // begin
                // FetchExtraPoreFactors(LPoreFactor, LExcessPore, XMid, YBottomMid);
                // TotalPore := LPoreFactor * (TotalPore + LExcessPore);
                // end;
                // *)
                Slices[i].EffectiveStress = Slices[i].TotalStress - Slices[i].TotalPore;
                if ((Slices[i].EffectiveStress < 0))
                {
                    Slices[i].TotalPore = Slices[i].TotalPore + Slices[i].EffectiveStress;
                    Slices[i].EffectiveStress = 0.0;
                }
                GetCohesionAndPhi(ref Slices[i]);
            }
        }

        private void CreateSoilContributionName()
        {
            FContributionname = new string[Constants.CMaxStd];
            FContributionname[0] = MStabProbabilisticData.CCohName;
            FContributionname[1] = MStabProbabilisticData.CPhiName;
            FContributionname[2] = MStabProbabilisticData.CPorePresurename;
            FContributionname[3] = MStabProbabilisticData.CUMeasuredname;
            FContributionname[4] = MStabProbabilisticData.CUCalculatedname;
            FContributionname[5] = MStabProbabilisticData.CuStressTableName;
            FContributionname[6] = MStabProbabilisticData.CuGradientName;
            FContributionname[7] = MStabProbabilisticData.CUCalcPassivename;
            FContributionname[8] = MStabProbabilisticData.CUCalcActivename;
            FContributionname[9] = MStabProbabilisticData.CPopName;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-02-23       Created
        // =======================================================================================================================
        private void CreateShortCuts()
        {
            // make copy of soil data and degree of consolidation as these may change in probabilistic calculations
            FSoilData = FInterfaceData.StabSoilData;
            FDegreeOfConsolidationSoil = FInterfaceData.DegreeOfConsolidationSoil;
            // Create shortcuts for other parts
            FCalculationOptions = FInterfaceData.CalculationOptions;
            FModelData = FInterfaceData.ModelData;
            FLimitvalueModel = FInterfaceData.ModelData.LimitValue;
            FProbabilisticDefaults = FInterfaceData.ProbabilisticDefaults;
            FStresstable = FInterfaceData.Stresstable;
            FSoilParameterConversion = new TSoilParameterConversion();
            FNSlices = FSlices.Length;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================
        private void AddProbCPhiData(int AMatNo, TStabSoilData ASoil, ref int[][] Vararr, ref bool WithCorrelation, ref int NextCorrel, ref double[][] CorrelArr, List<double> X, List<double> Ex, List<double> Sx, List<int> Verdeling, List<string> AParamName)
        {
            TConvertTypeSet LConvert;
            double LPhi;
            double LCohesion;
            int LMat;
            LMat = Convert.ToInt32(Vararr[AMatNo - 1][1]);
            if ((ASoil.StdCohesion > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctCohesion;
                LCohesion = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][2] = 1;
                Ex.Add(LCohesion);
                X.Add(LCohesion);
                Sx.Add(ASoil.StdCohesion);
                Verdeling.Add((int) ASoil.DistCohesion);
                AParamName.Add(LMat.ToString() + ' ' + Constants.sCohesion);
            }

            if ((ASoil.StdPhi > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctPhi;
                LPhi = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][3] = 1;
                Ex.Add(LPhi);
                X.Add(LPhi);
                Sx.Add(ASoil.StdPhi);
                Verdeling.Add((int) ASoil.DistPhi);
                AParamName.Add(LMat.ToString() + ' ' + Constants.sPhi);
            }

            CheckPorePressures(AMatNo, ASoil, ref Vararr, X, Ex, Sx, Verdeling, AParamName);
            if ((Math.Abs(ASoil.CorrelationCPhi) > 1.0E-8))
            {
                if ((ASoil.StdPhi > 1.0E-8) && (ASoil.StdCohesion > 1.0E-8))
                {
                    // bepaal van de correlaties waar ze moeten komen
                    // in de correlatie matrix en welke waarden ze hebben
                    WithCorrelation = true;
                    NextCorrel ++;
                    CorrelArr = ArraySupport.CreateJaggedArray(3, 3);
                    CorrelArr[0][NextCorrel - 1] = NStochastic;
                    CorrelArr[1][NextCorrel - 1] = NStochastic - 1;
                    CorrelArr[2][NextCorrel - 1] = ASoil.CorrelationCPhi;
                }
            }
        }

        // (*(var Vararr: TVararrMax;
        // var CorrelArr: TDynamic2DDoubleArr;
        // var X, Ex, Sx: TDynamic1DDoubleArr;
        // var NStochastic: Integer; var aanpasarr: TAanpasarrMax;
        // var Verdeling: TDynamic1DIntArr;
        // NSlices: Integer; Slices: TSliceTypesArr;
        // var WithCorrelation: Boolean;
        // var AParamName: TDynamic1DString);
        // *)
        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-02-23       Created
        // =======================================================================================================================
        private TMatStrengthTypeSet GetStrengthType()
        {
            TMatStrengthTypeSet result;
            result = TMatStrengthTypeSet.mstCphi;
            switch (FInterfaceData.ModelData.DefaultStrength)
            {
                case TMatStrengthTypeSet.mstCphi:
                    result = TMatStrengthTypeSet.mstCphi;
                    break;
                case TMatStrengthTypeSet.mstStressTab:
                    result = TMatStrengthTypeSet.mstStressTab;
                    break;
                case TMatStrengthTypeSet.mstPseudoStressTab:
                    result = TMatStrengthTypeSet.mstPseudoStressTab;
                    break;
                case TMatStrengthTypeSet.mstMeasuredCu:
                    result = TMatStrengthTypeSet.mstMeasuredCu;
                    break;
                case TMatStrengthTypeSet.mstGradientCu:
                    result = TMatStrengthTypeSet.mstGradientCu;
                    break;
                case TMatStrengthTypeSet.mstCalculatedCu:
                    result = TMatStrengthTypeSet.mstCalculatedCu;
                    break;
                case TMatStrengthTypeSet.mstNone:
                    result = TMatStrengthTypeSet.mstCphi;
                    break;
            }
            return result;
        }

        // =======================================================================================================================
        // Method           : FillFormArrays
        //
        // Description      : Fils the variables in the form array ( mean standard deviation
        // and start value ( = mean here )
        //
        // The Vararr keeps track of the material number
        // from each cohesion and phi.
        // i,1 = material number
        // i,2 = cohesion stochastic(1) or not (0)
        // i,3 = Phi stochastic(1) or not (0)
        // i,4 = Pn values stochastic(1) or not (0)
        // i,5 = Measured Cu values stochastic(1) or not (0)
        // i,6 = Calculated Cu values stochastic(1) or not (0)
        // i,7 = Stresstable data
        // i,8 = Cu gradient (Cu-top = 5)
        // i,9 =  Calculated Cu /cp ratio active
        // i,10 =  Calculated Cu /cp ratio passive
        // i,11 =  Pop (Calculated Cu)
        //
        // Keep in mind that the sequence of calling is identical to the
        // above mentioned sequence
        // Cu values top and bottom, active passive as well as Stess
        // table values are supposed to be totaly corolated.
        // Values for stress table are put in a factor
        // Cu-gradient uses the Measured cu values for cu-top and gradient
        // for gradient
        //
        // For adding a new soil parameter increase the CMaxStd.
        // Add the variable with the strength type.
        // Add the variable in PutAdjustedParametersInMaterial
        // See that the slices are corrected in AdjustSliceData
        // Reset the parameters in Resetglobals
        // Dump new parameters in ProbabilisticResultDump
        // Read new parameters in MSTContributiondump
        //
        // Degree of consolidation all values different from 0 or 100
        // are part of the stochastic values  this is kept in a special array
        // Faanpassarr
        //
        // Date        ID   Modification
        // Created
        // 2001-08-28  Best Verdeling wordt gevuld met material distribution ipv global
        // soildistribution
        // 2003-12-15  Best Correlation between materials from the same soilgroup.
        // This correlation coefficient is fixed at one at the moment
        // =======================================================================================================================
        private void FillFormArrays()
        {
            int i;
            int j;
            int k;
            bool Found;
            int next;
            int nextCorrel;
            int MatNo;
            int LOtherMatNo;
            int LNumberOfSoils;
            int LFromLayer;
            int LInLayer;
            double LReference;
            TDistributionTypeSet LRefDistribution;
            TMatStrengthTypeSet LStrengthType;
            int LSoilGroup;
            int LOtherSoilGroup;
            int LNStochastic1;
            int LNStochastic2;
            int LVarLoop;
            double LfixedCorrelCoef;
            TMatStrengthTypeSet LStrengthType1;
            TMatStrengthTypeSet LStrengthType2;
            int LNLayers;
            string Lstr;
            int LAanpasPercentage;
            LfixedCorrelCoef = 0.95;
            next = 0;
            nextCorrel = 0;
            FWithCorrelation = false;
            // zoek eerst alle materialen op die in het glijvlak
            // een rol spelen en vul daarmee de variabele array zoek tevens
            // de laatste laag
            for (i = 0; i < FNSlices; i ++)
            {
                Found = false;
                j = 0;
                do
                {
                    j ++;
                    // kijk of het materiaal al eerder is gevonden
                    if ((FVarArr.GetUpperBound(0) >= (j - 1)))
                    {
                        Found = (Slices[i].SoilNumber == (VarArr[j - 1][1]));
                    }
                } while (!(Found || (j >= next)));
                if (!Found)
                {
                    // indien het materiaal er nog niet inzit maak dan een nieuw aan
                    next ++;
                    FVarArr = ArraySupport.ExtendJaggedArray(FVarArr, next, Constants.CMaxStd + 1);
                    VarArr[next - 1][1] = Slices[i].SoilNumber;
                    // initialisatie van rest Vararr
                    for (k = 2; k <= Constants.CMaxStd; k ++)
                    {
                        VarArr[next - 1][k] = 0;
                    }
                }
            }
            LNumberOfSoils = next;
            // nu de materialen bekend zijn kijken in welke materialen
            // stochastische variaties zitten. De waarden van de array zijn geinitialiseerd op nul
            for (MatNo = 1; MatNo <= next; MatNo ++)
            {
                LStrengthType = FSoilData[VarArr[MatNo - 1][1]].MaterialStrength;
                if ((new ArrayList(new TMatStrengthTypeSet[]
                    {
                        TMatStrengthTypeSet.Default, TMatStrengthTypeSet.mstNone
                    }).Contains(LStrengthType)))
                {
                    LStrengthType = GetStrengthType();
                }
                switch (LStrengthType)
                {
                    case TMatStrengthTypeSet.mstCphi:
                        AddProbCPhiData(MatNo, FSoilData[VarArr[MatNo - 1][1]], ref FVarArr, ref FWithCorrelation, ref nextCorrel, ref FCorrelArr, FX, FEx, FSx, FVerdeling, FAParamName);
                        break;
                    case TMatStrengthTypeSet.mstMeasuredCu:
                        AddMeasuredCuData(MatNo, FSoilData[VarArr[MatNo - 1][1]], ref FVarArr, FX, FEx, FSx, FVerdeling, FAParamName);
                        break;
                    case TMatStrengthTypeSet.mstGradientCu:
                        AddGradientCuData(MatNo, FSoilData[VarArr[MatNo - 1][1]], ref FVarArr, FX, FEx, FSx, FVerdeling, FAParamName);
                        break;
                    case TMatStrengthTypeSet.mstCalculatedCu:
                        AddCalculatedCuData(MatNo, FSoilData[VarArr[MatNo - 1][1]], ref FVarArr, FX, FEx, FSx, FVerdeling, FAParamName);
                        break;
                    case TMatStrengthTypeSet.mstStressTab:
                        AddStressTabData(MatNo, FSoilData[VarArr[MatNo - 1][1]], ref FVarArr, FX, FEx, FSx, FVerdeling, FNSlices, FSlices, FAParamName);
                        break;
                }
            }
            // ... find  correlations between soils ...
            for (MatNo = 1; MatNo <= LNumberOfSoils; MatNo ++)
            {
                LSoilGroup = FSoilData[VarArr[MatNo - 1][1]].SoilGroup;
                if ((LSoilGroup > 0))
                {
                    for (LOtherMatNo = MatNo + 1; LOtherMatNo <= LNumberOfSoils; LOtherMatNo ++)
                    {
                        LOtherSoilGroup = FSoilData[VarArr[LOtherMatNo - 1][1]].SoilGroup;
                        // both materials belong to the same group
                        if ((LSoilGroup == LOtherSoilGroup))
                        {
                            // correlation between parameters of those groupes
                            // first see if they are from the same material strength type
                            LStrengthType2 = FSoilData[VarArr[MatNo - 1][1]].MaterialStrength;
                            LStrengthType1 = FSoilData[VarArr[LOtherMatNo - 1][1]].MaterialStrength;
                            if ((LStrengthType1 == TMatStrengthTypeSet.mstNone))
                            {
                                LStrengthType1 = FModelData.DefaultStrength;
                            }
                            if ((LStrengthType2 == TMatStrengthTypeSet.mstNone))
                            {
                                LStrengthType2 = FModelData.DefaultStrength;
                            }
                            // StrengthType := GetStrengthType;
                            if ((LStrengthType1 == LStrengthType2))
                            {
                                // All variables in material are correlated
                                for (LVarLoop = VarArr.GetLowerBound(0) + 1; LVarLoop <= VarArr.GetUpperBound(0); LVarLoop ++)
                                {
                                    // find the order list of the variables
                                    if ((Convert.ToInt32(VarArr[MatNo - 1][LVarLoop]) == 1) && (Convert.ToInt32(VarArr[LOtherMatNo - 1][LVarLoop]) == 1))
                                    {
                                        FWithCorrelation = true;
                                        LNStochastic2 = GetStochasticNumber(FVarArr, MatNo - 1, LVarLoop);
                                        LNStochastic1 = GetStochasticNumber(FVarArr, LOtherMatNo - 1, LVarLoop);
                                        nextCorrel ++;
                                        FCorrelArr = ArraySupport.CreateJaggedArray(3, 3);
                                        CorrelArr[0][nextCorrel - 1] = LNStochastic1;
                                        CorrelArr[1][nextCorrel - 1] = LNStochastic2;
                                        // For the time being only full correlation is asumed
                                        // LfixedCorrelCoef := correl[ MatNo - 1, LOtherMatNo - 1];
                                        CorrelArr[2][nextCorrel - 1] = LfixedCorrelCoef;
                                        // CorrelationCPhi;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            // ... Stochastic variable of degree of consolidation ...
            // LReference := ModelFactor.Reference;
            LReference = FProbabilisticDefaults.ConsolidationCoefTotalStdDev;
            LRefDistribution = FProbabilisticDefaults.ConsolidationCoefDistribution;
            // next statement only to remove hint
            try
            {
                if ((LReference > 1.0E-8))
                {
                    // nu kijken waar de aanpasings percentages zitten
                    // alleen voor de beschouwde lagen inlayers
                    next = 0;
                    // all layers present
                    LNLayers = InterfaceData.Layers.Length;
                    // Create the aanpas array with all the relevant data
                    for (i = 0; i < FNSlices; i ++)
                    {
                        LInLayer = Slices[i].InLayer;
                        // See if the aanpasarr excists
                        Found = false;
                        for (j = 0; j < FAanpasArr.Length; j ++)
                        {
                            Found = (LInLayer == AanpasArr[j][0]);
                            if (Found)
                            {
                                break;
                            }
                        }
                        // the inlayer array is not yet found create a new one
                        if (!Found)
                        {
                            // indien het materiaal er nog niet inzit maak dan een nieuw aan
                            next++;
                            // de 2e dimensie is het aantal lagen  + laag zelf
                            FAanpasArr = ArraySupport.ExtendJaggedArray(FAanpasArr, next, LNLayers + 1);
                            // de eerste positie is om de laag waarop de aanpassing werkt te bepalen
                            AanpasArr[next - 1][0] = LInLayer;
                            // Initialiseer deze lagen
                            for (k = 1; k <= LNLayers; k ++)
                            {
                                AanpasArr[next - 1][k] = 0;
                            }
                            // Find Degree of consolidation for these parts
                            for (LFromLayer = 1; LFromLayer <= LNLayers; LFromLayer ++)
                            {
                                LAanpasPercentage = Convert.ToInt32(FDegreeOfConsolidationSoil[LFromLayer - 1][LInLayer]);
                                if ((LAanpasPercentage > 0) && (LAanpasPercentage < 100))
                                {
                                    FEx.Add(LAanpasPercentage/100.0);
                                    FX.Add(LAanpasPercentage/100.0);
                                    FSx.Add(4*LReference/100.0*(1 - LAanpasPercentage/100.0)*LAanpasPercentage/100.0);
                                    AanpasArr[next - 1][LFromLayer] = 1;
                                    FAParamName.Add((LInLayer).ToString() + ' ' + Constants.sDOC);
                                    FVerdeling.Add((int) LRefDistribution);
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception E)
            {
                Lstr = E.Message;
                throw E;
            }
            // ...  modelfactor (limit value) ...
            FLimitvalueStDev = 0;
            FLimitValue = 0;
            FLimitVerdeling = 2;
            if ((FModelData.CalcType == TCalculationTypeSet.csBishop))
            {
                FLimitValue = FProbabilisticDefaults.LimitValueBishopMean;
                FLimitvalueStDev = FProbabilisticDefaults.LimitValueBishopStdDev;
                FLimitVerdeling = ((int) FProbabilisticDefaults.LimitValueBishopDistribution);
            }
            else
            {
                if ((FModelData.CalcType == TCalculationTypeSet.csLift))
                {
                    FLimitValue = FProbabilisticDefaults.LimitValueVanMean;
                    FLimitvalueStDev = FProbabilisticDefaults.LimitValueVanStdDev;
                    FLimitVerdeling = ((int) FProbabilisticDefaults.LimitValueVanDistribution);
                }
            }
            FLimitvalueModel = FLimitValue;
            if ((FLimitvalueStDev > 1.0E-8))
            {
                FEx.Add(FLimitValue);
                FX.Add(FLimitValue);
                FSx.Add(FLimitvalueStDev);
                FAParamName.Add('-' + ' ' + Constants.sLimitVal);
                FVerdeling.Add(FLimitVerdeling);
            }
        }

        // =======================================================================================================================
        // Description: Fills the mean value and standard deviation array
        //
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================

        // =======================================================================================================================
        // Description   : Probabilistic pore pressures. Note that the sequence of calling
        // the variables must be correct so first coh and phi then pore pressures and
        // then the cu e.d.
        //
        // Date        ID   Modification
        // 2004-01-21  Best Created
        // =======================================================================================================================
        private void CheckPorePressures(int AMatNo, TStabSoilData ASoil, ref int[][] Vararr, List<double> X, List<double> Ex, List<double> Sx, List<int> Verdeling, List<string> AParamName)
        {
            int LVerdeling;
            if ((ASoil.StdPn > 1.0E-8))
            {
                Vararr[AMatNo - 1][4] = 1;
                Ex.Add(0);
                X.Add(0);
                Sx.Add(ASoil.StdPn);
                LVerdeling = ((int) ASoil.DistPn);
                AParamName.Add(AMatNo.ToString() + ' ' + Constants.sPnlevel);
                // lognormal not allowed with mean value of 0
                if ((LVerdeling == 3))
                {
                    LVerdeling = 2;
                }
                Verdeling.Add(LVerdeling);
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================
        private void FINITVP()
        {
            for (int i = 0; i < NStochastic; i++)
            {
                for (int j = 0; j <= 3; j ++)
                {
                    Vp[j][i] = 0.0;
                }
                for (int j = 4; j <= 9; j ++)
                {
                    Vp[j][i] = 1.0;
                }
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================
        private void FINITCOV()
        {
            int i;
            int j;
            for (i = 0; i < NStochastic; i++)
            {
                for (j = 0; j < NStochastic; j++)
                {
                    Covariantie[i][j] = 0.0;
                }
                Covariantie[i][i] = 1.0;
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================
        private void AddMeasuredCuData(int AMatNo, TStabSoilData ASoil, ref int[][] Vararr, List<double> X, List<double> Ex, List<double> Sx, List<int> Verdeling, List<string> AParamName)
        {
            TConvertTypeSet LConvert;
            double LCUTop;
            int LMat;
            CheckPorePressures(AMatNo, ASoil, ref Vararr, X, Ex, Sx, Verdeling, AParamName);
            if ((ASoil.StdCu > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctCuTop;
                LCUTop = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][5] = 1;
                FEx.Add(LCUTop);
                FX.Add(LCUTop);
                FSx.Add(ASoil.StdCu);
                FVerdeling.Add(((int) ASoil.DistCu));
                LMat = Convert.ToInt32(Vararr[AMatNo - 1][1]);
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sCu);
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2006-03-08  Best Created
        // =======================================================================================================================
        private void AddGradientCuData(int AMatNo, TStabSoilData ASoil, ref int[][] Vararr, List<double> X, List<double> Ex, List<double> Sx, List<int> Verdeling, List<string> AParamName)
        {
            TConvertTypeSet LConvert;
            double LCUTop;
            double LCuGradient;
            int LMat;
            CheckPorePressures(AMatNo, ASoil, ref Vararr, X, Ex, Sx, Verdeling, AParamName);
            LMat = Vararr[AMatNo - 1][1];
            if ((ASoil.StdCu > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctCuGradientTop;
                LCUTop = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][5] = 1;
                FEx.Add(LCUTop);
                FX.Add(LCUTop);
                FSx.Add(ASoil.StdCu);
                FVerdeling.Add(((int) ASoil.DistCu));
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sCu);
            }
            if ((ASoil.StdCuGradient > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctCuGradient;
                LCuGradient = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][8] = 1;
                FEx.Add(LCuGradient);
                FX.Add(LCuGradient);
                FSx.Add(ASoil.StdCuGradient);
                FVerdeling.Add(((int) ASoil.DistCuGradient));
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sCugrad);
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================
        private void AddCalculatedCuData(int AMatNo, TStabSoilData ASoil, ref int[][] Vararr, List<double> X, List<double> Ex, List<double> Sx, List<int> Verdeling, List<string> AParamName)
        {
            TConvertTypeSet LConvert;
            double LRatioCuPc;
            double LRatioCuPcActive;
            double LRatioCuPcPassive;
            double LPop;
            int LMat;
            CheckPorePressures(AMatNo, ASoil, ref Vararr, X, Ex, Sx, Verdeling, AParamName);
            LMat = Convert.ToInt32((Vararr[AMatNo - 1][1]));
            if ((ASoil.StdRatioCuPc > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctRatioCuPc;
                LRatioCuPc = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][6] = 1;
                FEx.Add(LRatioCuPc);
                FX.Add(LRatioCuPc);
                FSx.Add(ASoil.StdRatioCuPc);
                FVerdeling.Add(((int) ASoil.DistRatioCuPc));
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sRatioCuPc);
            }
            if ((ASoil.StdRatioCuPcActive > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctRatioCuPcActive;
                LRatioCuPcActive = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][9] = 1;
                FEx.Add(LRatioCuPcActive);
                FX.Add(LRatioCuPcActive);
                FSx.Add(ASoil.StdRatioCuPcActive);
                FVerdeling.Add(((int) ASoil.DistRatioCuPcActive));
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sActiveRatioCuPc);
            }
            if ((ASoil.StdRatioCuPcPassive > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctRatioCuPcPassive;
                LRatioCuPcPassive = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][10] = 1;
                FEx.Add(LRatioCuPcPassive);
                FX.Add(LRatioCuPcPassive);
                FSx.Add(ASoil.StdRatioCuPcPassive);
                FVerdeling.Add(((int) ASoil.DistRatioCuPcPassive));
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sPassiveRatioCuPc);
            }
            if ((ASoil.StdPOP > 1.0E-8))
            {
                LConvert = TConvertTypeSet.ctPop;
                LPop = FSoilParameterConversion.GetSoilParameterValue(LConvert, ASoil, ASoil.CalculationOptions, ASoil.ModelData, FProbabilisticDefaults);
                Vararr[AMatNo - 1][11] = 1;
                FEx.Add(LPop);
                FX.Add(LPop);
                FSx.Add(ASoil.StdPOP);
                FVerdeling.Add(((int) ASoil.DistPOP));
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sPop);
            }
        }

        // =======================================================================================================================
        // Description: Get the average stress from a soilgroup along a slide plane
        //
        // Date        ID   Modification
        // 2003-12-01  Best Created
        // =======================================================================================================================
        private double GetAverageStress(int AGroupNumber, int NSlices, Tslice[] Slices)
        {
            double result;
            int i;
            double Length;
            double StressOverLength;
            Length = 0;
            StressOverLength = 0;
            for (i = 0; i < NSlices; i ++)
            {
                if ((Slices[i].SoilGroupNumber == AGroupNumber))
                {
                    Length = Length + Slices[i].ArcLength;
                    StressOverLength = StressOverLength + Slices[i].ArcLength*Slices[i].EffectiveStress;
                }
            }
            if ((Length == 0))
            {
                result = 0;
            }
            else
            {
                result = StressOverLength/Length;
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================
        private void AddStressTabData(int AMatNo, TStabSoilData ASoil, ref int[][] Vararr, List<double> X, List<double> Ex, List<double> Sx, List<int> Verdeling, int NSlices, Tslice[] Slices, List<string> AParamName)
        {
            double LAverageLevel;
            int LMat;
            CheckPorePressures(AMatNo, ASoil, ref Vararr, X, Ex, Sx, Verdeling, AParamName);
            LMat = Convert.ToInt32(Vararr[AMatNo - 1][1]);
            if (ASoil.UseProbDefaults)
            {
                if ((FProbabilisticDefaults.StressTableVariationTotal > 1.0E-8))
                {
                    Vararr[AMatNo - 1][7] = 1;
                    FEx.Add(ASoil.StresstableFactor);
                    FX.Add(ASoil.StresstableFactor);
                    FSx.Add(Constants.CNormValue*FProbabilisticDefaults.StressTableVariationTotal);
                    FVerdeling.Add(((int) ASoil.DistStressTable));
                    FAParamName.Add((LMat).ToString() + ' ' + Constants.sStressTablefactor);
                }
            }
            else
            {
                // if not use prob defaults
                // calculate std from mean and design values
                TStressTable _wvar1 = ASoil.StressTable;
                LAverageLevel = GetAverageStress(ASoil.SoilGroup, NSlices, Slices);
                Vararr[AMatNo - 1][7] = 1;
                FEx.Add(Constants.CNormValue);
                FX.Add(Constants.CNormValue);
                FAParamName.Add((LMat).ToString() + ' ' + Constants.sStressTableNormvalue);
                if ((ASoil.DistStressTable == TDistributionTypeSet.dsNormal))
                {
                    FSx.Add(Constants.CNormValue*_wvar1.GetNormalCoefOfVariation(LAverageLevel));
                }
                else
                {
                    if ((ASoil.DistStressTable == TDistributionTypeSet.dsLogNormal))
                    {
                        FSx.Add(Constants.CNormValue*_wvar1.GetLogNormalCoefOfVariation(LAverageLevel));
                    }
                    else
                    {
                        FSx.Add(Constants.CNormValue);
                    }
                }
                FVerdeling.Add(((int) ASoil.DistStressTable));
            }
        }

        // =======================================================================================================================
        // Description: Get the variable number in the stochastic array
        // If a Stochastic number is present a 1 is in the vararr
        //
        // Date        ID   Modification
        // 2003-12-15  Best Created
        // =======================================================================================================================
        private int GetStochasticNumber(int[][] AVararr, int AMatNumber, int AVarNumber)
        {
            int result;
            int i;
            int j;
            result = 0;
            for (i = 0; i < AMatNumber; i ++)
            {
                for (j = AVararr[i].GetLowerBound(0) + 1; j <= AVararr[i].GetUpperBound(0); j ++)
                {
                    if ((AVararr[i][j] > 0.5))
                    {
                        result ++;
                    }
                }
            }
            for (j = 2; j <= AVarNumber; j ++)
            {
                if ((AVararr[AMatNumber][j] > 0.5))
                {
                    result ++;
                }
            }
            return result;
        }

        // LSoil := FSoilData[SoilNumber];
        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================

        // =======================================================================================================================
        // Date        ID   Modification
        // 2003-11-17  Best Created header
        // =======================================================================================================================
        private void GetCohesionAndPhi(ref Tslice ASlice)
        {
            double LCuGem = 0;
            double LCuActief = 0;
            double LCuPasief = 0;
            double LCU = 0;
            double LZLayerTop = 0;
            double LZLayerBottom = 0;
            int LPoint = 0;
            double LocPhi = 0;
            double LocCoh = 0;
            switch (ASlice.StrengthType)
            {
                case TMatStrengthTypeSet.mstCphi:
                    ASlice.PhiBottom = FSoilData[ASlice.SoilNumber].Phi;
                    ASlice.CohBottom = FSoilData[ASlice.SoilNumber].Cohesion;
                    break;
                case TMatStrengthTypeSet.mstStressTab:
                    FSoilData[ASlice.SoilNumber].StressTable.GetCohPhiAvg(ASlice.EffectiveStress, ref LocCoh, ref LocPhi, FSoilData[ASlice.SoilNumber].StresstableFactor/Constants.CNormValue, ref LPoint);
                    ASlice.PhiBottom = LocPhi;
                    ASlice.CohBottom = LocCoh;
                    break;
                case TMatStrengthTypeSet.mstMeasuredCu:
                    TStabSoilData _wvar1 = FSoilData[ASlice.SoilNumber];
                    LCuGem = ASlice.InterpolationFactorCu*(_wvar1.CuTop - _wvar1.CuBottom) + _wvar1.CuBottom;
                    LCuActief = ASlice.InterpolationFactorCu*(_wvar1.CuActiveTop - _wvar1.CuActiveBottom) + _wvar1.CuActiveBottom;
                    LCuPasief = ASlice.InterpolationFactorCu*(_wvar1.CuPassiveTop - _wvar1.CuPassiveBottom) + _wvar1.CuPassiveBottom;
                    if ((ASlice.IsInActiveArea))
                    {
                        LCU = (LCuGem + (LCuActief - LCuGem)*Math.Sin(2*Math.Abs(ASlice.BottomAngle)));
                    }
                    else
                    {
                        LCU = (LCuGem - (LCuGem - LCuPasief)*Math.Sin(2*Math.Abs(ASlice.BottomAngle)));
                    }
                    ASlice.Cu = LCU;
                    ASlice.PhiBottom = 0;
                    ASlice.CohBottom = LCU;
                    break;
                case TMatStrengthTypeSet.mstCalculatedCu:
                    TStabSoilData _wvar2 = FSoilData[ASlice.SoilNumber];
                    LCuActief = _wvar2.RatioCuPcActive;
                    LCuPasief = _wvar2.RatioCuPcPassive;
                    LCuGem = _wvar2.RatioCuPc;
                    if ((ASlice.IsInActiveArea))
                    {
                        LCU = Math.Max(ASlice.PreLoadStress + _wvar2.POP, ASlice.EffectiveStress)*(LCuGem + (LCuActief - LCuGem)*Math.Sin(2*Math.Abs(ASlice.BottomAngle)));
                    }
                    else
                    {
                        LCU = Math.Max(ASlice.PreLoadStress + _wvar2.POP, ASlice.EffectiveStress)*(LCuGem - (LCuGem - LCuPasief)*Math.Sin(2*Math.Abs(ASlice.BottomAngle)));
                    }
                    ASlice.Cu = LCU;
                    ASlice.PhiBottom = 0;
                    ASlice.Cu = LCU;
                    ASlice.CohBottom = LCU;
                    break;
                case TMatStrengthTypeSet.mstGradientCu:
                    // ... Cu Gradient  ...
                    ASlice.Vertical.DetermineTopAndBottomFromLayer(ASlice.ZBottomMid, ref LZLayerTop, ref LZLayerBottom);
                    ASlice.Vertical.DetermineTopAndBottomFromLayer(ASlice.ZBottomMid, ref LZLayerTop, ref LZLayerBottom);
                    LCU = FSoilData[ASlice.SoilNumber].CuTop + (LZLayerTop - ASlice.ZBottomMid)*FSoilData[ASlice.SoilNumber].CuGradient;
                    ASlice.Cu = LCU;
                    ASlice.PhiBottom = 0;
                    ASlice.CohBottom = LCU;
                    break;
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-05-27       Created
        // =======================================================================================================================
    }

    // end TMStabProbabilisticData
}

namespace Deltares.Stability.Calculation.Inner
{
    public class MStabProbabilisticData
    {
        public const string CCohName = "Cohesion ";
        public const string CPhiName = "Phi ";
        public const string CPorePresurename = "Pore pressure ";
        public const string CUMeasuredname = "Cu measured ";
        public const string CUCalculatedname = "Cu calculated ";
        public const string CuStressTableName = "StressTable ";
        public const string CuGradientName = "Cu gradient";
        public const string CUCalcPassivename = "Cu calc. passive";
        public const string CUCalcActivename = "Cu calc. passive";
        public const string CPopName = "Pop";
    }

    // end MStabProbabilisticData
}