更新 调度验证界面

Shuxia Ning

2024-07-29 8f15f93b380fac12676487603297e3cc32f377f8

 IStation.Service/09-hydraulic/ModeVerifyHelper.cs

@@ -114,10 +114,6 @@
        }






        /// <summary>
        /// 实时验证
        /// </summary>
@@ -288,20 +284,136 @@
        }



        /// <summary>
        /// 历史数据验证
        /// </summary>
        /// <param name="verify_id">验证标识</param>
        /// <param name="file_path">文件</param>
        /// <param name="verify_file_path">验证模型文件</param>
        /// <param name="zy_scada_day_dict">ZyScada数据列表</param> 
        /// <returns></returns>
        public static Dictionary<DateTime, List<Model.HydraulicModelRecord>> Verify(
            long verify_id,
            string verify_file_path,
            Dictionary<DateTime, Dictionary<DateTime, List<Model.ZyScada>>> zy_scada_day_dict)
        {
            var log_title = "初始化验证数据";
            var log_msg = string.Empty;
            if (zy_scada_day_dict == null || !zy_scada_day_dict.Any())
            {
                log_msg = "zy_scada_day_dict 数据为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }

            var pump_nr_dict = GlobalHelper.ModelPumpNrDict;
            var pattern_id_mapping_dict = GlobalHelper.ModelPatternIdMappingDict;
            var flow_id_mapping_dict = GlobalHelper.ModelFlowIdMappingDict;
            var pressure_id_mapping_dict = GlobalHelper.ModelPressureIdMappingDict;
            var pressure_id_kPa_list = GlobalHelper.ModelPressureIdkPaList;

            var day_value_dict = new Dictionary<DateTime, Tuple<Dictionary<string, float[]>, Dictionary<DateTime, Dictionary<string, double>>>>();
            foreach (var day_item in zy_scada_day_dict)
            {
                var day = day_item.Key;
                var zy_scada_list_dict = day_item.Value;

                var pattern_list_dict = new Dictionary<string, List<float>>();
                foreach (var item in pattern_id_mapping_dict)
                {
                    pattern_list_dict.Add(item.Key, new List<float>());
                }


                var scada_dict_dict = new Dictionary<DateTime, Dictionary<string, double>>();

                #region 初始化 pattern_dict scada_dict 
                for (int i = 0; i < zy_scada_list_dict.Count; i++)
                {
                    var item = zy_scada_list_dict.ElementAt(i);
                    var time = item.Key;
                    var zy_scada_list = item.Value;  

                    var scada_dict = new Dictionary<string, double>();
                    foreach (var zy_scada in zy_scada_list)
                    {
                        var tag = zy_scada.Code;
                        var value = zy_scada.Value;

                        #region Pattern  
                        foreach (var mapping in pattern_id_mapping_dict)
                        {
                            if (mapping.Value != tag)
                                continue;
                            var pattern_id = mapping.Key;
                            var factor = value ?? 0;

                            if (value.HasValue && pump_nr_dict.ContainsKey(pattern_id))
                            {
                                factor /= pump_nr_dict[pattern_id];
                                factor = factor < 0 ? 0 : factor;
                            } 
                            pattern_list_dict[pattern_id].Add((float)factor);
                        }

                        #endregion

                        #region Scada

                        foreach (var mapping in flow_id_mapping_dict)
                        {
                            if (mapping.Value != tag)
                                continue;
                            scada_dict.Add(tag, value ?? 0);
                        }

                        foreach (var mapping in pressure_id_mapping_dict)
                        {
                            if (mapping.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);
                            scada_dict.Add(tag, pressure_value);
                        }
                        #endregion
                    }
                    scada_dict_dict.Add(time, scada_dict);
                }
                #endregion

                var pattern_array_dict = pattern_list_dict.ToDictionary(x => x.Key, y => y.Value.ToArray());
                day_value_dict.Add(day, new(pattern_array_dict, scada_dict_dict));
            }

            var hydraulic_record_list_dict = Verify(verify_id, verify_file_path, flow_id_mapping_dict, pressure_id_mapping_dict, day_value_dict);
            return hydraulic_record_list_dict;
        }

        /// <summary>
        /// 历史数据验证
        /// </summary>
        /// <param name="verify_id">验证标识</param>
        /// <param name="verify_file_path">验证模型文件</param>
        /// <param name="flow_id_mapping_dict">流量Scada标识字典</param>
        /// <param name="pressure_id_mapping_dict">压力Scada标识字典</param>
        /// <param name="day_value_list">每日分析数据</param> 
        /// <param name="day_value_dict">日数据列表</param>
        /// <returns></returns>
        public static List<Model.HydraulicModelRecord> Verify(long verify_id, string file_path, Dictionary<string, string> flow_id_mapping_dict, Dictionary<string, string> pressure_id_mapping_dict, List<DayValue> day_value_list)
        public static Dictionary<DateTime, List<Model.HydraulicModelRecord>> Verify(
            long verify_id,
            string verify_file_path,
            Dictionary<string, string> flow_id_mapping_dict,
            Dictionary<string, string> pressure_id_mapping_dict,
            Dictionary<DateTime, Tuple<Dictionary<string, float[]>, Dictionary<DateTime, Dictionary<string, double>>>> day_value_dict)
        {
            var log_title = "初始化";
            #region 入参验证

            var log_title = "开始验证";
            var log_msg = string.Empty;
            var hydraulic_record_list = new List<Model.HydraulicModelRecord>();
            var hydraulic_record_list_dict = new Dictionary<DateTime, List<Model.HydraulicModelRecord>>();
            if (flow_id_mapping_dict == null || !flow_id_mapping_dict.Any())
            {
                log_msg = "流量标签字典为空!";
@@ -314,20 +426,29 @@
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }
            if (day_value_list == null || !day_value_list.Any())
            if (day_value_dict == null || !day_value_dict.Any())
            {
                log_msg = "日验证数据为空!";
                log_msg = "日数据列表为空!";
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }

            var err = EpanetMethods.ENopen(file_path, "", "");
            #endregion

            #region 加载模型


            var err = EpanetMethods.ENopen(verify_file_path, "", "");
            if (err != 0)
            {
                log_msg = err.GetMsg();
                Log.Info(verify_id, log_title, log_msg);
                return default;
            }

            EpanetMethods.ENsettimeparam(TimeParameter.PatternStep, 1);
            EpanetMethods.ENsettimeparam(TimeParameter.HydStep, 1);
            EpanetMethods.ENsettimeparam(TimeParameter.ReportStep, 1);
            err = EpanetMethods.ENopenH();
            if (err != 0)
            {
@@ -336,27 +457,32 @@
                return default;
            }

            log_msg = "初始化成功";
            Log.Info(verify_id, log_title, log_msg);
            #endregion


            log_title = "验证";
            var model_time_step = 0;
            var model_id_build = new StringBuilder(31);
            foreach (var day_value in day_value_list)
            var pattern_init = true;
            var pattern_time_step = 0;
            foreach (var day_value in day_value_dict)
            {
                var pattern_list = day_value.PatternList;
                var time_value_list = day_value.TimeValueList;
                if (pattern_list == null || time_value_list == null)
                var day = day_value.Key;
                var pattern_dict = day_value.Value.Item1;
                var time_value_dict = day_value.Value.Item2;
                if (time_value_dict == null || !time_value_dict.Any())
                {
                    continue;
                }
                var pattern_init = true;
                foreach (var pattern in pattern_list)

                #region 模式初始化
                pattern_init = true;
                pattern_time_step = 0;
                foreach (var pattern in pattern_dict)
                {
                    var patternId = pattern.Id;
                    var pattern_factor_array = pattern.FactorList.ToArray();
                    var pattern_id = pattern.Key;
                    var pattern_factor_array = pattern.Value;
                    var pattern_factor_array_count = pattern_factor_array.Length == 0 ? 1 : pattern_factor_array.Length;
                    err = EpanetMethods.ENgetpatternindex(patternId, out int pattern_index);
                    err = EpanetMethods.ENgetpatternindex(pattern_id, out int pattern_index);
                    if (err != ErrorCode.Ok)
                    {
                        pattern_init = false;
@@ -376,11 +502,16 @@

                if (!pattern_init)
                {
                    log_msg = $"{day_value.Year}_{day_value.Month}_{day_value.Day}:模式初始化失败!";
                    log_msg = $"{day:G}:模式初始化失败!";
                    Log.Info(verify_id, log_title, log_msg);
                    continue;
                    return default;
                }
                #endregion

                #region 模型验证

                var time_value_dict_dict = time_value_dict.ToDictionary(x => x.Key.TimeOfDay.TotalSeconds, y => y);
               
                EpanetMethods.ENinitH(0);
                do
                {
@@ -389,11 +520,13 @@
                    EpanetMethods.ENgetcount(CountType.Node, out int node_count);

                    var current_time = TimeSpan.FromSeconds(current_ts);
                    var time_value = time_value_list.Find(x => x.Time.TimeOfDay == current_time);
                    if (time_value != null)
                    if (time_value_dict_dict.ContainsKey(current_time.TotalSeconds))
                    {
                        var time = time_value.Time;
                        var scada_value_dcit = time_value.Value;
                        var hydraulic_record_list = new List<Model.HydraulicModelRecord>();

                        var time_value = time_value_dict_dict[current_ts];
                        var verify_time = time_value.Key;
                        var scada_dict = time_value.Value;
                        for (int link_index = 1; link_index <= link_count; link_index++)
                        {
                            if (EpanetMethods.ENgetlinkid(link_index, model_id_build) != ErrorCode.Ok)
@@ -403,21 +536,27 @@
                            if (flow_id_mapping_dict.ContainsKey(model_id))
                            {
                                var scada_id = flow_id_mapping_dict[model_id];
                                var scada_value = scada_value_dcit[scada_id];
                                EpanetMethods.ENgetlinkvalue(link_index, LinkValue.Flow, out float model_value);
                                var scada_value = scada_dict[scada_id];

                                var record = new IStation.Model.HydraulicModelRecord();
                                record.VerificationID = verify_id;
                                record.Time = time;
                                record.ModelId = model_id;
                                record.ScadaId = scada_id;
                                record.ValueType = IStation.eValueType.Flow;
                                record.ModelValue = (double)model_value;
                                record.ScadaValue = scada_value;
                                if (record.ModelValue.HasValue)
                                    record.ModelValue = Math.Abs(record.ModelValue.Value);
                                EpanetMethods.ENgetlinkvalue(link_index, LinkValue.Flow, out float model_value);
                                var record = new IStation.Model.HydraulicModelRecord
                                {
                                    VerificationID = verify_id,
                                    Time = verify_time,
                                    ModelId = model_id,
                                    ScadaId = scada_id,
                                    ValueType = IStation.eValueType.Flow,
                                    ModelValue = (double)Math.Abs(model_value),
                                    ScadaValue = scada_value
                                };
                                record.DifferenceValue = record.ScadaValue - record.ModelValue;
                                hydraulic_record_list.Add(record);
                            }

                            EpanetMethods.ENgetlinktype(link_index, out LinkType linkType);
                            if (linkType == LinkType.Pump)
                            {
                                EpanetMethods.ENgetlinkvalue(link_index, LinkValue.InitStatus, out float on_off);
                            }
                        }

@@ -426,38 +565,44 @@
                            if (EpanetMethods.ENgetnodeid(node_index, model_id_build) != ErrorCode.Ok)
                                continue;
                            var model_id = model_id_build.ToString();


                            if (pressure_id_mapping_dict.ContainsKey(model_id))
                            {
                                var scada_id = pressure_id_mapping_dict[model_id];
                                var scada_value = scada_value_dcit[scada_id];
                                var scada_value = scada_dict[scada_id];

                                EpanetMethods.ENgetnodevalue(node_index, NodeValue.Head, out float model_value);

                                var record = new IStation.Model.HydraulicModelRecord();
                                record.VerificationID = verify_id;
                                record.Time = time;
                                record.ModelId = model_id;
                                record.ScadaId = scada_id;
                                record.ValueType = IStation.eValueType.Head;
                                record.ModelValue = (double)model_value;
                                record.ScadaValue = scada_value;
                                if (record.ModelValue.HasValue)
                                    record.ModelValue = Math.Abs(record.ModelValue.Value);
                                var record = new IStation.Model.HydraulicModelRecord
                                {
                                    VerificationID = verify_id,
                                    Time = verify_time,
                                    ModelId = model_id,
                                    ScadaId = scada_id,
                                    ValueType = IStation.eValueType.Head,
                                    ModelValue = (double)model_value,
                                    ScadaValue = scada_value
                                };
                                record.DifferenceValue = record.ScadaValue - record.ModelValue;
                                hydraulic_record_list.Add(record);
                            }
                        }

                        hydraulic_record_list_dict.Add(verify_time, hydraulic_record_list);
                    }

                    EpanetMethods.ENnextH(out model_time_step);
                    EpanetMethods.ENnextH(out pattern_time_step);

                } while (model_time_step > 0);
                } while (pattern_time_step > 0);

                #endregion

            }
            EpanetMethods.ENcloseH();
            return hydraulic_record_list;
            return hydraulic_record_list_dict;
        }


    }

    }
}