blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
Shuxia Ning
2024-09-10 049f546f25cabfb5b08e29c54f49d61a544b0395 
 IStation.Service/08-algorithm/01-analysis/AnalysisHelper.cs


@@ -7,147 +7,157 @@


    /// </summary>


    public partial class AnalysisHelper


    {


        private readonly double _frequency_def = 50;


        private readonly double _frequency_min = 25;


        private readonly double _frequency_max = 50;


        private readonly double _frequency_space = 0.10;//频率间隔  


        private readonly decimal _head_space = 0.1m;//扬程间隔




        double _frequency_def = 50;


        double _frequency_min = 25;


        double _frequency_max = 50;


        double _frequency_space = 0.1;//频率间隔 




        double _head_space = 0.1;//扬程间隔




        readonly DAL.SQLite.AnalysisCombine _dal_analysis_combine = new();


        readonly DAL.SQLite.AnalysisConclusion _dal_analysis_conclusion = new();


        readonly DAL.SQLite.AnalysisLog _dal_analysis_log = new();


        readonly DAL.SQLite.AnalysisDeviation _dal_analysis_deviation = new();


        private readonly DAL.SQLite.AnalysisPump _dal_analysis_pump = new();


        private readonly DAL.SQLite.AnalysisParameter _dal_analysis_conclusion = new();


        private readonly DAL.SQLite.AnalysisFactor _dal_analysis_factor = new();






        /// <summary>


        /// 分析泵组合(目前只分析单泵)


        /// 分析泵


        /// </summary>


        /// <param name="pumps">泵列表</param>


        /// <returns></returns>


        public void AnalysisCombine(List<Model.Pump> pumps)


        public void AnalysisPump(List<Model.Pump> pumps)


        {


            InsertAnaLog("开始分析泵组合"); 


            InsertLog("开始分析泵组合");


            if (pumps == null || pumps.Count < 1)


            {


                InsertAnaLog("分析失败:没有泵数据!");


                InsertLog("分析失败:没有泵数据!");


                return;


            }




            var all_analysis_factor_list = _dal_analysis_factor.GetAll();


            var fre_def = _frequency_def;


            var ana_pump_list = new List<AnaPump>();


            var analysis_pump_list = new List<AnaPump>();


            foreach (var pump in pumps)


            {


                var pump_factor_list = all_analysis_factor_list?.Where(x => x.Flag == pump.Flag).ToList();


                if (pump.IsBp)


                {


                    //变频泵


                    var anaPump = new AnaPump(pump, fre_def, _frequency_min, _frequency_max, _frequency_space);


                    if (anaPump.AllowCalc)


                        ana_pump_list.Add(anaPump);


                    var fre_head_diff_avg_dict = pump_factor_list?.ToDictionary(x => x.Hz, y => y.HeadDeviation);


                    var analysisPump = new AnaPump(pump, fre_def, _frequency_min, _frequency_max, _frequency_space, fre_head_diff_avg_dict);


                    if (analysisPump.AllowCalc)


                        analysis_pump_list.Add(analysisPump);


                }


                else


                {


                    //固频泵


                    var anaPump = new AnaPump(pump);


                    if (anaPump.AllowCalc)


                        ana_pump_list.Add(anaPump);


                    var analysisPump = new AnaPump(pump);


                    if (analysisPump.AllowCalc)


                        analysis_pump_list.Add(analysisPump);


                }


            }


            if (!ana_pump_list.Any())


            if (!analysis_pump_list.Any())


            {


                InsertAnaLog($"分析进度:没有泵可分析");


                InsertLog($"分析进度:没有泵可分析");


                return;


            }


            for (int i = 0; i < ana_pump_list.Count; i++)


            for (int i = 0; i < analysis_pump_list.Count; i++)


            {


                var pump = ana_pump_list[i];


                var ana_frequency_items = pump.AnaFrequencyItems;


                if (ana_frequency_items == null || !ana_frequency_items.Any())


                var pump = analysis_pump_list[i];


                var analysis_frequency_items = pump.AnaFrequencyItems;


                if (analysis_frequency_items == null || !analysis_frequency_items.Any())


                    continue;




                var run_flag = RunFlagHelper.GetRunFlag(pump.Flag, pump.IsBp);


                InsertAnaLog($"分析进度:第{i + 1}台泵");


                InsertLog($"分析进度:第{i + 1}台泵");




                var list = new List<Entity.AnalysisCombine>(pump.AnaFrequencyItems.Count);


                foreach (var freItem in ana_frequency_items)


                var list = new List<Entity.AnalysisPump>(pump.AnaFrequencyItems.Count);


                foreach (var freItem in analysis_frequency_items)


                {


                    var scheduleCombine = new Entity.AnalysisCombine();


                    scheduleCombine.ID = Yw.YitIdHelper.NextId();


                    scheduleCombine.Pump = freItem.Frequency;


                    scheduleCombine.CurveQH = freItem.CurveQH.ToJson();


                    scheduleCombine.CurveQP = freItem.CurveQP.ToJson();


                    var analysis_pump = new Entity.AnalysisPump();


                    analysis_pump.ID = Yw.YitIdHelper.NextId();


                    analysis_pump.Flag = pump.Flag;


                    analysis_pump.Hz = freItem.Frequency;


                    analysis_pump.CurveQH = freItem.CurveQH.ToJson();


                    analysis_pump.CurveQP = freItem.CurveQP.ToJson();




                    freItem.CurveQH.GetMinMaxPointY(out double maxHead, out double minHead);


                    scheduleCombine.MinFlow = Math.Round(freItem.CurveQH.Min, 4);


                    scheduleCombine.MaxFlow = Math.Round(freItem.CurveQH.Max, 4);


                    scheduleCombine.MaxHead = Math.Round(maxHead, 4);


                    scheduleCombine.MinHead = Math.Round(minHead, 4);


                    scheduleCombine.AnaStatus = false;


                    list.Add(scheduleCombine);


                    analysis_pump.MinFlow = Math.Round(freItem.CurveQH.Min, 4);


                    analysis_pump.MaxFlow = Math.Round(freItem.CurveQH.Max, 4);


                    analysis_pump.MaxHead = Math.Round(maxHead, 4);


                    analysis_pump.MinHead = Math.Round(minHead, 4);


                    list.Add(analysis_pump);


                }


                InsertAnalysisCombineList(i + 1, run_flag, list);


                InsertList(i + 1, run_flag, list);


            }




            InsertAnaLog($"分析进度:{pumps.Count}台泵,分析完毕!");


            InsertLog($"分析进度:{pumps.Count}台泵,分析完毕!");


        }






        /// <summary>


        /// 分析结论


        /// 分析参数


        /// </summary>


        public void AnalysisConclusion()


        public void AnalysisParameter(List<Model.Pump> pumps)


        {


            InsertAnaLog($"开始分析泵组合结论!");


            _dal_analysis_conclusion.DeleteAllTable();


            var analysis_combine_table_list = _dal_analysis_combine.GetAllTableName();


            if (analysis_combine_table_list == null || !analysis_combine_table_list.Any())


            InsertLog($"开始分析泵结论!");


            if (pumps == null || pumps.Count < 1)


            {


                InsertAnaLog($"无泵组合表!");


                InsertLog("分析失败:没有泵数据!");


                return;


            }


            var tableCount = analysis_combine_table_list.Count();


            InsertAnaLog($"分析{tableCount}个组合!");


            for (int tableIndex = 0; tableIndex < tableCount; tableIndex++)




            _dal_analysis_conclusion.DeleteAllTable();


            for (int pump_index = 0; pump_index < pumps.Count; pump_index++)


            {


                var table_name = analysis_combine_table_list[tableIndex];


                var analysis_combine_list = _dal_analysis_combine.GetNoAnalysisByTableName(table_name);


                if (analysis_combine_list == null || !analysis_combine_list.Any())


                var pump = pumps[pump_index];


                var flag = pump.Flag;


                var run_flag = RunFlagHelper.GetRunFlag(flag, pump.IsBp);


                var table_name = _dal_analysis_pump.GetTableName(run_flag);


                var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);


                if (analysis_pump_list == null || !analysis_pump_list.Any())


                {


                    InsertAnaLog($"分析进度:{table_name},第{tableIndex + 1}个,分析完毕");


                    InsertLog($"分析进度:{table_name},第{pump_index + 1}个,分析完毕");


                    continue;


                }


                var analysis_combine_list_count = analysis_combine_list.Count();


                var analysis_conclusion_list = new List<List<Entity.AnalysisConclusion>>(analysis_combine_list_count);


                var analysis_combine_ids = new List<long>(analysis_combine_list_count);




                for (int combineIndex = 0; combineIndex < analysis_combine_list_count; combineIndex++)


                var analysis_pump_list_count = analysis_pump_list.Count();


                var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);


                for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)


                {


                    var analysis_combine = analysis_combine_list[combineIndex];


                    var analysis_combine_id = analysis_combine.ID;


                    analysis_combine_ids.Add(analysis_combine_id);


                    var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_combine.CurveQH);


                    var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_combine.CurveQP);


                    var analysis_pump = analysis_pump_list[analysis_pump_index];


                    var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);


                    var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);


                    var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);


                    if (!bol)


                        return;


                    var maxHead = Math.Ceiling(maxY);


                    var minHead = Math.Floor(minY);


                        throw new Exception("曲线异常");




                    var currentListCount = (int)((maxHead - minHead) / _head_space) + 1;


                    var current_analysis_conclusion_list = new List<Entity.AnalysisConclusion>(currentListCount);


                    for (double head = minHead; head <= maxHead; head += _head_space)


                    decimal max_head = (decimal)Math.Ceiling(maxY);


                    decimal min_head = (decimal)Math.Floor(minY);




                    var current_list_count = (int)((max_head - min_head) / _head_space) + 1;


                    var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);


                    for (decimal head = min_head; head <= max_head; head += _head_space)


                    {


                        var flow = curveQH.GetInterPointLastX(head);


                        if (!flow.HasValue)


                        var flow = curveQH.GetInterPointLastX((double)head) ?? 0;


                        if (flow < 1)


                        {


                            continue;


                        }


                        var analysis_conclusion = new Entity.AnalysisConclusion();




                        double differV = 0;


                        if (pump.Oc != null)


                        {


                            //1输和2输都是用的进口液位，不考虑进口口径


                            differV = PumpCalculateHelper.CalculateOtherPress(flow, null, pump.Oc, null, null);


                        }




                        var analysis_conclusion = new Entity.AnalysisParameter();


                        analysis_conclusion.ID = Yw.YitIdHelper.NextId();


                        analysis_conclusion.CombineID = analysis_combine_id;


                        analysis_conclusion.Pump = analysis_combine.Pump;


                        analysis_conclusion.Head = head;


                        analysis_conclusion.Flow = flow.Value;


                        analysis_conclusion.Power = curveQP.GetFitPointY(flow.Value);


                        analysis_conclusion.PumpID = analysis_pump.ID;


                        analysis_conclusion.Hz = analysis_pump.Hz;


                        analysis_conclusion.Head = (double)head;


                        analysis_conclusion.PressureDiff = (double)head - differV;


                        analysis_conclusion.Flow = flow;


                        analysis_conclusion.Power = curveQP.GetFitPointY(flow);


                        analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);


                        analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);




