using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
|
namespace IStation.WinFrmUI
|
{
|
/// <summary>
|
/// 导出 分析系数
|
/// </summary>
|
public partial class ExportScadaAnalysisFactorHelper
|
{
|
|
public class PumpModel
|
{
|
public DateTime Time { get; set; }
|
|
public int Flag { get; set; }
|
|
public double Rpm { get; set; }
|
|
public double Hz { get; set; }
|
public double Hz0 { get; set; }
|
|
public double Flow { get; set; }
|
|
public double Head { get; set; }
|
|
public double CurveHead { get; set; }
|
|
public double HeadDiff { get; set; }
|
|
public double CorrectCurveHead { get; set; }
|
|
public double CorrectHeadDiff { 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; }
|
|
|
}
|
|
static BLL.StationSignalRecordPacket _packet = new BLL.StationSignalRecordPacket();
|
|
/// <summary>
|
/// 绑定数据
|
/// </summary>
|
public static bool Export(long monitorDataSourcesId, long stationId, string name)
|
{
|
var packets = _packet.Get(monitorDataSourcesId, stationId);
|
if (packets == null || !packets.Any())
|
return false;
|
|
var eq_list = new BLL.Equipment().GetPumpListByBelongTypeAndBelongID(IStation.ObjectType.Station, stationId);
|
if (eq_list == null || !eq_list.Any())
|
return false;
|
var flag_list = eq_list.Select(x => x.SortCode).OrderBy(x => x).ToList();
|
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);
|
}
|
|
var vm_pump_list = new List<PumpModel>();
|
foreach (var packet in packets)
|
{
|
var station_signal_records = packet.StationSignalRecords;
|
if (station_signal_records == null || !station_signal_records.Any())
|
continue;
|
foreach (var record in station_signal_records)
|
{
|
var pump_signal_records = record.PumpSignalRecords;
|
if (pump_signal_records == null || !pump_signal_records.Any())
|
continue;
|
pump_signal_records = pump_signal_records.OrderBy(x => x.Flag).ToList();
|
|
foreach (var pump_record in pump_signal_records)
|
{
|
if (pump_record.Rpm == IStation.Error.Default || pump_record.Head == IStation.Error.Default)
|
{
|
continue;
|
}
|
var flag = pump_record.Flag;
|
var pump = flag_pump_dict[flag];
|
var curve_qh = flag_curve_dict[flag];
|
|
var hz = pump_record.Rpm / pump.Nr * 50;
|
hz = Math.Round(hz, 2);
|
|
var curve_head = GetCurveHead(curve_qh, pump.Nr, pump_record.Rpm, pump_record.FlowRate);
|
curve_head = Math.Round(curve_head, 2);
|
|
var pump_head50hz = Model.CurveCalcuHelper.Calculate50HByHz(pump_record.Head, hz);
|
var curve_head50hz = Model.CurveCalcuHelper.Calculate50HByHz(curve_head, hz);
|
|
var head_diff = pump_head50hz - curve_head50hz;
|
|
var vm_pump = new PumpModel();
|
vm_pump.Time = record.Time;
|
vm_pump.Flag = flag;
|
vm_pump.Rpm = pump_record.Rpm;
|
vm_pump.Hz = hz;
|
vm_pump.Hz0 = Math.Round(hz, 0);
|
vm_pump.Head = pump_record.Head;
|
vm_pump.Flow = pump_record.FlowRate;
|
vm_pump.CurveHead = curve_head;
|
vm_pump.HeadDiff = head_diff;
|
vm_pump_list.Add(vm_pump);
|
}
|
}
|
}
|
|
if (!vm_pump_list.Any())
|
return false;
|
|
var analysis_facotr_list = new List<AnalysisFactor>();
|
var group_by_flag_hz = vm_pump_list.GroupBy(x => new { x.Flag, x.Hz0 });
|
foreach (var flag_item in group_by_flag_hz)
|
{
|
var hz = flag_item.Key.Hz0;
|
if (hz < 20)
|
{
|
continue;
|
}
|
var flag = flag_item.Key.Flag;
|
var pump = flag_pump_dict[flag];
|
var qh = flag_curve_dict[flag];
|
|
var head_diff_list = flag_item.Select(x => x.HeadDiff).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_pump_list.GroupBy(x => x.Flag);
|
foreach (var flag_item in group_by_flag)
|
{
|
var flag = flag_item.Key;
|
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.HeadDiff).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 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 > 3)
|
{
|
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);
|
}
|
|
private static double GetCurveHead(Model.CurveExpress curve_qh, double nr, double rpm, double flow)
|
{
|
if (curve_qh == null)
|
return default;
|
var similar_qh = Model.CurveCalcuHelper.CalculateSimilarQH(curve_qh, nr, rpm);
|
if (similar_qh == null)
|
return default;
|
var head = similar_qh.GetFitPointY(flow);
|
return head;
|
}
|
|
|
#endregion
|
|
|
}
|
}
|
