duheng
2025-03-28 9b673ca69c30616b5e5807d665ed8efa2720e1c8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
using HStation.WinFrmUI;
using Yw.Pump;
 
namespace PBS.WinFrmUI.Hydro
{
    /// <summary>
    /// 调度分析辅助类
    /// </summary>
    public partial class AnalysisHelper
    {
        private readonly static decimal _frequency_def = 50m;
        private readonly static decimal _frequency_min = 10m;
        private readonly static decimal _frequency_max = 50m;
        private readonly static decimal _frequency_space = 1m;//频率间隔
        private readonly static decimal _head_space = 0.1m;//扬程间隔
 
 
 
        /// <summary>
        /// 分析泵
        /// </summary> 
        /// <exception cref="Exception"></exception>
        public static async Task<Dictionary<long, List<AnalysisParameter>>> Analysis(long Id)
        {
            return await Task.Run(async () =>
            {
                List<(HStation.Vmo.AssetsPumpMainVmo Pump, Yw.Pump.CurveQH CurveQH, Yw.Pump.CurveQP CurveQP)> list = new();
                var assetsPackageMain = await BLLFactory<HStation.BLL.AssetsPackageMain>.Instance.GetByID(Id);
                if (assetsPackageMain != null)
                {
                    var mappingList = await BLLFactory<HStation.BLL.AssetsPackagePumpMapping>.Instance.GetByKitID(assetsPackageMain.ID);
                    if (mappingList != null && mappingList.Any())
                    {
                        var pumpMainIds = mappingList.Select(x => x.PumpMainID).ToList();
                        var pumpMainList = await BLLFactory<HStation.BLL.AssetsPumpMain>.Instance.GetByIds(pumpMainIds);
                        if (pumpMainList != null && pumpMainList.Any())
                        {
                            foreach (var pumpMain in pumpMainList)
                            {
                                var relation = await BLLFactory<HStation.BLL.PhartDiagramRelation>.Instance.GetDefaultExByObjectTypeAndObjectID(HStation.Assets.DataType.PumpMain, pumpMain.ID);
                                var diagram = await BLLFactory<Yw.BLL.PhartDiagramExtensions>.Instance.GetByID(relation.DiagramID);
                                var pumpCurve = diagram.GetDefaultPumpCurveViewMdoel();
                                list.Add((pumpMain, pumpCurve.CurveQH, pumpCurve.CurveQP));
                            }
                        }
                    }
                }
 
                return Analysis(list);
            });
 
        }
 
 
        /// <summary>
        /// 分析泵
        /// </summary>
        /// <param name="list"></param>
        /// <exception cref="Exception"></exception>
        public static Dictionary<long, List<AnalysisParameter>> Analysis(List<(HStation.Vmo.AssetsPumpMainVmo Pump, Yw.Pump.CurveQH CurveQH, Yw.Pump.CurveQP CurveQP)> list)
        {
            if (list == null || list.Count < 1)
            {
                return default;
            }
            var dict = new Dictionary<long, List<AnalysisParameter>>();
            var ana_pump_list = new List<AnaPump>();
            foreach (var item in list)
            {
                var pump = item.Pump;
                var ana_pump = new AnaPump(item.Pump, item.CurveQH, item.CurveQP);
                if (!ana_pump.AllowCalc)
                {
                    throw new Exception("曲线数据异常!");
                }
                var ana_pump_fre_item_list = new List<AnaPumpFreItem>();
 
                ana_pump_fre_item_list = GetAnaPumpFreItems(_frequency_def, _frequency_min, _frequency_max, _frequency_space, item.CurveQH, item.CurveQP);
                ana_pump.AnaPumpFreItems = ana_pump_fre_item_list;
                ana_pump_list.Add(ana_pump);
            }
 
            if (!ana_pump_list.Any())
            {
                return default;
            }
            for (int i = 0; i < ana_pump_list.Count; i++)
            {
                var pump = ana_pump_list[i];
                var ana_pump_fre_items = pump.AnaPumpFreItems;
                if (ana_pump_fre_items == null || !ana_pump_fre_items.Any())
                    continue;
                var analysis_conclusion_list = new List<List<AnalysisParameter>>();
                foreach (var freItem in ana_pump_fre_items)
                {
                    var flag = pump.Flag; 
                    var analysis_pump_list_count = ana_pump_fre_items.Count(); 
                    for (int analysis_pump_index = 0; analysis_pump_index < analysis_pump_list_count; analysis_pump_index++)
                    {
                        var analysis_pump = ana_pump_fre_items[analysis_pump_index];
                        var curveQH = analysis_pump.CurveQH.FeatCurve;
                        var curveQP = analysis_pump.CurveQP.FeatCurve;
                        var qhPtList = curveQH.GetPointList().OrderBy(x => x.Y);
                        var maxY = qhPtList.Last().Y;
                        var minY = qhPtList.First().Y;
 
 
                        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<AnalysisParameter>(current_list_count);
                        for (decimal head = min_head; head <= max_head; head += _head_space)
                        {
                            var flow = curveQH.GetPointsX((double)head)?.FirstOrDefault() ?? 0d;
                            if (flow < 1)
                            {
                                continue;
                            }
 
                            double differV = 0;
                            //if (pump.Oc != null)
                            //{
                            //    //1输和2输都是用的进口液位,不考虑进口口径
                            //    differV =  CalculateHelper.CalculateOtherPress(flow, null, pump.Oc, null, null);
                            //}
 
                            var analysis_conclusion = new AnalysisParameter();
                            analysis_conclusion.PumpID = flag;
                            analysis_conclusion.Hz = analysis_pump.Frequency;
                            analysis_conclusion.Head = (double)head;
                            analysis_conclusion.PressureDiff = (double)head - differV;
                            analysis_conclusion.Flow = flow;
                            analysis_conclusion.Power = curveQP.GetPointY(flow);
                            analysis_conclusion.UWP = Yw.Pump.CalculationHelper.CalcuUWP(analysis_conclusion.Power, analysis_conclusion.Flow, analysis_conclusion.Head);
                            analysis_conclusion.WP = Yw.Pump.CalculationHelper.CalcuWP(analysis_conclusion.Power, analysis_conclusion.Flow);
 
 
 
                            int digits = 1;
                            analysis_conclusion.Hz = Math.Round(analysis_conclusion.Hz, digits);
                            analysis_conclusion.Head = Math.Round(analysis_conclusion.Head, digits);
                            analysis_conclusion.PressureDiff = Math.Round(analysis_conclusion.PressureDiff, digits);
                            analysis_conclusion.Flow = Math.Round(analysis_conclusion.Flow, digits);
                            analysis_conclusion.Power = Math.Round(analysis_conclusion.Power, digits);
                            analysis_conclusion.WP = Math.Round(analysis_conclusion.WP, digits);
                            analysis_conclusion.UWP = Math.Round(analysis_conclusion.UWP, digits);
                            current_analysis_conclusion_list.Add(analysis_conclusion);
                        }
                        analysis_conclusion_list.Add(current_analysis_conclusion_list);
                    }
 
                }
 
                dict[pump.Flag]=(analysis_conclusion_list.SelectMany(x => x).ToList());
            }
 
            return dict;
 
        }
 
 
 
        /// <summary>
        /// 获取分析泵变频项
        /// </summary>  
        private static List<AnaPumpFreItem> GetAnaPumpFreItems(
             decimal fre_def,
             decimal fre_min,
             decimal fre_max,
             decimal fre_space,
             Yw.Pump.CurveQH qh,
             Yw.Pump.CurveQP qp)
        {
 
            var list = new List<AnaPumpFreItem>();
            for (decimal fre = fre_max; fre >= fre_min; fre -= fre_space)
            {
                var hz = (double)Math.Round(fre, 1);
                var hz0 = Math.Round(hz, 0);
 
                var qh_pt_list = qh.GetPointListByN((double)fre_def, (double)fre);
                var qp_pt_list = qp.GetPointListByN((double)fre_def, (double)fre);
 
 
                var freItem = new AnaPumpFreItem();
                freItem.Frequency = hz;
                freItem.CurveQH = new CurveQH(qh.FeatType, qh_pt_list);
                freItem.CurveQP = new CurveQP(qp.FeatType, qp_pt_list);
                list.Add(freItem);
            }
 
            return list;
        }
 
 
 
 
 
    }
}