原水反馈 , 用曲线计算, 频率偏低, 人为增加0.5HZ

tangxu

2023-03-20 3bf8bf5179de8b83bbd6ad997e82d98302abd1c3

 Calculation/IStation.Calculation.Dispatch/helper/DispatchAnaGeneralHelperѹÁ¦.cs

@@ -22,7 +22,7 @@
        /// <summary>
        /// 
        /// </summary>
        static public double ExtendMaxRatio = 1.25;//最大延长率 25%
        static public double ExtendMaxRatio = 1.25;//曲线最大延长率 25%
        /// <summary>
        /// 
        /// </summary>
@@ -32,23 +32,20 @@
        /// </summary>
        static public double ChangeFrequenceSpaece = 0.5;//频率变化值(粗算)

        //private double _defaultInletDia = 1000;
        //private double _defaultOutletDia = 800;
        ///// <summary>
        ///// 
        ///// </summary>
        ///// <param name="inletDia"></param>
        ///// <param name="outletDia"></param>
        //public void SetDia(double inletDia, double outletDia)
        //{
        //    this._defaultInletDia = inletDia;
        //    this._defaultOutletDia = outletDia;
        //}
        private double _targetQmaxDefaultPercent = 125;
        /// <summary>
        ///  æµé‡èŒƒå›´æœ€å¤§ç™¾åˆ†æ¯” 0 è¡¨ç¤ºæ²¡æœ‰è®¾ç½®(至少大于100)
        /// </summary>
        public double TargetQmaxDefaultPercent { get { return _targetQmaxDefaultPercent; } set { _targetQmaxDefaultPercent = value; } }  

        private double _targetQinDefaultPercent = 85;


        private double _targetQ;
        private double _targetInletPress;
        private double _targetOutletPress;
        private double _targetQmax, _targetQmin;


        private List<IStation.Calculation.DispatchAna.Model.MachineRunFilter> _machineRunFilterList = null;
        private List<long> _must_open_machine_array = null;
