package com.ruoyi.caltools.controller;


import com.ruoyi.caltools.model.FlowProps;
import com.ruoyi.caltools.model.GasProps;

import javax.swing.*;
import java.util.Optional;

public class DpFlowCalc {

    /**
     * 计算管道绝对粗糙度 K (GB/T 21446-2008 附录C)
     * @return 粗糙度修正系数 K (保留4位小数)
     */
    public  static  double calculateK(FlowProps flowProps){
        return switch (flowProps.getdPipeType()) {
            case 0 -> 0.029F;
            case 1, 2, 3 -> 0.075F;
            case 4 -> 0.1F;
            case 5,9 -> 0.15F;
            case 6 -> 1;
            case 7 -> 2.1F;
            case 8 -> 0.04F;
            case 10 -> 0.13F;
            case 11 -> 0.25F;
            default ->
                // 处理未知类型（可选）
                    throw new IllegalArgumentException("未知的管道类型: ");
        };
    }

    /**
     * 计算管道粗糙度修正系数 G_me (GB/T 21446-2008 附录C)
     * @param D_pipe 管道内径 (mm)
     * @param K 绝对粗糙度 (mm)
     * @param C 未修正的流出系数
     * @return 粗糙度修正系数 G_me (保留4位小数)
     */
    public static double calculateRoughnessFactor(double D_pipe, double K, double C) {
        // 计算相对粗糙度 K/D
        double K_over_D = K / D_pipe;

        // 判断是否需要修正
        if (K_over_D <= 0.0004) {
            return 1.0000;
        }

        // 计算修正项
        double term = (K_over_D * 1e6) - 400; // 转换为无量纲项
        if (term < 0) {
            throw new IllegalArgumentException("K/D 超出修正公式适用范围");
        }

        double G_me = 1 + (0.011 / C) * Math.sqrt(term);
        return FormatUtil.format(G_me, Optional.of(4)); // 保留四位小数
    }

    /**
     * 热膨胀修正（GB/T 21446-2008 第6.2.1节）
     * @param flowProps 流量参数
     */
    public static void thermalExpansionCorrection(FlowProps flowProps) {
        // 孔板孔径修正
        double dOrificeMaterial = flowProps.getdOrificeMaterial(); // 材料膨胀系数 (e.g. 16e-6/℃)
        double dOrificeD = flowProps.getdOrificeD(); // 初始孔径(mm)
        double dOrificeD_corrected = dOrificeD * (1 +  0.000001*dOrificeMaterial * (flowProps.getdTf() - 293.15)); // 20℃为参考温度
        flowProps.setdOrificeD(FormatUtil.format(dOrificeD_corrected, Optional.of(2)));

        // 管道内径修正
        double dPipeMaterial = flowProps.getdPipeMaterial();
        double dPipeD = flowProps.getdPipeD();
        double dPipeD_corrected = dPipeD * (1 + 0.000001*dPipeMaterial * (flowProps.getdTf() - 293.15));
        flowProps.setdPipeD(FormatUtil.format(dPipeD_corrected,Optional.of(2)));

// 新增：喷嘴喉部直径热膨胀修正（对应ISO 1932喷嘴）
        if (flowProps.getdCoreType() == 1) {
            double nozzleMaterial = flowProps.getdOrificeMaterial(); // 喷嘴与孔板共用材料参数（可单独扩展）
            double nozzleD = flowProps.getdNozzleD();
            double nozzleD_corrected = nozzleD * (1 + 0.000001*nozzleMaterial * (flowProps.getdTf() - 293.15));
            flowProps.setdNozzleD(FormatUtil.format(nozzleD_corrected, Optional.of(2)));
        }

        // 新增：文丘里管喉部直径热膨胀修正
        if (flowProps.getdCoreType() == 2) {
            double venturiMaterial = flowProps.getdOrificeMaterial(); // 文丘里管与孔板共用材料参数（可单独扩展）
            double venturiD = flowProps.getdVenturiD();
            double venturiD_corrected = venturiD * (1 + 0.000001*venturiMaterial * (flowProps.getdTf() - 293.15));
            flowProps.setdVenturiD(FormatUtil.format(venturiD_corrected, Optional.of(2)));
        }

        // 更新直径比β（新增：根据节流装置类型切换计算基准）
        double beta;
        if (flowProps.getdCoreType() == 0) {
            // 孔板：孔径/管道内径
            beta = flowProps.getdOrificeD() / flowProps.getdPipeD();
        } else if (flowProps.getdCoreType() == 1) {
            // 喷嘴：喉部直径/管道内径
            beta = flowProps.getdNozzleD() / flowProps.getdPipeD();
        } else if (flowProps.getdCoreType() == 2) {
            // 文丘里管：喉部直径/管道内径
            beta = flowProps.getdVenturiD() / flowProps.getdPipeD();
        } else {
            throw new IllegalArgumentException("不支持的节流装置类型，无法计算直径比β");
        }
        // 更新直径比β
        flowProps.setdBeta( FormatUtil.format(beta,Optional.of(4)));
    }