@@ -156,10 +166,91 @@


                    }


                    analysis_conclusion_list.Add(current_analysis_conclusion_list);


                }


                UpdateAnaStatus(table_name, analysis_combine_ids);


                var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();


                var run_flag = _dal_analysis_combine.GetRunFlag(table_name);


                InsertAnalysisConclusionList(tableIndex + 1, run_flag, list);


                InsertList(pump_index + 1, run_flag, list);


            }


        }






        /// <summary>


        /// 分析参数


        /// </summary>


        public void Test(List<Model.Pump> pumps)


        {


            if (pumps == null || pumps.Count < 1)


            {


                return;


            }




            _dal_analysis_conclusion.DeleteAllTable();


            for (int pump_index = 0; pump_index < pumps.Count; pump_index++)


            {


                var pump = pumps[pump_index];


                var flag = pump.Flag;


                var run_flag = RunFlagHelper.GetRunFlag(flag, pump.IsBp);


                var table_name = _dal_analysis_pump.GetTableName(run_flag);


                var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);


                if (analysis_pump_list == null || !analysis_pump_list.Any())


                {


                    continue;


                }




                var analysis_pump_list_count = analysis_pump_list.Count();


                var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);


                for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)


                {


                    var analysis_pump = analysis_pump_list[analysis_pump_index];


                    var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);


                    var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);


                    var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);


                    if (!bol)


                        throw new Exception("曲线异常");




                    decimal max_head = (decimal)Math.Ceiling(maxY);


                    decimal min_head = (decimal)Math.Floor(minY);




                    decimal head_space = 0.01m;


                    var current_list_count = (int)((max_head - min_head) / head_space) + 1;


                    var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);


                    for (decimal head = min_head; head <= max_head; head += head_space)


                    {


                        var flow = curveQH.GetInterPointLastX((double)head) ?? 0;


                        if (flow < 1)


                        {


                            continue;


                        }




                        double differV = 0;


                        if (pump.Oc != null)


                        {


                            differV = PumpCalculateHelper.CalculateOtherPress(flow, pump.Ic, pump.Oc, null, null);


                        }




                        var analysis_conclusion = new Entity.AnalysisParameter();


                        analysis_conclusion.ID = Yw.YitIdHelper.NextId();


                        analysis_conclusion.PumpID = analysis_pump.ID;


                        analysis_conclusion.Hz = analysis_pump.Hz;


                        analysis_conclusion.Head = (double)head;


                        analysis_conclusion.PressureDiff = (double)head - differV;


                        analysis_conclusion.Flow = flow;


                        analysis_conclusion.Power = curveQP.GetFitPointY(flow);


                        analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);


                        analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);






                        analysis_conclusion.Hz = Math.Round(analysis_conclusion.Hz, 1);


                        analysis_conclusion.Head = Math.Round(analysis_conclusion.Head, 2);


                        analysis_conclusion.PressureDiff = Math.Round(analysis_conclusion.PressureDiff, 2);


                        analysis_conclusion.Flow = Math.Round(analysis_conclusion.Flow, 1);


                        analysis_conclusion.Power = Math.Round(analysis_conclusion.Power, 1);


                        analysis_conclusion.WP = Math.Round(analysis_conclusion.WP, 1);


                        analysis_conclusion.UWP = Math.Round(analysis_conclusion.UWP, 1);


                        current_analysis_conclusion_list.Add(analysis_conclusion);


                    }


                    analysis_conclusion_list.Add(current_analysis_conclusion_list);


                }


                var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();


                InsertList(pump_index + 1, run_flag, list);


            }


        }




