using MetroGauges.General;

using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;

namespace MetroGauges.Model
{
    /// <summary>
    /// MetroGaugeFormulae(限界计算公式)
    /// </summary>
    public class KineModel : DataModel
    {
        public KineModel() { }
        public KineModel(string strPosition, string name, double x, double y)
        {
            StrPosition = strPosition;
            Name = name;
            X = x;
            Y = y;
        }
        /// <summary>
        /// 所在位置
        /// </summary>
        public override PositionI Position
        {
            get
            {
                if (StrPosition == "受电弓")
                {
                    return PositionI.Pantograph;
                }
                else if (StrPosition == "受流器")
                {
                    return PositionI.Collector;
                }
                else if (StrPosition == "车体")
                {
                    return PositionI.Body;
                }
                else if (StrPosition == "转向架构架")
                {
                    return PositionI.BogieFrame;
                }
                else if (StrPosition == "簧下")
                {
                    return PositionI.Unsprung;
                }
                else if (StrPosition == "轮缘")
                {
                    return PositionI.Rim;
                }
                else if (StrPosition == "踏面")
                {
                    return PositionI.Tread;
                }
                else
                {
                    return PositionI.INVAIL;
                }
            }
        }

        #region Parameters
        /// <summary>
        /// A型车：B型车
        /// </summary>
        public static NMetro nMetro;
        /// <summary>
        /// 工况
        /// </summary>
        public static WorkCondition Condition;
        /// <summary>
        /// 上受流切除向上：下受流释放反弹量
        /// </summary>
        public static CollectorStatus collectorStatus;
        /// <summary>
        /// 车辆限界-整体道床：碎石道床
        /// </summary>
        public static Ballast m_Bal;
        /// <summary>
        /// 站台：区间
        /// </summary>
        public static Location location;
        /// <summary>
        /// 直线：曲线
        /// </summary>
        public static CurveType CurType;
        /// <summary>
        /// 车辆运行环境
        /// </summary>88
        public static General.Environment Env;
        /// <summary>
        /// 判断高度阀点数
        /// </summary>
        public static HeightValve heightValve;
        /// <summary>
        /// 接触网物理性质
        /// </summary>
        public static Physics Catenary;
        /// <summary>
        /// 车轮物理性质
        /// </summary>
        public static Physics Wheel;
        /// <summary>
        /// 高架受电弓高度
        /// </summary>
        public static ElvateHeight Eh;
        /// <summary>
        /// 销内：销外
        /// </summary>
        public static Pin pin;
        /// <summary>
        /// 车辆结构
        /// </summary>
        public static Structure structure;
        /// <summary>
        /// 含钢轨内侧磨耗的最大轨距(mm)
        /// </summary>
        private double l => 1441;
        /// <summary>
        /// 轮对轮缘最大磨耗量时的最小外侧距(mm)
        /// </summary>
        private double d => 1397;
        /// <summary>
        /// 线路中心线横向位差值(mm)
        /// </summary>
        private double Δ_c
        {
            get
            {
                switch (m_Bal)
                {
                    case Ballast.Monolithic:
                        return 5;
                    case Ballast.Gravel:
                        return 25;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架轴箱轴承横向游隙(mm)
        /// </summary>
        private double Δ_q1 => 1;
        /// <summary>
        /// 车轮横向弹性变形量（mm）
        /// </summary>
        private double Δ_q2
        {
            get
            {
                switch (Wheel)
                {
                    case Physics.Flexibility:
                        return 2;
                    case Physics.Inflexibility:
                        return 0;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架一系弹簧横向弹性变形量（mm）
        /// </summary>
        private double Δ_q3
        {
            get
            {
                switch (location)
                {
                    case Location.Platform:
                        return 3;
                    case Location.Region:
                        return 6;
                    default:
                        return double.NaN;
                }

            }
        }
        /// <summary>
        /// 转向架中心销径向间隙及磨耗量（mm）
        /// </summary>
        private double Δ_w1 => 0;

        #region 用户设置参数
        //public  double result => 15;
        private static double δ_w2;
        /// <summary>
        /// 转向架二系弹簧相对名义中心位置的横向弹性变形量（mm）15~20:20~25
        /// </summary>
        public double Δ_w2 { get => δ_w2; set { δ_w2 = value; OnPropertyChanged(); } }
        //{
        //    get
        //    {
        //switch (loc)
        //{
        //    case Location.Platform:
        //        if (result >= 15 && result <= 20)
        //        {
        //            return result;
        //        }
        //        else
        //        {
        //            throw new ArgumentOutOfRangeException("Δ_w2需在15~20mm之间");
        //        }
        //    case Location.Region:
        //        if (result >= 20 && result <= 25)
        //        {
        //            return result;
        //        }
        //        else
        //        {
        //            throw new ArgumentOutOfRangeException("Δ_w2需在20~25mm之间");
        //        }
        //    default:
        //        return double.NaN;
        //}
        //}
        //set
        //{
        //double result = 15;
        //if (loc == Location.Platform)
        //{
        //    if (value > 15 && value < 20)
        //    {
        //        result = value;
        //    }
        //    else
        //    {
        //        throw new ArgumentOutOfRangeException("位于站台时，Δ_w2需在15~20mm之间");
        //    }
        //}
        //else if (loc == Location.Region)
        //{
        //    if (value > 20 && value < 25)
        //    {
        //        result = value;
        //    }
        //    else
        //    {
        //        throw new ArgumentOutOfRangeException("位于区间时，Δ_w2需在20~25mm之间");
        //    }
        //}
        //}
        //}
        private static double δX_Bxgpx;
        /// <summary>
        /// 悬挂故障引起的车体横向偏移量（mm）
        /// </summary>
        public double ΔX_Bxgpx { get => δX_Bxgpx; set { δX_Bxgpx = value; OnPropertyChanged(); } }

        private static double δY_Bxgpx1;
        /// <summary>
        /// 悬挂故障引起的车体竖向向上偏移量（mm）
        /// </summary>
        public double ΔY_Bxgpx1 { get => δY_Bxgpx1; set { δY_Bxgpx1 = value; OnPropertyChanged(); } }

        private static double δY_Bxgpx2;
        /// <summary>
        /// 悬挂故障引起的车体竖向向下偏移量（mm）
        /// </summary>
        public double ΔY_Bxgpx2 { get => δY_Bxgpx2; set { δY_Bxgpx2 = value; OnPropertyChanged(); } }
        /// <summary>
        /// 转向架高度阀杆横向间距（mm）
        /// </summary>
        private double _b_h;
        public double b_h { get => _b_h; set { _b_h = value; OnPropertyChanged(); } }
        /// <summary>
        /// 计算ΔXa 或ΔXi 时取线路最小平面曲线半径（m）
        /// </summary>
        public double R_min;
        /// <summary>
        /// 设备限界在曲线地段标准加宽量（mm）
        /// </summary>
        public double ΔX_bz;
        /// <summary>
        /// 车体销外AW3 上翘量/AW0 下垂量或车体销内AW0上拱量（mm）
        /// </summary>
        public double ΔM_t9
        {
            get
            {
                switch (pin)
                {
                    case Pin.Inside:
                        switch (Condition)
                        {
                            case WorkCondition.AW0:
                                return 8;
                            case WorkCondition.AW3:
                                return 0;
                            default:
                                return 0;
                        }
                    case Pin.Outside:
                        switch (Condition)
                        {
                            case WorkCondition.AW0:
                                return -5;
                            case WorkCondition.AW3:
                                return 0;
                            default:
                                return 0;
                        }
                    default:
                        return double.NaN;
                }
            }
        }
        private static double _n;
        private static double _m;
        /// <summary>
        /// 转向架计算断面至相邻轴距离
        /// </summary>
        public double m { get => _m; set { _m = value; OnPropertyChanged(); } }
        /// <summary>
        /// 车体计算断面至相邻中心销距离
        /// </summary>
        public double n { get => _n; set { _n = value; OnPropertyChanged(); } }

        private static double δX_txgpx;
        /// <summary>
        /// 悬挂故障引起的构架横向偏移量（mm）
        /// </summary>
        public double ΔX_txgpx { get => δX_txgpx; set { δX_txgpx = value; OnPropertyChanged(); } }

        private static double δY_txgpx1;
        /// <summary>
        /// 悬挂故障引起的构架竖向向上偏移量（mm）
        /// </summary>
        public double ΔY_txgpx1 { get => δY_txgpx1; set { δY_txgpx1 = value; OnPropertyChanged(); } }
        private static double δY_txgpx2;
        /// <summary>
        /// 悬挂故障引起的构架竖向向下偏移量（mm）
        /// </summary>
        public double ΔY_txgpx2 { get => δY_txgpx2; set { δY_txgpx2 = value; OnPropertyChanged(); } }
        /// <summary>
        /// 曲线加宽校验补偿量（mm）（A2B2受电弓，A1B1撤下与接触轨接近部分轮廓线校核时）
        /// </summary>
        private double _ΔX => 0;
        #endregion

        /// <summary>
        /// 轨道横向弹性变形量（mm）
        /// </summary>
        private double Δ_e
        {
            get
            {
                switch (CurType)
                {
                    case CurveType.Straight:
                        return 1;
                    case CurveType.Curve:
                        return 3;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// AW3 时载客不对称的计算载客重量（kg），AW0 时不对称的计算,载客重量为0
        /// </summary>
        public double m_z
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 12600;
                    case NMetro.B:
                        return 10200;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架高度阀不感度（mm）
        /// </summary>
        private double _f_2 => 5;
        /// <summary>
        /// 两条钢轨的相对高度误差值（mm）
        /// </summary>
        public double Δh_c1
        {
            get
            {
                switch (m_Bal)
                {
                    case Ballast.Monolithic:
                        return 4;
                    case Ballast.Gravel:
                        return 10;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 两条钢轨的相对高度的弹性变化量（mm）
        /// </summary>
        public double Δh_c2
        {
            get
            {
                switch (m_Bal)
                {
                    case Ballast.Monolithic:
                        return 1;
                    case Ballast.Gravel:
                        return 2;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 车体受风面积（m2）
        /// </summary>
        private double A_w
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 70;
                    case NMetro.B:
                        return 57;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 风压 (N/m2)
        /// </summary>
        private double P_w
        {
            get
            {
                switch (location)
                {
                    case Location.Platform:
                        return 210;
                    case Location.Region:
                        return 400;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 横向加速度（m/s2）
        /// </summary>
        public double a_B
        {
            get
            {
                switch (location)
                {
                    case Location.Platform:
                        switch (CurType)
                        {
                            case CurveType.Straight:
                                return 0.3;
                            case CurveType.Curve:
                                return 0.6;
                            default:
                                return double.NaN;
                        }
                    case Location.Region:
                        return 1.0;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 受电弓相对车体横向晃动量（mm）
        /// </summary>
        public double ΔS_hd => 25;
        /// <summary>
        /// 轮对横向制造误差值（mm）
        /// </summary>
        public double Δ_d => 2;
        /// <summary>
        /// 转向架中心销安装定位误差值（mm）
        /// </summary>
        public double ΔM_t1 => 1;
        /// <summary>
        /// 转向架一系弹簧横向定位误差值（mm）
        /// </summary>
        public double ΔM_t2 => 1;
        /// <summary>
        /// 车体半宽横向制造误差值（mm）
        /// </summary>
        public double ΔM_t3 => 5;
        /// <summary>
        /// 车体表面设备安装误差值（mm）
        /// </summary>
        public double ΔM_t4 => 2;
        /// <summary>
        /// 受电弓横向安装误差值（mm）
        /// </summary>
        private double ΔM_t5 => 5;
        /// <summary>
        /// 车体倾斜量（mm）
        /// </summary>
        private double ΔX_Bq => 15;
        /// <summary>
        /// 车体侧墙高度（mm）
        /// </summary>
        private double H_cq
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 2500;
                    case NMetro.B:
                        return 2300;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 车底架边梁底面距轨顶平面高度（mm）
        /// </summary>
        private double h_sj
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 870;
                    case NMetro.B:
                        return 870;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 车辆一侧一系弹簧并列数
        /// </summary>
        private double n_p => 4;
        /// <summary>
        /// 每一轴箱一系弹簧垂向刚度值 (N/mm)
        /// </summary>
        private double c_p
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 1200;
                    case NMetro.B:
                        return 1200;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架一系弹簧横向间距（mm）
        /// </summary>
        private double b_p
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 1940;
                    case NMetro.B:
                        return 1930;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 车辆一侧二系弹簧并列数，四点高度阀为2，三点高度阀为1，二点高度阀为0
        /// </summary>
        private double n_s
        {
            get
            {
                switch (heightValve)
                {
                    case HeightValve.Two:
                        return 0;
                    case HeightValve.Three:
                        return 1;
                    case HeightValve.Four:
                        return 2;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架一侧二系弹簧垂向刚度值 (N/mm)
        /// </summary>
        private double c_s
        {
            get
            {
                switch (Condition)
                {
                    case WorkCondition.AW0:
                        return 200;
                    case WorkCondition.AW3:
                        switch (nMetro)
                        {
                            case NMetro.A:
                                return 350;
                            case NMetro.B:
                                return 400;
                            default:
                                return double.NaN;
                        }
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架二系弹簧横向间距（mm）
        /// </summary>
        private double b_s
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 1880;
                    case NMetro.B:
                        return 1850;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 每根抗侧滚扭杆的抗侧滚刚度(N.mm/rad)
        /// </summary>
        private double K_φn
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 2.5 * 1E9;
                    case NMetro.B:
                        return 2.5 * 1E9;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// AW0 或含AW3 载客的车体重量（kg）
        /// </summary>
        public double m_B
        {
            get
            {
                switch (Condition)
                {
                    case WorkCondition.AW0:
                        return 23400;
                    case WorkCondition.AW3:
                        switch (nMetro)
                        {
                            case NMetro.A:
                                return 48000;
                            case NMetro.B:
                                return 42000;
                            default:
                                return double.NaN;
                        }
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 重力加速度（m/s2），取9.81m/s2
        /// </summary>
        private double g => 9.81;
        /// <summary>
        /// 车体重心距轨顶平面高度（mm）
        /// </summary>
        private double h_sc
        {
            get
            {
                switch (Condition)
                {
                    case WorkCondition.AW0:
                        switch (nMetro)
                        {
                            case NMetro.A:
                                return 1600;
                            case NMetro.B:
                                return 1450;
                            default:
                                return double.NaN;
                        }
                    case WorkCondition.AW3:
                        switch (nMetro)
                        {
                            case NMetro.A:
                                return 1800;
                            case NMetro.B:
                                return 1650;
                            default:
                                return double.NaN;
                        }
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架一系弹簧上支承面距轨顶平面高度（mm）
        /// </summary>
        private double h_cp
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 500;
                    case NMetro.B:
                        return 500;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架二系弹簧上支承面距轨顶平面高度（mm）
        /// </summary>
        private double h_cs
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 890;
                    case NMetro.B:
                        return 860;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 车体受风面积形心距轨顶平面高度（mm）
        /// </summary>
        private double h_sw
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 2350;
                    case NMetro.B:
                        return 2350;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 车辆地板面未能补赏的高度误差值（mm）
        /// </summary>
        private double ΔM_t6 => 10;
        /// <summary>
        /// 车体下部及吊挂物高度尺寸制造安装误差值（mm）
        /// </summary>
        private double ΔM_t7 => -10;
        /// <summary>
        /// 车体上部或上部安装设备的高度尺寸制造安装误差值（mm）
        /// </summary>
        private double ΔM_t8 => 12;
        /// <summary>
        /// 转向架构架横向制造误差值（mm）
        /// </summary>
        private double ΔM_t10
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 2;
                    case NMetro.B:
                        return 2;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架构架向上竖向制造误差值（mm）
        /// </summary>
        private double ΔM_t11
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 1.5;
                    case NMetro.B:
                        return 1.5;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架构架向下竖向制造误差值（mm）；
        /// </summary>
        private double ΔM_t12
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 1.5;
                    case NMetro.B:
                        return 1.5;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架簧下部分横向制造误差值（mm）
        /// </summary>
        private double ΔM_t13 => 1;
        /// <summary>
        /// 转向架簧下部分竖向制造误差值（mm）
        /// </summary>
        private double ΔM_t14
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 1;
                    case NMetro.B:
                        return 1;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 受流器横向安装误差值及受流器横向尺寸公差值（mm）
        /// </summary>
        private double ΔM_t15 => 2;
        /// <summary>
        /// 受流器竖向安装误差值及受流器竖向尺寸公差值（mm）
        /// </summary>
        private double ΔM_t16 => 2;
        /// <summary>
        /// 转向架一系弹簧竖向动挠度（mm）
        /// </summary>
        private double Δf_p
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 12;
                    case NMetro.B:
                        return 15;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架二系弹簧竖向动挠度（mm）
        /// </summary>
        private double Δf_s
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 15;
                    case NMetro.B:
                        return 20;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 线路中心线竖向位差值（mm）
        /// </summary>
        private double δ_c
        {
            get
            {
                switch (m_Bal)
                {
                    case Ballast.Monolithic:
                        return 5;
                    case Ballast.Gravel:
                        return 10;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 轨道竖向弹性变形量（mm）
        /// </summary>
        private double δ_e
        {
            get
            {
                switch (m_Bal)
                {
                    case Ballast.Monolithic:
                        return -2;
                    case Ballast.Gravel:
                        return -5;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 轨道竖向磨耗量（mm）
        /// </summary>
        private double δ_w0 => 10.0;
        /// <summary>
        /// 车轮最大镟削量（mm）
        /// </summary>
        private double δ_w1 => -35.0;
        /// <summary>
        /// 两次镟轮间不可补偿的踏面磨耗量（mm）
        /// </summary>
        private double _δ_w1
        {
            get
            {
                switch (Position)
                {
                    case PositionI.Body:
                        return -12;
                    case PositionI.Rim:
                        return -8;
                    default:
                        return δ_w1;
                }
            }
        }
        /// <summary>
        /// 转向架一系弹簧空重车挠度变化量
        /// </summary>
        private double f_1
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return -25;
                    case NMetro.B:
                        return -19;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架一系弹簧垂向永久变形量（mm）
        /// </summary>
        private double f_01 => -5.0;
        /// <summary>
        /// 车轮竖向弹性变形量（mm）
        /// </summary>
        private double _f_01
        {
            get
            {
                switch (Wheel)
                {
                    case Physics.Flexibility:
                        return -1;
                    case Physics.Inflexibility:
                        return 0;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架二系弹簧垂向永久变形量（mm）
        /// </summary>
        private double f_02 => 0;
        /// <summary>
        /// 转向架二系弹簧空重车挠度变化量（mm）
        /// </summary>
        private double f_2 => 5.0;
        /// <summary>
        /// 车辆定距
        /// </summary>
        public double a
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 15700;
                    case NMetro.B:
                        return 12600;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 转向架固定轴距 A:2.5 B 2.2,2.3
        /// </summary>
        public double p
        {
            get
            {
                switch (nMetro)
                {
                    case NMetro.A:
                        return 2.5;
                    case NMetro.B:
                        return 2.3;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 柔性架空线抬升量或刚性架空线安装误差（mm）
        /// </summary>
        private double ΔJ_vd
        {
            get
            {
                switch (Catenary)
                {
                    case Physics.Flexibility:
                        return 25;
                    case Physics.Inflexibility:
                        return 10;
                    default:
                        return double.NaN;
                }


            }
        }
        /// <summary>
        /// 架空线磨耗量（mm）
        /// </summary>
        private double ΔJ_vw
        {
            get
            {
                switch (Catenary)
                {
                    case Physics.Flexibility:
                        return 3.7;
                    case Physics.Inflexibility:
                        return 6;
                    default:
                        return double.NaN;
                }


            }
        }
        /// <summary>
        /// 受电弓炭精板磨耗量（mm）
        /// </summary>
        private static double ΔS_vw => 15.0;
        /// <summary>
        /// 轨道横向弹性变形直线与曲线差值
        /// </summary>
        private double Δ_de => 0;
        /// <summary>
        /// 上部受流器切除竖向向上位移量或下部受流工作释放反弹量（mm）
        /// </summary>
        private double ΔH_vt
        {
            get
            {
                switch (collectorStatus)
                {
                    case CollectorStatus.Upper:
                        return 55;
                    case CollectorStatus.Lower:
                        return 70;
                    default:
                        return double.NaN;
                }
            }
        }
        /// <summary>
        /// 接触轨距走行轨轨顶平面高度公差值（mm）
        /// </summary>
        private double ΔC_vt => 6.0;//Δcvt取正公差+6mm

        #endregion
        /// <summary>
        /// 被比较式子
        /// </summary>
        private double ComparedFormula => 2 * _f_2 / b_h;
        /// <summary>
        /// 整车一系弹簧侧滚刚度 (N.mm/rad)
        /// </summary>
        /// <returns></returns>
        private double K_φp => 0.5 * n_p * c_p * b_p * b_p;
        /// <summary>
        /// 整车二系弹簧侧滚刚度 (N.mm/rad)
        /// </summary>
        /// <returns></returns>
        private double K_φs => 0.5 * n_s * c_s * b_s * b_s + 2 * K_φn;
        /// <summary>
        /// 含一、二系影响的重力倾角附加系数
        /// </summary>
        /// <returns></returns>
        private double S => m_B * g * ((h_sc - h_cp) / K_φp + (h_sc - h_cs) / K_φs);
        /// <summary>
        /// 只含一系影响的重力倾角附加系数
        /// </summary>
        private double S_1 => m_B * g * (h_sc - h_cp) / K_φp;
        /// <summary>
        /// 只含二系影响的重力倾角附加系数
        /// </summary>
        private double S_2 => m_B * g * (h_sc - h_cs) / K_φs;

        #region 车辆限界
        /// <summary>
        /// 侧风载荷引起侧倾的转换系数
        /// </summary>
        private double C_h => (Y - h_cp) * (h_sw - h_cp) / K_φp + (Y - h_cs) * (h_sw - h_cs) / K_φs;
        /// <summary>
        /// 横向加速度载荷引起侧倾的转换系数
        /// </summary>
        private double _C_h => (Y - h_cp) * (h_sc - h_cp) / K_φp + (Y - h_cs) * (h_sc - h_cs) / K_φs;
        /// <summary>
        /// 横向制造误差值（mm）
        /// </summary>
        private double ΔM()
        {
            double result;
            result = Squa(Δ_d / 2) + Squa(ΔM_t1) + Squa(ΔM_t2) + Squa(ΔM_t3) + Squa(ΔM_t4) + Squa(ΔM_t5) + Math.Sqrt(ΔX_Bq / H_cq * (Y - h_sj) * (Y - h_sj));
            return result;
        }
        #region 车体横向平移和倾角产生横向偏移方向相同时
        /// <summary>
        /// 车体侧倾横向偏移量（mm）
        /// </summary>
        public double ΔX_Bcp()
        {
            //Formula
            double F1 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F2 = 100 * m_z * g * (1 + S_2) / K_φs;
            if (F2 > ComparedFormula)
            {
                F2 = ComparedFormula;
            }
            double F3 = Squa(Δh_c1 / 1500 * Y * (1 + S));
            double F4 = Squa(Δh_c2 / 1500 * Y * (1 + S));
            double F5 = Squa(A_w * P_w * (1 + S) * C_h);
            double F6 = Squa(m_B * a_B * (1 + S) * _C_h);
            double F7 = ΔS_hd;

            if (Env == General.Environment.Tunnel)
            {
                F5 = 0.0;
            }
            if (Position != PositionI.Pantograph)
            {
                F7 = 0;
            }
            return F2 * Math.Abs(Y - h_cs) + F1 * Math.Abs(Y - h_cp) + Math.Sqrt(F3 + F4 + F5 + F6 + Squa(F7));
        }


        private double δX_BP()
        {
            double result;
            double F1 = Math.Sqrt(Squa((l - d) / 2) + Squa(Δ_c));
            double F2 = (Δ_q1 + Δ_q2 + Δ_q3);
            double F3 = Δ_w1 + Δ_w2;
            result = (F1 + F2 + F3) * (2 * n + a) / a + Δ_e + ΔM() + _ΔX + ΔX_Bxgpx + ΔX_Bcp();
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);

        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相同时，车体横向偏移量
        /// </summary>
        public double ΔX_BP
        {
            get
            {
                double result = δX_BP();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δX_BP();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        private double δY_BPu()
        {
            double result;
            double F1 = Squa(ΔM_t6) + Squa(ΔM_t8) + Squa(ΔX_Bq / H_cq * X);
            double F2 = Squa(Δf_s * (2 * n + a) / a) + Squa(Δf_p * (2 * n + a) / a) + Squa(δ_c);
            double F3 = 100 * m_z * g * (1 + S_2) / K_φs;
            if (F3 > ComparedFormula)
            {
                F3 = ComparedFormula;
            }
            double F4 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F5 = Squa(Δh_c1 / 1500 * (1 + S) * X) + Squa(Δh_c2 / 1500 * (1 + S) * X);
            double F6 = Squa(A_w * P_w * (1 + S) * X * ((h_sw - h_cp) / K_φp + (h_sw - h_cs) / K_φs));
            double F7 = Squa(m_B * a_B * (1 + S) * X * ((h_sc - h_cp) / K_φp + (h_sc - h_cs) / K_φs));

            if (Env == General.Environment.Tunnel)
            {
                F6 = 0.0;
            }

            result = ΔM_t9 + Math.Sqrt(F1) + Math.Sqrt(F2) - (X * F3 + X * F4 + ΔY_Bxgpx1 + Math.Sqrt(F5 + F6 + F7));
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);

        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相同时，车体竖向向上偏移量
        /// </summary>
        public double ΔY_BPu
        {
            get
            {
                double result = δY_BPu();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_BPu();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相同时，车体侧倾竖向偏移量
        /// </summary>
        /// <param name="Y"></param>
        /// <returns></returns>
        private double ΔY_Bcpd()
        {
            double result;
            double F1 = 100 * m_z * g * (1 + S_2) / K_φs;
            if (F1 > ComparedFormula)
            {
                F1 = ComparedFormula;
            }
            double F2 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F3 = Squa(Δf_s * (2 * n + a) / a) + Squa(Δf_p * (2 * n + a) / a) + Squa(δ_c);
            double F4 = Squa(Δh_c1 / 1500 * (1 + S) * X) + Squa(Δh_c2 / 1500 * (1 + S) * X);
            double F5 = Squa(A_w * P_w * (1 + S) * X * ((h_sw - h_cp) / K_φp + (h_sw - h_cs) / K_φs));
            double F6 = Squa(m_B * a_B * (1 + S) * X * ((h_sc - h_cp) / K_φp + (h_sc - h_cs) / K_φs));

            if (Env == General.Environment.Tunnel)
            {
                F5 = 0;
            }
            result = F1 * X + F2 * X + Math.Sqrt(F3 + F4 + F5 + F6);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);

        }
        private double δY_BPd()
        {
            double result;
            double F1 = Squa(ΔM_t6) + Squa(ΔM_t7) + Squa(ΔX_Bq / H_cq * X);
            var value = f_01 + _f_01 + f_1 + f_02 + f_2 + δ_e + δ_w0 + _δ_w1;
            result = value + Math.Sqrt(F1) + ΔY_Bxgpx2 + ΔY_Bcpd();
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);

        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相同时，车体竖向向下偏移量  
        /// </summary>
        public double ΔY_BPd
        {
            get
            {
                double result = δY_BPd();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_BPd();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        #endregion

        #region 车体横向平移和倾角产生横向偏移方向相反时
        private double _δX_BP()
        {
            double result;
            double F1 = Math.Sqrt(Squa(l - d) / 2 + Squa(Δ_c));
            double F2 = (Δ_q1 + Δ_q2 + Δ_q3);
            double F3 = (Δ_w1 + Δ_w2);
            result = (F1 + F2 + F3) * (2 * n + a) / a + Δ_e + ΔM() + _ΔX - ΔX_Bxgpx - ΔX_Bcp();
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);

        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相反时，车体横向偏移量
        /// </summary>
        public double _ΔX_BP
        {
            get
            {
                double result = _δX_BP();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = _δX_BP();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        ///// <summary>
        ///// 横向平移和倾角产生横向偏移方向相反时，车体侧倾竖向偏移量
        ///// </summary>
        ///// <param name="X"></param>
        ///// <returns></returns>
        //private double _ΔY_Bcpd()
        //{
        //    double result;
        //    double F1 = 100 * m_z * g * (1 + S_2) / K_φs;
        //    double F2 = 100 * m_z * g * (1 + S_1) / K_φp;
        //    double F3 = Squa(Δf_s * (2 * n + a) / a) + Squa(Δf_p * (2 * n + a) / a) + Squa(δ_c);
        //    double F4 = Squa(Δh_c1 / 1500 * (1 + S) * X) + Squa(Δh_c2 / 1500 * (1 + S) * X);
        //    double F5 = Squa(A_w * P_w * (1 + S) * X * ((h_sw - h_cp) / K_φp + (h_sw - h_cs) / K_φs));
        //    double F6 = Squa(m_B * a_B * (1 + S) * X * ((h_sc - h_cp) / K_φp + (h_sc - h_cs) / K_φs));
        //    if (F1 > ComparedFormula)
        //    {
        //        F1 = ComparedFormula;
        //    }
        //    if (Env == General.Environment.Tunnel)
        //    {
        //        F5 = 0;
        //    }
        //    result = -F2 * X - F1 * X + F3 - Math.Sqrt(F4 + F5 + F6);
        //    return Math.Round(result, decimals, MidpointRounding.AwayFromZero);

        //}

        private double _δY_BPu()
        {
            double result;
            double F1 = Squa(ΔM_t6) + Squa(ΔM_t8) + Squa(ΔX_Bq / H_cq * X);
            double F2 = Squa(Δf_s * (2 * n + a) / a) + Squa(Δf_p * (2 * n + a) / a) + Squa(δ_c);
            double F3 = 100 * m_z * g * (1 + S_2) / K_φs;
            if (F3 > ComparedFormula)
            {
                F3 = ComparedFormula;
            }
            double F4 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F5 = Squa(Δh_c1 / 1500 * (1 + S) * X) + Squa(Δh_c2 / 1500 * (1 + S) * X);
            double F6 = Squa(A_w * P_w * (1 + S) * X * ((h_sw - h_cp) / K_φp + (h_sw - h_cs) / K_φs));
            double F7 = Squa(m_B * a_B * (1 + S) * X * ((h_sc - h_cp) / K_φp + (h_sc - h_cs) / K_φs));

            if (Env == General.Environment.Tunnel)
            {
                F6 = 0.0;
            }

            result = ΔM_t9 + Math.Sqrt(F1) + Math.Sqrt(F2) + X * F3 + X * F4 + ΔY_Bxgpx1 + Math.Sqrt(F5 + F6 + F7);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相反时，车体竖向向上偏移量
        /// </summary>
        public double _ΔY_BPu
        {
            get
            {
                double result = _δY_BPu();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = _δY_BPu();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        private double _δY_BPd()
        {
            double result;
            double F1 = Squa(ΔM_t6) + Squa(ΔM_t7) + Squa(ΔX_Bq / H_cq * X);
            double F2 = Squa(Δf_s * (2 * n + a) / a) + Squa(Δf_p * (2 * n + a) / a) + Squa(δ_c);
            double F3 = 100 * m_z * g * (1 + S_2) / K_φs;
            if (F3 > ComparedFormula)
            {
                F3 = ComparedFormula;
            }
            double F4 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F5 = Squa(Δh_c1 / 1500 * (1 + S) * X) + Squa(Δh_c2 / 1500 * (1 + S) * X);
            double F6 = Squa(A_w * P_w * (1 + S) * X * ((h_sw - h_cp) / K_φp + (h_sw - h_cs) / K_φs));
            double F7 = Squa(m_B * a_B * (1 + S) * X * ((h_sc - h_cp) / K_φp + (h_sc - h_cs) / K_φs));
            result = f_01 + _f_01 + f_1 + f_02 + f_2 + δ_e + δ_w0 + _δ_w1 + Math.Sqrt(F1) + Math.Sqrt(F2) - (X * F3 + X * F4 + ΔY_Bxgpx2 + Math.Sqrt(F5 + F6 + F7));
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);

        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相反时，车体竖向向下偏移量
        /// </summary>
        public double _ΔY_BPd
        {
            get
            {
                double result = _δY_BPd();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = _δY_BPd();
                if (Position != PositionI.Body)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        #endregion
        private double δX_t()
        {
            double result;
            double F1 = Math.Sqrt(Squa(l - d) / 2 + Squa(Δ_c));
            double F2 = (Δ_q1 + Δ_q2 + Δ_q3);
            double F3 = Squa(ΔM_t10) + Squa(Δ_d / 2);
            double F4 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F5 = Squa(Δh_c1 / 1500 * Y * (1 + S_1));
            double F6 = Squa(Δh_c2 / 1500 * Y * (1 + S_1));
            double F7 = Squa(A_w * P_w * (1 + S_1) * (Y - h_cp) * (h_sw - h_cp) / K_φp);
            double F8 = Squa(m_B * a_B * (1 + S_1) * (Y - h_cp) * (h_sc - h_cp) / K_φp);

            if (Position == PositionI.Collector)
            {
                F3 = Squa(ΔM_t15) + Squa(Δ_d / 2);
            }
            if (Env == General.Environment.Tunnel)
            {
                F7 = 0.0;
            }
            result = (F1 + F2) * ((2 * m) + p) / p + Δ_e + Math.Sqrt(F3) + F4 * Math.Abs(Y - h_cp) + ΔX_txgpx + _ΔX + Math.Sqrt(F5 + F6 + F7 + F8);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相同，构架横向偏移量 
        /// </summary>
        public double ΔX_t
        {
            get
            {
                double result = δX_t();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δX_t();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        private double _δY_tu()
        {
            double result;
            double F1 = ΔM_t11;
            double F2 = Squa(Δf_p * ((2 * m + p) / p)) + Squa(δ_c);
            double F3 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F4 = Squa(((Δh_c1 / 1500) * (1 + S_1)) * X);
            double F5 = Squa(((Δh_c2 / 1500) * (1 + S_1)) * X);
            double F6 = Squa(A_w * P_w * (1 + S_1) * X * (h_sw - h_cp) / K_φp);
            double F7 = Squa(m_B * a_B * (1 + S_1) * X * (h_sc - h_cp) / K_φp);
            if (Position == PositionI.Collector)
            {
                F1 = Squa(ΔM_t16);
            }
            if (Env == General.Environment.Tunnel)
            {
                F6 = 0.0;
            }
            result = F1 + F3 * X + _ΔX + ΔY_txgpx1 + Math.Sqrt(F2 + F4 + F5 + F6 + F7);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 竖向平移和倾角产生竖向偏移方向相反，构架竖向向上偏移量
        /// </summary>
        public double _ΔY_tu
        {
            get
            {
                double result = _δY_tu();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = _δY_tu();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        private double δY_td()
        {
            double result;
            double F1 = ΔM_t12;
            double F2 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F3 = Squa(Δf_p * ((2 * m + p) / p)) + Squa(δ_c);
            double F4 = Squa(((Δh_c1 / 1500) * (1 + S_1)) * X);
            double F5 = Squa(((Δh_c2 / 1500) * (1 + S_1)) * X);
            double F6 = Squa((A_w * P_w) * (1 + S_1) * X * (h_sw - h_cp) / K_φp);
            double F7 = Squa(m_B * a_B * (1 + S_1) * X * (h_sc - h_cp) / K_φp);
            if (Position == PositionI.Collector)
            {
                F1 = ΔM_t16;
            }
            if (Env == General.Environment.Tunnel)
            {
                F6 = 0.0;
            }
            result = _f_01 + δ_w1 + f_01 + f_1 + δ_e + δ_w0 + F1 + F2 * X + _ΔX + ΔY_txgpx2 + Math.Sqrt(F3 + F4 + F5 + F6 + F7);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 竖向平移和倾角产生竖向偏移方向相同，构架竖向向下偏移量
        /// </summary>
        public double ΔY_td
        {
            get
            {
                double result = δY_td();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_td();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }


        private double _δX_t()
        {
            double result;
            double F1 = Math.Sqrt(Squa(l - d) / 2 + Squa(Δ_c));
            double F2 = (Δ_q1 + Δ_q2 + Δ_q3);
            double F3 = Squa(ΔM_t10) + Squa(Δ_d / 2);
            double F4 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F5 = Squa(Δh_c1 / 1500 * Y * (1 + S_1));
            double F6 = Squa(Δh_c2 / 1500 * Y * (1 + S_1));
            double F7 = Squa(A_w * P_w * (1 + S_1) * (Y - h_cp) * (h_sw - h_cp) / K_φp);
            double F8 = Squa(m_B * a_B * (1 + S_1) * (Y - h_cp) * (h_sc - h_cp) / K_φp);

            if (Position == PositionI.Collector)
            {
                F3 = Squa(ΔM_t15) + Squa(Δ_d / 2);
            }
            if (Env == General.Environment.Tunnel)
            {
                F7 = 0.0;
            }
            result = (F1 + F2) * (2 * m + p) / p + Δ_e + Math.Sqrt(F3) + F4 * Math.Abs(Y - h_cp) - ΔX_txgpx + _ΔX - Math.Sqrt(F5 + F6 + F7 + F8);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 横向平移和倾角产生横向偏移方向相反，水平偏移量
        /// </summary>
        public double _ΔX_t
        {
            get
            {
                double result = _δX_t();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = _δX_t();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        private double δY_tu()
        {
            double result;
            double F1 = ΔM_t11;
            double F2 = Squa(Δf_p * ((2 * m + p) / p)) + Squa(δ_c);
            double F3 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F4 = Squa(((Δh_c1 / 1500) * (1 + S_1)) * X);
            double F5 = Squa(((Δh_c2 / 1500) * (1 + S_1)) * X);
            double F6 = Squa(A_w * P_w * (1 + S_1) * X * (h_sw - h_cp) / K_φp);
            double F7 = Squa(m_B * a_B * (1 + S_1) * X * (h_sc - h_cp) / K_φp);
            if (Position == PositionI.Collector)
            {
                F1 = Squa(ΔM_t16);
            }
            if (Env == General.Environment.Tunnel)
            {
                F6 = 0.0;
            }
            result = F1 + Math.Sqrt(F2) - (F3 * X) + _ΔX - ΔY_txgpx1 - Math.Sqrt(F4 + F5 + F6 + F7);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 竖向平移和倾角产生竖向偏移方向相同，构架竖向向上偏移量
        /// </summary>
        public double ΔY_tu
        {
            get
            {
                double result = δY_tu();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_tu();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        private double _δY_td()
        {
            double result;
            double F1 = ΔM_t12;
            double F2 = 100 * m_z * g * (1 + S_1) / K_φp;
            double F3 = Squa(Δf_p * ((2 * m + p) / p)) + Squa(δ_c);
            double F4 = Squa(((Δh_c1 / 1500) * (1 + S_1)) * X);
            double F5 = Squa(((Δh_c2 / 1500) * (1 + S_1)) * X);
            double F6 = Squa((A_w * P_w) * (1 + S_1) * X * (h_sw - h_cp) / K_φp);
            double F7 = Squa(m_B * a_B * (1 + S_1) * X * (h_sc - h_cp) / K_φp);
            if (Position == PositionI.Collector)
            {
                F1 = ΔM_t16;
            }
            if (Env == General.Environment.Tunnel)
            {
                F6 = 0.0;
            }
            result = _f_01 + δ_w1 + f_01 + f_1 + δ_e + δ_w0 + F1 + _ΔX + Math.Sqrt(F3) - ΔY_txgpx2 - F2 * X - Math.Sqrt(F4 + F5 + F6 + F7);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 竖向平移和倾角产生竖向偏移方向相反，构架竖向向下偏移量
        /// </summary>
        public double _ΔY_td
        {
            get
            {
                double result = _δY_td();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = _δY_td();
                if (Position != PositionI.BogieFrame)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }
        #endregion
        private double δX_w()
        {
            double result;
            double F1 = Squa((l - d) / 2) + Squa(Δ_c);
            double F2 = Squa(ΔM_t13) + Squa(Δ_d / 2);
            double F3 = Squa(Δh_c1) + Squa(Δh_c2);
            result = F1 + Δ_e + Math.Sqrt(F2) + Y / 1500 * Math.Sqrt(F3);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 簧下部分横向偏移量
        /// </summary>
        public double ΔX_w
        {
            get
            {
                double result = δX_w();
                if (Position != PositionI.Unsprung)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δX_w();
                if (Position != PositionI.Unsprung)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        private double δY_wd()
        {
            double result;
            double F1 = Squa(δ_c) + Squa(Δh_c1 / 1500 * X) + Squa(Δh_c2 / 1500 * X);
            result = _f_01 + δ_w1 + δ_e + δ_w0 + ΔM_t14 + Math.Sqrt(F1);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 簧下部分竖向偏移量
        /// </summary>
        public double ΔY_wd
        {
            get
            {
                double result = δY_wd();
                if (Position != PositionI.Unsprung)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_wd();
                if (Position != PositionI.Unsprung)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        private double δY_f()
        {
            double result;
            double F1 = Squa(δ_c) + Squa(Δh_c1 / 2) + Squa(Δh_c2 / 2);
            result = _δ_w1 + δ_e + δ_w0 + Math.Sqrt(F1);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 轮缘部分竖向偏移量
        /// </summary>
        public double ΔY_f
        {
            get
            {
                double result = δY_f();
                if (Position != PositionI.Rim)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_f();
                if (Position != PositionI.Rim)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        private double δY_m()
        {
            double result;
            double F1 = Squa(δ_c) + Squa(Δh_c1 / 2) + Squa(Δh_c2 / 2);
            result = δ_e + δ_w0 + Math.Sqrt(F1);
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 踏面部分竖向偏移量
        /// </summary>
        public double ΔY_m
        {
            get
            {
                double result = δY_m();
                if (Position != PositionI.Tread)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_m();
                if (Position != PositionI.Tread)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        private double δX_gu()
        {
            double result;
            double F1 = Math.Sqrt(Squa(l - d) / 2 + Squa(Δ_c));
            double F2 = (Δ_q1 + Δ_q2 + Δ_q3);
            double F3 = (Δ_w1 + Δ_w2);
            result = (F1 + F2 + F3) + Δ_e + ΔM() + ΔX_Bxgpx + ΔX_Bcp();
            return Math.Round(result, decimals, MidpointRounding.AwayFromZero);
        }
        /// <summary>
        /// 受电弓横向偏移量
        /// </summary>
        public double ΔX_gu
        {
            get
            {
                double result = δX_gu();
                if (Position != PositionI.Pantograph)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δX_gu();
                if (Position != PositionI.Pantograph)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        private double δY_gu()
        {
            return ΔJ_vd + ΔJ_vw + ΔS_vw;
        }
        /// <summary>
        /// 受电弓竖向向上偏移量（mm），注：柔性接触网和刚性接触网的ΔJvd 25,10， ΔJvw 3.7,6
        /// </summary>
        public double ΔY_gu
        {
            get
            {
                double result = δY_gu();
                if (Position != PositionI.Pantograph)
                {
                    result = double.NaN;
                }
                return result;
            }
            set
            {
                double result = δY_gu();
                if (Position != PositionI.Pantograph)
                {
                    result = double.NaN;
                }
                result = value;
                OnPropertyChanged();
            }
        }

        /// <summary>
        /// 受流器横向偏移量（mm）
        /// </summary>
        /// <param name="Y"></param>
        /// <returns></returns>
        private double δX_sd()
        {
            return δX_t() + Δ_de;
        }
        /// <summary>
        /// 上部受流工作状态时受流器根部转轴点的竖向向上偏移量（mm）
        /// </summary>
        private double δY_su1()
        {
            return δY_tu() + ΔM_t16;
        }
        /// <summary>
        /// 上部受流工作状态时受流器与接触轨接触点的竖向向上偏移量（mm）
        /// </summary>
        private double δY_su2 => ΔC_vt;
        /// <summary>
        /// 上部受流工作释放状态的竖向向上偏移量（mm）
        /// </summary>
        private double δY_su3()
        {
            return δY_tu() + ΔH_vt + ΔM_t16;
        }
        /// <summary>
        /// 上部受流工作状态时受流器根部转轴的竖向向下偏移量（mm）
        /// </summary>
        /// <returns></returns>
        private double δY_sd1()
        {
            return δY_td() + ΔM_t16;
        }
        /// <summary>
        /// 上部受流工作状态时受流器与接触轨接触点的竖向向下偏移量（mm）
        /// </summary>
        private double δY_sd2 => ΔC_vt;
        /// <summary>
        /// 上部受流工作释放状态的竖向向下偏移量（mm）
        /// </summary>
        private double δY_sd3()
        {
            return δY_td() + ΔM_t16;
        }
        /// <summary>
        /// 下部受流工作状态的竖向向上偏移量（mm）
        /// </summary>
        private double δY_su4 => ΔC_vt;
        /// <summary>
        /// 下部受流工作状态的竖向向下偏移量（mm）
        /// </summary>
        private double δY_su5()
        {
            return δY_tu() + ΔH_vt + ΔM_t16;
        }
        /// <summary>
        /// 下部受流工作状态的竖向向下偏移量（mm)
        /// </summary>
        private double δY_sd4 => ΔC_vt;


        /// <summary>
        /// 下部受流工作释放状态的竖向向下偏移量（mm）
        /// </summary>
        public double δY_sd5()
        {
            return δY_td() + ΔM_t16;
        }

        public static KineModel Copy(KineModel kine)
        {
            return new KineModel(kine.StrPosition, kine.Name, kine.X, kine.Y);
        }
    }
}