    /**
     * 计算渐近速度系数E（GB/T 21446-2008 式(8)）
     */
    public static void calculateE(FlowProps flowProps) {
        double beta = flowProps.getdBeta();
        flowProps.setdE( FormatUtil.format(1 / Math.sqrt(1 - Math.pow(beta, 4)),Optional.of(4)));
    }

    /**
     * 计算相对密度系数FG（GB/T 21446-2008 式(9)）
     */
    public static void calculateFG(FlowProps flowProps,GasProps gasProps) {
        gasProps.setdRD_Real(gasProps.getdRD_Real());
        flowProps.setdFG( FormatUtil.format(1 / Math.sqrt(gasProps.dRD_Real),Optional.of(4)));
    }

    /**
     * 计算流动温度系数FT（GB/T 21446-2008 式(10)）
     */
    public static void calculateFT(FlowProps flowProps) {
        double Tb = flowProps.getdTb_M() ; // 参比温度转K
        double Tf = flowProps.getdTf() ;   // 工况温度转K
        flowProps.setdFT( FormatUtil.format(Math.sqrt(Tb / Tf),Optional.of(4)));
    }

    /**
     * 计算可膨胀系数ε（GB/T 21446-2008 式(11)）
     */
    public static void calculateEpsilon(FlowProps flowProps) {
        double P1 = flowProps.getdPf();
        double deltaP = flowProps.getdDp();
        double beta = flowProps.getdBeta();
        double kappa = flowProps.getdKappa();
        double tau = FormatUtil.format((P1 - deltaP) / P1, Optional.of(4));
        double epsilon;
        switch (flowProps.getdCoreType()) {
            case 0:  // 孔板（原有逻辑保留）
                epsilon = 1 - (0.351 + 0.256 * Math.pow(beta, 4) + 0.93 * Math.pow(beta, 8)) * (1 - Math.pow(tau, 1 / kappa));
                break;
            case 1:   // ISO 932喷嘴（新增：符合GB/T 21446-2008附录B）
                if (flowProps.getdNozzleType() == 0) {
                    // 长径喷嘴
                    epsilon = 1 - (0.41 + 0.35 * Math.pow(beta, 4)) * (1 - Math.pow(tau, 1 / kappa)) / kappa;
                } else {
                    // 短径喷嘴
                    epsilon = 1 - (0.39 + 0.38 * Math.pow(beta, 4)) * (1 - Math.pow(tau, 1 / kappa)) / kappa;
                }
                break;
            case 2:   // 经典文丘里管（新增：符合GB/T 21446-2008附录C）
                epsilon = switch (flowProps.getdVenturiType()) { // 粗铸收缩段
                    // 机械加工收缩段
                    case 0, 1, 2 -> // 粗焊铁板收缩段
                            1 - (0.386 + 0.318 * Math.pow(beta, 4)) * (1 - Math.pow(tau, 1 / kappa)) / kappa;
                    case 3 -> // 文丘里喷嘴
                            1 - (0.40 + 0.36 * Math.pow(beta, 4)) * (1 - Math.pow(tau, 1 / kappa)) / kappa;
                    default -> throw new IllegalArgumentException("未知的文丘里管类型");
                };
                break;
            default:
                throw new IllegalArgumentException("不支持的节流装置类型，无法计算可膨胀系数ε");
        }


        flowProps.setdDExpCoefficient(FormatUtil.format(epsilon, Optional.of(4)));
    }
    /**
     * 计算等熵指数κ（GB/T 21446-2008 推荐方法）
     * @param gasProps 气体参数（需包含等熵指数或热容比）
     * @return 等熵指数κ
     */
    public static double calculateKappa(GasProps gasProps) {
        // 若已通过AGA 8或其他方法计算，直接返回
//        if (gasProps.getdKappa() > 0) {
//            return gasProps.getdKappa();
//        }

        // 近似公式：基于理想气体比热比和压缩因子修正
        double gamma = 1.3; // 天然气典型比热比（Cp/Cv≈1.3）
        double Z = gasProps.getdZf(); // 工况压缩因子

        // 修正公式（经验关系）
        double kappa = gamma / (1 - (gamma - 1) * (1 / Z - 1));
        return  FormatUtil.format(kappa,Optional.of(4));
    }