@@ -169,10 +260,11 @@


        /// <summary>


        /// 圆整


        /// </summary> 


        private void Round(Entity.AnalysisConclusion conclusion)


        private void Round(Entity.AnalysisParameter conclusion)


        {


            conclusion.Pump = Math.Round(conclusion.Pump, 1);


            conclusion.Hz = Math.Round(conclusion.Hz, 1);


            conclusion.Head = Math.Round(conclusion.Head, 1);


            conclusion.PressureDiff = Math.Round(conclusion.PressureDiff, 1);


            conclusion.Flow = Math.Round(conclusion.Flow, 1);


            conclusion.Power = Math.Round(conclusion.Power, 1);


            conclusion.WP = Math.Round(conclusion.WP, 1);


@@ -180,76 +272,251 @@


        }




        /// <summary>


        /// 插入分析日志


        /// 插入日志


        /// </summary> 


        private void InsertAnaLog(string info)


        private void InsertLog(string info)


        {


            var entity = new Entity.AnalysisLog(info);


            _dal_analysis_log.Insert(entity);


        }




        /// <summary>


        /// 更新分析状态


        /// </summary>


        public bool UpdateAnaStatus(string tableName, List<long> ids)


        {


            if (ids == null || !ids.Any())


            {


                return false;


            }


            return _dal_analysis_combine.UpdateAnaStatus(tableName, ids);


            LogHelper.Info(info);


        }




        /// <summary>


        /// 插入分析组合列表


        /// </summary> 


        public void InsertAnalysisCombineList(int index, string runFlag, List<Entity.AnalysisCombine> list)


        public void InsertList(int index, string runFlag, List<Entity.AnalysisPump> list)


        {


            string log;


            if (list == null || !list.Any())


            {


                log = $"{runFlag}:下标:{index},无数据";


                InsertAnaLog(log);


                InsertLog(log);


                return;


            }




            var sw = Stopwatch.StartNew();


            _dal_analysis_combine.BulkInsertsEx(runFlag, list);


            _dal_analysis_pump.BulkInsertsEx(runFlag, list);


            log = $"{runFlag}:下标:{index},数量:{list.Count},插入耗时:{sw.ElapsedMilliseconds / 1000}m";


            InsertAnaLog(log);


            InsertLog(log);


        }




        /// <summary>


        /// 插入分析结论列表


        /// 插入分析参数列表


        /// </summary> 


        public void InsertAnalysisConclusionList(int index, string runFlag, List<Entity.AnalysisConclusion> list)


        public void InsertList(int index, string runFlag, List<Entity.AnalysisParameter> list)


        {


            string log;


            if (list == null || !list.Any())


            {


                log = $"{runFlag}:下标:{index},无数据";


                InsertAnaLog(log);


                InsertLog(log);


                return;


            }




            var sw = Stopwatch.StartNew();


            _dal_analysis_conclusion.BulkInsertsEx(runFlag, list);


            log = $"分析进度:{runFlag},下标:{index},数量:{list.Count},插入耗时:{sw.ElapsedMilliseconds / 1000}m";


            InsertAnaLog(log);


            InsertLog(log);


        }




        /// <summary>


        /// 插入分析偏差


        /// </summary> 


        private bool InsertAnalysisDeviationList(List<Entity.AnalysisDeviation> analysis_deviation_list)


        {


            var bol = _dal_analysis_deviation.Inserts(analysis_deviation_list);


            return bol;


        }






        #endregion




    }




}