@@ -117,7 +114,15 @@
                error_info = "流量值过低无法分析";
                return false;
            }
            if(this._targetOutletPress<= this._targetInletPress + 0.01)
            double min_rated_h = 1000;
            foreach(var m in pipeMachineList)
            {
                if (m.RatedH < 0.1)
                    continue;

                min_rated_h = Math.Min(min_rated_h, m.RatedH);
            }
            if (this._targetOutletPress <= this._targetInletPress + min_rated_h / 2000)
            {
                error_info = "进出口压力值设置不合理";
                return false;
@@ -126,8 +131,12 @@
            this._allMachineList = pipeMachineList;


            this._targetQmax = targetQ * 1.25;
            this._targetQmin = targetQ * 0.85;

            if(_targetQmaxDefaultPercent >101)
                this._targetQmax = targetQ * _targetQmaxDefaultPercent / 100;
            else
                this._targetQmax = targetQ * 1.25;
            this._targetQmin = targetQ * _targetQinDefaultPercent /100;
            if (!string.IsNullOrEmpty(MinQ))
            {
                double minq = targetQ;
@@ -285,7 +294,7 @@
        /// <param name="SchemeSortType"></param>
        /// <param name="ReturnSchemeNumber"></param>
        /// <returns></returns>
        public List<IStation.Calculation.DispatchAna.Model.AnaScheme> CalcOptList( 
        public List<IStation.Calculation.DispatchAna.Model.AnaScheme> CalcOptList(
            IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType SchemeSortType,
            int ReturnSchemeNumber)
        {
@@ -293,15 +302,45 @@
            {
                return null;
            }
 

            #region  é¢„算一下
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> all_machine_ana_result_list =
                new List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>();
            bool isHaveFrequency = false;
            foreach (var machine in this._allMachineList)
            {
                if (machine.IsFrequency)
                {//变频泵
                    isHaveFrequency = true;
                    break;
                }
            }

            if (isHaveFrequency)
            {
                return CalcOptList有变频(SchemeSortType, ReturnSchemeNumber);
            }
            else
            {
                return CalcOptList无变频(SchemeSortType, ReturnSchemeNumber);
            }
        }

        /// <summary>
        /// æœ‰å˜é¢‘æ³µ
        /// </summary>
        /// <param name="SchemeSortType"></param>
        /// <param name="ReturnSchemeNumber"></param>
        /// <returns></returns>
        private List<IStation.Calculation.DispatchAna.Model.AnaScheme> CalcOptList有变频(
                     IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType SchemeSortType,
                     int ReturnSchemeNumber)
        {
            #region é¢„算一下
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> all_machine_ana_result_list =
            new List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>();
            int frequency_pump_count = 0;
            foreach (var machine in this._allMachineList)
            {
                if (machine.IsFrequency)
                {//变频泵
                    frequency_pump_count++;
                    var anaData = GetFrePumpAnaData(machine);
                    if (anaData != null)
                    {
@@ -325,17 +364,69 @@
            {
                return null;
            }
            else if (all_machine_ana_result_list.Count() == 1)
            if (frequency_pump_count > 0)
            {
                var first_pump = all_machine_ana_result_list.First();
                first_pump.AsFrequency = true;
                IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[] open_machine_list = new
                     IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[] { first_pump };
                AnaMahineComb(open_machine_list);
                #region æœ‰å˜é¢‘æ³µ,可以精确计算
                if (all_machine_ana_result_list.Count() == 1)
                {
                    var first_pump = all_machine_ana_result_list.First();
                    first_pump.AsFrequency = true;
                    IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[] open_machine_list = new
                         IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[] { first_pump };
                    AnaMahineComb(open_machine_list);
                }
                else
                {
                    int max_fre_num = 2;//最多变频2台, å…¶ä½™çš„即使变频,也按50HZ运行
                    var arry_allMachineList = all_machine_ana_result_list.ToArray();
                    for (int openPumpNum = 1; openPumpNum <= all_machine_ana_result_list.Count(); openPumpNum++)
                    {
                        //得到所有排列组合 
                        List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[]> open_machine_combine_list =
                            IStation.Model.PermutationAndCombination<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>.GetCombination(
                                arry_allMachineList, openPumpNum);

                        foreach (var open_machine_list in open_machine_combine_list)
                        {
                            var fre_machines = (from x in open_machine_list where x.IsFrequency select x).ToArray();

                            if (fre_machines.Count() > max_fre_num)
                            {//最多把2台泵当作变频泵运行, å…¶ä½™æŒ‰å·¥é¢‘泵运行
                                List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[]> real_fre_machine_combine_list =
                     IStation.Model.PermutationAndCombination<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>.GetCombination(
                     fre_machines, max_fre_num);//排列组合,找里面的2台

                                foreach (var real_fre_machine_list in real_fre_machine_combine_list)
                                {
                                    foreach (var m in fre_machines)
                                    {//先把所有变频泵当作工频泵
                                        m.AsFrequency = false;
                                    }
                                    foreach (var m in real_fre_machine_list)
                                    {//把排列组合中的两台设置位变频泵
                                        m.AsFrequency = true;
                                    }
                                    int ana_ret = AnaMahineComb(open_machine_list);
                                }

                            }
                            else
                            {
                                foreach (var m in fre_machines)
                                {
                                    if (m.IsFrequency)
                                        m.AsFrequency = true;
                                }
                                int ana_ret = AnaMahineComb(open_machine_list);
                            }
                        }
                    }
                }
                #endregion
            }
            else
            {
                int max_fre_num = 2;//最多变频2台, å…¶ä½™çš„即使变频,也按50HZ运行
                #region éƒ½æ˜¯å·¥é¢‘æ³µ
                var arry_allMachineList = all_machine_ana_result_list.ToArray();
                for (int openPumpNum = 1; openPumpNum <= all_machine_ana_result_list.Count(); openPumpNum++)
                {
@@ -346,39 +437,10 @@

                    foreach (var open_machine_list in open_machine_combine_list)
                    {
                        var fre_machines = (from x in open_machine_list where x.IsFrequency select x).ToArray();

                        if (fre_machines.Count() > max_fre_num)
                        {//最多把2台泵当作变频泵运行, å…¶ä½™æŒ‰å·¥é¢‘泵运行
                            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[]> real_fre_machine_combine_list =
                 IStation.Model.PermutationAndCombination<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>.GetCombination(
                 fre_machines, max_fre_num);//排列组合,找里面的2台

                            foreach (var real_fre_machine_list in real_fre_machine_combine_list)
                            {
                                foreach (var m in fre_machines)
                                {//先把所有变频泵当作工频泵
                                    m.AsFrequency = false;
                                }
                                foreach (var m in real_fre_machine_list)
                                {//把排列组合中的两台设置位变频泵
                                    m.AsFrequency = true;
                                }
                                int ana_ret = AnaMahineComb(open_machine_list);
                            }

                        }
                        else
                        {
                            foreach (var m in fre_machines)
                            {
                                if (m.IsFrequency)
                                    m.AsFrequency = true;
                            }
                            int ana_ret =  AnaMahineComb(open_machine_list);
                        }
                        int ana_ret = AnaMahineComb(open_machine_list);
                    }
                }
                #endregion
            }

            #endregion
@@ -420,6 +482,232 @@
        }

        /// <summary>
        /// æ²¡æœ‰å˜é¢‘æ³µ,全是工频泵
        /// </summary>
        /// <param name="SchemeSortType"></param>
        /// <param name="ReturnSchemeNumber"></param>
        /// <returns></returns>
        private List<IStation.Calculation.DispatchAna.Model.AnaScheme> CalcOptList无变频 (
                     IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType SchemeSortType,
                     int ReturnSchemeNumber)
        {
            //
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> all_machine_ana_result_list =
            new List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>();

            foreach (var machine in this._allMachineList)
            {
                var anaData = GetFixPumpAnaData(machine);
                if (anaData != null)
                {
                    all_machine_ana_result_list.Add(anaData);
                }
            }
            if (all_machine_ana_result_list.Count() == 0)
            {
                return null;
            }

            #region  å¼€å§‹åˆ†æž
            _anaSchemeList = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();


            var ds_disp_project_list = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();

            var arry_allMachineList = all_machine_ana_result_list.ToArray();
            for (int openPumpNum = 1; openPumpNum <= all_machine_ana_result_list.Count(); openPumpNum++)
            {
                //得到所有排列组合 
                List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[]> open_machine_combine_list =
                    IStation.Model.PermutationAndCombination<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>.GetCombination(
                        arry_allMachineList, openPumpNum);

                foreach (var open_machine_list in open_machine_combine_list)
                {
                    //检查是否符合开机约束
                    List<long> machine_ids = (from x in open_machine_list select x.MachineID).ToList();
                    if (!IsAccordMachineRunFilter(machine_ids))
                    {
                        continue;
                    }
                    var total_flow = (from x in open_machine_list select x.AnaItem50Hz.WorkPointQ).Sum();
                    if (total_flow > _targetQmax || total_flow < this._targetQmin)
                    {
                        continue;
                    }

                    var project = new IStation.Calculation.DispatchAna.Model.AnaScheme();
                    project.ID = 1;
                    project.TotalWrkQ = total_flow;
   
                    project.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();

                    foreach (var fixPump in open_machine_list)
                    {
                        if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                            continue;

                        var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);

                        project.Items.Add(itemRow);
                    }

                    project.TotalWrkP = (from x in project.Items where x.WorkPointP > 0 select x.WorkPointP).Sum();
                
                    var default_pump = open_machine_list.FirstOrDefault();
                    project.TotalWrkH = Math.Round(this.CalcHeadByPress(this._targetInletPress,
                        this._targetOutletPress,
                        default_pump.MachineDetail.InletCaliber, default_pump.MachineDetail.OutletCaliber,
                        total_flow / open_machine_list.Count()), 3);
                    project.TotalWrkE = IStation.Common.PumpParaHelper.CalculateE(project.TotalWrkQ, project.TotalWrkH, project.TotalWrkP);
                    project.UWP = Math.Round(project.UWP, 3);
                    project.WP = Math.Round(project.WP, 3);
                    project.SpanQ = Math.Round(project.TotalWrkQ - _targetQ, 0);
                    project.CalcItemParas();

                    ds_disp_project_list.Add(project);
                }
            }
            #endregion

 



            // 0 åŠŸçŽ‡ 1 æµé‡é—´éš”
            if (SchemeSortType == IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType.功率)
                ds_disp_project_list = (from x in ds_disp_project_list orderby x.TotalWrkP select x).ToList();
            else if (SchemeSortType == IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType.流量差值)
                ds_disp_project_list = (from x in ds_disp_project_list orderby Math.Abs(x.SpanQ) select x).ToList();


            //重新编号ID
            for (int i = 0; i < ds_disp_project_list.Count; i++)
            {
                ds_disp_project_list[i].ID = i + 1;
            }

            if (ReturnSchemeNumber <= 0)
                return ds_disp_project_list;
            else
                return ds_disp_project_list.Take(ReturnSchemeNumber).ToList();
        }


        /// <summary>
        /// æ²¡æœ‰å˜é¢‘æ³µ,全是工频泵
        /// </summary>
        /// <param name="SchemeSortType"></param>
        /// <param name="ReturnSchemeNumber"></param>
        /// <returns></returns>
        private List<IStation.Calculation.DispatchAna.Model.AnaScheme> CalcOptList无变频_最近(
                     IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType SchemeSortType,
                     int ReturnSchemeNumber)
        {
            //
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> all_machine_ana_result_list =
            new List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>();

            foreach (var machine in this._allMachineList)
            {
                var anaData = GetFixPumpAnaData(machine);
                if (anaData != null)
                {
                    all_machine_ana_result_list.Add(anaData);
                }
            }
            if (all_machine_ana_result_list.Count() == 0)
            {
                return null;
            }

            #region  å¼€å§‹åˆ†æž
            _anaSchemeList = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();

            double total_flow_最靠近 = 0;
            double total_flow_最靠近_dis = this._targetQ * 2;
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> open_machine_combine_list_最靠近 = null;

            var arry_allMachineList = all_machine_ana_result_list.ToArray();
            for (int openPumpNum = 1; openPumpNum <= all_machine_ana_result_list.Count(); openPumpNum++)
            {
                //得到所有排列组合 
                List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[]> open_machine_combine_list =
                    IStation.Model.PermutationAndCombination<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>.GetCombination(
                        arry_allMachineList, openPumpNum);

                foreach (var open_machine_list in open_machine_combine_list)
                {
                    //检查是否符合开机约束
                    List<long> machine_ids = (from x in open_machine_list select x.MachineID).ToList();

                    if (!IsAccordMachineRunFilter(machine_ids))
                    {
                        continue;
                    }
                    var total_flow = (from x in open_machine_list select x.AnaItem50Hz.WorkPointQ).Sum();
                    if (Math.Abs(this._targetQ - total_flow) < total_flow_最靠近_dis)
                    {
                        if (total_flow_最靠近 < total_flow)
                        {
                            if ((Math.Abs(total_flow_最靠近 - total_flow) / this._targetQ) < 10)
                                continue;
                        }
                        total_flow_最靠近 = total_flow;
                        total_flow_最靠近_dis = Math.Abs(total_flow_最靠近 - total_flow);
                        open_machine_combine_list_最靠近 = open_machine_list.ToList();
                    }
                }
            }
            #endregion

            if (total_flow_最靠近 > _targetQmax && total_flow_最靠近 < this._targetQmin)
                return null;
            var project = new IStation.Calculation.DispatchAna.Model.AnaScheme();
            project.ID = 1;
            project.TotalWrkQ = total_flow_最靠近;

            var default_pump = open_machine_combine_list_最靠近.FirstOrDefault();
            project.TotalWrkH = Math.Round(this.CalcHeadByPress(this._targetInletPress,
                this._targetOutletPress,
                default_pump.MachineDetail.InletCaliber, default_pump.MachineDetail.OutletCaliber,
                total_flow_最靠近 / open_machine_combine_list_最靠近.Count()), 3);
            project.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();

            foreach (var fixPump in open_machine_combine_list_最靠近)
            {
                if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                    continue;

                var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);

                project.Items.Add(itemRow);
            }


            var ds_disp_project_list = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();

     
            ds_disp_project_list.Add(project);

            project.UWP = Math.Round(project.UWP, 3);
            project.WP = Math.Round(project.WP, 3);
            project.SpanQ = Math.Round(project.TotalWrkQ - _targetQ, 0);
            project.CalcItemParas();


            // 0 åŠŸçŽ‡ 1 æµé‡é—´éš”
            if (SchemeSortType == IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType.功率)
                ds_disp_project_list = (from x in ds_disp_project_list orderby x.TotalWrkP select x).ToList();
            else if (SchemeSortType == IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType.流量差值)
                ds_disp_project_list = (from x in ds_disp_project_list orderby Math.Abs(x.SpanQ) select x).ToList();


            return ds_disp_project_list;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="open_machine_list"></param>
@@ -439,12 +727,16 @@
            int fre_pump_count = 0;
            double total_min_flow_开机泵 = 0;
            double total_max_flow_开机泵 = 0;
           
            foreach (var machine in open_machine_list)
            {
                if (machine.AnaItem50Hz == null)
                    return 0;

                total_max_flow_开机泵 += machine.AnaItem50Hz.CurveInfoQH.Max;

                if (machine.IsFrequency)
                {
                {            
                    if (!machine.AsFrequency)
                    {
                        fixPumpAnaCombine.Add(machine);
@@ -483,10 +775,10 @@
            if (fre_pump_count == 0)
            {//只用固频泵即可
                var ret = AddOnlyFixPumpPrj(open_machine_list, _targetQ);
                if(ret == null)
                    return 0;
                else
                if (ret)
                    return 1;
                else
                    return 0;
            }
            else if (fre_pump_count == 1)
            {  //只有一台变频泵
@@ -713,7 +1005,7 @@
            anaData.CurveInfoQH = Machine.MaxCurveInfoQH;
            anaData.CurveInfoQP = Machine.MaxCurveInfoQP;
            anaData.Frequence = 50;
            anaData.Speed = Machine.Ratedn;
            anaData.Speed = Machine.RatedN;

            return new IStation.Calculation.DispatchAna.Model.FixPumpAnaData() { MachineID = Machine.MachineID, MachineDetail = Machine, AnaItem50Hz = anaData };
        }
@@ -1385,11 +1677,10 @@


        #region æ·»åŠ é¡¹ç›® (只用固频泵)
        private IStation.Calculation.DispatchAna.Model.AnaScheme AddOnlyFixPumpPrj(
        private bool AddOnlyFixPumpPrj(
            IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[] fixPumpAnaDataList,
            double totalQ)
        {
            //
            int pump_count = fixPumpAnaDataList.Count();
            var default_pump = fixPumpAnaDataList.First();
            var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();
@@ -1410,9 +1701,7 @@

                rowPrj.Items.Add(itemRow);
            }
            AddScheme(rowPrj, false);

            return rowPrj;
            return AddScheme(rowPrj, false);
        }
        #endregion

@@ -1435,16 +1724,17 @@

            int addPrjNum = 0;
            var freqPump = allFreqPumpAnaList.FirstOrDefault();
            { 
            {
                var frePump_flow = (this._targetQ - fix_pump_total_flow);
                double h = //this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress);
                    Math.Round(this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress,
                        freqPump.MachineDetail.InletCaliber, freqPump.MachineDetail.OutletCaliber,
                        (this._targetQ - fix_pump_total_flow) ), 3);

                        freqPump.MachineDetail.InletCaliber, freqPump.MachineDetail.OutletCaliber, frePump_flow), 3);
                var dp = new IStation.Model.CurvePoint(frePump_flow, h);
                var wrkSpeed = IStation.Common.SpeedSimuCalculer.GetSimuValue(
                                 freqPump.MachineDetail.MaxCurveInfoQH,
                                 new IStation.Model.CurvePoint(_targetQ - fix_pump_total_flow, h), 2900);

                                 dp, 2900);
                if (wrkSpeed < 0)
                    return 0;//
                IStation.Calculation.DispatchAna.Model.AnaCurveItem currentAna = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();

                double fre = Math.Round(50 * wrkSpeed / 2900, 1);