    /**
     * 迭代计算流量（GB/T 21446-2008 第7章）
     * @param flowProps 流量参数
     * @param gasProps 气体参数
     */
    public static void iterativeFlowCalculation(FlowProps flowProps, GasProps gasProps) {
        // 0. 单位转换
        thermalExpansionCorrection(flowProps); // 热膨胀修正

        double D = flowProps.getdPipeD() / 1000.0;   // 管道内径(m)
        double d = flowProps.getdOrificeD() / 1000.0; // 孔板孔径(m)
        double beta = flowProps.getdBeta();
        double P1 = flowProps.getdPf();             // 绝对压力(Pa)
        double deltaP = flowProps.getdDp();         // 差压(Pa)
        double Tf = flowProps.getdTf() ;    // 工况温度(K)




        flowProps.setdPb_M(gasProps.getdPb());
        flowProps.setdTb_M(gasProps.getdTb());
        flowProps.setdFpv(FormatUtil.format(gasProps.dFpv,Optional.of(4)));

        // 1. 计算中间参数
        calculateE(flowProps);
        calculateFG(flowProps,gasProps);
        calculateFT(flowProps);

        flowProps.setdKappa( calculateKappa(gasProps));
//        flowProps.setdDViscosity( calculateDynamicViscosity(gasProps));
        flowProps.setdDViscosity(FormatUtil.format( Dlndjs(flowProps.getdPf()/1e6,flowProps.getdTf()),Optional.of(5)));
        calculateEpsilon(flowProps );
//
//        flowProps.setdKappa(1.357);
//        flowProps.setdBeta(0.5792);
//        flowProps.setdFpv(1.0195);
//        flowProps.setdFG(1.2531);
//        flowProps.setdE(1.0615);
//        flowProps.setdDExpCoefficient(0.9977);
//        flowProps.setdFT(1.0086);


        // 2. 初始雷诺数估算（假设初始C=0.6）
        double C_initial = flowProps.getdCoreType() == 0 ? 0.6 : 0.99; // 喷嘴/文丘里初始C值更高
        double Qf_initial = (C_initial * flowProps.getdE() * flowProps.getdDExpCoefficient() * Math.PI * Math.pow(d, 2) / 4)
                * Math.sqrt(2 * deltaP / (gasProps.dRhof * (1 - Math.pow(beta, 4))));
        flowProps.setdVFlowf(Qf_initial); // 初始工况流量(m³/s)

        // 3. 迭代参数
        double tolerance = 1e-6;
        int maxIter = 100;
        double currentC = C_initial;
        double currentReD = calculateReD(Qf_initial, D, gasProps.dRhof, flowProps.getdDViscosity());
        int iter = 0;
        double prevC;
        // 4. 迭代循环
        do {
            prevC = currentC;

            // 4.1 计算流出系数C（GB/T 21446-2008 附录A）
//            currentC =FormatUtil.format( calculateCd(beta, currentReD, flowProps.getdPipeD(), flowProps.getdPtmode()),Optional.of(4));
            currentC = calculateCd(beta, currentReD, flowProps.getdPipeD(), flowProps.getdPtmode(), flowProps.getdCoreType(),
                    flowProps.getdNozzleType(),                    flowProps.getdVenturiType() );

            // 4.2 更新流量
//            double Qf =FormatUtil.format ((currentC  * flowProps.getdDExpCoefficient() * Math.PI * Math.pow(d, 2) / 4)
//                    * Math.sqrt(2 * deltaP / (gasProps.dRhof * (1 - Math.pow(beta, 4)))),Optional.of(4));
            double Qf =(currentC  * flowProps.getdDExpCoefficient() * Math.PI * Math.pow(d, 2) / 4)
                    * Math.sqrt(2 * deltaP / (gasProps.dRhof * (1 - Math.pow(beta, 4))));
            flowProps.setdVFlowf(Qf);

            // 4.3 更新雷诺数
//            currentReD =FormatUtil.format( calculateReD(Qf, D, gasProps.dRhof, flowProps.getdDViscosity()), Optional.of(2));
            currentReD = calculateReD(Qf, D, gasProps.dRhof, flowProps.getdDViscosity());

            iter++;
            if (iter > maxIter) {
                throw new RuntimeException("迭代未收敛，超过最大迭代次数！");
            }
        } while (Math.abs(currentC - prevC) / currentC > tolerance);
        // 5. 保存最终结果

        // 在迭代计算流出系数后，添加粗糙度修正

        double K = calculateK(flowProps); // 根据实际管道类型选择
        double G_me = calculateRoughnessFactor(flowProps.getdPipeD(), K, currentC);

        // 喷嘴/文丘里管无需粗糙度修正，仅孔板应用
        double C_corrected = flowProps.getdCoreType() == 0
                ? FormatUtil.format(currentC * G_me, Optional.of(4))
                : FormatUtil.format(currentC, Optional.of(4));

        flowProps.setdCd(C_corrected);
        flowProps.setdRoughNessPipe(G_me);
        flowProps.setdRnPipe(currentReD);

        // 6. 计算标况流量（GB/T 21446-2008 式(1)）
        double Qn = flowProps.getdVFlowf() * (flowProps.getdFpv()*flowProps.getdFpv() * P1 / flowProps.getdPb_M())
                * (flowProps.getdTb_M()) / Tf;
        flowProps.setdVFlowb(FormatUtil.format(Qn,Optional.of(5)));

        flowProps.setdBk(1);

        //标况质量流量
        flowProps.setdMFlowb(FormatUtil.format(flowProps.getdVFlowb() * gasProps.dRhob,Optional.of(5)));
        //标况能量流量
        flowProps.setdEFlowb(FormatUtil.format(flowProps.getdVFlowb() * gasProps.dHhvv,Optional.of(5)));
        //管道内天然气流速
        flowProps.setdVelocityFlow(FormatUtil.format(flowProps.getdVFlowf() / (Math.PI * Math.pow((flowProps.getdPipeD() / 2000), 2)),Optional.of(3)));
        //压力损失
        flowProps.setdPressLost(FormatUtil.format(YaLiSunShi(flowProps.getdCd(), flowProps.getdBeta(), flowProps.getdDp(), flowProps.getdCoreType()),Optional.of(2)));

    }