///// <summary>


///// 分析参数


///// </summary>


//public void Test_bak(List<Model.Pump> pumps)


//{


//    if (pumps == null || pumps.Count < 1)


//    {


//        return;


//    }




//    _dal_analysis_conclusion.DeleteAllTable();


//    for (int pump_index = 0; pump_index < pumps.Count; pump_index++)


//    {


//        var pump = pumps[pump_index];


//        var flag = pump.Flag;


//        var run_flag = RunFlagHelper.GetRunFlag(flag, pump.IsBp);


//        var table_name = _dal_analysis_pump.GetTableName(run_flag);


//        var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);


//        if (analysis_pump_list == null || !analysis_pump_list.Any())


//        {


//            continue;


//        }




//        var analysis_pump_list_count = analysis_pump_list.Count();


//        var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);


//        for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)


//        {


//            var analysis_pump = analysis_pump_list[analysis_pump_index];


//            var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);


//            var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);


//            var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);


//            if (!bol)


//                throw new Exception("曲线异常");




//            var min_flow = curveQH.Min;


//            var max_flow = curveQH.Max;




//            var min_flow_head = curveQH.GetFitPointY(min_flow);


//            var max_flow_head = curveQH.GetFitPointY(max_flow);




//            var min_flow_diffV = PumpCalculateHelper.CalculateOtherPress(min_flow, pump.Ic, pump.Oc, null, null);


