using IStation.Calculation.DispatchAna.Model;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Crypto.IO;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.PortableExecutable;
using System.Text;
using System.Threading.Tasks;

namespace IStation.Calculation.DispatchAna.Common
{
    /// <summary>
    /// 调度分析(核心算法)
    /// </summary>
    public class DispatchAnaGeneralHelper压力
    {
        /// <summary>
        /// 
        /// </summary>
        static public double MinFlowIngore = 50;//流量低于多少就不考虑了
        /// <summary>
        /// 
        /// </summary>
        static public double ExtendMaxRatio = 1.25;//曲线最大延长率 25%
        /// <summary>
        /// 
        /// </summary>
        static public double MinChangeFrequence = 15;//最小变化的频率
        /// <summary>
        /// 
        /// </summary>
        static public double ChangeFrequenceSpaece = 0.5;//频率变化值(粗算)

        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;
        private List<long> _must_close_machine_array = null;
        private Dictionary<long, double> _machine_flow_limit_max_dict = null;
        private Dictionary<long, double> _machine_flow_limit_min_dict = null;
        private int _max_open_machine_number = 0;//最多开机数量
        private List<IStation.Calculation.DispatchAna.Model.AnaScheme> _anaSchemeList = null;
        private List<IStation.Calculation.DispatchAna.Model.MachineDetail> _allMachineList = null;
        //组合运行约束(禁止判断)
        private List<IStation.Calculation.DispatchAna.Model.CombineRunJudge> _allCombineRunJudgeList4Forbid = null;
        //组合运行约束(必须判断)
        private List<List<long>> _allCombineRunJudgeList4Must = null;


        private bool _isAllowOverTargetPress = false;
        /// <summary>
        /// 是否允许超过目标压力, 但最小变频频率都比要求压力高时, 按最小频率开泵
        /// </summary>
        public bool IsAllowOverTargetPress { set { _isAllowOverTargetPress = value; } }

        /// <summary>
        /// 初始化参数
        /// </summary>
        /// <param name="targetQ"></param>
        /// <param name="inlet_para"></param>
        /// <param name="inlet_is_waterlevel"></param>
        /// <param name="outlet_para"></param>
        /// <param name="outlet_is_waterlevel"></param>
        /// <param name="MinQ"></param>
        /// <param name="MaxQ"></param>
        /// <param name="pipeMachineList"></param>
        /// <param name="MachineRunFilterList"></param>
        /// <param name="error_info"></param>
        /// <returns></returns>
        public bool InitialParas(
            double targetQ, 
            double inlet_para,bool inlet_is_waterlevel,
            double outlet_para,bool outlet_is_waterlevel,
            string MinQ, string MaxQ,
            List<IStation.Calculation.DispatchAna.Model.MachineDetail> pipeMachineList,
            List<IStation.Calculation.DispatchAna.Model.MachineRunFilter> MachineRunFilterList,
            out string error_info)
        { 
            if (inlet_is_waterlevel)
            {
                this._targetInletPress = Math.Round(inlet_para / 102, 4);
            }
            else
            {
                this._targetInletPress = Math.Round(inlet_para, 4);
            }

            if (outlet_is_waterlevel)
            {
                this._targetOutletPress = Math.Round(outlet_para / 102, 4);
            }
            else
            {
                this._targetOutletPress = outlet_para;
            }

            this._targetQ = targetQ;
            if (targetQ < 10)
            {
                error_info = "流量值过低无法分析";
                return false;
            }
            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;
            }

            this._allMachineList = pipeMachineList;



            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;
                if (MinQ.Contains("%"))
                {
                    double ratio;
                    if (double.TryParse(MinQ.Replace("%", ""), out ratio))
                    {
                        minq = targetQ * (1 - Math.Abs(ratio));
                    }
                }
                else
                {
                    double.TryParse(MinQ, out minq);
                }
                if (minq < targetQ)
                {
                    _targetQmin = minq;
                }
            }
            //IStation.LogHelper.Info("min_q:" + _targetQmin);

            if (!string.IsNullOrEmpty(MaxQ))
            {
                double maxq = targetQ;
                if (MaxQ.Contains("%"))
                {
                    double ratio;
                    if (double.TryParse(MaxQ.Replace("%", ""), out ratio))
                    {
                        maxq = targetQ * (1 + Math.Abs(ratio));
                    }
                }
                else
                {
                    double.TryParse(MaxQ, out maxq);
                }
                if (maxq > targetQ)
                {
                    _targetQmax = maxq;
                }
            }


            InitialFilter(MachineRunFilterList);

