Shuxia Ning
2024-08-28 1a8a81785470302fc7fbd6914a9df5d1094dac2a
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
namespace IStation.Test
{
    /// <summary>
    /// 模型验证辅助类
    /// </summary> 
    public class HydraulicModelValidationHelperJob
    {
        private static readonly string _hydraulic_model_file = Path.Combine(
               Settings.ParasHelper.LocalFile.DataFolderDirectory,
               Settings.ParasHelper.LocalFile.HydraulicModelFile);
 
        private static readonly Dictionary<string, double> _pump_nr_dict = new() {
            { "Pump11",524},
            { "Pump12",524},
            { "Pump13",524},
            { "Pump14",524},
            //{ "Pump15",545},
            //{ "Pump16",524},
            { "Pump17",524},
            { "Pump18",524},
 
            { "Pump21",740},
            { "Pump22",495},
            { "Pump23",495},
            { "Pump24",495},
            { "Pump25",495},
            { "Pump26",495},
            { "Pump27",740}
        };
 
        /// <summary>
        /// 
        /// </summary>
        public static void Execute()
        {
 
            var verification_id = Yw.YitIdHelper.NextId();
            var current_time = DateTime.Now;
 
            if (!File.Exists(_hydraulic_model_file))
            {
                //Log.Info(verification_id, $"模型验证计划任务中,水力模型文件不存在,自动跳过当前数据!");
                return;
            }
            var hydraulic_model_validation_config = new IStation.Service.HydraulicModelValidationConfig().Get();
            if (hydraulic_model_validation_config == null)
            {
                //Log.Info(verification_id, "模型验证计划任务中,水力模型验证文件不存在,自动跳过当前数据!");
                return;
            }
 
            var hydraulic_model_scada_list = new List<Model.HydraulicModelScada>();
 
            var scada_debug_json_file = Path.Combine(Settings.ParasHelper.LocalFile.DataFolderDirectory, "scada_debug.txt");
            var scada_debug_json = File.ReadAllText(scada_debug_json_file);
 
 
            var zy_scada_output = Yw.JsonHelper.Json2Object<IStation.Dto.ScadaScheduleInput>(scada_debug_json);
 
            if (zy_scada_output.data != null && zy_scada_output.data.Any())
            {
                var data_dict = zy_scada_output.data;
                foreach (var scada_dict in data_dict)
                {
                    var vals = scada_dict.Value.ElementAt(0).Value;
                    var time = scada_dict.Value.ElementAt(1).Value;
                    var key = scada_dict.Value.ElementAt(2).Value;
                    var hydraulic_model_scada = new Model.HydraulicModelScada();
                    hydraulic_model_scada.VerificationID = verification_id;
                    hydraulic_model_scada.Tag = key;
                    if (DateTime.TryParse(time, out DateTime t))
                        hydraulic_model_scada.Time = t;
                    if (double.TryParse(vals, out double v))
                        hydraulic_model_scada.Value = v;
                    hydraulic_model_scada_list.Add(hydraulic_model_scada);
                }
            }
 
            if (!hydraulic_model_scada_list.Any())
            {
                //Log.Info(verification_id, "模型验证计划任务中,接收Scada数据为空,自动跳过当前数据!");
                return;
            }
            else
            {
                var json = Yw.JsonHelper.Object2Json(hydraulic_model_scada_list);
                // Log.Debug(verification_id, json);
            }
 
            var flow_id_mapping_dict = hydraulic_model_validation_config.FlowIdMappingDict;
            var pressure_id_mapping_dict = hydraulic_model_validation_config.PressureIdMappingDict;
            var pattern_id_mapping_dict = hydraulic_model_validation_config.PatternIdMappingDict;
            var pressure_id_kPa_list = hydraulic_model_validation_config.PressureIdkPaList;
 
            var pattern_list = new List<IStation.Hydraulic.Pattern>();
            var time_value = new IStation.Hydraulic.TimeValue
            {
                Time = current_time,
                Value = new Dictionary<string, double>()
            };
 
            foreach (var hydraulic_model_scada in hydraulic_model_scada_list)
            {
                var tag = hydraulic_model_scada.Tag;
                var value = hydraulic_model_scada.Value;
                foreach (var item in flow_id_mapping_dict)
                {
                    if (item.Value != tag)
                        continue;
                    time_value.Value.Add(tag, value ?? 0);
                }
 
                foreach (var item in pressure_id_mapping_dict)
                {
                    if (item.Value != tag)
                        continue;
                    var pressure_value = value ?? 0;
                    if (pressure_id_kPa_list.Contains(tag))
                    {
                        pressure_value /= 1000;
                    }
                    pressure_value = IStation.Curve.PumpCalculateHelper.Mpa2M(pressure_value);
                    time_value.Value.Add(tag, pressure_value);
                }
 
                foreach (var item in pattern_id_mapping_dict)
                {
                    if (item.Value != tag)
                        continue;
                    var pattern_id = item.Key;
                    var factor = value;
                    if (_pump_nr_dict.ContainsKey(pattern_id))
                    {
                        factor /= _pump_nr_dict[pattern_id];
                        factor = factor < 0 ? 0 : factor;
                    }
                    var pattern = new IStation.Hydraulic.Pattern
                    {
                        Id = pattern_id,
                        FactorList = new List<float>()
                    };
                    if (factor.HasValue)
                        pattern.FactorList.Add((float)factor.Value);
                    pattern_list.Add(pattern);
                }
            }
 
 
            var hydraulic_model_record_list = IStation.Hydraulic.ModeVerifyHelper.Verify(verification_id, _hydraulic_model_file, flow_id_mapping_dict, pressure_id_mapping_dict, pattern_list, time_value);
            if (hydraulic_model_record_list == null || !hydraulic_model_record_list.Any())
            {
 
                return;
            }
 
            var hydraulic_model_validation = new Model.HydraulicModelValidation();
            hydraulic_model_validation.ID = verification_id;
            hydraulic_model_validation.Time = current_time;
            //hydraulic_model_validation.Config = Yw.JsonHelper.Object2Json(hydraulic_model_validation_config);
 
            var bol = new IStation.Service.HydraulicModelValidation().Insert(hydraulic_model_validation) > 0;
            if (!bol)
            {
            }
 
            bol = new IStation.Service.HydraulicModelScada().Inserts(hydraulic_model_scada_list);
            if (!bol)
            {
            }
 
            bol = new IStation.Service.HydraulicModelRecord().Inserts(hydraulic_model_record_list);
            if (!bol)
            {
            }
 
 
        }
    }
}