    /**
     * 计算天然气动力粘度（Sutherland公式简化版，适用于低压天然气）
     * @param gasProps 气体参数（需包含温度、密度、组分）
     * @return 动力粘度 (Pa·s)
     */
    public static double calculateDynamicViscosity(GasProps gasProps) {
        double T = gasProps.getdTf() ; // 工况温度(K)
        double rho = gasProps.getdRhof();      // 工况密度(kg/m³)
        double Rd = gasProps.getdRD_Real();    // 真实相对密度

        // Sutherland常数（天然气典型值，C=120）
        double C = 120.0;                      // Sutherland常数
        double mu0 = 1.0e-5;                   // 参考粘度 (Pa·s，@293.15K)

        // 计算粘度（简化公式，忽略压力修正）
        double mu = mu0 * Math.pow(T / 293.15, 0.7) * (293.15 + C) / (T + C);

        // 密度修正（经验公式）
        mu *= 1 + 0.001 * (rho - 1.2);        // 密度对粘度的粗略修正

        return FormatUtil.format( mu*1000,Optional.of(5));
    }
    /**
     * 计算雷诺数ReD（GB/T 21446-2008 式(5)）
     */
    public static double calculateReD(double Qf, double D, double rho, double mu) {
        return  FormatUtil.format( (4 * Qf * rho*1000) / (Math.PI * D * mu),Optional.of(2)); // Qf: m³/s, D: m, rho: kg/m³, mu: Pa·s
    }

