package com.ruoyi.caltools.controller;

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

import java.math.BigDecimal;
import java.math.RoundingMode;

public class NozellFlowCalc {


        // 喷嘴类型枚举
        public enum NozzleType {
            TOROIDAL, CYLINDRICAL
        }

        // 计算流出系数
        public static double calculateDischargeCoefficient(NozzleType nozzleType, double reynoldsNumber) {
            double a, b, c, d, e, f, n;
            switch (nozzleType) {
                case TOROIDAL:
                    a = 0.9990;
                    b = 3.415;
                    c = 0.0031;
                    d = 0.690;
                    e = 10;
                    f = 120000;
                    n = 0.5;
                    break;
                case CYLINDRICAL:
                    a = 1.0000;
                    b = 6.341;
                    c = 0.008; // 假设天然气，按用户场景取c值
                    d = 3.000;
                    e = 6;
                    f = 170000;
                    n = 0.5;
                    break;
                default:
                    throw new IllegalArgumentException("不支持的喷嘴类型");
            }

            double numerator = c - d * Math.pow(reynoldsNumber, -n);
            double denominator = 1 + Math.exp(e - reynoldsNumber / f);
            return (a - b * Math.pow(reynoldsNumber, -n)) - numerator / denominator;
        }

        // 计算雷诺数
        public static double calculateReynoldsNumber(double pipeDiameter, double velocity, double dynamicViscosity, double density) {
            return (pipeDiameter * velocity * density) / dynamicViscosity;
        }

        // 迭代计算流出系数和雷诺数
        public static void iterativeCalculation(FlowProps flowProps, GasProps gasProps, NozzleType nozzleType) {
            double tolerance = 1e-6;
            int maxIterations = 100;
            double prevCd = 0;
            double prevRe = 0;

            for (int i = 0; i < maxIterations; i++) {
                double velocity = calculateVelocity(flowProps, gasProps);
                double reynoldsNumber = calculateReynoldsNumber(
                        flowProps.getdPipeD(),
                        velocity,
                        gasProps.getdMu(),
                        gasProps.dRhof
                );
                double cd = calculateDischargeCoefficient(nozzleType, reynoldsNumber);

                // 检查收敛
                if (Math.abs(cd - prevCd) < tolerance && Math.abs(reynoldsNumber - prevRe) < tolerance) {
                    flowProps.setdCdCorrect(cd);
                    flowProps.setdRnPipe(reynoldsNumber);
                    return;
                }

                prevCd = cd;
                prevRe = reynoldsNumber;
            }
            throw new RuntimeException("迭代未收敛");
        }

        // 计算流速
        private static double calculateVelocity(FlowProps flowProps, GasProps gasProps) {
            // 假设工况体积流量计算逻辑，需根据实际流量公式补充
            // 这里简化示例，实际需根据ISO公式结合临界流函数等计算
            return flowProps.getdVFlowf() / (Math.PI * Math.pow(flowProps.getdPipeD() / 2, 2));
        }

        // 计算质量流量（示例）
        public static double calculateMassFlow(FlowProps flowProps, GasProps gasProps, NozzleType nozzleType) {
            iterativeCalculation(flowProps, gasProps, nozzleType);
            double criticalFlowFactor = gasProps.dCstar;
            double area = Math.PI * Math.pow(flowProps.getdOrificeD() / 2, 2);
            double pressure = flowProps.getdPf();
            double temperature = flowProps.getdTf();
            double gasConstant = calculateGasConstant(gasProps);

            // 根据ISO公式计算理论质量流量，再结合流出系数
            double theoreticalMassFlow = area * criticalFlowFactor * pressure / Math.sqrt((gasConstant / gasProps.dMrx) * temperature);
            return flowProps.getdCdCorrect() * theoreticalMassFlow;
        }

        // 计算气体常数（示例）
        private static double calculateGasConstant(GasProps gasProps) {
            return 8.314 / gasProps.dMrx; // 通用气体常数处理，需根据实际精确计算
        }

        // 高精度计算辅助方法
        private static double highPrecisionCalculate(double value, int scale) {
            return new BigDecimal(value).setScale(scale, RoundingMode.HALF_UP).doubleValue();
        }
//
//        public static void main(String[] args) {
//            FlowProps flowProps = new FlowProps();
//            GasProps gasProps = new GasProps();
//            NozzleType nozzleType = NozzleType.CYLINDRICAL;
//
//            // 初始化输入参数
//            flowProps.dPipeD = 0.1; // 示例管道直径
//            flowProps.dOrificeD = 0.05; // 示例喉径
//            gasProps.dMu = 0.00001; // 示例动力粘度
//            gasProps.dRhof = 1.0; // 示例工况密度
//            gasProps.dCstar = 0.9; // 示例临界流函数
//
//            // 执行计算
//            double massFlow = calculateMassFlow(flowProps, gasProps, nozzleType);
//            System.out.println("计算的质量流量: " + massFlow);
//        }




}