//            var max_flow_diffV = PumpCalculateHelper.CalculateOtherPress(max_flow, pump.Ic, pump.Oc, null, null);




//            decimal min_flow_pressure_diff = (decimal)(min_flow_head - min_flow_diffV);


//            decimal max_flow_pressure_diff = (decimal)(max_flow_head - max_flow_diffV);




//            decimal pressure_space = 0.1m;


//            for (decimal pressure_diff = max_flow_pressure_diff; pressure_diff < max_flow_pressure_diff; pressure_diff += pressure_space)


//            {




//            }




//            var max_head = Math.Ceiling(maxY);


//            var min_head = Math.Floor(minY);




//            //var curve_max_flow= max.X;


//            //var curve_min_flow= min.X;




//            //var curve_max_diffV = PumpCalculateHelper.CalculateOtherPress(curve_max_flow, pump.Ic, pump.Oc, null, null);


//            //var curve_min_diffV = PumpCalculateHelper.CalculateOtherPress(curve_min_flow, pump.Ic, pump.Oc, null, null);




//            //var curve_max_pressure_diff = max_head - curve_max_diffV;


//            //var curve_min_pressure_diff = min_head - curve_min_diffV;










//            var max_diffV = PumpCalculateHelper.CalculateOtherPress(min_flow, pump.Ic, pump.Oc, null, null);


//            var min_diffV = PumpCalculateHelper.CalculateOtherPress(max_flow, pump.Ic, pump.Oc, null, null);




//            var max_pressure_diff = max_head - max_diffV;


//            var min_pressure_diff = min_head - min_diffV;


//            //max_pressure_diff = Math.Round(max_pressure_diff);




//            var current_list_count = (int)((max_head - min_head) / _head_space) + 1;


//            var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);


//            for (double head = min_head; head <= max_head; head += _head_space)


//            {


//                var flow = curveQH.GetInterPointLastX(head) ?? 0;


//                if (flow < 1)


//                {


//                    continue;


//                }




//                double diffV = 0;


//                if (pump.Oc != null)


//                {


//                    diffV = PumpCalculateHelper.CalculateOtherPress(flow, pump.Ic, pump.Oc, null, null);


//                }




//                var analysis_conclusion = new Entity.AnalysisParameter();


//                analysis_conclusion.ID = Yw.YitIdHelper.NextId();


//                analysis_conclusion.PumpID = analysis_pump.ID;