            error_info = null;
            return true;
        }

        #region 过滤
        private void InitialFilter(List<IStation.Calculation.DispatchAna.Model.MachineRunFilter> MachineRunFilterList)
        {
            this._machineRunFilterList = MachineRunFilterList;

            if (_machineRunFilterList != null)
            {
                _must_open_machine_array = null;
                _must_close_machine_array = null;
                _machine_flow_limit_max_dict = null;
                _machine_flow_limit_min_dict = null;
                foreach (var m in _machineRunFilterList)
                {
                    if (m.RunStatus == 1)
                    {
                        if (_must_open_machine_array == null)
                            _must_open_machine_array = new List<long>();

                        _must_open_machine_array.Add(m.MachineID);
                    }

                    if (m.RunStatus == 0)
                    {
                        if (_must_close_machine_array == null)
                            _must_close_machine_array = new List<long>();

                        _must_close_machine_array.Add(m.MachineID);
                    }

                    if (m.MaxFlow > 10)
                    {
                        if (this._machine_flow_limit_max_dict == null)
                            _machine_flow_limit_max_dict = new Dictionary<long, double>();
                        _machine_flow_limit_max_dict[m.MachineID] = m.MaxFlow;
                    }

                }

            }
        }

        //是否符合过滤
        private bool IsAccordMachineRunFilter(List<long> current_open_machine_id_array)
        {
            if (current_open_machine_id_array == null || current_open_machine_id_array.Count() == 0)
                return false;

            //必须开机
            if (_must_open_machine_array != null && _must_open_machine_array.Count > 0)
            {
                foreach (var machine_id in _must_open_machine_array)
                {
                    if (!current_open_machine_id_array.Contains(machine_id))
                        return false;
                }
            }

            //不能开机
            if (_must_close_machine_array != null && _must_close_machine_array.Count > 0)
            {
                foreach (var machine_id in current_open_machine_id_array)
                {
                    if (_must_close_machine_array.Contains(machine_id))
                        return false;
                }
            }

            //开机组合 约束(禁止)
            if (_allCombineRunJudgeList4Forbid != null && _allCombineRunJudgeList4Forbid.Count() > 0)
            {
                foreach (var combineRunJudge in _allCombineRunJudgeList4Forbid)
                {//符合禁止约束就不行
                    if (combineRunJudge.Judgement(current_open_machine_id_array))
                        return false;
                }
            }


            //开机组合 约束(必须)
            if (this._allCombineRunJudgeList4Must != null)
            {
                foreach (var item_arr in this._allCombineRunJudgeList4Must)
                {
                    var q = from a in item_arr join b in current_open_machine_id_array on a equals b select a;
                    bool flag = item_arr.Count == current_open_machine_id_array.Count && q.Count() == item_arr.Count;
                    if (!flag)
                        return false;
                }
            }

            //判断最大开机数
            if (_max_open_machine_number > 0)
            {
                if (current_open_machine_id_array.Count() > _max_open_machine_number)
                    return false;
            }
            return true;
        }
        #endregion


        /// <summary>
        /// 计算(最优)
        /// </summary> 
        /// <param name="SchemeSortType"></param>
        /// <param name="ReturnSchemeNumber"></param>
        /// <returns></returns>
        public List<IStation.Calculation.DispatchAna.Model.AnaScheme> CalcOptList(
            IStation.Calculation.DispatchAna.Model.eAnaSchemeSortType SchemeSortType,
            int ReturnSchemeNumber)
        {
            if (this._allMachineList == null || this._allMachineList.Count() == 0)
            {
                return null;
            }
            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)
                    {
                        all_machine_ana_result_list.Add(anaData);
                    }
                }
                else
                {//固频泵
                    var anaData = GetFixPumpAnaData(machine);
                    if (anaData != null)
                    {
                        all_machine_ana_result_list.Add(anaData);
                    }
                }
            }
            #endregion

            #region  开始分析
            _anaSchemeList = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();
            if (all_machine_ana_result_list.Count() == 0)
            {
                return null;
            }
            if (frequency_pump_count > 0)
            {
                #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
            {
                #region 都是工频泵
                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)
                    {
                        int ana_ret = AnaMahineComb(open_machine_list);
                    }
                }
                #endregion
            }

            #endregion

            if (_anaSchemeList.Count() == 0)
                return null;

            //计算
            var ds_disp_project_list = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();
            foreach (var project in _anaSchemeList)
            {
                //计算流量
                //project.TotalWrkQ = (from x in project.Items where x.WorkPointQ > 0 select x.WorkPointQ).Sum();
                if (project.TotalWrkQ <= _targetQmax && project.TotalWrkQ >= this._targetQmin)
                    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();

            //重新编号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>();


            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>
        private int AnaMahineComb(IStation.Calculation.DispatchAna.Model.PumpAnaDataBase[] open_machine_list)
        {
            List<long> machine_ids = (from x in open_machine_list select x.MachineID).ToList();

            #region 检查是否符合开机约束
            if (!IsAccordMachineRunFilter(machine_ids))
            {
                return 0;
            }
            #endregion

            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> fixPumpAnaCombine = new List<PumpAnaDataBase>();
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> frePumpAnaDataList = new List<PumpAnaDataBase>();
            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);
                        total_min_flow_开机泵 += machine.AnaItem50Hz.CurveInfoQH.Min;
                    }
                    else
                    {
                        frePumpAnaDataList.Add(machine);
                        fre_pump_count++;
                        total_min_flow_开机泵 += machine.AnaItemList.Last().WorkPointQ;//最小频率的流量
                    }
                }
                else
                {
                    total_min_flow_开机泵 += machine.AnaItem50Hz.CurveInfoQH.Min;
                    fixPumpAnaCombine.Add(machine);
                }
            }
            if (fre_pump_count > 0)
            {
                if (total_min_flow_开机泵 > _targetQmax * 1.02)
                {
                    //if(open_machine_list.Count() == 1 && this._isAllowOverTargetPress)
                    //{
                    //    return AddSinglePumpOver低(open_machine_list.FirstOrDefault(),_targetQ);
                    //}
                    return 0;
                }
                if (total_max_flow_开机泵 < _targetQmin * 0.98)
                {
                    return 0;
                }
            }


            if (fre_pump_count == 0)
            {//只用固频泵即可
                var ret = AddOnlyFixPumpPrj(open_machine_list, _targetQ);
                if (ret)
                    return 1;
                else
                    return 0;
            }
            else if (fre_pump_count == 1)
            {  //只有一台变频泵
                return AddSingleFreqPumpPrj1(fixPumpAnaCombine, frePumpAnaDataList);
            }
            else if (fre_pump_count == 2)
            { //有2台变频泵
                return AddMultiFreqPumpPrj2(fixPumpAnaCombine, frePumpAnaDataList);
            }
            else if (fre_pump_count == 3)
            {//有3台变频泵
                return AddMultiFreqPumpPrj3(fixPumpAnaCombine, frePumpAnaDataList);
            }
            else if (fre_pump_count == 4)
            {//有4台变频泵
                return AddMultiFreqPumpPrj4(fixPumpAnaCombine, frePumpAnaDataList);
            }
            else if (fre_pump_count == 5)
            {//有5台变频泵
                return AddMultiFreqPumpPrj5(fixPumpAnaCombine, frePumpAnaDataList);
            }
            else if (fre_pump_count == 6)
            {//有6台变频泵
                return AddMultiFreqPumpPrj5(fixPumpAnaCombine, frePumpAnaDataList);
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// 最小变频量都无法满足, 按最小变频, 超扬程运行
        /// </summary>
        /// <param name="freqPump"></param>
        /// <param name="targetQ"></param>
        /// <returns></returns>
        private int AddSinglePumpOver低(IStation.Calculation.DispatchAna.Model.PumpAnaDataBase freqPump, double targetQ)
        {
            if (freqPump == null)
                return 0;
            if (!freqPump.IsFrequency)
                return 0;//暂时只支持变频
 
            double ok_fre = 0;
            double ok_h = 0;
            IStation.Model.CurveExpress ok_curve_qh = null;
            double target_h = (this._targetOutletPress - this._targetInletPress) * 102;
            for (double fre = MinChangeFrequence; fre <= 50; fre++)
            {
                var qh_curve = IStation.Common.SpeedSimuCalculer.GetSimuPointQH(  freqPump.MachineDetail.MaxCurveInfoQH, 50, fre);
                if (targetQ > qh_curve.Max * 1.1)
                {
                    continue;
                }
                if (targetQ < qh_curve.Min * 0.8)
                {
                    continue;
                }

                var h_c = IStation.Model.FitCurveHelper.GetFitPointY(qh_curve, targetQ);
                if(h_c > target_h)
                {
                    ok_h = h_c;
                    ok_curve_qh = qh_curve;
                    ok_fre = fre;
                    break;
                }
            }
            if (ok_curve_qh == null)
                return 0;
  
            var min_curve_qp = IStation.Common.SpeedSimuCalculer.GetSimuPointQP(freqPump.MachineDetail.MaxCurveInfoQP, 50, ok_fre);

    
            var p = IStation.Model.FitCurveHelper.GetFitPointY(min_curve_qp, targetQ);




            IStation.Calculation.DispatchAna.Model.AnaCurveItem currentAna = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();

            currentAna.Note = "超所需扬程";
            currentAna.Status = 2;

            currentAna.Frequence = ok_fre;
            currentAna.CurveInfoQH = ok_curve_qh;
            currentAna.CurveInfoQP = min_curve_qp;
            currentAna.WorkPointQ = targetQ;
            currentAna.WorkPointH = ok_h;
            currentAna.WorkPointP = Math.Round(p, 1);
            currentAna.WorkPointE = Math.Round(IStation.Common.PumpParaHelper.CalculateE(
                currentAna.WorkPointQ, currentAna.WorkPointH, currentAna.WorkPointP), 1);

            currentAna.Speed = freqPump.MachineDetail.CalcSpeedByFrequence(ok_fre);


            var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();
            rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();
 
            var itemRowF = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump.MachineDetail, currentAna);
            rowPrj.Items.Add(itemRowF);

            AddScheme(rowPrj, false);
        


            return 1;
        }


        /// <summary>
        /// 计算(保持当前开泵状态)
        /// </summary>
        /// <param name="openMachineIdList"></param> 
        /// <returns></returns>
        public IStation.Calculation.DispatchAna.Model.AnaScheme CalcKeepStatus(List<long> openMachineIdList)
        {
            if (_allMachineList == null || _allMachineList.Count() == 0)
            {
                return null;
            }
            if (openMachineIdList == null || openMachineIdList.Count() == 0)
            {
                return null;
            }
            this._allCombineRunJudgeList4Must = new List<List<long>>();
            _allCombineRunJudgeList4Must.Add(openMachineIdList);

            #region 获取并预算一下

            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> all_machine_ana_result_list =
                new List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase>(); 
     
            foreach (var machine_id in openMachineIdList)
            {
                var machine = this._allMachineList.Find(x => x.MachineID == machine_id);
                if (machine == null)
                    continue;

                if (machine.IsFrequency)
                {//变频泵
                    var anaData = GetFrePumpAnaData(machine);
                    if (anaData != null)
                        all_machine_ana_result_list.Add(anaData);
                }
                else
                {//固频泵
                    var anaData = GetFixPumpAnaData(machine);
                    if (anaData != null)
                        all_machine_ana_result_list.Add(anaData);
                }
            }
            #endregion

            #region  开始分析
            _anaSchemeList = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();

            // AnaMahineComb(all_machine_ana_result_list.ToArray());
            int max_fre_num = 2;//最多变频2台, 其余的即使变频,也按50HZ运行

            var fre_machines = (from x in all_machine_ana_result_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;
                    }
                    AnaMahineComb(all_machine_ana_result_list.ToArray());
                }

            }
            else
            {
                foreach (var m in fre_machines)
                {
                    m.AsFrequency = true;
                }
                AnaMahineComb(all_machine_ana_result_list.ToArray());
            }

            #endregion

            if (_anaSchemeList.Count() == 0)
                return null;

            //计算
            var ds_disp_project_list = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();
            foreach (var project in _anaSchemeList)
            {
                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);
            }

            return (from x in ds_disp_project_list orderby x.TotalWrkP select x).FirstOrDefault();
        }

        #region 算出是否符合的固频泵:GetFixPumpAnaData
        private IStation.Calculation.DispatchAna.Model.FixPumpAnaData GetFixPumpAnaData(IStation.Calculation.DispatchAna.Model.MachineDetail Machine)
        {
            if (Machine == null)
                return null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem anaData = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
            if (CalcAnaCurve(Machine.MaxCurveInfoQH, Machine.MaxCurveInfoQP,
                this._targetInletPress, this._targetOutletPress, 
                Machine.InletCaliber , Machine.OutletCaliber, 50, ref anaData) <= 0)
                return null;

            anaData.CurveInfoQH = Machine.MaxCurveInfoQH;
            anaData.CurveInfoQP = Machine.MaxCurveInfoQP;
            anaData.Frequence = 50;
            anaData.Speed = Machine.RatedN;

            return new IStation.Calculation.DispatchAna.Model.FixPumpAnaData() { MachineID = Machine.MachineID, MachineDetail = Machine, AnaItem50Hz = anaData };
        }
        #endregion

        /// <summary>
        /// 
        /// </summary>
        /// <param name="InletPress"></param>
        /// <param name="OutletPress"></param>
        /// <param name="InletDia"></param>
        /// <param name="OutletDia"></param>
        /// <param name="Flow"></param>
        /// <returns></returns>
        private double CalcHeadByPress(double InletPress, double OutletPress, double? InletDia, double? OutletDia, double Flow)
        {
            //return (OutletPress - InletPress) * 102;
            double h4Press = (OutletPress - InletPress) * 102;
            if (Flow > 0  )
            {
                double rPipeInV = 0;
                if(InletDia.HasValue && InletDia > 0)
                {
                    rPipeInV = OtherPressCoeff * Flow / InletDia.Value / InletDia.Value;
                }
                double rPipeOutV = 0;
                if (OutletDia.HasValue && OutletDia > 0)
                {
                    rPipeOutV = OtherPressCoeff * Flow / OutletDia.Value / OutletDia.Value;
                }
                double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / 9.81 / 2.0;

                return h4Press + rVDif;
            }
            else
            {
                return h4Press;
            }
        }

        #region 算出是否符合的变频泵:GetFrePumpAnaData

        private IStation.Calculation.DispatchAna.Model.FrePumpAnaData GetFrePumpAnaData(
            IStation.Calculation.DispatchAna.Model.MachineDetail Machine)
        {
            if (Machine == null)
                return null;

            IStation.Calculation.DispatchAna.Model.FrePumpAnaData anaData = new IStation.Calculation.DispatchAna.Model.FrePumpAnaData();
            anaData.MachineID = Machine.MachineID;
            anaData.MachineDetail = Machine;
            anaData.AnaItemList = new List<IStation.Calculation.DispatchAna.Model.AnaCurveItem>();

          

            double targetH = this.CalcHeadByPress(this._targetInletPress,
                this._targetOutletPress, Machine.InletCaliber, Machine.OutletCaliber,
                this._targetQ);
            //CalcHeadByPress(this._targetInletPress, this._targetOutletPress);




            double maxH;
            double minH;
            var points50 = IStation.Model.FitCurveHelper.GetFitPoints(Machine.MaxCurveInfoQH, 50);
            IStation.Model.FitCurveHelper.GetMinMaxPointY(points50, out maxH, out minH);
            if (maxH < targetH)
            {
                return null;
            }


            var pointsMin = IStation.Common.SpeedSimuCalculer.GetSimuPointQH(Machine.MaxCurveInfoQH, 50, MinChangeFrequence);
            IStation.Model.FitCurveHelper.GetMinMaxPointY(pointsMin, out maxH, out minH);
            if (minH > targetH)
            {
                return null;
            }

            //获取每个频率的值(粗算)
            for (double freqCurrentFrequ = 50; freqCurrentFrequ > MinChangeFrequence;
                    freqCurrentFrequ = freqCurrentFrequ - ChangeFrequenceSpaece)
            {
                IStation.Calculation.DispatchAna.Model.AnaCurveItem curve = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
                int ret = CalcAnaCurve(Machine.MaxCurveInfoQH, Machine.MaxCurveInfoQP,
                    this._targetInletPress, this._targetOutletPress,
                    Machine.InletCaliber, Machine.OutletCaliber, freqCurrentFrequ, ref curve);
                if (ret == -1)
                    break;//-1 表示最大扬程都已经低于目标扬程了, 没必要再迭代了
                if (ret == 0)
                    continue;
                if (ret == -99)
                    continue;

                curve.Speed = Machine.CalcSpeedByFrequence(curve.Frequence);

                anaData.AnaItemList.Add(curve);
            }

            anaData.AnaItem50Hz = anaData.AnaItemList.FirstOrDefault();

            return anaData;
        }
        #endregion


        #region 精算
        private void CalcDetailAccurate(ref IStation.Calculation.DispatchAna.Model.AnaScheme project)
        {
            //没有变频泵, 就没有必要精算
            var frequecePumps = (from x in project.Items where x.IsFrequency select x);
            if (frequecePumps == null || frequecePumps.Count() == 0)
                return;


            if (frequecePumps.Count() == 1)
            {//只有一台,比较简单
                #region 只有一台,比较简单
                IStation.Calculation.DispatchAna.Model.AnaSchemeItem current_adjust_item = 
                    frequecePumps.FirstOrDefault();
                var current_machine = (from x in this._allMachineList where x.MachineID == current_adjust_item.MachineID select x).FirstOrDefault();
                if (current_machine == null)
                    return;

                var totalWrkQ_other = (from x in project.Items where x.WorkPointQ > 0 && x.MachineID != current_adjust_item.MachineID select x.WorkPointQ).Sum();
                // var target_pump_flow = this._targetQ - totalWrkQ_other;

                var max_fr = Math.Min(50, current_adjust_item.Frequence + ChangeFrequenceSpaece * 2);
                var min_fr = current_adjust_item.Frequence - ChangeFrequenceSpaece * 2;

                double flow_chajiu = Math.Abs(project.TotalWrkQ - this._targetQ);

                for (double fre = max_fr; fre > min_fr; fre = fre - 0.1)
                {
                    IStation.Calculation.DispatchAna.Model.AnaCurveItem ana_item = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
                    int ret = CalcAnaCurve(current_machine.MaxCurveInfoQH, current_machine.MaxCurveInfoQP,
                        this._targetInletPress, this._targetOutletPress,
                        current_machine.InletCaliber, current_machine.OutletCaliber,
                        fre, ref ana_item);
                    if (ret == -1)
                        return;//-1 表示最大扬程都已经低于目标扬程了, 没必要再迭代了

                    if (ret == 0)
                        continue;
                    var total_q = totalWrkQ_other + ana_item.WorkPointQ;
                    if (total_q < this._targetQmin)
                        break;//如果已经低于最小,不用再变频了
                    if (Math.Abs(total_q - this._targetQ) < flow_chajiu)
                    {
                        flow_chajiu = Math.Abs(total_q - this._targetQ);
                        current_adjust_item.Frequence = Math.Round(fre, 1);
                        current_adjust_item.WorkPointQ = Math.Round(ana_item.WorkPointQ, 1);
                        current_adjust_item.WorkPointP = Math.Round(ana_item.WorkPointP, 1);


                        // 再汇总一下
                        project.TotalWrkQ = (from x in project.Items where x.WorkPointQ > 0 select x.WorkPointQ).Sum();
                        project.TotalWrkP = (from x in project.Items where x.WorkPointP > 0 select x.WorkPointP).Sum();

                        project.UWP = Calcu_UWP(project.TotalWrkP, project.TotalWrkQ, this._targetInletPress, this._targetOutletPress);
                        project.WP = Calcu_WP(project.TotalWrkP, project.TotalWrkQ);
                    }

                    if (total_q < this._targetQ)
                    {
                        break;
                    }
                }
                #endregion

            }
            else if (frequecePumps.Count() == 2)
            {
                IStation.Calculation.DispatchAna.Model.AnaSchemeItem adjust_item_1 = frequecePumps.ElementAt(0);
                IStation.Calculation.DispatchAna.Model.AnaSchemeItem adjust_item_2 = frequecePumps.ElementAt(1);
                var adjust_machine_1 = (from x in this._allMachineList where x.MachineID == adjust_item_1.MachineID select x).FirstOrDefault();
                if (adjust_machine_1 == null)
                    return;
                var adjust_machine_2 = (from x in this._allMachineList where x.MachineID == adjust_item_2.MachineID select x).FirstOrDefault();
                if (adjust_machine_2 == null)
                    return;
                //除了调解泵的其他泵流量
                var total_flow_other = (from x in project.Items where x.WorkPointQ > 0 && x.MachineID != adjust_machine_1.MachineID && x.MachineID != adjust_machine_2.MachineID select x.WorkPointQ).Sum();

                var total_power_other = (from x in project.Items where x.WorkPointP > 0 && x.MachineID != adjust_machine_1.MachineID && x.MachineID != adjust_machine_2.MachineID select x.WorkPointP).Sum();

                List<IStation.Calculation.DispatchAna.Model.AnaCurveItem> item_js_1 = new List<IStation.Calculation.DispatchAna.Model.AnaCurveItem>();
                for (double fre = Math.Min(50, adjust_item_1.Frequence + ChangeFrequenceSpaece * 2);
                    fre > adjust_item_1.Frequence - ChangeFrequenceSpaece * 2;
                    fre = fre - 0.1)
                {
                    IStation.Calculation.DispatchAna.Model.AnaCurveItem ana_item = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
                    int ret = CalcAnaCurve(adjust_machine_1.MaxCurveInfoQH,
                        adjust_machine_1.MaxCurveInfoQP,
                        this._targetInletPress, this._targetOutletPress,
                        adjust_machine_1.InletCaliber, adjust_machine_1.OutletCaliber,
                        fre, ref ana_item);
                    if (ret == -1)
                        break;
                    item_js_1.Add(ana_item);
                }

                List<IStation.Calculation.DispatchAna.Model.AnaCurveItem> item_js_2 = new List<IStation.Calculation.DispatchAna.Model.AnaCurveItem>();
                for (double fre = Math.Min(50, adjust_item_2.Frequence + ChangeFrequenceSpaece * 2);
                    fre > adjust_item_2.Frequence - ChangeFrequenceSpaece * 2;
                    fre = fre - 0.1)
                {
                    IStation.Calculation.DispatchAna.Model.AnaCurveItem ana_item = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
                    int ret = CalcAnaCurve(adjust_machine_2.MaxCurveInfoQH, adjust_machine_2.MaxCurveInfoQP,
                        this._targetInletPress, this._targetOutletPress,
                        adjust_machine_2.InletCaliber, adjust_machine_2.OutletCaliber,
                        fre, ref ana_item);
                    if (ret == -1)
                        break;
                    item_js_2.Add(ana_item);
                }

                double ump_chajiu = project.UWP;

                foreach (var item1 in item_js_1)
                {
                    foreach (var item2 in item_js_2)
                    {
                        var total_flow = item1.WorkPointQ + item2.WorkPointQ + total_flow_other;
                        if (Math.Abs(total_flow - this._targetQ) < this._targetQ * 0.01)
                        {
                            var total_power = item1.WorkPointP + item2.WorkPointP + total_power_other;
                            var uwp = Calcu_UWP(total_power, total_flow, this._targetInletPress, this._targetOutletPress);

                            if (uwp < ump_chajiu)
                            {
                                adjust_item_1.ResetItem(item1);
                                adjust_item_2.ResetItem(item2);
                                adjust_item_1.Frequence = Math.Round(item1.Frequence, 1);
                                adjust_item_2.Frequence = Math.Round(item2.Frequence, 1);

                                // 再汇总一下
                                project.TotalWrkQ = (from x in project.Items where x.WorkPointQ > 0 select x.WorkPointQ).Sum();
                                project.TotalWrkP = (from x in project.Items where x.WorkPointP > 0 select x.WorkPointP).Sum();

                                project.UWP = Calcu_UWP(project.TotalWrkP, project.TotalWrkQ, this._targetInletPress, this._targetOutletPress);
                                project.WP = Calcu_WP(project.TotalWrkP, project.TotalWrkQ);
                            }

                        }
                    }
                }



            }
            else
            {
                //哪个泵流量大,就调整哪个泵
                IStation.Calculation.DispatchAna.Model.AnaSchemeItem aj_pump = frequecePumps.FirstOrDefault();
                foreach (var p in project.Items)
                {
                    if (!p.IsFrequency)
                        continue;
                    if (p.WorkPointQ > aj_pump.WorkPointQ)
                    {
                        aj_pump = p;
                    }
                }
                //除了调解泵的其他泵流量
                var total_flow_other = (from x in project.Items where x.WorkPointQ > 0 && x.MachineID != aj_pump.MachineID select x.WorkPointQ).Sum();
                //
                double flow_chajiu = Math.Abs(project.TotalWrkQ - this._targetQ);
                //
                var pump_curve = (from x in this._allMachineList where x.MachineID == aj_pump.MachineID select x).FirstOrDefault();
                if (pump_curve != null)
                {
                    var max_fr = Math.Min(50, aj_pump.Frequence + ChangeFrequenceSpaece * 2);
                    var min_fr = aj_pump.Frequence - ChangeFrequenceSpaece * 2;
                    for (double fre = max_fr; fre > min_fr; fre = fre - 0.1)
                    {
                        IStation.Calculation.DispatchAna.Model.AnaCurveItem curve = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
                        int ret = CalcAnaCurve(pump_curve.MaxCurveInfoQH, pump_curve.MaxCurveInfoQP,
                            this._targetInletPress, this._targetOutletPress,
                            pump_curve.InletCaliber, pump_curve.OutletCaliber,
                            fre, ref curve);
                        if (ret == -1)
                            break;//-1 表示最大扬程都已经低于目标扬程了, 没必要再迭代了
                        if (ret == 0)
                            continue;
                        var total_q = total_flow_other + curve.WorkPointQ;
                        if (total_q < this._targetQmin)
                            break;//如果已经低于最小,不用再变频了
                        if (Math.Abs(total_q - this._targetQ) < flow_chajiu)
                        {
                            flow_chajiu = Math.Abs(total_q - this._targetQ);
                            aj_pump.Frequence = Math.Round(fre, 1);
                            aj_pump.WorkPointQ = Math.Round(curve.WorkPointQ, 1);
                            aj_pump.WorkPointP = Math.Round(curve.WorkPointP, 1);

                            //再汇总一下
                            project.TotalWrkQ = (from x in project.Items where x.WorkPointQ > 0 select x.WorkPointQ).Sum();
                            project.TotalWrkP = (from x in project.Items where x.WorkPointP > 0 select x.WorkPointP).Sum();

                            project.UWP = Calcu_UWP(project.TotalWrkP, project.TotalWrkQ, this._targetInletPress, this._targetOutletPress);
                            project.WP = Calcu_WP(project.TotalWrkP, project.TotalWrkQ);
                        }

                        if (total_q < this._targetQ)
                        {
                            break;
                        }
                    }
                }
            }


        }
        #endregion


        #region 根据频率值,计算变频曲线
        /// <summary>
        /// 根据频率值,计算变频曲线(外部也会调用)
        /// </summary>
        /// <param name="MaxCurveInfoQH"></param>
        /// <param name="MaxCurveInfoQP"></param>
        /// <param name="inletPress"></param>
        /// <param name="outletPress"></param>
        /// <param name="InletDia"></param>
        /// <param name="OutletDia"></param>
        /// <param name="freqCurrentFrequ"></param>
        /// <param name="ana_data"></param>
        /// <returns></returns>
        public static int CalcAnaCurve(
            IStation.Model.CurveExpress MaxCurveInfoQH,
            IStation.Model.CurveExpress MaxCurveInfoQP,
            double inletPress, double outletPress,
            double? InletDia, double? OutletDia,
            double freqCurrentFrequ,//频率值
            ref IStation.Calculation.DispatchAna.Model.AnaCurveItem ana_data)
        {
            if (ana_data == null)
                ana_data = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();

            if (Math.Abs(freqCurrentFrequ - 50) < 0.1)
            {
                ana_data.Frequence = freqCurrentFrequ;
                ana_data.CurveInfoQH = MaxCurveInfoQH;
                ana_data.CurveInfoQP = MaxCurveInfoQP;

                double flow = 0;
                if (!GetFolwByPress(ana_data.CurveInfoQH, inletPress, outletPress, InletDia, OutletDia, ref flow))
                {
                    ana_data.IsOverMaxH = true;
                    ana_data.Note = "已超出最大可行的流量";
                    return 0;
                }
                flow = Math.Round(flow, 1);

                var head = IStation.Model.FitCurveHelper.GetFitPointY(ana_data.CurveInfoQH, Math.Round(flow, 1));
                head = Math.Round(head, 2);
                ana_data.WorkPointQ = flow;
                ana_data.WorkPointH = head;
                ana_data.WorkPointP = Math.Round(IStation.Model.FitCurveHelper.GetFitPointY(ana_data.CurveInfoQP, ana_data.WorkPointQ), 1);
                if (ana_data.WorkPointP < 0.1)
                {
                    if (ana_data.WorkPointQ > ana_data.CurveInfoQP.Max && ana_data.WorkPointQ < ana_data.CurveInfoQP.Max * 1.15)
                    {
                        ana_data.WorkPointP = Math.Round(IStation.Model.FitCurveHelper.GetFitPointY(ana_data.CurveInfoQP, ana_data.CurveInfoQP.Max), 1);
                    }
                    else
                    {
                        return -99;
                    } 
                }
                ana_data.WorkPointE = Math.Round(IStation.Common.PumpParaHelper.CalculateE(ana_data.WorkPointQ, ana_data.WorkPointH, ana_data.WorkPointP), 1);

                ana_data.IsExtendCurve = false;
                if (flow > ana_data.CurveInfoQH.Max)
                {//在延长线上
                    ana_data.IsExtendCurve = true;

                    //延长率
                    double extRatioQ = Math.Round(flow * 100 / ana_data.CurveInfoQH.Max, 1);
                    ana_data.Note = string.Format("在延长曲线部分,参数可能不准确,延长率为:{0:0.0}", extRatioQ);
                }

                return 1;
            }
            else
            {
                #region 变频

                ana_data.Frequence = Math.Round(freqCurrentFrequ, 1);

                ana_data.CurveInfoQH = IStation.Common.SpeedSimuCalculer.GetSimuPointQH(MaxCurveInfoQH, 50, ana_data.Frequence);
                ana_data.CurveInfoQP = IStation.Common.SpeedSimuCalculer.GetSimuPointQP(MaxCurveInfoQP, 50, ana_data.Frequence);

                double flow = 0;
                if (!GetFolwByPress(ana_data.CurveInfoQH, inletPress, outletPress, InletDia, OutletDia, ref flow))
                {
                    ana_data.IsOverMaxH = true;
                    ana_data.Note = "已超出最大可行的流量";
                    return 0;
                }
                flow = Math.Round(flow, 1);

                var head = IStation.Model.FitCurveHelper.GetFitPointY(ana_data.CurveInfoQH, Math.Round(flow, 1));
                head = Math.Round(head, 2);
                ana_data.WorkPointQ = flow;
                ana_data.WorkPointH = head;
                ana_data.WorkPointP = Math.Round(IStation.Model.FitCurveHelper.GetFitPointY(ana_data.CurveInfoQP, ana_data.WorkPointQ), 1);

                if (ana_data.WorkPointP < 0.1)
                {
                    if(ana_data.WorkPointQ > ana_data.CurveInfoQP.Max && ana_data.WorkPointQ <  ana_data.CurveInfoQP.Max *  1.15)
                    {
                        ana_data.WorkPointP = Math.Round(IStation.Model.FitCurveHelper.GetFitPointY(ana_data.CurveInfoQP, ana_data.CurveInfoQP.Max ), 1);
                    }
                    else
                    {
                        return -99;
                    }   
                }
                  
                ana_data.WorkPointE = Math.Round(IStation.Common.PumpParaHelper.CalculateE(ana_data.WorkPointQ, ana_data.WorkPointH, ana_data.WorkPointP), 1);

                ana_data.IsExtendCurve = false;
                if (flow > ana_data.CurveInfoQH.Max)
                {//在延长线上
                    ana_data.IsExtendCurve = true;

                    //延长率
                    double extRatioQ = Math.Round(flow * 100 / ana_data.CurveInfoQH.Max, 1);
                    ana_data.Note = string.Format("在延长曲线部分,参数可能不准确,延长率为:{0:0.0}", extRatioQ);
                }

                #endregion

                return 1;
            }

        }

        //根据压差计算流量
        private static double OtherPressCoeff = 4 * 1000 / Math.PI / 3.6;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="curveInfoQH"></param>
        /// <param name="InletPress"></param>
        /// <param name="OutletPress"></param>
        /// <param name="InletDia"></param>
        /// <param name="OutletDia"></param>
        /// <param name="flow"></param>
        /// <returns></returns>
        public static bool GetFolwByPress(
            IStation.Model.CurveExpress curveInfoQH,
            double InletPress, double OutletPress,
            double? InletDia, double? OutletDia,
            ref double flow)
        {
            double g = 9.81;

            double h4Press = (OutletPress - InletPress) * 102;
            //计算流量
            var points = IStation.Model.FitCurveHelper.GetFitPointsByExtend(curveInfoQH, ExtendMaxRatio, 50);
            List<IStation.Model.CurvePoint> listQ = IStation.Model.FitCurveHelper.GetInterPointX(points, h4Press);
            if (listQ == null || listQ.Count == 0)
            {
                return false;
            }

            flow = listQ.Last().X;

            double initialQ = listQ.Last().X;
            double calcQ = initialQ;//用于计算的流量
            for (int calcNo = 1; calcNo <= 3; calcNo++)
            {
                double rPipeInV = 0;
                if(InletDia.HasValue && InletDia > 10)
                {
                    rPipeInV = OtherPressCoeff * calcQ / InletDia.Value / InletDia.Value;
                }
                double rPipeOutV = 0;
                if (OutletDia.HasValue && OutletDia > 10)
                {
                    rPipeOutV = OtherPressCoeff * calcQ / OutletDia.Value / OutletDia.Value;
                }
                double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / g / 2.0;
                double dieDai1H = h4Press + rVDif;

                if (GetFolwByHead(points, dieDai1H, ref flow))
                {
                    if (Math.Abs(calcQ - flow) / flow < 0.005)
                    {
                        return true;
                    }
                    //继续迭代
                    if (calcQ > flow)
                    {
                        calcQ = flow + Math.Abs(calcQ - flow) / 2;
                    }
                    else
                    {
                        calcQ = flow - Math.Abs(calcQ - flow) / 2;
                    }
                }
                else
                {
                    return false;
                }
            }

            return true;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="curveInfoQH"></param>
        /// <param name="h"></param>
        /// <param name="q"></param>
        /// <returns></returns>
        public static bool GetFolwByHead(List<IStation.Model.CurvePoint> curveInfoQH, double h, ref double q)
        {
            List<IStation.Model.CurvePoint> listQ = IStation.Model.FitCurveHelper.GetInterPointX(curveInfoQH, h);
            if (listQ == null || listQ.Count == 0)
            {
                return false;
            }

            q = listQ.Last().X;

            return true;
        }
        /// <summary>
        /// 根据频率值,计算变频曲线
        /// </summary>
        /// <param name="MaxCurveInfoQH"></param>
        /// <param name="targetH"></param>
        /// <param name="freqCurrentFrequ"></param>
        /// <param name="curve"></param>
        /// <returns></returns>
        public static int CalcAnaCurveDDD(
            IStation.Model.CurveExpress MaxCurveInfoQH,
            double targetH,
            double freqCurrentFrequ,//频率值
            ref IStation.Calculation.DispatchAna.Model.AnaCurveItem curve)
        {
            if (curve == null)
                curve = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
            if (Math.Abs(freqCurrentFrequ - 50) < 0.1)
            {
                curve.Frequence = freqCurrentFrequ;
                curve.CurveInfoQH = MaxCurveInfoQH;
                double maxH;
                double minH;
                var points = IStation.Model.FitCurveHelper.GetFitPointsByExtend(curve.CurveInfoQH, ExtendMaxRatio, 50);
                IStation.Model.FitCurveHelper.GetMinMaxPointY(points, out maxH, out minH);
                if (maxH < targetH)
                {
                    curve.IsOverMaxH = true;
                    curve.Note = "已超出最大运行扬程";
                    return -1;//-1 表示最大扬程都已经低于目标扬程了, 没必要再迭代了
                }

                List<IStation.Model.CurvePoint> interPts = IStation.Model.FitCurveHelper.GetInterPointX(points, targetH);
                if (interPts == null || interPts.Count == 0)
                {
                    curve.IsOverMaxH = true;
                    curve.Note = "已超出最大可行的流量";
                    return 0;
                }
                IStation.Model.CurvePoint pt = interPts.Last();
                if (pt.X < MinFlowIngore)
                {
                    curve.IsOverMaxH = true;
                    curve.Note = "已超出最大可行的流量";
                    return -1;
                }

                curve.IsExtendCurve = false;
                curve.WorkPointQ = Math.Round(pt.X, 1);
                curve.WorkPointH = Math.Round(pt.Y, 1);

                if (pt.X > curve.CurveInfoQH.Max)
                {//在延长线上
                    curve.IsExtendCurve = true;

                    //延长率
                    double extRatioQ = Math.Round(pt.X * 100 / curve.CurveInfoQH.Max, 1);
                    curve.Note = string.Format("在延长曲线部分,参数可能不准确,延长率为:{0:0.0}", extRatioQ);

                    //效率延长不稳定
                    //if (anaData.CurveInfoQP != null)
                    //{
                    //    var exPointsQP = IStation.Model.FitCurveHelper.GetFitPointsByExtend(anaData.CurveInfoQP, ExtendMaxRatio, 50);//延长  
                    //    anaData.WorkPointP = Math.Round(IStation.Model.FitCurveHelper.GetFitPointY(exPointsQP, anaData.WorkPointQ), 1);
                    //    anaData.WorkPointE = IStation.Common.PumpParaHelper.CalculateE(anaData.WorkPointQ, anaData.WorkPointH, anaData.WorkPointP);
                    //}
                }
                else
                {
                    curve.IsExtendCurve = false;
                }
                return 1;
            }
            else
            {
                #region 变频

                curve.Frequence = freqCurrentFrequ;


                curve.CurveInfoQH = IStation.Common.SpeedSimuCalculer.GetSimuPointQH(MaxCurveInfoQH, 50, freqCurrentFrequ);

                var points = IStation.Model.FitCurveHelper.GetFitPointsByExtend(curve.CurveInfoQH, ExtendMaxRatio, 50);//延长

                //IStation.Model.FitCurveHelper.GetMinMaxPointY(points, out maxH, out minH); 
                List<IStation.Model.CurvePoint> extPtsQH = IStation.Model.FitCurveHelper.GetInterPointX(points, targetH);
                if (extPtsQH == null || extPtsQH.Count == 0)
                {//在延长线都没有交点,就不要再迭代了.
                    if (targetH > curve.CurveInfoQH.Index0)
                        return -1;//-1 表示最大扬程都已经低于目标扬程了, 没必要再迭代了

                    return 0;
                }

                IStation.Model.CurvePoint pt = extPtsQH.Last();
                if (pt.X < MinFlowIngore)
                {
                    return -1;
                }


                curve.IsExtendCurve = false;
                curve.WorkPointQ = Math.Round(pt.X, 1);
                curve.WorkPointH = Math.Round(pt.Y, 1);

                if (pt.X > curve.CurveInfoQH.Max)
                {//在延长线上
                    curve.IsExtendCurve = true;
                    //延长率
                    double extRatioQ = Math.Round(pt.X * 100 / curve.CurveInfoQH.Max, 1);
                    curve.Note = string.Format("在延长曲线部分,参数可能不准确,延长率为:{0:0.0}", extRatioQ);
                    //if (MaxCurveInfoQP != null)
                    //{
                    //    curve.CurveInfoQP = IStation.Common.SpeedSimuCalculer.GetSimuPointQP(MaxCurveInfoQP, 50, freqCurrentFrequ);
                    //    var exPointsQP = IStation.Model.FitCurveHelper.GetFitPointsByExtend(curve.CurveInfoQP, ExtendMaxRatio, 50);//延长
                    //    curve.WorkPointP = Math.Round(IStation.Model.FitCurveHelper.GetFitPointY(exPointsQP, curve.WorkPointQ), 1);
                    //    curve.WorkPointE = IStation.Common.PumpParaHelper.CalculateE(curve.WorkPointQ, curve.WorkPointH, curve.WorkPointP);
                    //} 
                }
                else
                {
                    curve.IsExtendCurve = false;
                    //if (MaxCurveInfoQP != null)
                    //{
                    //    curve.CurveInfoQP = IStation.Common.SpeedSimuCalculer.GetSimuPointQP(MaxCurveInfoQP, 50, freqCurrentFrequ);
                    //    curve.WorkPointP = Math.Round(IStation.Model.FitCurveHelper.GetFitPointY(curve.CurveInfoQP, curve.WorkPointQ), 1);
                    //    curve.WorkPointE = IStation.Common.PumpParaHelper.CalculateE(curve.WorkPointQ, curve.WorkPointH, curve.WorkPointP);
                    //}
                }
                #endregion

                return 1;
            }

        }


        #endregion


        #region 添加项目 (只用固频泵)
        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();

            rowPrj.TotalWrkQ = totalQ;
            rowPrj.TotalWrkH = Math.Round(this.CalcHeadByPress(this._targetInletPress,
                this._targetOutletPress, 
                default_pump.MachineDetail.InletCaliber, default_pump.MachineDetail.OutletCaliber, 
                totalQ / pump_count), 3);
            rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();

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

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

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


        #region 添加项目 只有1台变频泵:AddOneFreqPumpPrj
        private int AddSingleFreqPumpPrj1(
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFixPumpAnaList,
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFreqPumpAnaList)
        {
            if (allFreqPumpAnaList == null || allFreqPumpAnaList.Count() != 1)
                return 0;

            double fix_pump_total_flow = 0;
            if (allFixPumpAnaList != null && allFixPumpAnaList.Count>0)
            {
                fix_pump_total_flow = (from x in allFixPumpAnaList select x.AnaItem50Hz.WorkPointQ).Sum();
            }
            if (fix_pump_total_flow >= this._targetQ * 0.99)
                return 0;

            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, frePump_flow), 3);
                var dp = new IStation.Model.CurvePoint(frePump_flow, h);
                var wrkSpeed = IStation.Common.SpeedSimuCalculer.GetSimuValue(
                                 freqPump.MachineDetail.MaxCurveInfoQH,
                                 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);
                int ret = CalcAnaCurve(freqPump.MachineDetail.MaxCurveInfoQH,
                    freqPump.MachineDetail.MaxCurveInfoQP, this._targetInletPress, this._targetOutletPress,
                    freqPump.MachineDetail.InletCaliber, freqPump.MachineDetail.OutletCaliber, fre, ref currentAna);
                if (ret == -1)
                    return 0;
                if (ret == -99)
                    return 0;
                if (ret == 0)
                    return 0;
                currentAna.Speed = freqPump.MachineDetail.CalcSpeedByFrequence(fre);


                var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();
                rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();

                #region 加入固频泵开启信息
                if (allFixPumpAnaList != null)
                {
                    foreach (var fixPump in allFixPumpAnaList)
                    {
                        if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                            continue;
                        var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);
                        rowPrj.Items.Add(itemRow);
                    }
                }
                #endregion


                var itemRowF = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump.MachineDetail, currentAna);
                rowPrj.Items.Add(itemRowF);

                AddScheme(rowPrj, false);
                addPrjNum++;
            }

            return addPrjNum;
        }
        #endregion


        #region 添加项目 只有2台变频泵:AddTwoFreqPumpPrj
        private int AddMultiFreqPumpPrj2(
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFixPumpAnaList,
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFreqPumpAnaList)
        {
            int addPrjNum = 0;
            int frePumpNum = 2;
            if (allFreqPumpAnaList == null || allFreqPumpAnaList.Count() != frePumpNum)
                return addPrjNum;



            double fix_pump_total_flow = 0;
            if (allFixPumpAnaList != null && allFixPumpAnaList.Count > 0)
            {
                fix_pump_total_flow = (from x in allFixPumpAnaList select x.AnaItem50Hz.WorkPointQ).Sum();
            }


            var freqPump1 = allFreqPumpAnaList[0];
            var freqPump2 = allFreqPumpAnaList[1];



            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData1 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData2 = null;


            var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();
            rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();

            #region 加入固频泵开启信息
            if (allFixPumpAnaList != null)
            {
                foreach (var fixPump in allFixPumpAnaList)
                {
                    if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                        continue;

                    var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);
                    rowPrj.Items.Add(itemRow);
                }
            }
            #endregion

            bool isActCalc = true;
            if (freqPump1.MachineDetail.PumpCode == freqPump2.MachineDetail.PumpCode)
            {//同型号
                #region 流量对半分
                var fre_pump_total_flow = this._targetQ - fix_pump_total_flow;
                isActCalc = false;

                double h = //this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress);  
                    Math.Round(this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress,
                    freqPump1.MachineDetail.InletCaliber, freqPump1.MachineDetail.OutletCaliber, 
                    fre_pump_total_flow/2), 3);

                //流量对半分
                var wrkSpeed1 = IStation.Common.SpeedSimuCalculer.GetSimuValue(freqPump1.MachineDetail.MaxCurveInfoQH,
                    new IStation.Model.CurvePoint(fre_pump_total_flow * 0.5, h), 2900);
                curveData1 = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
                double fre1 = Math.Round(50 * wrkSpeed1 / 2900, 1);
                int ret1 = CalcAnaCurve(freqPump1.MachineDetail.MaxCurveInfoQH,
                    freqPump1.MachineDetail.MaxCurveInfoQP, this._targetInletPress, this._targetOutletPress,
                    freqPump1.MachineDetail.InletCaliber, freqPump1.MachineDetail.OutletCaliber, 
                    fre1, ref curveData1);
                if (ret1 == -1)
                    return 0;
                if (ret1 == 0)
                    return 0;
                curveData1.Speed = freqPump1.MachineDetail.CalcSpeedByFrequence(fre1);



                var wrkSpeed2 = IStation.Common.SpeedSimuCalculer.GetSimuValue(freqPump2.MachineDetail.MaxCurveInfoQH,
new IStation.Model.CurvePoint(fre_pump_total_flow * 0.5, h), 2900);
                curveData2 = new IStation.Calculation.DispatchAna.Model.AnaCurveItem();
                double fre2 = Math.Round(50 * wrkSpeed2 / 2900, 1);
                int ret2 = CalcAnaCurve(freqPump2.MachineDetail.MaxCurveInfoQH,
                    freqPump2.MachineDetail.MaxCurveInfoQP,
                    this._targetInletPress, this._targetOutletPress,
                    freqPump2.MachineDetail.InletCaliber, freqPump2.MachineDetail.OutletCaliber, 
                    fre2, ref curveData2);
                if (ret2 == -1)
                    return 0;
                if (ret2 == 0)
                    return 0;
                curveData2.Speed = freqPump2.MachineDetail.CalcSpeedByFrequence(fre2);
                #endregion
            }
            else
            {
                #region MyRegion
                isActCalc = true;

                double minSpanQ = _targetQ;

                //找到离_targetQ最接近的频率点
                for (int index1 = 0; index1 < freqPump1.AnaItemList.Count; index1++)
                {//频率越来越小,c.WorkPointQ也越来越小
                    for (int index2 = 0; index2 < freqPump2.AnaItemList.Count; index2++)
                    {//频率越来越小,c.WorkPointQ也越来越小
                        double freTotalQ = freqPump1.AnaItemList[index1].WorkPointQ +
                            freqPump2.AnaItemList[index2].WorkPointQ;
                        if (Math.Abs(fix_pump_total_flow + freTotalQ - _targetQ) < minSpanQ)
                        {
                            minSpanQ = Math.Abs(fix_pump_total_flow + freTotalQ - _targetQ);
                            curveData1 = freqPump1.AnaItemList[index1];
                            curveData2 = freqPump2.AnaItemList[index2];
                        }
                    }
                }
                if (curveData1 == null || curveData2 == null)
                    return 0;
                #endregion
            }




            if (curveData1.WorkPointQ > 10)
            {
                var itemRowF1 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump1.MachineDetail, curveData1);
                rowPrj.Items.Add(itemRowF1);
            }


            if (curveData2.WorkPointQ > 10)
            {
                var itemRowF2 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump2.MachineDetail, curveData2);
                rowPrj.Items.Add(itemRowF2);
            }

            if (AddScheme(rowPrj, isActCalc))
                addPrjNum++;



            return addPrjNum;
        }
        #endregion


        #region 添加项目 只有3台变频泵:AddThreeFreqPumpPrj
        private int AddMultiFreqPumpPrj3(
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFixPumpAnaList,
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFreqPumpAnaList)
        {
            int addPrjNum = 0;
            int frePumpNum = 3;
            if (allFreqPumpAnaList == null || allFreqPumpAnaList.Count() != frePumpNum)
                return addPrjNum;

            double fix_pump_total_flow = 0;
            if (allFixPumpAnaList != null && allFixPumpAnaList.Count > 0)
            {
                fix_pump_total_flow = (from x in allFixPumpAnaList select x.AnaItem50Hz.WorkPointQ).Sum();
            }


            var freqPump1 = allFreqPumpAnaList[0];
            var freqPump2 = allFreqPumpAnaList[1];
            var freqPump3 = allFreqPumpAnaList[2];

            double freTotalQ = fix_pump_total_flow;
            double minSpanQ = _targetQmax;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData1 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData2 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData3 = null;

            //
            var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();

            rowPrj.TotalWrkQ = freTotalQ;
            rowPrj.TotalWrkH = //this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress); 
                Math.Round(this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress,
                    freqPump1.MachineDetail.InletCaliber, freqPump1.MachineDetail.OutletCaliber,
                    (this._targetQ- fix_pump_total_flow)/3), 3);
            rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();

            //找到离_targetQ最接近的频率点
            for (int index1 = 0; index1 < freqPump1.AnaItemList.Count; index1++)
            {//频率越来越小,c.WorkPointQ也越来越小
                for (int index2 = 0; index2 < freqPump2.AnaItemList.Count; index2++)
                {//频率越来越小,c.WorkPointQ也越来越小
                    for (int index3 = 0; index3 < freqPump3.AnaItemList.Count; index3++)
                    {//频率越来越小,c.WorkPointQ也越来越小
                        double wrkQ = freqPump1.AnaItemList[index1].WorkPointQ +
                            freqPump2.AnaItemList[index2].WorkPointQ +
                            freqPump3.AnaItemList[index3].WorkPointQ;

                        if (Math.Abs(fix_pump_total_flow + wrkQ - _targetQ) < minSpanQ)
                        {
                            freTotalQ = fix_pump_total_flow + wrkQ;
                            rowPrj.TotalWrkQ = freTotalQ;
                            minSpanQ = Math.Abs(freTotalQ - _targetQ);
                            curveData1 = freqPump1.AnaItemList[index1];
                            curveData2 = freqPump2.AnaItemList[index2];
                            curveData3 = freqPump3.AnaItemList[index3];
                        }
                    }
                }
            }

            //
            if (freTotalQ < _targetQmax && freTotalQ > _targetQmin && curveData1 != null)
            {
                #region 加入固频泵开启信息
                if (allFixPumpAnaList != null)
                {
                    foreach (var fixPump in allFixPumpAnaList)
                    {
                        if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                            continue;
                        var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);
                        rowPrj.Items.Add(itemRow);
                    }
                }
                #endregion


                if (curveData1.WorkPointQ > 10)
                {
                    var itemRowF1 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump1.MachineDetail, curveData1);
                    rowPrj.Items.Add(itemRowF1);
                }

                if (curveData2.WorkPointQ > 10)
                {
                    var itemRowF2 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump2.MachineDetail, curveData2);
                    rowPrj.Items.Add(itemRowF2);
                }

                if (curveData3.WorkPointQ > 10)
                {
                    var itemRowF3 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump3.MachineDetail, curveData3);
                    rowPrj.Items.Add(itemRowF3);
                }

                AddScheme(rowPrj, true);
                addPrjNum++;
            }


            return addPrjNum;
        }
        #endregion


        #region 添加项目 只有4台变频泵:AddFourFreqPumpPrj
        private int AddMultiFreqPumpPrj4(
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFixPumpAnaList,
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFreqPumpAnaList)
        {
            double fix_pump_total_flow = 0;
            if (allFixPumpAnaList != null && allFixPumpAnaList.Count > 0)
            {
                fix_pump_total_flow = (from x in allFixPumpAnaList select x.AnaItem50Hz.WorkPointQ).Sum();
            }
            int addPrjNum = 0;
            int frePumpNum = 4;
            if (allFreqPumpAnaList == null || allFreqPumpAnaList.Count() != frePumpNum)
                return addPrjNum;




            var freqPump1 = allFreqPumpAnaList[0];
            var freqPump2 = allFreqPumpAnaList[1];
            var freqPump3 = allFreqPumpAnaList[2];
            var freqPump4 = allFreqPumpAnaList[3];



            double freTotalQ = fix_pump_total_flow;
            double minSpanQ = _targetQmax;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData1 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData2 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData3 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData4 = null;

            var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();
            rowPrj.TotalWrkQ = freTotalQ;
            rowPrj.TotalWrkH = //this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress);  
               Math.Round(this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress,
                    freqPump1.MachineDetail.InletCaliber, freqPump1.MachineDetail.OutletCaliber,
                    (this._targetQ - fix_pump_total_flow) / 4), 3);
            rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();



            //找到离_targetQ最接近的频率点
            for (int index1 = 0; index1 < freqPump1.AnaItemList.Count; index1++)
            {//频率越来越小,c.WorkPointQ也越来越小
                for (int index2 = 0; index2 < freqPump2.AnaItemList.Count; index2++)
                {//频率越来越小,c.WorkPointQ也越来越小
                    for (int index3 = 0; index3 < freqPump3.AnaItemList.Count; index3++)
                    {//频率越来越小,c.WorkPointQ也越来越小
                        for (int index4 = 0; index4 < freqPump4.AnaItemList.Count; index4++)
                        {//频率越来越小,c.WorkPointQ也越来越小
                            double wrkQ = freqPump1.AnaItemList[index1].WorkPointQ +
                                freqPump2.AnaItemList[index2].WorkPointQ +
                                freqPump3.AnaItemList[index3].WorkPointQ +
                                freqPump4.AnaItemList[index4].WorkPointQ;
                            if (Math.Abs(fix_pump_total_flow + wrkQ - _targetQ) < minSpanQ)
                            {
                                freTotalQ = fix_pump_total_flow + wrkQ;
                                rowPrj.TotalWrkQ = freTotalQ;
                                minSpanQ = Math.Abs(freTotalQ - _targetQ);
                                curveData1 = freqPump1.AnaItemList[index1];
                                curveData2 = freqPump2.AnaItemList[index2];
                                curveData3 = freqPump3.AnaItemList[index3];
                                curveData4 = freqPump4.AnaItemList[index4];
                            }
                        }
                    }
                }
            }

            //
            if (freTotalQ < _targetQmax && freTotalQ > _targetQmin && curveData1 != null)
            {
                #region 加入固频泵开启信息
                if (allFixPumpAnaList != null)
                {
                    foreach (var fixPump in allFixPumpAnaList)
                    {
                        if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                            continue;
                        var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);
                        rowPrj.Items.Add(itemRow);
                    }
                }
                #endregion


                var itemRowF1 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump1.MachineDetail, curveData1);
                rowPrj.Items.Add(itemRowF1);

                var itemRowF2 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump2.MachineDetail, curveData2);
                rowPrj.Items.Add(itemRowF2);

                var itemRowF3 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump3.MachineDetail, curveData3);
                rowPrj.Items.Add(itemRowF3);

                var itemRowF4 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump4.MachineDetail, curveData4);
                rowPrj.Items.Add(itemRowF4);


                AddScheme(rowPrj, true);
                addPrjNum++;
            }


            return addPrjNum;
        }
        #endregion


        #region 添加项目 只有5台变频泵:AddMultiFreqPumpPrj5
        private int AddMultiFreqPumpPrj5(
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFixPumpAnaList,
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFreqPumpAnaList)
        {
            int addPrjNum = 0;
            int frePumpNum = 5;
            if (allFreqPumpAnaList == null || allFreqPumpAnaList.Count() != frePumpNum)
                return addPrjNum;
            double fix_pump_total_flow = 0;
            if (allFixPumpAnaList != null && allFixPumpAnaList.Count() > 0)
            {
                fix_pump_total_flow = (from x in allFixPumpAnaList select x.AnaItem50Hz.WorkPointQ).Sum();
            }



            var freqPump1 = allFreqPumpAnaList[0];
            var freqPump2 = allFreqPumpAnaList[1];
            var freqPump3 = allFreqPumpAnaList[2];
            var freqPump4 = allFreqPumpAnaList[3];
            var freqPump5 = allFreqPumpAnaList[4];

            #region 检查是否符合开机约束
            List<long> machine_ids = new List<long>();
            machine_ids.Add(freqPump1.MachineDetail.MachineID);
            machine_ids.Add(freqPump2.MachineDetail.MachineID);
            machine_ids.Add(freqPump3.MachineDetail.MachineID);
            machine_ids.Add(freqPump4.MachineDetail.MachineID);
            machine_ids.Add(freqPump5.MachineDetail.MachineID);
            if (allFixPumpAnaList != null)
            {
                foreach (var item in allFixPumpAnaList)
                    machine_ids.Add(item.MachineDetail.MachineID);
            }

            #endregion

            double freTotalQ = fix_pump_total_flow;
            double minSpanQ = _targetQmax;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData1 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData2 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData3 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData4 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData5 = null;

            var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();
            rowPrj.TotalWrkQ = freTotalQ;
            rowPrj.TotalWrkH = //this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress);
            Math.Round(this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress,
                         freqPump1.MachineDetail.InletCaliber, freqPump1.MachineDetail.OutletCaliber,
                        (this._targetQ - fix_pump_total_flow) / 5), 3);
            rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();

            //double TotalWrkP = 0;


            //找到离_targetQ最接近的频率点
            for (int index1 = 0; index1 < freqPump1.AnaItemList.Count; index1++)
            {//频率越来越小,c.WorkPointQ也越来越小
                for (int index2 = 0; index2 < freqPump2.AnaItemList.Count; index2++)
                {//频率越来越小,c.WorkPointQ也越来越小
                    for (int index3 = 0; index3 < freqPump3.AnaItemList.Count; index3++)
                    {//频率越来越小,c.WorkPointQ也越来越小
                        for (int index4 = 0; index4 < freqPump4.AnaItemList.Count; index4++)
                        {//频率越来越小,c.WorkPointQ也越来越小
                            for (int index5 = 0; index5 < freqPump5.AnaItemList.Count; index5++)
                            {//频率越来越小,c.WorkPointQ也越来越小
                                double wrkQ =
                                    freqPump1.AnaItemList[index1].WorkPointQ +
                                    freqPump2.AnaItemList[index2].WorkPointQ +
                                    freqPump3.AnaItemList[index3].WorkPointQ +
                                    freqPump4.AnaItemList[index4].WorkPointQ +
                                    freqPump5.AnaItemList[index5].WorkPointQ;
                                if (Math.Abs(fix_pump_total_flow + wrkQ - _targetQ) < minSpanQ)
                                {
                                    freTotalQ = fix_pump_total_flow + wrkQ;
                                    rowPrj.TotalWrkQ = freTotalQ;
                                    minSpanQ = Math.Abs(freTotalQ - _targetQ);
                                    curveData1 = freqPump1.AnaItemList[index1];
                                    curveData2 = freqPump2.AnaItemList[index2];
                                    curveData3 = freqPump3.AnaItemList[index3];
                                    curveData4 = freqPump4.AnaItemList[index4];
                                    curveData5 = freqPump5.AnaItemList[index5];
                                }
                            }
                        }
                    }
                }
            }

            //
            if (freTotalQ < _targetQmax && freTotalQ > _targetQmin && curveData1 != null)
            {
                #region 加入固频泵开启信息
                if (allFixPumpAnaList != null)
                {
                    foreach (var fixPump in allFixPumpAnaList)
                    {
                        if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                            continue;
                        var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);
                        rowPrj.Items.Add(itemRow);
                    }
                }
                #endregion


                var itemRowF1 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump1.MachineDetail, curveData1);
                rowPrj.Items.Add(itemRowF1);

                var itemRowF2 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump2.MachineDetail, curveData2);
                rowPrj.Items.Add(itemRowF2);

                var itemRowF3 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump3.MachineDetail, curveData3);
                rowPrj.Items.Add(itemRowF3);

                var itemRowF4 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump4.MachineDetail, curveData4);
                rowPrj.Items.Add(itemRowF4);

                var itemRowF5 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump5.MachineDetail, curveData5);
                rowPrj.Items.Add(itemRowF5);


                AddScheme(rowPrj, true);
                addPrjNum++;
            }


            return addPrjNum;
        }
        #endregion


        #region 添加项目 只有6台变频泵:AddMultiFreqPumpPrj6
        private int AddMultiFreqPumpPrj6(
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFixPumpAnaList,
            List<IStation.Calculation.DispatchAna.Model.PumpAnaDataBase> allFreqPumpAnaList)
        {
            int addPrjNum = 0;
            int frePumpNum = 6;
            if (allFreqPumpAnaList == null || allFreqPumpAnaList.Count() != frePumpNum)
                return addPrjNum;
            double fix_pump_total_flow = 0;
            if (allFixPumpAnaList != null && allFixPumpAnaList.Count() > 0)
            {
                fix_pump_total_flow = (from x in allFixPumpAnaList select x.AnaItem50Hz.WorkPointQ).Sum();
            }



            var freqPump1 = allFreqPumpAnaList[0];
            var freqPump2 = allFreqPumpAnaList[1];
            var freqPump3 = allFreqPumpAnaList[2];
            var freqPump4 = allFreqPumpAnaList[3];
            var freqPump5 = allFreqPumpAnaList[4];
            var freqPump6 = allFreqPumpAnaList[5];

            #region 检查是否符合开机约束
            List<long> machine_ids = new List<long>();
            machine_ids.Add(freqPump1.MachineDetail.MachineID);
            machine_ids.Add(freqPump2.MachineDetail.MachineID);
            machine_ids.Add(freqPump3.MachineDetail.MachineID);
            machine_ids.Add(freqPump4.MachineDetail.MachineID);
            machine_ids.Add(freqPump5.MachineDetail.MachineID);
            machine_ids.Add(freqPump6.MachineDetail.MachineID);
            if (allFixPumpAnaList != null)
            {
                foreach (var item in allFixPumpAnaList)
                    machine_ids.Add(item.MachineDetail.MachineID);
            }

            #endregion


            double freTotalQ = fix_pump_total_flow;
            double minSpanQ = _targetQmax;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData1 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData2 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData3 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData4 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData5 = null;
            IStation.Calculation.DispatchAna.Model.AnaCurveItem curveData6 = null;

            var rowPrj = new IStation.Calculation.DispatchAna.Model.AnaScheme();
            rowPrj.TotalWrkQ = freTotalQ;
            rowPrj.TotalWrkH = //this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress);
                Math.Round(this.CalcHeadByPress(this._targetInletPress, this._targetOutletPress,
                         freqPump1.MachineDetail.InletCaliber, freqPump1.MachineDetail.OutletCaliber,
                        (this._targetQ - fix_pump_total_flow) / 6), 3);
            rowPrj.Items = new List<IStation.Calculation.DispatchAna.Model.AnaSchemeItem>();


            //找到离_targetQ最接近的频率点
            for (int index1 = 0; index1 < freqPump1.AnaItemList.Count; index1++)
            {//频率越来越小,c.WorkPointQ也越来越小
                for (int index2 = 0; index2 < freqPump2.AnaItemList.Count; index2++)
                {//频率越来越小,c.WorkPointQ也越来越小
                    for (int index3 = 0; index3 < freqPump3.AnaItemList.Count; index3++)
                    {//频率越来越小,c.WorkPointQ也越来越小
                        for (int index4 = 0; index4 < freqPump4.AnaItemList.Count; index4++)
                        {//频率越来越小,c.WorkPointQ也越来越小
                            for (int index5 = 0; index5 < freqPump5.AnaItemList.Count; index5++)
                            {//频率越来越小,c.WorkPointQ也越来越小
                                for (int index6 = 0; index6 < freqPump6.AnaItemList.Count; index6++)
                                {//频率越来越小,c.WorkPointQ也越来越小
                                    double wrkQ =
                                        freqPump1.AnaItemList[index1].WorkPointQ +
                                        freqPump2.AnaItemList[index2].WorkPointQ +
                                        freqPump3.AnaItemList[index3].WorkPointQ +
                                        freqPump4.AnaItemList[index4].WorkPointQ +
                                        freqPump5.AnaItemList[index5].WorkPointQ +
                                        freqPump6.AnaItemList[index6].WorkPointQ;
                                    if (Math.Abs(fix_pump_total_flow + wrkQ - _targetQ) < minSpanQ)
                                    {
                                        freTotalQ = fix_pump_total_flow + wrkQ;
                                        rowPrj.TotalWrkQ = freTotalQ;
                                        minSpanQ = Math.Abs(freTotalQ - _targetQ);
                                        curveData1 = freqPump1.AnaItemList[index1];
                                        curveData2 = freqPump2.AnaItemList[index2];
                                        curveData3 = freqPump3.AnaItemList[index3];
                                        curveData4 = freqPump4.AnaItemList[index4];
                                        curveData5 = freqPump5.AnaItemList[index5];
                                        curveData6 = freqPump6.AnaItemList[index6];
                                    }
                                }
                            }
                        }
                    }
                }
            }

            //
            if (freTotalQ < _targetQmax && freTotalQ > _targetQmin && curveData1 != null)
            {
                #region 加入固频泵开启信息
                if (allFixPumpAnaList != null)
                {
                    foreach (var fixPump in allFixPumpAnaList)
                    {
                        if (fixPump.AnaItem50Hz.WorkPointQ < 1)
                            continue;
                        var itemRow = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(fixPump.MachineDetail, fixPump.AnaItem50Hz);

                        rowPrj.Items.Add(itemRow);
                    }
                }
                #endregion


                var itemRowF1 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump1.MachineDetail, curveData1);
                rowPrj.Items.Add(itemRowF1);

                var itemRowF2 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump2.MachineDetail, curveData2);
                rowPrj.Items.Add(itemRowF2);

                var itemRowF3 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump3.MachineDetail, curveData3);
                rowPrj.Items.Add(itemRowF3);

                var itemRowF4 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump4.MachineDetail, curveData4);
                rowPrj.Items.Add(itemRowF4);

                var itemRowF5 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump5.MachineDetail, curveData5);
                rowPrj.Items.Add(itemRowF5);

                var itemRowF6 = new IStation.Calculation.DispatchAna.Model.AnaSchemeItem(freqPump6.MachineDetail, curveData6);
                rowPrj.Items.Add(itemRowF6);

                AddScheme(rowPrj, true);
                addPrjNum++;
            }


            return addPrjNum;
        }
        #endregion



        private int _schemeID = 1;
        private bool AddScheme(IStation.Calculation.DispatchAna.Model.AnaScheme project, bool IsAccurateCalc)
        {
            //
            project.TotalWrkQ = (from x in project.Items where x.WorkPointQ > 0 select x.WorkPointQ).Sum();
            project.TotalWrkH = Math.Round((from x in project.Items where x.WorkPointH > 0 select x.WorkPointH).Average(), 2);

            project.TotalWrkP = Math.Round((from x in project.Items where x.WorkPointP > 0 select x.WorkPointP).Sum(), 2);
            project.TotalWrkE = IStation.Common.PumpParaHelper.CalculateE(project.TotalWrkQ, project.TotalWrkH, project.TotalWrkP);
            project.UWP = Calcu_UWP(project.TotalWrkP, project.TotalWrkQ, this._targetInletPress, this._targetOutletPress);
            project.WP = Calcu_WP(project.TotalWrkP, project.TotalWrkQ);

            if (project.TotalWrkQ > _targetQmax || project.TotalWrkQ < _targetQmin)
            {
                return false;
            }
            //计算流量
            //rowPrj.TotalWrkQ = (from x in rowPrj.Items where x.WorkPointQ > 0 select x.WorkPointQ).Sum();
            //if (rowPrj.TotalWrkQ <= _targetQmax && rowPrj.TotalWrkQ >= this._targetQmin)
            //    ds_disp_project_list.Add(project);

            if (_machine_flow_limit_max_dict != null)
            {
                foreach (var item in project.Items)
                {
                    if (_machine_flow_limit_max_dict.ContainsKey(item.MachineID))
                    {//操作开机限制
                        if (item.WorkPointQ > _machine_flow_limit_max_dict[item.MachineID])
                            return false;
                    }
                }
            }

            if (_machine_flow_limit_min_dict != null)
            {
                foreach (var item in project.Items)
                {
                    if (_machine_flow_limit_min_dict.ContainsKey(item.MachineID))
                    {//操作开机限制
                        if (item.WorkPointQ < _machine_flow_limit_min_dict[item.MachineID])
                            return false;
                    }
                }
            }




            if (_anaSchemeList == null)
                _anaSchemeList = new List<IStation.Calculation.DispatchAna.Model.AnaScheme>();



            //再精算一下
            if (IsAccurateCalc)
                CalcDetailAccurate(ref project);


            project.ID = _schemeID;
            _anaSchemeList.Add(project);
            _schemeID++;

            return true;
        }
        /// <summary>
        /// 单位水耗 千吨水
        /// </summary>
        public static double Calcu_UWP(double P, double Q, double H)
        {
            if (Q <= 0.001)
                return 0;
            if (H <= 0.00001)
                return 0;
            if (P <= 0.001)
                return 0;
            return P * 1000f / Q / H;
        }
        /// <summary>
        /// 单位水耗 千吨水
        /// </summary>
        public static double Calcu_UWP(double P, double Q, double inletPress, double outletPress)
        {
            double H = (outletPress - inletPress) * 102;
            if (Q <= 0.001)
                return 0;
            if (H <= 0.00001)
                return 0;
            if (P <= 0.001)
                return 0;
            return P * 1000f / Q / H;
        }
        /// <summary>
        /// 单位水耗
        /// </summary>
        public static double Calcu_WP(double P, double Q)
        {
            if (Q <= 0.001)
                return 0;

            if (P <= 0.001)
                return 0;
            return P * 1000f / Q;
        }
    }







}