using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.EtaCalculation
{
    /// <summary>
    /// 泵站分析
    /// </summary>
    public abstract class EtaAnalyCalculatorBase4Station  : EtaAnalyCalculatorBase, IEtaStationAnalyCalculator
    {   

        /// <summary>
        /// 
        /// </summary>
        protected int _machineCount = 0;//由外部输入,检验数据,保证外部数据没有遗漏
        /// <summary>
        /// 
        /// </summary>
        protected long _stationID = 0;

        /// <summary>
        /// 所有机泵
        /// </summary>
        protected List<IStation.Calculation.Eta.Model.PumpAnaResult> _allMachineList = null;

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public List<IStation.Calculation.Eta.Model.PumpAnaResult> GetAllMachineBundleList()
        {
            return _allMachineList;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public Calculation.Eta.Model.StationAnaInfoBundle GetAnaBundle()
        {
            Calculation.Eta.Model.StationAnaInfoBundle bundle = new Calculation.Eta.Model.StationAnaInfoBundle();
            bundle.StationID = this._stationID;
            bundle.AnaResult = this._stationAnaResult;

            return bundle;
        }

        /// <summary>
        /// 获取分析结果(机泵)
        /// </summary>
        /// <returns></returns>
        public virtual List<Model.EtaSingleRealRecordPure> GetAllSingleAnaRecord()
        {
            if(this._allMachineList == null)    
                return null;    
            List<Model.EtaSingleRealRecordPure> single_ana_result_list = new List<Model.EtaSingleRealRecordPure>();
            foreach (var item in this._allMachineList)
            {
                single_ana_result_list.Add(item.AnaResult);
            }

            return single_ana_result_list;
        }
        /// <summary>
        /// 分析结果(泵站)
        /// </summary>
        protected IStation.Model.EtaMultiRealRecordPure _stationAnaResult = null;
        /// <summary>
        /// 获取分析结果(泵站和支线)
        /// </summary>
        /// <returns></returns>
        public virtual IStation.Model.EtaMultiRealRecordPure GetStationAnaRecord()
        {
            return _stationAnaResult;
        }

        /// <summary>
        /// (支线)
        /// </summary>
        protected List<Model.EtaMultiRealRecordPure> _pipeAnaResultList = null;
        /// <summary>
        /// 获取分析结果(泵站和支线)
        /// </summary>
        /// <returns></returns>
        public virtual List<Model.EtaMultiRealRecordPure> GetAllPipeAnaRecord()
        {
            return _pipeAnaResultList;
        }

        /// <summary>
        /// /所有测点
        /// </summary>
        protected List<Model.EtaMonitorPointAnalyContextitem> _allMonitorList = null;

        /// <summary>
        /// 
        /// </summary>
        protected double _threshold_flow = 100;//流量计阀值(大于此值 就认为开通)


        /// <summary>
        /// 外部调用
        /// </summary>
        /// <param name="context"></param>
        /// <param name="error_info"></param>
        /// <returns></returns>
        public virtual bool Calculate(
            IStation.Model.EtaStationAnalyContextItem context, out string error_info)
        {
            error_info = "未实例化";
            return false;
        }


        /// <summary>
        /// 计算总管数据 
        /// </summary>
        /// <param name="total_flow"></param>
        /// <param name="result_pipe"></param>
        /// <param name="all_machine_list">子管路时只要输入相关泵即可,其余的泵,对于子管路来说就认为关机,泵站为空即可</param> 
        /// <returns></returns>
        protected virtual bool BuildConnectResult(
            double? total_flow,
            Model.EtaMultiRealRecordPure result_pipe,
            List<IStation.Calculation.Eta.Model.PumpAnaResult> all_machine_list = null)
        {
            if (_allMachineList == null)
                return false;

            if (all_machine_list == null  )//为空,表示分析的是泵站, 直接给所有泵即可
                all_machine_list  = this._allMachineList;

     
            List<double> all_flow = new List<double>();
            List<double> all_head = new List<double>();
            List<double> all_power = new List<double>();

            //用的是泵站的总数量,
            result_pipe.InitialRunList(this._allMachineList.Count());

            double qhTotal = 0; 

            #region  开机状态 和数量
            int pump_open_count = 0;
            bool allFlowMonitorOk = true;
            bool allPumpHeadOk = true;
            bool allPumpPowerOk = true;
         
            for (int i = 0; i < this._allMachineList.Count; i++)
            {
                var pump = all_machine_list.Find(x => x.MachineID == this._allMachineList[i].MachineID);
                if (pump == null)
                {//子管路时只要输入相关泵即可,其余的泵,对于子管路来说就认为关机
                    continue;
                }


                var result_pump = pump.AnaResult;
                if (result_pump == null)
                {
                    allFlowMonitorOk = false;
                    allPumpHeadOk = false;
                    allPumpPowerOk = false;
                    continue;
                }
                
                if (!pump.IsRunIng)
                {
                    result_pipe.SetPumpStatusByIndex(i, result_pump.HZa, result_pump.RSa);
                    continue;
                }


                bool validQ = false, validH = false;

                result_pipe.PutStationAnalyInfo(result_pump.AnalyInfo, pump.MachineID);

                pump_open_count++;
     
                result_pipe.SetPumpStatusByIndex(i, result_pump.HZa, result_pump.RSa);

                if (result_pump.IsHaveAnaTag(IStation.Model.EtaBasicRealRecord.InfoTag_RU))
                {
                    allPumpPowerOk = false;
                    allPumpHeadOk = false;
                    allFlowMonitorOk = false;
                }

                if (result_pump.IsHaveAnaTag(IStation.Model.EtaBasicRealRecord.InfoTag_Qa))
                {
                    allFlowMonitorOk = false;
                }
                else if (result_pump.Qa == null)
                {
                    allFlowMonitorOk = false;
                }
                else
                {
                    all_flow.Add(result_pump.Qa.Value);
                    validQ = true;
                }

                if (result_pump.IsHaveAnaTag(IStation.Model.EtaBasicRealRecord.InfoTag_Ha) ||
                    result_pump.IsHaveAnaTag(IStation.Model.EtaBasicRealRecord.InfoTag_P2))
                {
                    allPumpHeadOk = false;
                }
                else if (result_pump.Ha == null)
                {
                    allPumpHeadOk = false;
                }
                else if (result_pump.Ha < 1)
                {
                    allPumpHeadOk = false;
                }
                else
                {
                    all_head.Add(result_pump.Ha.Value);
                    validH = true;
                }

                if (validQ && validH)
                {
                    qhTotal += result_pump.Qa.Value * result_pump.Ha.Value;
                }

                if (result_pump.IsHaveAnaTag(IStation.Model.EtaBasicRealRecord.InfoTag_Pa))
                {
                    allPumpPowerOk = false;
                }
                else if (result_pump.Pa == null)
                {
                    allPumpPowerOk = false;
                }
                else if (result_pump.Pa < 1)
                {
                    allPumpPowerOk = false;
                }
                else
                {
                    all_power.Add(result_pump.Pa.Value);
                }
            }

            result_pipe.RunningCount = pump_open_count; 
            #endregion


            if (total_flow != null)
                result_pipe.Qa = total_flow.Value;

            if (pump_open_count > 0)
            {
                if (allFlowMonitorOk && result_pipe.Qa == null && all_flow.Count > 0)
                {
                    result_pipe.Qa = Math.Round(all_flow.Sum(), 1);
                }

                if (allPumpHeadOk && all_head.Count > 0)
                {
                    result_pipe.Ha = Math.Round(all_head.Average(), 3);
                }

                if (allPumpPowerOk && all_power.Count > 0)
                {
                    result_pipe.Pa = all_power.Sum();
                }

                if (allPumpPowerOk && result_pipe.Ha != null && result_pipe.Pa != null && result_pipe.Qa != null)
                {
                    //计算效率 旧代码
                    //double eta = Math.Round(Model.EtaSingleRealRecordPure.Calc_Eta(result_pipe.Qa.Value, result_pipe.Ha.Value, result_pipe.Pa.Value, WaterDensity, g), 1);

                    double eta = 0;
                    foreach (var item in all_machine_list)
                    {
                        var result = item.AnaResult;
                        if (result == null)
                            continue;
                        if (result.IsHaveAnaTag(IStation.Model.EtaBasicRealRecord.InfoTag_Qa) || result.IsHaveAnaTag(IStation.Model.EtaBasicRealRecord.InfoTag_Ha))
                            continue;
                        if (result.Ea.HasValue && result.Qa.HasValue && result.Ha.HasValue)
                        {
                            eta += (result.Qa.Value * result.Ha.Value / qhTotal) * result.Ea.Value;
                        }
                    }
                     

                    result_pipe.Ea = Math.Round(eta, 1);
                    result_pipe.UWPa = 0;
                    result_pipe.WPa = 0; 
                    // 检查效率
                    if (eta > 95)
                    {//有时, 大流量曲线部分,是曲线不精确, 造成Q H曲线不符合实际, 造成效率计算出问题                 
                        result_pipe.AnalyStatus = Model.Eta.eAnalyStatus.Abnormal;
                        result_pipe.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ea, eta.ToString());
                    }
                    else
                    {//计算 
                        if (result_pipe.AnalyStatus == Model.Eta.eAnalyStatus.Unkonw)
                            result_pipe.AnalyStatus = Model.Eta.eAnalyStatus.Normal;
                        result_pipe.CalcUnitPower(); 
                    }
                }
                else
                {
                    result_pipe.AnalyStatus = Model.Eta.eAnalyStatus.Abnormal;
                }
            }
            else
            {//表示没有开机的
                result_pipe.SetEmptyPipe(this._machineCount);
            }


            return true;
        }

        #region 初始化测点列表
        /// <summary>
        /// 初始化测点列表
        /// </summary>
        /// <param name="context"></param>
        /// <param name="error_info"></param>
        /// <returns></returns>
        protected bool InitialMonitorList(
            Model.EtaStationAnalyContextItem context,
            out string error_info)
        {
            if (this._allMonitorList != null && this._allMonitorList.Count > 0)
            {//只用初始化一次即可
                error_info = null;
                return true;
            }
            List<Model.EtaPipeLineAnalyContextItem> PatternContextItems = context.PipeLineContextItems;
            this._allMonitorList = new List<Model.EtaMonitorPointAnalyContextitem>();
            foreach (var s in PatternContextItems)
            {
                if (s.MonitorPointContextItems != null)
                {
                    _allMonitorList.AddRange(s.MonitorPointContextItems);
                }
            }
            if (_allMonitorList.Count() == 0)
            {
                error_info = "没有任何监测数据";
                return false;
            }
            error_info = null;
            return true;
        }

        #endregion

        /// <summary>
        /// 初始化泵列表
        /// </summary>
        /// <param name="context"></param>
        /// <param name="error_info"></param>
        /// <returns></returns>
        protected virtual bool InitialPumpList(Model.EtaStationAnalyContextItem context, out string error_info)
        {
            error_info = "没有实例化";
            return false;
        }

        #region 构造机泵列表
        /// <summary>
        /// 构造机泵列表
        /// </summary>
        /// <param name="context">泵站上下文</param>
        /// <param name="machine_id_array"></param>
        /// <param name="monitor_id_run_status"></param>
        /// <param name="monitor_id_pump_flow"></param>
        /// <param name="is液位代替进口压力"></param>
        /// <param name="monitor_id_inlet_press"></param>
        /// <param name="monitor_id_outlet_press"></param>
        /// <param name="monitor_id_motor_power"></param>
        /// <param name="monitor_id_frequence"></param>
        /// <param name="monitor_id_zhuansu"></param>
        /// <param name="monitor_id_ele_curret"></param>
        /// <param name="error_info"></param>
        /// <returns></returns>
        protected List<IStation.Calculation.Eta.Model.PumpAnaResult> InitialPumpMachineList(
            Model.EtaStationAnalyContextItem context,
            long[] machine_id_array, //基本ID
            long[] monitor_id_run_status,//运行状态 
            long[] monitor_id_pump_flow,// 流量计
            bool is液位代替进口压力,
            long[] monitor_id_inlet_press,//进口压力计
            long[] monitor_id_outlet_press,//出口压力
            long[] monitor_id_motor_power,//瞬间功率
            long[] monitor_id_frequence,//频率
            long[] monitor_id_zhuansu,//转速
            long[] monitor_id_ele_curret,//电流
            out string error_info)
        {
            int machine_count = machine_id_array.Count();

            if (monitor_id_run_status == null || monitor_id_run_status.Count() != machine_count)
            {
                error_info = $"{context.Name}运行状态测点ID设置不正确!Error:67";
                return null;
            }
            if (monitor_id_pump_flow == null || monitor_id_pump_flow.Count() != machine_count)
            {
                error_info = $"{context.Name}流量测点ID设置不正确!Error:72";
                return null;
            }
            if (monitor_id_outlet_press == null || monitor_id_outlet_press.Count() != machine_count)
            {
                error_info = $"{context.Name}压力测点ID设置不正确!Error:77";
                return null;
            }


            error_info = null;
            List<IStation.Calculation.Eta.Model.PumpAnaResult> machine_list = new List<IStation.Calculation.Eta.Model.PumpAnaResult>(machine_count);
            for (int i = 0; i < machine_count; i++)
            {
                var machine_id = machine_id_array[i];
                Model.EtaEnginePumpAnalyContextItem machine_context = null;
                foreach (var item in context.PipeLineContextItems)
                {
                    if (item.Catalog != IStation.Product.Catalog_JiBeng)
                        continue;

                    machine_context = item.ProductContextItem as Model.EtaEnginePumpAnalyContextItem;
                    if (machine_context == null)
                        continue;
                    if (machine_id == machine_context.ObjectID)
                    {
                        var series_no = 0;
                        if (item.SerialNO.HasValue)
                        {
                            series_no = item.SerialNO.Value;
                        }
                        var bundle = new IStation.Calculation.Eta.Model.PumpAnaResult(machine_context)
                        {
                            SerialNO = series_no,
                            PipeLineID = machine_context.PipeLineID,
                            MachineID = machine_id
                        };

                        var result_pump = new Model.EtaSingleRealRecordPure();

                        result_pump.ObjectType = IStation.ObjectType.PipeLine;
                        result_pump.ObjectID = machine_context.PipeLineID;

                        result_pump.RSa = IStation.RunStatus.UnKnown;//默认未知
                        result_pump.AnalyStatus = Model.Eta.eAnalyStatus.Unkonw;
                        if (monitor_id_pump_flow != null && monitor_id_pump_flow.Count() > i)
                        {
                            bundle.MonitorID_PumpFlow = monitor_id_pump_flow[i];
                        }
                        if (monitor_id_run_status != null && monitor_id_run_status.Count() > i)
                        {
                            bundle.MonitorID_RunStatus = monitor_id_run_status[i];
                        }
                        bundle.Is液位代替进口压力 = is液位代替进口压力;
                        if (monitor_id_inlet_press != null && monitor_id_inlet_press.Count() > i)
                        {
                            bundle.MonitorID_InletPress = monitor_id_inlet_press[i];
                        }
                        if (monitor_id_outlet_press != null && monitor_id_outlet_press.Count() > i)
                        {
                            bundle.MonitorID_OutletPress = monitor_id_outlet_press[i];
                        }
                        if (monitor_id_motor_power != null && monitor_id_motor_power.Count() > i)
                        {
                            bundle.MonitorID_MotorPower = monitor_id_motor_power[i];
                        }
                        if (monitor_id_frequence != null && monitor_id_frequence.Count() > i)
                        {
                            bundle.MonitorID_Frequence = monitor_id_frequence[i];
                        }
                        if (monitor_id_zhuansu != null && monitor_id_zhuansu.Count() > i)
                        {
                            bundle.MonitorID_ZhuanSu = monitor_id_zhuansu[i];
                        }
                        if (monitor_id_ele_curret != null && monitor_id_ele_curret.Count() > i)
                        {
                            bundle.MonitorID_ele_current = monitor_id_ele_curret[i];
                        }
                        bundle.AnaResult = result_pump;
                        machine_list.Add(bundle);
                    }

                }


                if (machine_context == null)
                {
                    error_info = "此机泵无法找到对应管路设置 , 机泵ID=" + machine_id_array[i];
                    return null;
                }
            }

            if (machine_list.Count() != machine_count)
            {
                error_info = string.Format("错误代码Error:230, 能效实时分析任务中，机泵无法全部获取！stationID={0}", this._stationID);

                return null;
            }

            var sort_machine_list = (from x in machine_list orderby x.SerialNO select x).ToList();

            return sort_machine_list;
        }
        #endregion

        #region 分析 泵的运行状态(开机关机)
        /// <summary>
        /// 分析单泵的运行状态
        /// </summary>
        /// <param name="error_info"></param>
        /// <returns></returns>
        protected bool AnaAllPumpRunStatus(out string error_info)
        {
            for (int i = 0; i < this._allMachineList.Count(); i++)
            {
                var pump_context = this._allMachineList[i];

                if (!AnaPumpRunStatus(pump_context, out error_info))
                {//分析单泵
                    return false;
                }

                if (pump_context.AnaResult.RSa == IStation.RunStatus.Shut)
                {
                    pump_context.AnaResult.Qa = 0;
                    pump_context.AnaResult.Ha = 0;
                    pump_context.AnaResult.Pa = 0;
                    pump_context.AnaResult.Ea = 0;
                    pump_context.AnaResult.UWPa = 0;
                    pump_context.AnaResult.WPa = 0;

                    if (pump_context.AnaResult.AnalyStatus ==  Model.Eta.eAnalyStatus.Unkonw)
                        pump_context.AnaResult.AnalyStatus = Model.Eta.eAnalyStatus.Normal;
                }

            }



            error_info = null;
            return true;
        }

        /// <summary>
        /// 分析单泵的运行状态
        /// </summary>
        /// <param name="pump_context"></param>
        /// <param name="error_info"></param>
        /// <returns></returns>
        protected bool AnaPumpRunStatus( IStation.Calculation.Eta.Model.PumpAnaResult pump_context, out string error_info)
        {
            if (pump_context == null)
            {
                error_info = "Error 375";
                return false;
            }


            #region 开停机状态,以及频率, 电流
            var ana_context = pump_context.AnaResult;
            if (ana_context == null)
            {
                error_info = "AnaResult 为空 错误代码! Error:359";
                return false;
            }
            bool isAnaOk = false;
            if (pump_context.MonitorID_RunStatus > 0)
            {
                var monitor_run = _allMonitorList.Find(x => x.ObjectID == pump_context.MonitorID_RunStatus);

                if (monitor_run == null)
                {
                    ana_context.AnalyStatus =  Model.Eta.eAnalyStatus.Missing;
                    ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_RU, null);
                }
                else if (monitor_run.DataValue > 0.1)
                {
                    isAnaOk = true;
                    ana_context.RSa = IStation.RunStatus.Run;
                }
                else
                {
                    isAnaOk = true;
                    ana_context.RSa = IStation.RunStatus.Shut;
                    ana_context.Qa = 0;
                    ana_context.Ha = 0;
                    ana_context.Pa = 0;
                }
            }

            #endregion

            bool isOk频率 = false;
            bool isAddTag_hz = false;
            //分析频率
            if (isAnaOk)
            {
                #region 开机状态分析正常
                if (pump_context.IsRunIng)
                {
                    if (!pump_context.IsFrequency)
                    {
                        isOk频率 = true;
                        ana_context.HZa = 50;
                    }
                    else
                    {
                        if (pump_context.MonitorID_Frequence > 0)
                        {
                            #region 变频, 且已开机
                            var monitor_frequence = _allMonitorList.Find(x => x.ObjectID == pump_context.MonitorID_Frequence);
                            if (monitor_frequence == null)
                            {
                                isAddTag_hz = true;
                                ana_context.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                                ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_HZ, null);
                            }
                            else if (monitor_frequence.DataValue < 10 || monitor_frequence.DataValue > 55)
                            {//数据不正常
                                ana_context.HZa  = monitor_frequence.DataValue;
                                ana_context.AnalyStatus = Model.Eta.eAnalyStatus.Abnormal;
                                ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_HZ, null);
                            }
                            else
                            {
                                isOk频率 = true;
                                ana_context.HZa = monitor_frequence.DataValue;
                            }
                            #endregion
                        }
                        else
                        {
                            isAddTag_hz = true;
                            ana_context.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                            ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_HZ, null);
                        }
                    }
                }
                else
                {
                    isOk频率 = true;
                    ana_context.HZa = 0;
                }
                #endregion
            }
            else
            {
                #region 开机状态分析不正常, 看看用频率判断开停机行不行
                if (pump_context.MonitorID_Frequence > 0)
                {
                    var monitor_frequence = _allMonitorList.Find(x => x.ObjectID == pump_context.MonitorID_Frequence);
                    if (monitor_frequence == null)
                    {
                        ana_context.AnalyStatus =  Model.Eta.eAnalyStatus.Missing;
                        ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_HZ, null);
                    }
                    else if (monitor_frequence.DataValue < 10 || monitor_frequence.DataValue > 55)
                    {//数据不正常
                        ana_context.HZa = monitor_frequence.DataValue;
                        ana_context.AnalyStatus = Model.Eta.eAnalyStatus.Abnormal;
                        ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_HZ, null);
                    }
                    else
                    {//数据正常
                        isOk频率 = true;
                        ana_context.HZa = monitor_frequence.DataValue;
                        ana_context.RSa = IStation.RunStatus.Run;//表示开机了
                    }

                }
                #endregion
            }


            //
            var monitor_id_转速 = pump_context.MonitorID_ZhuanSu;
            if (monitor_id_转速 > 0 && !isOk频率)
            {
                var monitor_zhuansu = _allMonitorList.Find(x => x.ObjectID == monitor_id_转速);
                if (monitor_zhuansu == null)
                {
                    if (!isAddTag_hz)
                    {
                        ana_context.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                        ana_context.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_HZ, null);
                    }
                }
                else
                {
                    var zhuansu = monitor_zhuansu.DataValue;
                    if (zhuansu < 10)
                    {
                        ana_context.HZa = 0;
                        ana_context.AnalyStatus =  Model.Eta.eAnalyStatus.Abnormal;
                        ana_context.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_HZ, null);
                    }
                    else
                    {
                        if (pump_context.Context != null)
                        {
                            if (pump_context.Context.RatedParas.N < 10)
                            {
                                ana_context.AnalyStatus = Model.Eta.eAnalyStatus.Abnormal;
                                ana_context.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_HZ, "额定转速未设置");
                            }
                            else
                            {
                                if (isAddTag_hz)
                                {
                                    ana_context.RemoveAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_HZ);
                                }
                                ana_context.HZa = Math.Round(50 * zhuansu / pump_context.Context.RatedParas.N, 2);
                            }
                        }
                    }
                }
            }



            //用电流判断是否开机
            if (!isAnaOk)
            {
                #region  用电流判断是否开机
                if (pump_context.MonitorID_ele_current > 0)
                {
                    var monitor_ele_current = _allMonitorList.Find(x => x.ObjectID == pump_context.MonitorID_ele_current);
                    if (monitor_ele_current == null)
                    {
                        ana_context.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                        ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_Ia, null);
                    }
                    else if (monitor_ele_current.DataValue < 1)
                    {//数据不正常
                        ana_context.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                        ana_context.PutAnalyInfo(Model.EtaSingleRealRecordPure.InfoTag_Ia, null);
                    }
                    else
                    {//数据正常 
                        ana_context.RSa = IStation.RunStatus.Run;//表示开机了
                    }
                }
                #endregion
            }


            error_info = null;
            return true;
        }

        #endregion


        /// <summary>
        /// 根据压差计算流量扬程点
        /// </summary>
        /// <param name="pump_curve"></param>
        /// <param name="inlet_dia"></param>
        /// <param name="inlet_press"></param>
        /// <param name="outlet_dia"></param>
        /// <param name="outlet_press" ></param>
        /// <param name="hz"></param>
        /// <returns></returns>
        protected IStation.Model.CurvePoint GetFolwByPress(
            IStation.Model.CurveExpress pump_curve,
            double inlet_dia, double inlet_press,
            double outlet_dia, double outlet_press,
            double hz)
        {
            //转成米
            double h4Press = UnitConvert_MPa2M(outlet_press - inlet_press);

            IStation.Model.CurveExpress curve_qh = null;
            if (hz < 49 && hz > 20)
            {//进行曲线换算
                curve_qh = CalcCurveQhByHz(pump_curve, hz);
            }
            else
            {//原始曲线即可
                curve_qh = pump_curve;
            }
            if (curve_qh == null)
                return null;

            //先用压差查询流量   
            List<IStation.Model.CurvePoint> listQ0 = IStation.Model.FitCurveHelper.GetInterPointExX(curve_qh, h4Press, 50, 1.5);//放大一点
            if (listQ0 == null || listQ0.Count == 0)
            {
                return null;
            }

            var m_inlet_dia = inlet_dia / 1000;//转成m
            var m_outlet_dia = outlet_dia / 1000;//转成m

            double OtherPressCoeff = 4 / Math.PI / 3600;
            //OtherPressCoeff = 4 * 1000 / Math.PI / 3.6;
            double dieDai_q = listQ0.Last().X;//用于计算的流量
            double dieDai_h = 0;
            double last_dieDai_q = dieDai_q;
            for (int calcNo = 1; calcNo <= 3; calcNo++)//迭代三次
            {
                if (last_dieDai_q < 1)
                {//流量不可能过小
                    return null;
                }
                double rPipeInV = 0;
                if (inlet_dia > 0)
                {
                    rPipeInV = OtherPressCoeff * dieDai_q / m_inlet_dia / m_inlet_dia;
                }

                double rPipeOutV = 0;
                if (outlet_dia > 0)
                {
                    rPipeOutV = OtherPressCoeff * dieDai_q / m_outlet_dia / m_outlet_dia;
                }


                double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / 9.81 / 2.0;
                dieDai_h = h4Press + rVDif;

                List<IStation.Model.CurvePoint> listQ = IStation.Model.FitCurveHelper.GetInterPointExX(curve_qh, dieDai_h, 50, 1.5);//放大一点
                if (listQ == null || listQ.Count() == 0)
                {
                    return new IStation.Model.CurvePoint(dieDai_q, dieDai_h);
                }
                dieDai_q = listQ.Last().X;
                if (Math.Abs(dieDai_q - last_dieDai_q) / last_dieDai_q < 0.005)
                {
                    return new IStation.Model.CurvePoint(dieDai_q, dieDai_h);
                }
                //继续迭代
                if (dieDai_q > last_dieDai_q)
                {
                    dieDai_q = dieDai_q - Math.Abs(dieDai_q - last_dieDai_q) / 2;
                }
                else
                {
                    dieDai_q = dieDai_q + Math.Abs(dieDai_q - last_dieDai_q) / 2;
                }

                last_dieDai_q = dieDai_q;
            }

            return new IStation.Model.CurvePoint(dieDai_q, dieDai_h);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="curve_QH"></param>
        /// <param name="hz"></param>
        /// <returns></returns>
        public static IStation.Model.CurveExpress CalcCurveQhByHz(
            IStation.Model.CurveExpress curve_QH, double hz)
        {
            if (curve_QH == null)
                return null;
            if (hz > 49.5)
                return curve_QH;

            double f_ratio = hz / 50.0;
            var points = IStation.Model.FitCurveHelper.GetFitPoints(curve_QH, 12);

            List<IStation.Model.CurvePoint> simu_points = new List<IStation.Model.CurvePoint>();
            foreach (var pt in points)
            {
                double xshsFlow = pt.X * f_ratio;
                double xshsHead = pt.Y * f_ratio * f_ratio;
                simu_points.Add(new IStation.Model.CurvePoint(xshsFlow, xshsHead));
            }

            return new IStation.Model.CurveExpress(simu_points);
        }



        #region  单泵分析
        /// <summary>
        /// 单泵流量计(运行状态待分析)
        /// </summary>
        /// <param name="context_pump"></param>
        /// <returns></returns>
        protected bool Analy_有单泵流量计_运行状态已分析_工频泵(
            ref IStation.Calculation.Eta.Model.PumpAnaResult context_pump)
        {
            var ana_result = context_pump.AnaResult;
            if (ana_result == null)
                return false;

            bool is液位代替出口压力 = context_pump.Is液位代替出口压力;
            bool is液位代替进口压力 = context_pump.Is液位代替进口压力;
            long monitor_id_进口压力 = context_pump.MonitorID_InletPress;
            long monitor_id_出口压力 = context_pump.MonitorID_OutletPress;
            long monitor_id_瞬时流量 = context_pump.MonitorID_PumpFlow;
            long monitor_id_瞬时功率 = context_pump.MonitorID_MotorPower;



            if (!context_pump.IsRunIng)
            {//表示关机
                context_pump.Ana_flow_ok = true;//没有开机就认为是成功
                context_pump.Ana_head_ok = true;
                context_pump.Ana_eta_ok = true;
                context_pump.Ana_power_ok = true;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;
                ana_result.RSa = IStation.RunStatus.Shut;
                ana_result.Qa = 0;
                ana_result.Ha = 0;
                ana_result.Pa = 0;
                ana_result.HZa  = 0;
                return true;
            }

            ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;


            context_pump.Ana_flow_ok = false;
            context_pump.Ana_head_ok = false;
            context_pump.Ana_eta_ok = false;

            #region 流量
            double total_flow = 0;
            var monitor_flow = _allMonitorList.Find(x => x.ObjectID == monitor_id_瞬时流量);
            if (monitor_flow == null)
            {
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Qa, null);
                context_pump.Ana_flow_ok = false;
            }
            else
            {
                ana_result.Qa = monitor_flow.DataValue;
                total_flow = monitor_flow.DataValue;
                if (monitor_flow.DataValue < _threshold_flow)
                {
                    ana_result.Qa = monitor_flow.DataValue;
                    ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Abnormal;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Qa, null);
                    context_pump.Ana_flow_ok = false;
                }
                context_pump.Ana_flow_ok = true;
            }

            #endregion


            #region  功率
            double total_power = 0;
            var monitor_power = _allMonitorList.Find(x => x.ObjectID == monitor_id_瞬时功率);
            if (monitor_power == null)
            {
                context_pump.Ana_power_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, null);
            }
            else
            {
                total_power = monitor_power.DataValue;
                if (total_power < 1)
                {
                    context_pump.Ana_power_ok = false;
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, total_power.ToString());
                }
                else
                {
                    context_pump.Ana_power_ok = true;
                }
                ana_result.Pa = total_power;
            }
            #endregion


            #region 频率
            ana_result.HZa = 50;
            #endregion


            #region  进口压力
            var monitor_inlet_press = _allMonitorList.Find(x => x.ObjectID == monitor_id_进口压力);
            if (monitor_inlet_press == null)
            {
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P1, null);
                return false;
            }
            double p1m = monitor_inlet_press.DataValue;
            if (is液位代替进口压力)
            {//液位一般都是m
                p1m = UnitConvert_M2MPa(p1m);
            }

            if (monitor_inlet_press.Elevation != null)
            {//判断是否有标高
                p1m += UnitConvert_M2MPa(monitor_inlet_press.Elevation.Value);
            }

            double mm_inlet_dia = 0;//用 mm
            if (monitor_inlet_press.PipeDia.HasValue)
            {
                mm_inlet_dia = monitor_inlet_press.PipeDia.Value;
            }
            #endregion


            #region  出口压力

            var monitor_outlet_press = _allMonitorList.Find(x => x.ObjectID == monitor_id_出口压力);
            if (monitor_outlet_press == null)
            {
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P2, null);
                return false;
            }
            double p2m = monitor_outlet_press.DataValue;
            if (is液位代替出口压力)
            {//液位一般都是m
                p2m = UnitConvert_M2MPa(p2m);
            }
            if (monitor_outlet_press.Elevation != null)
            {//判断是否有标高
                p2m += UnitConvert_M2MPa(monitor_outlet_press.Elevation.Value);
            }

            double mm_outlet_dia = 0;//用 mm
            if (monitor_outlet_press.PipeDia.HasValue)
            {
                mm_outlet_dia = monitor_outlet_press.PipeDia.Value;
            }

            #endregion


            #region 计算扬程
            double OtherPressCoeff = 4 * 1000 / Math.PI / 3.6;
            double rPipeInV = 0;
            if (mm_inlet_dia > 10)
            {
                rPipeInV = OtherPressCoeff * total_flow / mm_inlet_dia / mm_inlet_dia;
            }

            double rPipeOutV = 0;
            if (mm_outlet_dia > 10)
            {
                rPipeOutV = OtherPressCoeff * total_flow / mm_outlet_dia / mm_outlet_dia;
            }

            double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / (g * 2.0);
            double total_head = Math.Round(UnitConvert_MPa2M(p2m - p1m) + rVDif, 2);
            ana_result.Ha = total_head;
            //检查扬程 
            if (total_head > 800)
            {
                context_pump.Ana_head_ok = false;
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
            }
            else if (total_head < 1)
            {
                context_pump.Ana_head_ok = false;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
            }
            else
            {
                context_pump.Ana_head_ok = true;
            }
            #endregion




            ana_result.CalcUnitPower();

            context_pump.Ana_eta_ok = false;

            if (total_power > 1 && context_pump.Ana_power_ok && context_pump.Ana_head_ok && context_pump.Ana_flow_ok)
            { 
                //计算效率
                double eta = Math.Round(Model.EtaSingleRealRecordPure.Calc_Eta(total_flow, total_head, total_power, WaterDensity, g), 1);
                ana_result.Ea = eta;

                // 检查效率
                if (eta > 95 || eta < 40)
                {//有时, 大流量曲线部分,是曲线不精确, 造成Q H曲线不符合实际, 造成效率计算出问题 
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ea, eta.ToString());
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                }
                else
                {//计算 
                    if (ana_result.AnalyStatus ==  Model.Eta.eAnalyStatus.Unkonw)
                        ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;

                    context_pump.Ana_eta_ok = true;
                }
            }

            return true;
        }

        /// <summary>
        /// 单泵流量计(运行状态待分析)
        /// </summary>
        /// <param name="context_pump"></param>
        /// <returns></returns>
        protected bool Analy_有单泵流量计_运行状态已分析_变频泵(
            ref IStation.Calculation.Eta.Model.PumpAnaResult context_pump)
        {
            var ana_result = context_pump.AnaResult;
            if (ana_result == null)
                return false;
            bool is液位代替出口压力 = context_pump.Is液位代替出口压力;
            bool is液位代替进口压力 = context_pump.Is液位代替进口压力;
            long monitor_id_进口压力 = context_pump.MonitorID_InletPress;
            long monitor_id_出口压力 = context_pump.MonitorID_OutletPress;
            long monitor_id_瞬时流量 = context_pump.MonitorID_PumpFlow;
            long monitor_id_瞬时功率 = context_pump.MonitorID_MotorPower;
           // long monitor_id_频率 = context_pump.MonitorID_Frequence;
           // long monitor_id_转速 = context_pump.MonitorID_ZhuanSu;

            if (!context_pump.IsRunIng)
            {//表示关机
                context_pump.Ana_flow_ok = true;//没有开机就认为是成功
                context_pump.Ana_head_ok = true;
                context_pump.Ana_eta_ok = true;
                context_pump.Ana_power_ok = true;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;
                ana_result.RSa = IStation.RunStatus.Shut;
                ana_result.Qa = 0;
                ana_result.Ha = 0;
                ana_result.Pa = 0;
                ana_result.HZa = 0;
                return true;
            }

            ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;

            context_pump.Ana_flow_ok = false;
            context_pump.Ana_head_ok = false;
            context_pump.Ana_eta_ok = false;

            #region 流量
            double total_flow = 0;
            var monitor_flow = _allMonitorList.Find(x => x.ObjectID == monitor_id_瞬时流量);
            if (monitor_flow == null)
            {
                ana_result.Qa = null;
                context_pump.Ana_flow_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Qa, null);
            }
            else
            {
                ana_result.Qa = monitor_flow.DataValue;
                total_flow = monitor_flow.DataValue;
                if (monitor_flow.DataValue < _threshold_flow)
                {
                    ana_result.Qa = monitor_flow.DataValue;
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Qa, null);
                    context_pump.Ana_flow_ok = false;
                }
                else
                {
                    context_pump.Ana_flow_ok = true;
                }
            }

            #endregion


            #region  功率
            double total_power = 0;
            var monitor_power = _allMonitorList.Find(x => x.ObjectID == monitor_id_瞬时功率);
            if (monitor_power == null)
            {
                context_pump.Ana_power_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, null);
            }
            else
            {
                total_power = monitor_power.DataValue;
                if (total_power < 1)
                {
                    context_pump.Ana_power_ok = false;
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, total_power.ToString());
                }
                else
                {
                    context_pump.Ana_power_ok = true;
                }
                ana_result.Pa = total_power;
            }
            #endregion


            #region  进口压力
            var monitor_inlet_press = _allMonitorList.Find(x => x.ObjectID == monitor_id_进口压力);
            if (monitor_inlet_press == null)
            {
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P1, null);
                return false;
            }

            double p1m = monitor_inlet_press.DataValue;
            if (is液位代替进口压力)
            {//液位一般都是m
                p1m = UnitConvert_M2MPa(p1m);
            }

            if (monitor_inlet_press.Elevation != null)
            {//判断是否有标高
                p1m += UnitConvert_M2MPa(monitor_inlet_press.Elevation.Value);
            }

            double mm_inlet_dia = 0;//用 mm
            if (monitor_inlet_press.PipeDia.HasValue)
            {
                mm_inlet_dia = monitor_inlet_press.PipeDia.Value;
            }
            #endregion


            #region  出口压力

            var monitor_outlet_press = _allMonitorList.Find(x => x.ObjectID == monitor_id_出口压力);
            if (monitor_outlet_press == null)
            {
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P2, null);
                return false;
            }
            double p2m = monitor_outlet_press.DataValue;
            if (is液位代替出口压力)
            {//液位一般都是m
                p2m = UnitConvert_M2MPa(p2m);
            }
            if (monitor_outlet_press.Elevation != null)
            {//判断是否有标高
                p2m += UnitConvert_M2MPa(monitor_outlet_press.Elevation.Value);
            }

            double mm_outlet_dia = 0;//用 mm
            if (monitor_outlet_press.PipeDia.HasValue)
            {
                mm_outlet_dia = monitor_outlet_press.PipeDia.Value;
            }

            #endregion


            #region 计算扬程
            double OtherPressCoeff = 4 * 1000 / Math.PI / 3.6;
            double rPipeInV = 0;
            if (mm_inlet_dia > 10)
            {
                rPipeInV = OtherPressCoeff * total_flow / mm_inlet_dia / mm_inlet_dia;
            }

            double rPipeOutV = 0;
            if (mm_outlet_dia > 10)
            {
                rPipeOutV = OtherPressCoeff * total_flow / mm_outlet_dia / mm_outlet_dia;
            }

            double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / (g * 2.0);
            double total_head = Math.Round(UnitConvert_MPa2M(p2m - p1m) + rVDif, 2);
            ana_result.Ha = total_head;
            //检查扬程
            if (total_head > 800)
            {
                context_pump.Ana_head_ok = false;
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
            }
            else if (total_head < 1)
            {
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                context_pump.Ana_head_ok = false;
            }
            else
            {
                context_pump.Ana_head_ok = true;
            }
            #endregion




            ana_result.CalcUnitPower();

            context_pump.Ana_eta_ok = false;

            if (total_power > 1 && total_flow > 1 &&
                context_pump.Ana_head_ok && context_pump.Ana_power_ok)
            { 
                //计算效率
                double eta = Math.Round(Model.EtaSingleRealRecordPure.Calc_Eta(total_flow, total_head, total_power, WaterDensity, g), 1);

                ana_result.Ea = eta;

                // 检查效率
                if (eta > 95 || eta < 40)
                {//有时, 大流量曲线部分,是曲线不精确, 造成Q H曲线不符合实际, 造成效率计算出问题 
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ea, eta.ToString());
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                }
                else
                {//计算 
                    if (ana_result.AnalyStatus == Model.Eta.eAnalyStatus.Unkonw)
                        ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;

                    context_pump.Ana_eta_ok = true;
                }
            }

            return true;
        }


        /// <summary>
        /// 单泵流量计
        /// </summary>
        /// <param name="pump_flow"></param> 
        /// <param name="pump"></param>
        /// <returns></returns>
        protected bool Analy_有单泵流量计_运行状态已分析_变频泵(
            double pump_flow,//
            ref IStation.Calculation.Eta.Model.PumpAnaResult pump)
        {
            if (pump == null)
                return false;
            var ana_result = pump.AnaResult;
            if (ana_result == null)
                ana_result = new IStation.Model.EtaSingleRealRecordPure();

            long monitor_id_进口压力 = pump.MonitorID_InletPress;
            long monitor_id_出口压力 = pump.MonitorID_OutletPress;
            long monitor_id_瞬时功率 = pump.MonitorID_MotorPower;

            Model.EtaMonitorPointAnalyContextitem monitor_record_进口压力 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_进口压力);
            Model.EtaMonitorPointAnalyContextitem monitor_record_出口压力 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_出口压力);
            Model.EtaMonitorPointAnalyContextitem monitor_record_瞬时功率 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_瞬时功率);

 

            pump.Ana_head_ok = false;
            pump.Ana_eta_ok = false;
            pump.Ana_flow_ok = true;

            ana_result.Qa = pump_flow;

            #region  功率
            double total_power = 0;
            if (monitor_record_瞬时功率 == null)
            {
                pump.Ana_power_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, null);
            }
            else
            {
                total_power = monitor_record_瞬时功率.DataValue;
                if (total_power < 1)
                {
                    pump.Ana_power_ok = false;
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, total_power.ToString());
                }
                else
                {
                    pump.Ana_power_ok = true;
                }
                ana_result.Pa = total_power;
            }

            #endregion


            #region  进口压力 
            if (monitor_record_进口压力 == null)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P1, null);
                return false;
            }
            double p1m = monitor_record_进口压力.DataValue;
            if (pump.Is液位代替进口压力)
            {//液位一般都是m
                p1m = UnitConvert_M2MPa(p1m);
            }

            if (monitor_record_进口压力.Elevation != null)
            {//判断是否有标高
                p1m += UnitConvert_M2MPa(monitor_record_进口压力.Elevation.Value);
            }

            double mm_inlet_dia = 0;//用 mm
            if (monitor_record_进口压力.PipeDia.HasValue)
            {
                mm_inlet_dia = monitor_record_进口压力.PipeDia.Value;
            }
            #endregion


            #region  出口压力 
            if (monitor_record_出口压力 == null)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P2, null);
                return false;
            }
            double p2m = monitor_record_出口压力.DataValue;
            if (monitor_record_出口压力.Elevation != null)
            {//判断是否有标高
                p2m += UnitConvert_M2MPa(monitor_record_出口压力.Elevation.Value);
            }

            double mm_outlet_dia = 0;//用 mm
            if (monitor_record_出口压力.PipeDia.HasValue)
            {
                mm_outlet_dia = monitor_record_出口压力.PipeDia.Value;
            }

            #endregion


            #region 计算扬程
            pump.Ana_head_ok = false;
            double OtherPressCoeff = 4 * 1000 / Math.PI / 3.6;
            double rPipeInV = 0;
            if (mm_inlet_dia > 10)
            {
                rPipeInV = OtherPressCoeff * pump_flow / mm_inlet_dia / mm_inlet_dia;
            }

            double rPipeOutV = 0;
            if (mm_outlet_dia > 10)
            {
                rPipeOutV = OtherPressCoeff * pump_flow / mm_outlet_dia / mm_outlet_dia;
            }


            double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / (g * 2.0);
            double total_head = Math.Round(UnitConvert_MPa2M(p2m - p1m) + rVDif, 2);
            ana_result.Ha = total_head;
            if (total_head > 800)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
            }
            else if (total_head < 1)
            {
                pump.Ana_head_ok = false;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
            }
            else
            {
                pump.Ana_head_ok = true;
            }
            #endregion





            ana_result.CalcUnitPower();


            pump.Ana_eta_ok = false;

            if (total_power > 1 && pump_flow > 1 && pump.Ana_head_ok)
            { 
                //计算效率
                double eta = Math.Round(Model.EtaSingleRealRecordPure.Calc_Eta(pump_flow, total_head, total_power, WaterDensity, g), 1);
                ana_result.Ea = eta;

                // 检查效率
                if (eta > 95 || eta < 40)
                {//有时, 大流量曲线部分,是曲线不精确, 造成Q H曲线不符合实际, 造成效率计算出问题 
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ea, eta.ToString());
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                }
                else
                {//计算 
                    ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;

                    pump.Ana_eta_ok = true;
                }
            }
            pump.AnaResult = ana_result;
            return true;
        }


        /// <summary>
        /// 无流量计分析
        /// </summary>
        /// <param name="averge_flow"></param> 
        /// <param name="pump"></param>
        /// <returns></returns>
        protected bool Analy_无单泵流量计_运行状态已分析_变频泵(
            double averge_flow,//平均流量(用于预算) 
            ref IStation.Calculation.Eta.Model.PumpAnaResult pump)
        {
            if (pump == null)
                return false;
            var ana_result = pump.AnaResult;
            if (ana_result == null)
                ana_result = new IStation.Model.EtaSingleRealRecordPure();

            pump.Ana_flow_ok = false;
            pump.Ana_head_ok = false;
            pump.Ana_eta_ok = false;

            long monitor_id_进口压力 = pump.MonitorID_InletPress;
            long monitor_id_出口压力 = pump.MonitorID_OutletPress;
            long monitor_id_瞬时功率 = pump.MonitorID_MotorPower;

            Model.EtaMonitorPointAnalyContextitem monitor_record_进口压力 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_进口压力);
            Model.EtaMonitorPointAnalyContextitem monitor_record_出口压力 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_出口压力);
            Model.EtaMonitorPointAnalyContextitem monitor_record_瞬时功率 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_瞬时功率);
 

            #region  功率
            double total_power = 0;
            if (monitor_record_瞬时功率 == null)
            {
                pump.Ana_power_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, null);
            }
            else
            {
                total_power = monitor_record_瞬时功率.DataValue;
                if (total_power < 1)
                {
                    pump.Ana_power_ok = false;
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, total_power.ToString());
                }
                else
                {
                    pump.Ana_power_ok = true;
                }
                ana_result.Pa = total_power;
            }
            #endregion


            #region  进口压力 
            if (monitor_record_进口压力 == null)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P1, null);
                return false;
            }
            double p1m = monitor_record_进口压力.DataValue;
            if (monitor_record_进口压力.Elevation != null)
            {//判断是否有标高
                p1m += UnitConvert_M2MPa(monitor_record_进口压力.Elevation.Value);
            }
            if (pump.Is液位代替进口压力)
            {//液位一般都是m
                p1m = UnitConvert_M2MPa(p1m);
            }

            double mm_inlet_dia = 0;//用 mm
            if (monitor_record_进口压力.PipeDia.HasValue)
            {
                mm_inlet_dia = monitor_record_进口压力.PipeDia.Value;
            }
            #endregion


            #region  出口压力 
            if (monitor_record_出口压力 == null)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P2, null);
                return false;
            }
            double p2m = monitor_record_出口压力.DataValue;
            if (monitor_record_出口压力.Elevation != null)
            {//判断是否有标高
                p2m += UnitConvert_M2MPa(monitor_record_出口压力.Elevation.Value);
            }

            double mm_outlet_dia = 0;//用 mm
            if (monitor_record_出口压力.PipeDia.HasValue)
            {
                mm_outlet_dia = monitor_record_出口压力.PipeDia.Value;
            }

            #endregion


            #region 计算扬程
            double OtherPressCoeff = 4 * 1000 / Math.PI / 3.6;
            double rPipeInV = 0;
            if (mm_inlet_dia > 10)
            {
                rPipeInV = OtherPressCoeff * averge_flow / mm_inlet_dia / mm_inlet_dia;
            }

            double rPipeOutV = 0;
            if (mm_outlet_dia > 10)
            {
                rPipeOutV = OtherPressCoeff * averge_flow / mm_outlet_dia / mm_outlet_dia;
            }


            double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / (g * 2.0);
            double total_head = Math.Round(UnitConvert_MPa2M(p2m - p1m) + rVDif, 2);
            ana_result.Ha = total_head;

            //检查扬程
            if (total_head > 800)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
            }
            else if (total_head < 1)
            {
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                pump.Ana_head_ok = false;
            }
            else
            {
                pump.Ana_head_ok = true;
            }

            #endregion



            #region 根据曲线计算流量
            pump.Ana_flow_ok = false;
            if (pump.Ana_head_ok)
            {
                var machine = pump.Context;
                if (machine == null || machine.CurveQH == null)
                {
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Curve, null);
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    return false;
                }
                if (ana_result.HZa <= 1)
                {
                    return false;
                }
                ////根据曲线计算
                var wrk_pt = GetFolwByPress(machine.CurveQH, mm_inlet_dia, p1m, mm_outlet_dia, p2m, ana_result.HZa);
                if (wrk_pt == null)
                {  //如果无法分析,就简单用进出口压差表示扬程
                    var h = Math.Round(UnitConvert_MPa2M(p2m - p1m), 2);
                    ana_result.Ha = h;
                    pump.Ana_flow_ok = false;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Curve, h.ToString("N2"));
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    return false;
                }
                pump.Ana_flow_ok = true;
                double qa = Math.Round(wrk_pt.X, 1);
                ana_result.Qa = qa;
            }


            #endregion





            ana_result.CalcUnitPower();

            pump.Ana_eta_ok = false;

            if (total_power > 1 && pump.Ana_flow_ok && pump.Ana_head_ok && pump.Ana_power_ok)
            { 
                //计算效率
                double eta = Math.Round(Model.EtaSingleRealRecordPure.Calc_Eta(averge_flow, total_head, total_power, WaterDensity, g), 1);
                ana_result.Ea = eta;

                // 检查效率
                if (eta > 95 || eta < 40)
                {//有时, 大流量曲线部分,是曲线不精确, 造成Q H曲线不符合实际, 造成效率计算出问题 
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ea, eta.ToString());
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                }
                else
                {//计算 
                    if (ana_result.AnalyStatus == Model.Eta.eAnalyStatus.Unkonw)
                        ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;

                    pump.Ana_eta_ok = true;
                }
            }


            return true;
        }

        /// <summary>
        /// 无流量计分析
        /// </summary>
        /// <param name="averge_flow"></param> 
        /// <param name="pump"></param>
        /// <returns></returns>
        protected bool Analy_无单泵流量计_运行状态已分析_工频泵(
            double averge_flow,//平均流量(用于预算) 
            ref IStation.Calculation.Eta.Model.PumpAnaResult pump)
        {
            if (pump == null)
                return false;
            var ana_result = pump.AnaResult;
            if (ana_result == null)
                ana_result = new IStation.Model.EtaSingleRealRecordPure();

            pump.Ana_flow_ok = false;
            pump.Ana_head_ok = false;
            pump.Ana_eta_ok = false;

            long monitor_id_进口压力 = pump.MonitorID_InletPress;
            long monitor_id_出口压力 = pump.MonitorID_OutletPress;
            long monitor_id_瞬时功率 = pump.MonitorID_MotorPower;

            Model.EtaMonitorPointAnalyContextitem monitor_record_进口压力 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_进口压力);
            Model.EtaMonitorPointAnalyContextitem monitor_record_出口压力 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_出口压力);
            Model.EtaMonitorPointAnalyContextitem monitor_record_瞬时功率 = this._allMonitorList.Find(x => x.ObjectID == monitor_id_瞬时功率);



            #region  功率
            double total_power = 0;
            if (monitor_record_瞬时功率 == null)
            {
                pump.Ana_power_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, null);
            }
            else
            {
                total_power = monitor_record_瞬时功率.DataValue;
                if (total_power < 1)
                {
                    pump.Ana_power_ok = false;
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Pa, total_power.ToString());
                }
                else
                {
                    pump.Ana_power_ok = true;
                }
                ana_result.Pa = total_power;
            }
            #endregion


            #region  进口压力 
            if (monitor_record_进口压力 == null)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P1, null);
                return false;
            }
            double p1m = monitor_record_进口压力.DataValue;
            if (monitor_record_进口压力.Elevation != null)
            {//判断是否有标高
                p1m += UnitConvert_M2MPa(monitor_record_进口压力.Elevation.Value);
            }
            if (pump.Is液位代替进口压力)
            {//液位一般都是m
                p1m = UnitConvert_M2MPa(p1m);
            }
            double mm_inlet_dia = 0;//用 mm
            if (monitor_record_进口压力.PipeDia.HasValue)
            {
                mm_inlet_dia = monitor_record_进口压力.PipeDia.Value;
            }
            #endregion


            #region  出口压力 
            if (monitor_record_出口压力 == null)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Missing;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_P2, null);
                return false;
            }
            double p2m = monitor_record_出口压力.DataValue;
            if (monitor_record_出口压力.Elevation != null)
            {//判断是否有标高
                p2m += UnitConvert_M2MPa(monitor_record_出口压力.Elevation.Value);
            }

            double mm_outlet_dia = 0;//用 mm
            if (monitor_record_出口压力.PipeDia.HasValue)
            {
                mm_outlet_dia = monitor_record_出口压力.PipeDia.Value;
            }

            #endregion


            #region 计算扬程
            double OtherPressCoeff = 4 * 1000 / Math.PI / 3.6;
            double rPipeInV = 0;
            if (mm_inlet_dia > 10)
            {
                rPipeInV = OtherPressCoeff * averge_flow / mm_inlet_dia / mm_inlet_dia;
            }

            double rPipeOutV = 0;
            if (mm_outlet_dia > 10)
            {
                rPipeOutV = OtherPressCoeff * averge_flow / mm_outlet_dia / mm_outlet_dia;
            }


            double rVDif = (rPipeOutV * rPipeOutV - rPipeInV * rPipeInV) / (g * 2.0);
            double total_head = Math.Round(UnitConvert_MPa2M(p2m - p1m) + rVDif, 2);
            ana_result.Ha = total_head;

            //检查扬程
            if (total_head > 800)
            {
                pump.Ana_head_ok = false;
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
            }
            else if (total_head < 1)
            {
                pump.Ana_head_ok = false;
                ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ha, total_head.ToString());
                ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                return false;
            }
            else
            {
                pump.Ana_head_ok = true;
            }


            #endregion



            #region 根据曲线计算流量
            pump.Ana_flow_ok = false;
            if (pump.Ana_head_ok)
            {
                var machine = pump.Context;
                if (machine == null || machine.CurveQH == null)
                {
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Curve, null);
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    return false;
                }

                ////根据曲线计算
                var wrk_pt = GetFolwByPress(machine.CurveQH, mm_inlet_dia, p1m, mm_outlet_dia, p2m, 50);
                if (wrk_pt == null)
                {  //如果无法分析,就简单用进出口压差表示扬程
                    var h = Math.Round(UnitConvert_MPa2M(p2m - p1m), 2);
                    ana_result.Ha = h;
                    pump.Ana_flow_ok = false;
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Curve, h.ToString("N2"));
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                    return false;
                }
                pump.Ana_flow_ok = true;
                double qa = Math.Round(wrk_pt.X, 1);
                ana_result.Qa = qa;
            }


            #endregion




            ana_result.CalcUnitPower();

            pump.Ana_eta_ok = false;

            if (total_power > 1 && pump.Ana_flow_ok && pump.Ana_head_ok && pump.Ana_power_ok)
            { 

                //计算效率
                double eta = Math.Round(Model.EtaSingleRealRecordPure.Calc_Eta(averge_flow, total_head, total_power, WaterDensity, g), 1);
                ana_result.Ea = eta;

                // 检查效率
                if (eta > 95 || eta < 40)
                {//有时, 大流量曲线部分,是曲线不精确, 造成Q H曲线不符合实际, 造成效率计算出问题 
                    ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ea, eta.ToString());
                    ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                }
                else
                {//计算 
                    if (ana_result.AnalyStatus == Model.Eta.eAnalyStatus.Unkonw)
                        ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;

                    pump.Ana_eta_ok = true;
                }
            }


            return true;
        }

        #endregion

        #region 多泵运行
        /// <summary>
        /// 多泵运行(注意不要有子节点的管路了,下面都是泵才行):返回的只有开机的Result
        /// </summary>
        /// <param name="monitor_value_total_flow"></param>
        /// <param name="all_pump_result_list"></param>
        /// <returns></returns>
        protected bool Analy_多泵并联运行_单管出口(
            double monitor_value_total_flow,
            List<IStation.Calculation.Eta.Model.PumpAnaResult> all_pump_result_list)
        {
            //获取所有开机的
            List<IStation.Calculation.Eta.Model.PumpAnaResult> open_pump_result_list = new List<IStation.Calculation.Eta.Model.PumpAnaResult>();
            for (int i = 0; i < all_pump_result_list.Count(); i++)
            {
                if (all_pump_result_list[i].IsRunIng)
                {
                    open_pump_result_list.Add(all_pump_result_list[i]);
                }
            }

            int open_pump_count = open_pump_result_list.Count;
            if (open_pump_count == 0)
            {
                return true;
            }

            bool isAllOk_flow = true;
            double ana_total_flow = 0;//分析的总流量
            //获取所有开机的
            for (int i = 0; i < open_pump_count; i++)
            {
                var pump_context = open_pump_result_list[i];

                if (pump_context.IsFrequency)
                {
                    Analy_无单泵流量计_运行状态已分析_变频泵(
    monitor_value_total_flow / open_pump_count,
    ref pump_context);
                }
                else
                {
                    Analy_无单泵流量计_运行状态已分析_工频泵(
    monitor_value_total_flow / open_pump_count,
    ref pump_context);
                }

                if (!pump_context.Ana_flow_ok)
                    isAllOk_flow = false;
                if (!pump_context.Ana_head_ok)
                    isAllOk_flow = false;

                if (pump_context.AnaResult.Qa == null)
                {
                    isAllOk_flow = false;
                }
                else
                {
                    ana_total_flow += pump_context.AnaResult.Qa.Value;
                }
            }

            #region 按总流量进行等比分
            if (isAllOk_flow)
            {
                for (int i = 0; i < open_pump_count; i++)
                {
                    var ana_result = open_pump_result_list[i].AnaResult;

                    ana_result.Qa = Math.Round(ana_result.Qa.Value * monitor_value_total_flow / ana_total_flow, 1);
                    ana_result.UWPa = 0;
                    ana_result.WPa = 0;
                    if (ana_result.Pa != null && ana_result.Pa > 1)
                    {
                        double eta = Math.Round(Model.EtaSingleRealRecordPure.Calc_Eta(ana_result.Qa.Value, ana_result.Ha.Value, ana_result.Pa.Value, WaterDensity, g), 1);
                        ana_result.Ea = eta;

                        // 检查效率
                        if (eta > 95 || eta < 40)
                        {//有时, 大流量曲线部分,是曲线不精确, 造成Q H曲线不符合实际, 造成效率计算出问题 
                            ana_result.PutAnalyInfo(IStation.Model.EtaSingleRealRecordPure.InfoTag_Ea, eta.ToString());
                            ana_result.AnalyStatus = IStation.Model.Eta.eAnalyStatus.Abnormal;
                        }
                        else
                        {//计算 
                            if (ana_result.AnalyStatus == Model.Eta.eAnalyStatus.Unkonw)
                                ana_result.AnalyStatus = Model.Eta.eAnalyStatus.Normal;
                            ana_result.CalcUnitPower(); 
                        }
                    }
                }
            }

            #endregion

            return true;
        }


        #endregion
    }
}