文件遗漏

tangxu

2022-10-08 bd40d6fa4c90c7097b9ee9154778298e12fffe50

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace IStation.Calculation.DispatchAna 
{
    /// <summary>
    /// 
    /// </summary>
    public class CalculatorBase  
    {
        /// <summary>
        /// 公司ID
        /// </summary>
        protected long _corpID = 0;
 
        /// <summary>
        /// 泵站ID
        /// </summary>
        protected long _stationID = 0;
 
 
        /// <summary>
        /// 初始化机泵列表
        /// </summary> 
        /// <param name="allMachineList"></param>
        /// <param name="error_info"></param>
        /// <returns></returns>
        protected bool BuildMachineList(
            out List<Model.MachineDetail> allMachineList,
            out string error_info)
        {
            if (_corpID <= 0)
            {
                allMachineList = null;
                error_info = "_corpID未赋值";
                return false;
            }
            if (_stationID <= 0)
            {
                allMachineList = null;
                error_info = "_stationID未赋值";
                return false;
            }
            allMachineList = null;
            Service.Product service_product = new Service.Product();
            Service.PumpCurve service_curve = new Service.PumpCurve();
 
            var allEnginePumpList = service_product.GetEnginePumpListByBelongTypeAndBelongID(
                _corpID,
                ObjectType.Station,
                _stationID); //获取机泵列表
            if (allEnginePumpList == null || allEnginePumpList.Count() == 0)
            {
                error_info = "未配置机泵";
                return false;
            }
 
            //var allPumpList =  service_product.GetChildPumpByID(this._stationID);
 
            allMachineList = new List<Model.MachineDetail>();
 
            allEnginePumpList = allEnginePumpList.OrderBy(x => x.SortCode).ToList();
            foreach (var engine in allEnginePumpList)
            {
                IStation.Model.Product<IStation.Model.Pump> pump = service_product.GetChildPumpByEnginePumpID(
                    _corpID, engine.ID);
                if (pump == null)
                {
                    error_info = string.Format("机泵ID:{0},未配备泵信息", engine.ID);
                    return false;
                }
 
 
                var curve_default = service_curve.GetWorkingByPumpID(_corpID, pump.ID);
                if (curve_default == null)
                {
                    error_info = string.Format("机泵ID:{0},泵{1},未配备泵曲线信息", engine.ID, pump.ID);
                    return false;
                }
                if (curve_default.CurveInfo == null)
                {
                    error_info = string.Format("机泵ID:{0},泵{1},未配备泵曲线信息", engine.ID, pump.ID);
                    return false;
                }
                //var motor = service_product.GetChildMotorProductByID(machine.ID);
                //if (motor == null)
                //    continue;
                Model.MachineDetail machine_detail =
                    new Model.MachineDetail(engine, pump, curve_default);
 
                allMachineList.Add(machine_detail);
            }
 
            error_info = null;
            return true;
        }
 
  
        #region 计算能耗
 
        /// <summary>
        /// 计算千吨能耗
        /// </summary>
        /// <param name="power">功率kW</param>
        /// <param name="flow">瞬时流量m³/h</param>
        /// <returns>kW·h/km³</returns>
        public static double CalculateWP(double power, double flow)
        {
            if (flow < 0.1)
                return 0;
            return power / flow * 1000;
        }
 
        /// <summary>
        /// 计算单位能耗
        /// </summary>
        /// <param name="p">功率kW</param>
        /// <param name="q">瞬时流量m³/h</param>
        /// <param name="h">扬程m</param>
        /// <returns>kW·h/km³</returns>
        public static double CalculateUWP(double p, double q, double h)
        {
            if (q < 0.1)
                return default;
            if (h < 0.1)
                return default;
            return p / q / h * 1000;
        }
 
        #endregion
 
    }
}