    /**
     * 计算流出系数C（GB/T 21446-2008 附录A）
     */
    public static double calculateCd(double beta, double ReD, double D_mm, int ptMode,
                                     int coreType, int nozzleType, int venturiType) {
        double Cd ;
        double L1, L2;

        switch (coreType) {
            case 0: // 孔板（原有逻辑保留）
                // 根据取压方式确定L1/L2（角接取压）
                switch (ptMode) {
                    case 1: // 角接取压
                        L1 = L2 = 0; // D单位为mm
                        break;
                    case 0: // 法兰取压
                        L1 = L2 = 25.4 / D_mm;
                        break;
                    case 2: // D-D/2取压
                        L1 = 1.0;
                        L2 = 0.47;
                        break;
                    default:
                        throw new IllegalArgumentException("不支持的取压方式");
                }

                double term1 = 0.5961 + 0.0261 * Math.pow(beta, 2) - 0.216 * Math.pow(beta, 8);
                double term2 = 0.000521 * Math.pow(1e6 * beta / ReD, 0.7);
                double A = Math.pow(19000 * beta / ReD, 0.8);
                double term3 = (0.0188 + 0.0063 * A) * Math.pow(beta, 3.5) * Math.pow(1e6 / ReD, 0.3);
                double term4 = (0.043 + 0.08 * Math.exp(-10 * L1) - 0.123 * Math.exp(-7 * L1))
                        * (1 - 0.11 * A) * Math.pow(beta, 4) / (1 - Math.pow(beta, 4));
                double term5 = -0.031 * (2 * L2 / (1 - beta) - 0.8 * Math.pow(2 * L2 / (1 - beta), 1.1))
                        * Math.pow(beta, 1.3);
                Cd = term1 + term2 + term3 + term4 + term5;
                // 孔径<71.12mm修正
                if (D_mm < 71.12) {
                    Cd += 0.011 * (0.75 - beta) * (2.8 - D_mm / 25.4);
                }
                break;

            case 1: // ISO 932喷嘴（新增）
                if (nozzleType == 0) {
                    // 长径喷嘴（角接取压专用）
                    Cd = 0.9975 - 0.00653 * Math.pow(beta, 0.5) * Math.pow(1e6 / ReD, 0.5);
                    // 管道内径修正
                    if (D_mm < 71.12) {
                        Cd += 0.0002 * (71.12 - D_mm) / 25.4;
                    }
                } else {
                    // 短径喷嘴（角接取压专用）
                    Cd = 0.9965 - 0.0060 * Math.pow(beta, 0.5) * Math.pow(1e6 / ReD, 0.5);
                }
                break;

            case 2: // 经典文丘里管（新增）
                Cd = switch (venturiType) {
                    case 0 -> // 粗铸收缩段
                            0.984; // 雷诺数ReD>2e5时近似为常数
                    case 1 -> // 机械加工收缩段
                            0.995; // 雷诺数ReD>2e5时近似为常数
                    case 2 -> // 粗焊铁板收缩段
                            0.975; // 雷诺数ReD>2e5时近似为常数
                    case 3 -> // 文丘里喷嘴
                            0.990 - 0.005 * Math.pow(beta, 0.5) * Math.pow(1e6 / ReD, 0.2);
                    default -> throw new IllegalArgumentException("未知的文丘里管类型");
                };
                break;

            default:
                throw new IllegalArgumentException("不支持的节流装置类型，无法计算流出系数C");
        }


        return  FormatUtil.format(Cd,Optional.of(4));
    }
    //查表计算粘度μ
    public static double Dlndjs(double tempP_jy, double tempT)
    {  double[][] Dlndjs_Dlnd_Data = new double[8][11];
        double[] Dlndjs_Dlnd_T = new double[8];
        double[] Dlndjs_Dlnd_P = new double[11];
        double s1 ;
        double s2 ;
        double ky ;
        double kx ;
        int i ;
        int m = 0;
        int n = 0;
        //On Error Resume Next VBConversions Warning: On Error Resume Next not supported in C#
        Dlndjs_Dlnd_T[0] = -15 + 273.15;
        Dlndjs_Dlnd_T[1] = 0 + 273.15;
        Dlndjs_Dlnd_T[2] = 15 + 273.15;
        Dlndjs_Dlnd_T[3] = 30 + 273.15;
        Dlndjs_Dlnd_T[4] = 45 + 273.15;
        Dlndjs_Dlnd_T[5] = 60 + 273.15;
        Dlndjs_Dlnd_T[6] = 75 + 273.15;
        Dlndjs_Dlnd_T[7] = 90 + 273.15;

        Dlndjs_Dlnd_P[0] = 0.1F;
        Dlndjs_Dlnd_P[1] = 1;
        Dlndjs_Dlnd_P[2] = 2;
        Dlndjs_Dlnd_P[3] = 3;
        Dlndjs_Dlnd_P[4] = 4;
        Dlndjs_Dlnd_P[5] = 5;
        Dlndjs_Dlnd_P[6] = 6;
        Dlndjs_Dlnd_P[7] = 7;
        Dlndjs_Dlnd_P[8] = 8;
        Dlndjs_Dlnd_P[9] = 9;
        Dlndjs_Dlnd_P[10] = 10;
        Dlndjs_Dlnd_Data[0][0] = 976;
        Dlndjs_Dlnd_Data[1][0] = 1027;
        Dlndjs_Dlnd_Data[2][0] = 1071;
        Dlndjs_Dlnd_Data[3][0] = 1123;
        Dlndjs_Dlnd_Data[4][0] = 1167;
        Dlndjs_Dlnd_Data[5][0] = 1213;
        Dlndjs_Dlnd_Data[6][0] = 1260;
        Dlndjs_Dlnd_Data[7][0] = 1303;
        Dlndjs_Dlnd_Data[0][1] = 991;
        Dlndjs_Dlnd_Data[1][1] = 1040;
        Dlndjs_Dlnd_Data[2][1] = 1082;
        Dlndjs_Dlnd_Data[3][1] = 1135;
        Dlndjs_Dlnd_Data[4][1] = 1178;
        Dlndjs_Dlnd_Data[5][1] = 1224;
        Dlndjs_Dlnd_Data[6][1] = 1270;
        Dlndjs_Dlnd_Data[7][1] = 1312;
        Dlndjs_Dlnd_Data[0][2] = 1014;
        Dlndjs_Dlnd_Data[1][2] = 1063;
        Dlndjs_Dlnd_Data[2][2] = 1106;
        Dlndjs_Dlnd_Data[3][2] = 1153;
        Dlndjs_Dlnd_Data[4][2] = 1196;
        Dlndjs_Dlnd_Data[5][2] = 1239;
        Dlndjs_Dlnd_Data[6][2] = 1281;
        Dlndjs_Dlnd_Data[7][2] = 1323;
        Dlndjs_Dlnd_Data[0][3] = 1044;
        Dlndjs_Dlnd_Data[1][3] = 1091;
        Dlndjs_Dlnd_Data[2][3] = 1127;
        Dlndjs_Dlnd_Data[3][3] = 1174;
        Dlndjs_Dlnd_Data[4][3] = 1216;
        Dlndjs_Dlnd_Data[5][3] = 1257;
        Dlndjs_Dlnd_Data[6][3] = 1297;
        Dlndjs_Dlnd_Data[7][3] = 1338;
        Dlndjs_Dlnd_Data[0][4] = 1073;
        Dlndjs_Dlnd_Data[1][4] = 1118;
        Dlndjs_Dlnd_Data[2][4] = 1149;
        Dlndjs_Dlnd_Data[3][4] = 1195;
        Dlndjs_Dlnd_Data[4][4] = 1236;
        Dlndjs_Dlnd_Data[5][4] = 1275;
        Dlndjs_Dlnd_Data[6][4] = 1313;
        Dlndjs_Dlnd_Data[7][4] = 1352;
        Dlndjs_Dlnd_Data[0][5] = 1114;
        Dlndjs_Dlnd_Data[1][5] = 1151;
        Dlndjs_Dlnd_Data[2][5] = 1180;
        Dlndjs_Dlnd_Data[3][5] = 1224;
        Dlndjs_Dlnd_Data[4][5] = 1261;
        Dlndjs_Dlnd_Data[5][5] = 1297;
        Dlndjs_Dlnd_Data[6][5] = 1333;
        Dlndjs_Dlnd_Data[7][5] = 1372;
        Dlndjs_Dlnd_Data[0][6] = 1156;
        Dlndjs_Dlnd_Data[1][6] = 1185;
        Dlndjs_Dlnd_Data[2][6] = 1211;
        Dlndjs_Dlnd_Data[3][6] = 1253;
        Dlndjs_Dlnd_Data[4][6] = 1287;
        Dlndjs_Dlnd_Data[5][6] = 1320;
        Dlndjs_Dlnd_Data[6][6] = 1352;
        Dlndjs_Dlnd_Data[7][6] = 1391;
        Dlndjs_Dlnd_Data[0][7] = 1207;
        Dlndjs_Dlnd_Data[1][7] = 1230;
        Dlndjs_Dlnd_Data[2][7] = 1250;
        Dlndjs_Dlnd_Data[3][7] = 1289;
        Dlndjs_Dlnd_Data[4][7] = 1318;
        Dlndjs_Dlnd_Data[5][7] = 1346;
        Dlndjs_Dlnd_Data[6][7] = 1374;
        Dlndjs_Dlnd_Data[7][7] = 1412;
        Dlndjs_Dlnd_Data[0][8] = 1261;
        Dlndjs_Dlnd_Data[1][8] = 1276;
        Dlndjs_Dlnd_Data[2][8] = 1289;
        Dlndjs_Dlnd_Data[3][8] = 1324;
        Dlndjs_Dlnd_Data[4][8] = 1350;
        Dlndjs_Dlnd_Data[5][8] = 1373;
        Dlndjs_Dlnd_Data[6][8] = 1396;
        Dlndjs_Dlnd_Data[7][8] = 1432;
        Dlndjs_Dlnd_Data[0][9] = 1331;
        Dlndjs_Dlnd_Data[1][9] = 1331;
        Dlndjs_Dlnd_Data[2][9] = 1335;
        Dlndjs_Dlnd_Data[3][9] = 1366;
        Dlndjs_Dlnd_Data[4][9] = 1385;
        Dlndjs_Dlnd_Data[5][9] = 1403;
        Dlndjs_Dlnd_Data[6][9] = 1424;
        Dlndjs_Dlnd_Data[7][9] = 1456;
        Dlndjs_Dlnd_Data[0][10] = 1405;
        Dlndjs_Dlnd_Data[1][10] = 1389;
        Dlndjs_Dlnd_Data[2][10] = 1383;
        Dlndjs_Dlnd_Data[3][10] = 1409;
        Dlndjs_Dlnd_Data[4][10] = 1421;
        Dlndjs_Dlnd_Data[5][10] = 1435;
        Dlndjs_Dlnd_Data[6][10] = 1451;
        Dlndjs_Dlnd_Data[7][10] = 1482;

        if (tempT < Dlndjs_Dlnd_T[0])
        {
            tempT = Dlndjs_Dlnd_T[0];
        }
        if (tempT > Dlndjs_Dlnd_T[7])
        {
            tempT = Dlndjs_Dlnd_T[7];
        }
        if (tempP_jy < Dlndjs_Dlnd_P[0])
        {
            tempP_jy = Dlndjs_Dlnd_P[0];
        }
        if (tempP_jy > Dlndjs_Dlnd_P[10])
        {
            tempP_jy = Dlndjs_Dlnd_P[10];
        }

        for (  i = 0; i <= 6; i++)
        {
            if (tempT >= Dlndjs_Dlnd_T[i] && tempT <= Dlndjs_Dlnd_T[i + 1])
            {
                m = i;
                break;
            }
        }

        for (i = 0; i <= 9; i++)
        {
            if (tempP_jy >= Dlndjs_Dlnd_P[i] && tempP_jy <= Dlndjs_Dlnd_P[i + 1])
            {
                n = i;
                break;
            }
        }

        if (Dlndjs_Dlnd_P[n + 1] - Dlndjs_Dlnd_P[n] != 0)
        {
            ky = (tempP_jy - Dlndjs_Dlnd_P[n]) / (Dlndjs_Dlnd_P[n + 1] - Dlndjs_Dlnd_P[n]);
        }
        else
        {
            ky = 0;
        }
        if (Dlndjs_Dlnd_T[m + 1] - Dlndjs_Dlnd_T[m] != 0)
        {
            kx = (tempT - Dlndjs_Dlnd_T[m]) / (Dlndjs_Dlnd_T[m + 1] - Dlndjs_Dlnd_T[m]);
        }
        else
        {
            kx = 0;
        }
        s1 = Dlndjs_Dlnd_Data[m][n] + (Dlndjs_Dlnd_Data[m][n + 1] - Dlndjs_Dlnd_Data[m][n]) * ky;
        s2 = Dlndjs_Dlnd_Data[m + 1][n] + (Dlndjs_Dlnd_Data[m + 1][n + 1] - Dlndjs_Dlnd_Data[m + 1][n]) * ky;
        return (s1 + (s2 - s1) * kx) / 100000.0D;
    }

    /**
     * 压力损失计算（适配多节流装置类型，需在FlowController中补充）
     * @param Cd 流出系数
     * @param beta 直径比
     * @param dp 差压(Pa)
     * @param coreType 节流装置类型
     * @return 压力损失(Pa)
     */
// 注：该方法原在FlowController中，此处补充扩展逻辑
    public static double YaLiSunShi(double Cd, double beta, double dp, int coreType) {
        return switch (coreType) {
            case 0 -> // 孔板（原有逻辑保留）
                    dp * (1 - Math.pow(beta, 4)) / (Cd * Cd);
            case 1 -> // 喷嘴（新增）
                    dp * 0.1; // 喷嘴压力损失约为差压的10%（经验值）
            case 2 -> // 文丘里管（新增）
                    dp * 0.05; // 文丘里管压力损失约为差压的5%（经验值）
            default -> throw new IllegalArgumentException("不支持的节流装置类型，无法计算压力损失");
        };
    }

}