//                analysis_conclusion.Hz = analysis_pump.Hz;


//                analysis_conclusion.Head = head;


//                analysis_conclusion.PressureDiff = head - diffV;


//                analysis_conclusion.Flow = flow;


//                analysis_conclusion.Power = curveQP.GetFitPointY(flow);


//                analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);


//                analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);




//                Round(analysis_conclusion);


//                current_analysis_conclusion_list.Add(analysis_conclusion);


//            }


//            analysis_conclusion_list.Add(current_analysis_conclusion_list);


//        }


//        var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();


//        InsertList(pump_index + 1, run_flag, list);


//    }




//}






///// <summary>


///// 分析参数


///// </summary>


//public void AnalysisParameterBak(List<Model.Pump> pumps)


//{


//    InsertLog($"开始分析泵结论!");


//    if (pumps == null || pumps.Count < 1)


//    {


//        InsertLog("分析失败:没有泵数据!");


//        return;


//    }




//    _dal_analysis_conclusion.DeleteAllTable();


//    var analysis_pump_table_list = _dal_analysis_pump.GetAllTableName();


//    if (analysis_pump_table_list == null || !analysis_pump_table_list.Any())


//    {


//        InsertLog($"无分析泵表!");


//        return;


//    }


//    var flag_pump_dict = pumps.ToDictionary(x => x.Flag, x => x);


//    var tableCount = analysis_pump_table_list.Count();


//    InsertLog($"分析{tableCount}台泵结论!");


//    for (int tableIndex = 0; tableIndex < tableCount; tableIndex++)


//    {


//        var table_name = analysis_pump_table_list[tableIndex];


//        var analysis_pump_list = _dal_analysis_pump.GetAllByTableName(table_name);


//        if (analysis_pump_list == null || !analysis_pump_list.Any())


//        {


//            InsertLog($"分析进度:{table_name},第{tableIndex + 1}个,分析完毕");


//            continue;


//        }


//        var analysis_pump_list_count = analysis_pump_list.Count();


//        var analysis_conclusion_list = new List<List<Entity.AnalysisParameter>>(analysis_pump_list_count);




//        for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)


//        {


//            var analysis_pump = analysis_pump_list[analysis_pump_index];


//            var pump = flag_pump_dict[analysis_pump.Flag];


//            var curveQH = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQH);


//            var curveQP = JsonHelper.Json2Object<Curve.CurveExpress>(analysis_pump.CurveQP);


//            var bol = curveQH.GetMinMaxPointY(out double maxY, out double minY);


//            if (!bol)


//                return;


//            var max_head = Math.Ceiling(maxY);


//            var min_head = Math.Floor(minY);




//            var current_list_count = (int)((max_head - min_head) / _head_space) + 1;


//            var current_analysis_conclusion_list = new List<Entity.AnalysisParameter>(current_list_count);


//            for (double head = min_head; head <= max_head; head += _head_space)


//            {


//                var flow = curveQH.GetInterPointLastX(head) ?? 0;


//                if (flow < 1)


//                {


//                    continue;


//                }




//                double differV = 0;


//                if (pump.Oc != null)


//                {


//                    differV = PumpCalculateHelper.CalculateOtherPress(flow, pump.Ic, pump.Oc, null, null);


//                }




//                var analysis_conclusion = new Entity.AnalysisParameter();


//                analysis_conclusion.ID = Yw.YitIdHelper.NextId();


//                analysis_conclusion.PumpID = analysis_pump.ID;


//                analysis_conclusion.Hz = analysis_pump.Hz;


//                analysis_conclusion.Head = head;


//                analysis_conclusion.PressureDiff = head - differV;


//                analysis_conclusion.Flow = flow;


//                analysis_conclusion.Power = curveQP.GetFitPointY(flow);


//                analysis_conclusion.UWP = PumpCalculateHelper.CalculateUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);


//                analysis_conclusion.WP = PumpCalculateHelper.CalculateWP(analysis_conclusion.Power, analysis_conclusion.Flow);




//                Round(analysis_conclusion);


//                current_analysis_conclusion_list.Add(analysis_conclusion);


//            }


//            analysis_conclusion_list.Add(current_analysis_conclusion_list);


//        }


//        var list = analysis_conclusion_list.SelectMany(x => x.ToList()).ToList();


//        var run_flag = _dal_analysis_pump.GetRunFlag(table_name);


//        InsertList(tableIndex + 1, run_flag, list);


//    }


//}