using IStation.Epanet;
|
using IStation.Epanet.Enums;
|
using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
|
namespace IStation.WinFrmUI
|
{
|
/// <summary>
|
/// 导出 分析系数
|
/// </summary>
|
public partial class ExportModelAnalysisFactorHelper
|
{
|
|
public class ModelDiffViewModel
|
{
|
public string Time { get; set; }
|
|
public string MonitorID { get; set; }
|
|
public string ModelID { get; set; }
|
|
public string Type { get; set; }
|
|
public double ModelValue { get; set; }
|
|
public double MonitorValue { get; set; }
|
|
public double DiffVlaue { get; set; }
|
|
public int? Flag { get; set; }
|
|
public double? Hz { get; set; }
|
public double? Hz0 { get; set; }
|
|
}
|
|
/// <summary>
|
/// 分析系数
|
/// </summary>
|
public class AnalysisFactor
|
{
|
|
/// <summary>
|
/// 泵标志
|
/// </summary>
|
public int Flag { get; set; }
|
|
/// <summary>
|
/// 频率
|
/// </summary>
|
public double Hz { get; set; }
|
|
/// <summary>
|
/// 扬程标准差
|
/// </summary>
|
public double? HeadSTDP { get; set; }
|
|
/// <summary>
|
/// 扬程偏差
|
/// </summary>
|
public double? HeadDeviation { get; set; }
|
|
/// <summary>
|
/// 准确度
|
/// </summary>
|
public double Accuracy { get; set; }
|
|
|
}
|
|
private static BLL.StationSignalRecordPacket _packet = new BLL.StationSignalRecordPacket();
|
|
private static string _model_file = System.IO.Path.Combine(SettingsD.File.RootDirectory, SettingsD.File.DataFolder, "ch2_v3_20240918(Clear).inp");
|
|
|
/// <summary>
|
/// 绑定数据
|
/// </summary>
|
public static bool Export(long monitorDataSourcesId, long stationId, int station_index, string name)
|
{
|
|
var eq_list = new BLL.Equipment().GetPumpListByBelongTypeAndBelongID(IStation.ObjectType.Station, stationId);
|
if (eq_list == null || !eq_list.Any())
|
{
|
return default;
|
}
|
|
var flag_pump_dict = eq_list.ToDictionary(x => x.SortCode, x => x.RatedParas);
|
var flag_curve_dict = new Dictionary<int, Model.CurveExpress>();
|
var bll_curve = new BLL.PumpCurve();
|
foreach (var pump in eq_list)
|
{
|
Model.CurveExpress qh = null;
|
var curve_info = bll_curve.GetDefaultWorkingByPumpID(pump.ID)?.CurveInfo;
|
if (curve_info != null)
|
{
|
qh = curve_info.CurveQH;
|
}
|
flag_curve_dict.Add(pump.SortCode, qh);
|
}
|
if (flag_curve_dict == null || !flag_curve_dict.Any())
|
{
|
return default;
|
}
|
|
var all_list = Get(monitorDataSourcesId, stationId, station_index, 300);
|
if (all_list == null || !all_list.Any())
|
return default;
|
|
var pressure_id_mapping_dict = GetPumpPressureIdMappingDict(station_index);
|
var flow_id_mapping_dict = GetPumpFlowIdMappingDict(station_index);
|
var pump_id_mapping_dict = GetPumpIdMappingDict(station_index);
|
|
|
var err = EpanetMethods.ENopen(_model_file, "", "");
|
if (err != ErrorCode.Ok)
|
{
|
return default;
|
}
|
|
err = EpanetMethods.ENopenH();
|
if (err != ErrorCode.Ok)
|
{
|
return default;
|
}
|
|
var multi_tag_head_diff_list = new List<Tuple<string, double>>();
|
var vm_list = new List<ModelDiffViewModel>();
|
var model_id_build = new StringBuilder(31);
|
foreach (var tuple in all_list)
|
{
|
var time = tuple.Item1.ToString("G");
|
var pattern_dict = tuple.Item2;
|
var scada_dict = tuple.Item3;
|
var pump_dict = tuple.Item4;
|
var pattern_init = true;
|
|
foreach (var pattern in pattern_dict)
|
{
|
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(pattern_id, out int pattern_index);
|
if (err != ErrorCode.Ok)
|
{
|
pattern_init = false;
|
continue;
|
}
|
err = EpanetMethods.ENsetpattern(pattern_index, pattern_factor_array, pattern_factor_array_count);
|
if (err != ErrorCode.Ok)
|
{
|
pattern_init = false;
|
continue;
|
}
|
}
|
if (!pattern_init)
|
continue;
|
|
|
EpanetMethods.ENinitH(0);
|
EpanetMethods.ENrunH(out _);
|
EpanetMethods.ENgetcount(CountType.Node, out int node_count);
|
EpanetMethods.ENgetcount(CountType.Link, out int link_count);
|
|
for (int node_index = 1; node_index <= node_count; node_index++)
|
{
|
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];
|
|
double? hz = null, hzr = null;
|
int? flag = null;
|
if (pump_dict.ContainsKey(scada_id))
|
{
|
if (!(pump_dict[scada_id] > 0))
|
{
|
continue;
|
}
|
hz = pump_dict[scada_id] * 50;
|
hz = Math.Round(hz.Value, 2);
|
hzr = Math.Round(hz.Value);
|
flag = pump_id_mapping_dict[model_id];
|
}
|
EpanetMethods.ENgetnodevalue(node_index, NodeValue.Head, out float model_head);
|
var scada_value = scada_dict[scada_id];
|
var vm = new ModelDiffViewModel();
|
vm.Time = time;
|
vm.MonitorID = scada_id;
|
vm.ModelID = model_id;
|
vm.ModelValue = model_head;
|
vm.MonitorValue = scada_value;
|
vm.DiffVlaue = scada_value - model_head;
|
vm.Type = "压力";
|
vm.Hz = hz;
|
vm.Hz0 = hzr;
|
vm.Flag = flag;
|
if (Math.Round(vm.DiffVlaue) > 100)
|
{
|
continue;
|
}
|
vm_list.Add(vm);
|
}
|
}
|
|
for (int link_index = 1; link_index <= link_count; link_index++)
|
{
|
if (EpanetMethods.ENgetlinkid(link_index, model_id_build) != ErrorCode.Ok)
|
continue;
|
var model_id = model_id_build.ToString();
|
|
if (flow_id_mapping_dict.ContainsKey(model_id))
|
{
|
var scada_id = flow_id_mapping_dict[model_id];
|
double? hz = null, hzr = null;
|
int? flag = null;
|
if (pump_dict.ContainsKey(scada_id))
|
{
|
if (!(pump_dict[scada_id] > 0))
|
{
|
continue;
|
}
|
hz = pump_dict[scada_id] * 50;
|
hz = Math.Round(hz.Value, 2);
|
hzr = Math.Round(hz.Value);
|
flag = pump_id_mapping_dict[model_id];
|
}
|
EpanetMethods.ENgetlinkvalue(link_index, LinkValue.Flow, out float model_value);
|
model_value = Math.Abs(model_value);
|
var scada_value = scada_dict[scada_id];
|
var vm = new ModelDiffViewModel();
|
vm.Time = time;
|
vm.MonitorID = scada_id;
|
vm.ModelID = model_id;
|
vm.ModelValue = model_value;
|
vm.MonitorValue = scada_value;
|
vm.DiffVlaue = scada_value - model_value;
|
vm.Type = "流量";
|
vm.Hz = hz;
|
vm.Hz0 = hzr;
|
vm.Flag = flag;
|
vm_list.Add(vm);
|
}
|
|
EpanetMethods.ENgetlinktype(link_index, out LinkType linkType);
|
if (linkType == LinkType.Pump)
|
{
|
EpanetMethods.ENgetlinkvalue(link_index, LinkValue.InitStatus, out float on_off);
|
}
|
}
|
}
|
EpanetMethods.ENcloseH();
|
EpanetMethods.ENclose();
|
|
if (!vm_list.Any())
|
return default;
|
|
var analysis_facotr_list = new List<AnalysisFactor>();
|
var group_by_flag_hz = vm_list.Where(x => x.Type == "压力" && x.Flag.HasValue).GroupBy(x => new { x.Flag, x.Hz0 });
|
foreach (var flag_item in group_by_flag_hz)
|
{
|
var hz = flag_item.Key.Hz0.Value;
|
if (hz < 20)
|
{
|
continue;
|
}
|
var flag = flag_item.Key.Flag.Value;
|
var pump = flag_pump_dict[flag];
|
var qh = flag_curve_dict[flag];
|
|
var head_diff_list = flag_item.Select(x => x.DiffVlaue).ToList();
|
double head_diff_avg = 0d, std_dev_pop = 0d, std_dev_pop_head_avg = 0d;
|
|
var filter_std_dev_pop_tuple = FilterBySTDP(head_diff_list.ToArray(), 0.3, 0);
|
var filter_std_dev_pop_array = filter_std_dev_pop_tuple.Item1;
|
std_dev_pop = filter_std_dev_pop_tuple.Item2;
|
|
std_dev_pop_head_avg = filter_std_dev_pop_array.Average();
|
head_diff_avg = std_dev_pop_head_avg;
|
if (Math.Abs(head_diff_avg) > 5)
|
{
|
continue;
|
}
|
if (std_dev_pop > 1)
|
{
|
continue;
|
}
|
if (std_dev_pop > 0.5 && flag_item.Count() < 5)
|
{
|
continue;
|
}
|
|
var analysis_facotr = new AnalysisFactor();
|
analysis_facotr.Flag = flag;
|
analysis_facotr.Hz = hz;
|
analysis_facotr.HeadSTDP = std_dev_pop;
|
analysis_facotr.HeadDeviation = std_dev_pop_head_avg;
|
analysis_facotr.Accuracy = 0;
|
analysis_facotr_list.Add(analysis_facotr);
|
}
|
|
analysis_facotr_list = analysis_facotr_list.OrderBy(x => x.Flag).ThenBy(x => x.Hz).ToList();
|
var flag_range5_hz_factor_dict = new Dictionary<int, Dictionary<double, Tuple<double, double, int>>>();
|
var group_by_flag = vm_list.Where(x => x.Type == "压力" && x.Flag.HasValue).GroupBy(x => x.Flag);
|
foreach (var flag_item in group_by_flag)
|
{
|
var flag = flag_item.Key.Value;
|
var pump = flag_pump_dict[flag];
|
var qh = flag_curve_dict[flag];
|
if (!pump.IsBp)
|
{
|
continue;
|
}
|
|
flag_range5_hz_factor_dict.Add(flag, new Dictionary<double, Tuple<double, double, int>>());
|
for (double i = 5; i <= 50; i += 5)
|
{
|
var min_hz = i - 5;
|
double max_hz = i;
|
|
var list = flag_item.Where(x => x.Hz >= min_hz && x.Hz <= max_hz).ToList();
|
if (list == null || list.Count() < 5)
|
continue;
|
|
var head_diff_list = list.Select(x => x.DiffVlaue).ToList();
|
double std_dev_pop = 0d, std_dev_pop_head_avg = 0d;
|
|
var filter_tuple = FilterBySTDP(head_diff_list.ToArray(), 0.3, 0);
|
var filter_array = filter_tuple.Item1;
|
|
std_dev_pop = filter_tuple.Item2;
|
std_dev_pop_head_avg = filter_array.Average();
|
flag_range5_hz_factor_dict[flag].Add(max_hz, new Tuple<double, double, int>(std_dev_pop, std_dev_pop_head_avg, filter_array.Count()));
|
|
}
|
}
|
|
|
var not_hz_list = new List<AnalysisFactor>();
|
foreach (var eq in eq_list)
|
{
|
var flag = eq.SortCode;
|
var pump = flag_pump_dict[flag];
|
if (!pump.IsBp)
|
{
|
continue;
|
}
|
var qh = flag_curve_dict[flag];
|
var dict_item = flag_range5_hz_factor_dict[flag];
|
for (int hz = 1; hz <= 50; hz++)
|
{
|
if (analysis_facotr_list.Exists(x => x.Flag == flag && x.Hz == hz))
|
{
|
continue;
|
}
|
|
var num = hz / 5;
|
|
var hz_key = (num + 1) * 5;
|
if (hz_key > 50)
|
hz_key = 50;
|
if (dict_item.ContainsKey(hz_key))
|
{
|
var tuple = dict_item[hz_key];
|
var analysis_facotr = new AnalysisFactor();
|
analysis_facotr.Flag = flag;
|
analysis_facotr.Hz = hz;
|
analysis_facotr.HeadSTDP = tuple.Item1;
|
analysis_facotr.HeadDeviation = tuple.Item2;
|
analysis_facotr.Accuracy = 0;
|
not_hz_list.Add(analysis_facotr);
|
}
|
else
|
{
|
var key_list = dict_item.Select(x => x.Key).ToList();
|
var key = key_list.Where(x => x >= hz_key)?.OrderBy(x => x).FirstOrDefault();
|
if (key == null)
|
{
|
key = key_list.OrderByDescending(x => x).FirstOrDefault();
|
}
|
if (key == null)
|
{
|
throw new Exception("error");
|
}
|
var tuple = dict_item[key.Value];
|
double ratio = hz / key.Value;
|
double head_dev = tuple.Item2 * ratio;
|
double head_stdp = tuple.Item1 * ratio;
|
|
var analysis_facotr = new AnalysisFactor();
|
analysis_facotr.Flag = flag;
|
analysis_facotr.Hz = hz;
|
analysis_facotr.HeadSTDP = head_stdp;
|
analysis_facotr.HeadDeviation = head_dev;
|
analysis_facotr.Accuracy = -1;
|
not_hz_list.Add(analysis_facotr);
|
}
|
}
|
}
|
|
var analysis_factor_list = new List<AnalysisFactor>();
|
analysis_factor_list.AddRange(analysis_facotr_list);
|
analysis_factor_list.AddRange(not_hz_list);
|
|
var root_folder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "分析系数");
|
if (!Directory.Exists(root_folder))
|
{
|
Directory.CreateDirectory(root_folder);
|
}
|
var fileName = root_folder + "\\" + name + ".json";
|
var json = JsonHelper.Object2Json(analysis_factor_list);
|
File.WriteAllText(fileName, json);
|
return true;
|
|
}
|
|
|
#region Function
|
|
private static List<Tuple<DateTime, Dictionary<string, float[]>, Dictionary<string, double>, Dictionary<string, double>>> Get(long monitorDataSourcesId, long stationId, int station_index, int timeStep = 300)
|
{
|
|
var bllSummary = new BLL.MonitorDataSetSummary();
|
var yearMonths = bllSummary.GetYearMonth(monitorDataSourcesId);
|
if (yearMonths == null || !yearMonths.Any())
|
{
|
return default;
|
}
|
|
var bllEquipment = new BLL.Equipment();
|
var enginePumps = bllEquipment.GetEnginePumpListByBelongTypeAndBelongID(IStation.ObjectType.Station, stationId);
|
if (enginePumps == null || !enginePumps.Any())
|
return default;
|
|
var bllMonitorPoint = new BLL.MonitorPoint();
|
var bllEquipmentMonitorMapping = new BLL.EquipmentMonitorMapping();
|
var bllMonitorDataSet = new BLL.MonitorDataSet();
|
|
|
var pumpParasDict = new Dictionary<int, Model.Pump>();
|
var pumpMonitorPointDict = new Dictionary<int, List<Model.MonitorPointExSignalWithSignalType>>();
|
var stationMonitorPointList = new List<Model.MonitorPointExSignalWithSignalType>();
|
var signalIds = new List<long>();
|
foreach (var enginePump in enginePumps)
|
{
|
var pump = bllEquipment.GetChildPumpByEnginePumpID(enginePump.ID);
|
if (pump == null)
|
continue;
|
var equipmentMonitorMappings = bllEquipmentMonitorMapping.GetByEquipmentID(enginePump.ID);
|
if (equipmentMonitorMappings == null || !equipmentMonitorMappings.Any())
|
continue;
|
var monitorPointIds = equipmentMonitorMappings.Select(x => x.MonitorPointID).ToList();
|
var monitorPoints = bllMonitorPoint.GetExSignalWithSignalTypeByIds(monitorPointIds);
|
monitorPoints = monitorPoints?.Where(x => !string.IsNullOrEmpty(x.TagName)).ToList();
|
monitorPoints = monitorPoints?.Where(x => x.SignalType != IStation.SignalType.频率).ToList();
|
monitorPoints = monitorPoints?.Where(x => x.Flags != null && !x.Flags.Contains(Flags.总站)).ToList();
|
if (monitorPoints == null || !monitorPoints.Any())
|
continue;
|
pumpParasDict.Add(enginePump.SortCode, pump.RatedParas);
|
pumpMonitorPointDict.Add(enginePump.SortCode, monitorPoints);
|
signalIds.AddRange(monitorPoints.Select(x => x.SignalID));
|
}
|
|
var monitorPoints_station = bllMonitorPoint.GetExSignalWithSignalTypeByBelongTypeAndBelongID(IStation.ObjectType.Station, stationId);
|
monitorPoints_station = monitorPoints_station?.Where(x => !string.IsNullOrEmpty(x.TagName)).ToList();
|
stationMonitorPointList = monitorPoints_station?
|
.Where(x => x.Flags != null && x.Flags.Contains(IStation.Flags.总站)).ToList();
|
if (stationMonitorPointList != null && stationMonitorPointList.Any())
|
{
|
signalIds.AddRange(stationMonitorPointList.Select(x => x.SignalID));
|
}
|
|
signalIds = signalIds.Distinct().ToList();
|
|
|
var pressure_monitor_points = monitorPoints_station.Where(x => x.SignalType == IStation.SignalType.压力).ToList();
|
var flow_monitor_points = monitorPoints_station.Where(x => x.SignalType == IStation.SignalType.瞬时流量).ToList();
|
|
var list = new List<Tuple<DateTime, Dictionary<string, float[]>, Dictionary<string, double>, Dictionary<string, double>>>();
|
foreach (var yearMonth in yearMonths)
|
{
|
var year = yearMonth.Year;
|
var month = yearMonth.Month;
|
|
var summaries = bllSummary.GetAllByDate(monitorDataSourcesId, year, month);
|
if (summaries == null || !summaries.Any())
|
return default;
|
|
var minTime = summaries.Min(x => x.MinTime);
|
var maxTime = summaries.Max(x => x.MaxTime);
|
var totalSeconds = (int)(maxTime - minTime).TotalSeconds;
|
|
var startDay = minTime;//.AddDays(1);
|
var days = (maxTime - minTime).Days;
|
var capacity = _packet.CalcuCapacity(days, timeStep);// 每个月的数据量
|
|
|
var findIndexDict = new Dictionary<long, int>();// 查找数据下标
|
var recordDict = new Dictionary<long, double>();// 数据字典
|
signalIds.ForEach(x =>
|
{
|
findIndexDict.Add(x, 0);
|
recordDict.Add(x, IStation.Error.Default);
|
});
|
|
var signalRecordPackets = bllMonitorDataSet.GetSignalRecordPacket(monitorDataSourcesId, signalIds, year, month);
|
if (signalRecordPackets == null || !signalRecordPackets.Any())
|
return default;
|
|
//按天整理数据
|
for (int i = 0; i <= days; i++)
|
{
|
var day = startDay.AddDays(i);
|
|
//分割步长
|
for (int seconds = 0; seconds < _packet.TotalSecondsOfDay; seconds += timeStep) //00点的数据不要
|
{
|
var realTime = day.AddSeconds(seconds);
|
_packet.GetRecordDict(realTime, signalRecordPackets, findIndexDict, recordDict, timeStep, out bool existRecord);
|
if (!existRecord)
|
continue;
|
|
var timeValue = new ExportEpanetHelper.TimeValue
|
{
|
Time = realTime,
|
Value = new Dictionary<string, double>()
|
};
|
|
if (stationMonitorPointList != null && stationMonitorPointList.Any())
|
{
|
foreach (var stationMonitorPoint in stationMonitorPointList)
|
{
|
var time = realTime;
|
var value = recordDict[stationMonitorPoint.SignalID];
|
if (stationMonitorPoint.SignalType == IStation.SignalType.压力)
|
{
|
value = Model.CurveCalcuHelper.Mpa2M(value);
|
}
|
else if (stationMonitorPoint.SignalType == IStation.SignalType.瞬时流量)
|
{
|
value = value < 0 ? 0 : value;
|
}
|
timeValue.Value.Add(stationMonitorPoint.TagName, value);
|
}
|
}
|
|
foreach (var pumpMonitorPointItem in pumpMonitorPointDict)
|
{
|
var key = pumpMonitorPointItem.Key;
|
var pumpParas = pumpParasDict[key];
|
var pumpMonitorPointList = pumpMonitorPointItem.Value;
|
foreach (var pumpMonitorPoint in pumpMonitorPointList)
|
{
|
var time = realTime;
|
var value = recordDict[pumpMonitorPoint.SignalID];
|
if (pumpMonitorPoint.SignalType == IStation.SignalType.转速)
|
{
|
value = value / pumpParas.Nr;
|
value = value < 0 ? 0 : value;
|
value = value > 1 ? 1 : value;
|
}
|
else if (pumpMonitorPoint.SignalType == IStation.SignalType.频率)
|
{
|
value = value / 50;
|
value = value < 0 ? 0 : value;
|
value = value > 1 ? 1 : value;
|
}
|
else if (pumpMonitorPoint.SignalType == IStation.SignalType.压力)
|
{
|
value = Model.CurveCalcuHelper.Mpa2M(value);
|
}
|
else if (pumpMonitorPoint.SignalType == IStation.SignalType.瞬时流量)
|
{
|
value = value < 0 ? 0 : value;
|
}
|
timeValue.Value.Add(pumpMonitorPoint.TagName, value);
|
}
|
}
|
|
if (station_index == 1)
|
{
|
list.Add(GetStation1(realTime, timeValue.Value));
|
}
|
else
|
{
|
list.Add(GetStation2(realTime, timeValue.Value));
|
}
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
private static Tuple<DateTime, Dictionary<string, float[]>, Dictionary<string, double>, Dictionary<string, double>> GetStation1(DateTime dateTime, Dictionary<string, double> time_dict)
|
{
|
var pattern_dict = new Dictionary<string, float[]>();
|
var scada_dict = new Dictionary<string, double>();
|
var pump_dict = new Dictionary<string, double>();
|
var limited_speed_ratio = 0.1;
|
|
var Pump11 = time_dict["Pump11"];
|
var Pump12 = time_dict["Pump12"];
|
var Pump13 = time_dict["Pump13"];
|
var Pump14 = time_dict["Pump14"];
|
var Pump15 = time_dict["Pump15"];
|
var Pump16 = time_dict["Pump16"];
|
var Pump17 = time_dict["Pump17"];
|
var Pump18 = time_dict["Pump18"];
|
|
Pump11 = Pump11 < limited_speed_ratio ? 0 : Pump11;
|
Pump12 = Pump12 < limited_speed_ratio ? 0 : Pump12;
|
Pump13 = Pump13 < limited_speed_ratio ? 0 : Pump13;
|
Pump14 = Pump14 < limited_speed_ratio ? 0 : Pump14;
|
Pump15 = Pump15 < limited_speed_ratio ? 0 : Pump15;
|
Pump16 = Pump16 < limited_speed_ratio ? 0 : Pump16;
|
Pump17 = Pump17 < limited_speed_ratio ? 0 : Pump17;
|
Pump18 = Pump18 < limited_speed_ratio ? 0 : Pump18;
|
|
|
pattern_dict.Add("R1", new float[] { (float)time_dict["R1"] });
|
pattern_dict.Add("R2", new float[] { (float)time_dict["R2"] });
|
pattern_dict.Add("R3", new float[] { (float)time_dict["R3"] });
|
pattern_dict.Add("SFJD1", new float[] { (float)time_dict["SFJD1"] });
|
pattern_dict.Add("SFJD2", new float[] { (float)time_dict["SFJD2"] });
|
pattern_dict.Add("SFJD3", new float[] { (float)time_dict["SFJD3"] });
|
pattern_dict.Add("Pump11", new float[] { (float)Pump11 });
|
pattern_dict.Add("Pump12", new float[] { (float)Pump12 });
|
pattern_dict.Add("Pump13", new float[] { (float)Pump13 });
|
pattern_dict.Add("Pump14", new float[] { (float)Pump14 });
|
pattern_dict.Add("Pump15", new float[] { (float)Pump15 });
|
pattern_dict.Add("Pump16", new float[] { (float)Pump16 });
|
pattern_dict.Add("Pump17", new float[] { (float)Pump17 });
|
pattern_dict.Add("Pump18", new float[] { (float)Pump18 });
|
|
scada_dict.Add("SPJD1", time_dict["SPJD1"]);
|
scada_dict.Add("SPJD2", time_dict["SPJD2"]);
|
scada_dict.Add("SPJD3", time_dict["SPJD3"]);
|
scada_dict.Add("SFJD1", time_dict["SFJD1"]);
|
scada_dict.Add("SFJD2", time_dict["SFJD2"]);
|
scada_dict.Add("SFJD3", time_dict["SFJD3"]);
|
scada_dict.Add("SPPump11", time_dict["SPPump11"]);
|
scada_dict.Add("SPPump12", time_dict["SPPump12"]);
|
scada_dict.Add("SPPump13", time_dict["SPPump13"]);
|
scada_dict.Add("SPPump14", time_dict["SPPump14"]);
|
scada_dict.Add("SPPump15", time_dict["SPPump15"]);
|
scada_dict.Add("SPPump16", time_dict["SPPump16"]);
|
scada_dict.Add("SPPump17", time_dict["SPPump17"]);
|
scada_dict.Add("SPPump18", time_dict["SPPump18"]);
|
|
pump_dict.Add("SPPump11", Pump11);
|
pump_dict.Add("SPPump12", Pump12);
|
pump_dict.Add("SPPump13", Pump13);
|
pump_dict.Add("SPPump14", Pump14);
|
pump_dict.Add("SPPump15", Pump15);
|
pump_dict.Add("SPPump16", Pump16);
|
pump_dict.Add("SPPump17", Pump17);
|
pump_dict.Add("SPPump18", Pump18);
|
|
|
return new Tuple<DateTime, Dictionary<string, float[]>, Dictionary<string, double>, Dictionary<string, double>>(dateTime, pattern_dict, scada_dict, pump_dict);
|
}
|
|
private static Tuple<DateTime, Dictionary<string, float[]>, Dictionary<string, double>, Dictionary<string, double>> GetStation2(DateTime dateTime, Dictionary<string, double> time_dict)
|
{
|
var pattern_dict = new Dictionary<string, float[]>();
|
var scada_dict = new Dictionary<string, double>();
|
var pump_dict = new Dictionary<string, double>();
|
var limited_speed_ratio = 0.1;
|
|
|
var Pump21 = time_dict["Pump21"];
|
var Pump22 = time_dict["Pump22"];
|
var Pump23 = time_dict["Pump23"];
|
var Pump24 = time_dict["Pump24"];
|
var Pump25 = time_dict["Pump25"];
|
var Pump26 = time_dict["Pump26"];
|
var Pump27 = time_dict["Pump27"];
|
|
|
Pump21 = Pump21 < limited_speed_ratio ? 0 : Pump21;
|
Pump22 = Pump22 < limited_speed_ratio ? 0 : Pump22;
|
Pump23 = Pump23 < limited_speed_ratio ? 0 : Pump23;
|
Pump24 = Pump24 < limited_speed_ratio ? 0 : Pump24;
|
Pump25 = Pump25 < limited_speed_ratio ? 0 : Pump25;
|
Pump26 = Pump26 < limited_speed_ratio ? 0 : Pump26;
|
Pump27 = Pump27 < limited_speed_ratio ? 0 : Pump27;
|
|
|
pattern_dict.Add("RPump21", new float[] { (float)time_dict["RPump21"] });
|
pattern_dict.Add("RPump22", new float[] { (float)time_dict["RPump22"] });
|
pattern_dict.Add("RPump23", new float[] { (float)time_dict["RPump23"] });
|
pattern_dict.Add("RPump24", new float[] { (float)time_dict["RPump24"] });
|
pattern_dict.Add("RPump25", new float[] { (float)time_dict["RPump25"] });
|
pattern_dict.Add("RPump26", new float[] { (float)time_dict["RPump26"] });
|
pattern_dict.Add("RPump27", new float[] { (float)time_dict["RPump27"] });
|
|
|
pattern_dict.Add("SFDN2400", new float[] { (float)time_dict["SFDN2400"] });
|
pattern_dict.Add("SFDN2700", new float[] { (float)time_dict["SFDN2700"] });
|
pattern_dict.Add("SFPump21", new float[] { (float)time_dict["SFPump21"] });
|
pattern_dict.Add("SFPump22", new float[] { (float)time_dict["SFPump22"] });
|
pattern_dict.Add("SFPump23", new float[] { (float)time_dict["SFPump23"] });
|
pattern_dict.Add("SFPump24", new float[] { (float)time_dict["SFPump24"] });
|
pattern_dict.Add("SFPump25", new float[] { (float)time_dict["SFPump25"] });
|
pattern_dict.Add("SFPump26", new float[] { (float)time_dict["SFPump26"] });
|
pattern_dict.Add("SFPump27", new float[] { (float)time_dict["SFPump27"] });
|
|
|
pattern_dict.Add("Pump21", new float[] { (float)Pump21 });
|
pattern_dict.Add("Pump22", new float[] { (float)Pump22 });
|
pattern_dict.Add("Pump23", new float[] { (float)Pump23 });
|
pattern_dict.Add("Pump24", new float[] { (float)Pump24 });
|
pattern_dict.Add("Pump25", new float[] { (float)Pump25 });
|
pattern_dict.Add("Pump26", new float[] { (float)Pump26 });
|
pattern_dict.Add("Pump27", new float[] { (float)(double)time_dict["Pump27"] });
|
|
|
|
scada_dict.Add("SPDN2400", time_dict["SPDN2400"]);
|
scada_dict.Add("SPDN2700", time_dict["SPDN2700"]);
|
scada_dict.Add("SPPump21", time_dict["SPPump21"]);
|
scada_dict.Add("SPPump22", time_dict["SPPump22"]);
|
scada_dict.Add("SPPump23", time_dict["SPPump23"]);
|
scada_dict.Add("SPPump24", time_dict["SPPump24"]);
|
scada_dict.Add("SPPump25", time_dict["SPPump25"]);
|
scada_dict.Add("SPPump26", time_dict["SPPump26"]);
|
scada_dict.Add("SPPump27", time_dict["SPPump27"]);
|
|
scada_dict.Add("SFDN2400", time_dict["SFDN2400"]);
|
scada_dict.Add("SFDN2700", time_dict["SFDN2700"]);
|
//scada_dict.Add("SFPump21", time_dict["SFPump21"]);
|
//scada_dict.Add("SFPump22", time_dict["SFPump22"]);
|
//scada_dict.Add("SFPump23", time_dict["SFPump23"]);
|
//scada_dict.Add("SFPump24", time_dict["SFPump24"]);
|
//scada_dict.Add("SFPump25", time_dict["SFPump25"]);
|
//scada_dict.Add("SFPump26", time_dict["SFPump26"]);
|
//scada_dict.Add("SFPump27", time_dict["SFPump27"]);
|
|
|
pump_dict.Add("SPPump21", Pump21);
|
pump_dict.Add("SPPump22", Pump22);
|
pump_dict.Add("SPPump23", Pump23);
|
pump_dict.Add("SPPump24", Pump24);
|
pump_dict.Add("SPPump25", Pump25);
|
pump_dict.Add("SPPump26", Pump26);
|
pump_dict.Add("SPPump27", Pump27);
|
|
|
pump_dict.Add("SFPump21", Pump21);
|
pump_dict.Add("SFPump22", Pump22);
|
pump_dict.Add("SFPump23", Pump23);
|
pump_dict.Add("SFPump24", Pump24);
|
pump_dict.Add("SFPump25", Pump25);
|
pump_dict.Add("SFPump26", Pump26);
|
pump_dict.Add("SFPump27", Pump27);
|
|
return new Tuple<DateTime, Dictionary<string, float[]>, Dictionary<string, double>, Dictionary<string, double>>(dateTime, pattern_dict, scada_dict, pump_dict);
|
}
|
|
private static Dictionary<string, string> GetPumpPressureIdMappingDict(int station_index)
|
{
|
var dict = new Dictionary<string, string>();
|
if (station_index == 1)
|
{
|
dict = new Dictionary<string, string>()
|
{
|
{ "Jjd1", "SPJD1"},
|
{ "Jjd2", "SPJD2"},
|
{ "Jjd3", "SPJD3"},
|
{"Jpump11","SPPump11"},
|
{"Jpump12","SPPump12"},
|
{"Jpump13","SPPump13"},
|
{"Jpump14","SPPump14"},
|
{"Jpump15","SPPump15"},
|
{"Jpump16","SPPump16"},
|
{"Jpump17","SPPump17"},
|
{"Jpump18","SPPump18"},
|
};
|
|
}
|
else
|
{
|
dict = new Dictionary<string, string>()
|
{
|
{"Jdn2400","SPDN2400"},
|
{"Jdn2700","SPDN2700"},
|
{"Jpump21","SPPump21"},
|
{"Jpump22","SPPump22"},
|
{"Jpump23","SPPump23"},
|
{"Jpump24","SPPump24"},
|
{"Jpump25","SPPump25"},
|
{"Jpump26","SPPump26"},
|
{"Jpump27","SPPump27"}
|
};
|
}
|
return dict;
|
}
|
|
private static Dictionary<string, string> GetPumpFlowIdMappingDict(int station_index)
|
{
|
var dict = new Dictionary<string, string>();
|
if (station_index == 1)
|
{
|
dict = new Dictionary<string, string>()
|
{
|
{ "Pjd1", "SFJD1"},
|
{ "Pjd2", "SFJD2"},
|
{ "Pjd3", "SFJD3"},
|
};
|
}
|
else
|
{
|
dict = new Dictionary<string, string>()
|
{
|
{ "Pdn2400", "SFDN2400"},
|
{ "Pdn2700", "SFDN2700"},
|
//{ "Ppump21", "SFPump21"},
|
//{ "Ppump22", "SFPump22"},
|
//{ "Ppump23", "SFPump23"},
|
//{ "Ppump24", "SFPump24"},
|
//{ "Ppump25", "SFPump25"},
|
//{ "Ppump26", "SFPump26"},
|
//{ "Ppump27", "SFPump27"}
|
};
|
}
|
return dict;
|
}
|
|
private static Dictionary<string, int> GetPumpIdMappingDict(int station_index)
|
{
|
var dict = new Dictionary<string, int>();
|
if (station_index == 1)
|
{
|
dict = new Dictionary<string, int>()
|
{
|
{"Jpump11",GlobalHelper.Flag11},
|
{"Jpump12",GlobalHelper.Flag12},
|
{"Jpump13",GlobalHelper.Flag13},
|
{"Jpump14",GlobalHelper.Flag14},
|
{"Jpump15",GlobalHelper.Flag15},
|
{"Jpump16",GlobalHelper.Flag16},
|
{"Jpump17",GlobalHelper.Flag17},
|
{"Jpump18",GlobalHelper.Flag18},
|
};
|
}
|
else
|
{
|
dict = new Dictionary<string, int>()
|
{
|
{ "Ppump21", GlobalHelper.Flag21},
|
{ "Ppump22", GlobalHelper.Flag22},
|
{ "Ppump23", GlobalHelper.Flag23},
|
{ "Ppump24", GlobalHelper.Flag24},
|
{ "Ppump25", GlobalHelper.Flag25},
|
{ "Ppump26", GlobalHelper.Flag26},
|
{ "Ppump27", GlobalHelper.Flag27},
|
{"Jpump21",GlobalHelper.Flag21},
|
{"Jpump22",GlobalHelper.Flag22},
|
{"Jpump23",GlobalHelper.Flag23},
|
{"Jpump24",GlobalHelper.Flag24},
|
{"Jpump25",GlobalHelper.Flag25},
|
{"Jpump26",GlobalHelper.Flag26},
|
{"Jpump27",GlobalHelper.Flag27}
|
};
|
}
|
return dict;
|
}
|
|
private static Tuple<double[], double> FilterBySTDP(double[] array, double min_dev, int count)
|
{
|
if (array == null || !array.Any())
|
{
|
return default;
|
}
|
var array_avg = array.Average();
|
var array_count = array.Count();
|
|
|
FilterOutliersHelper.STDEV(array, out double std_dev, out double std_dev_pop);
|
if (Math.Abs(std_dev_pop) < min_dev)
|
{
|
return new Tuple<double[], double>(array, std_dev_pop);
|
}
|
if (count > 5)
|
{
|
return new Tuple<double[], double>(array, std_dev_pop);
|
}
|
var filter_array = array.Where(x => !(Math.Abs(x - array_avg) > Math.Abs(std_dev_pop * 2))).ToArray();
|
if (filter_array == null || !filter_array.Any())
|
{
|
return default;
|
}
|
count++;
|
return FilterBySTDP(filter_array, min_dev, count);
|
}
|
|
|
#endregion
|
|
}
|
}
|
