namespace Yw.WinFrmUI.Phart
|
{
|
/// <summary>
|
///
|
/// </summary>
|
public partial class PumpCoordinate
|
{
|
#region 计算显示参数方法
|
|
#region 默认
|
/// <summary>
|
/// 最大流量(显示参数)
|
/// </summary>
|
public double DispMaxQ()
|
{
|
return this.CoordMinQ + this.GridNumberX * this.CoordSpaceQ;
|
}
|
|
/// <summary>
|
/// 最小扬程(显示参数)
|
/// </summary>
|
public double DispMinH()
|
{
|
return this.CoordMinH + this.StartLineNoH * this.CoordSpaceH;
|
}
|
|
/// <summary>
|
/// 最大扬程(显示参数)
|
/// </summary>
|
public double DispMaxH()
|
{
|
return CoordMinH + this.EndLineNoH * this.CoordSpaceH;
|
}
|
|
/// <summary>
|
/// 最小效率(显示参数)
|
/// </summary>
|
public double DispMinE()
|
{
|
return this.CoordMinE + this.StartLineNoE * this.CoordSpaceE;
|
}
|
|
/// <summary>
|
/// 最大效率(显示参数)
|
/// </summary>
|
public double DispMaxE()
|
{
|
return this.CoordMinE + this.EndLineNoE * this.CoordSpaceE;
|
}
|
|
/// <summary>
|
/// 最小功率(显示参数)
|
/// </summary>
|
public double DispMinP()
|
{
|
return this.CoordMinP + this.StartLineNoP * this.CoordSpaceP;
|
}
|
|
/// <summary>
|
/// 最大功率(显示参数)
|
/// </summary>
|
public double DispMaxP()
|
{
|
return this.CoordMinP + this.EndLineNoP * this.CoordSpaceP;
|
}
|
|
#endregion
|
|
/// <summary>
|
/// 重置扬程坐标
|
/// </summary>
|
public void ResetCoordH(double space, double disMinH, double disMaxH)
|
{
|
this.CoordSpaceH = space;
|
this.EndLineNoH = this.GridNumberY;
|
this.StartLineNoH = this.EndLineNoH - (int)((disMaxH - disMinH) / this.CoordSpaceH);
|
this.CoordMinH = disMaxH - this.EndLineNoH * this.CoordSpaceH;
|
}
|
#endregion
|
|
#region 计算坐标
|
|
/// <summary>
|
/// 计算坐标
|
/// </summary>
|
/// <param name="QH">流量扬程线</param>
|
/// <param name="QE">流量效率线</param>
|
/// <param name="QP">流量功率线</param>
|
/// <returns></returns>
|
public static PumpCoordinate CalcCoordinate(List<Yw.Geometry.Point2d> QH, List<Yw.Geometry.Point2d> QE, List<Yw.Geometry.Point2d> QP)
|
{
|
if (QH == null)
|
return null;
|
double max_flow = 0.0;
|
double min_flow = 1000.0;
|
double max_head = 0.0;
|
double min_head = 1000.0;
|
double max_eff = 0.0;
|
double min_eff = 1000.0;
|
double max_power = 0.0;
|
double min_power = 1000.0;
|
|
if (QE == null && QP == null)
|
{
|
min_flow = QH.Min(x => x.X);
|
max_flow = QH.Max(x => x.X);
|
if (min_flow > max_flow)
|
{
|
return null;
|
}
|
min_head = QH.Min(x => x.Y);
|
max_head = QH.Max(x => x.Y);
|
if (min_head > max_head)
|
{
|
return null;
|
}
|
}
|
else
|
{
|
CalcMinMaxValue(QH, QE, QP, ref max_flow, ref min_flow, ref max_head, ref min_head, ref max_eff, ref min_eff, ref max_power, ref min_power);
|
}
|
|
var calc_corrd = CalcCoordinate(min_flow, max_flow, min_head, max_head, min_eff, max_eff, min_power, max_power);
|
|
#region 修正Y轴
|
|
var head_num_y = calc_corrd.EndLineNoH - calc_corrd.StartLineNoH;
|
var eff_num_y = calc_corrd.EndLineNoE - calc_corrd.StartLineNoE;
|
var power_num_y = calc_corrd.EndLineNoP - calc_corrd.StartLineNoP;
|
var sun_num_y = Math.Abs(head_num_y + eff_num_y + power_num_y);
|
if (sun_num_y < calc_corrd.GridNumberY)
|
{
|
calc_corrd.StartLineNoP = 1;
|
}
|
#endregion
|
|
return calc_corrd;
|
}
|
|
/// <summary>
|
/// 计算最大最小值
|
/// </summary>
|
/// <param name="QH">流量扬程线</param>
|
/// <param name="QE">流量效率线</param>
|
/// <param name="QP">流量功率线</param>
|
/// <param name="max_flow">最大流量</param>
|
/// <param name="min_flow">最小流量</param>
|
/// <param name="max_head">最大扬程</param>
|
/// <param name="min_head">最小扬程</param>
|
/// <param name="max_eff">最大效率</param>
|
/// <param name="min_eff">最小效率</param>
|
/// <param name="max_power">最大功率</param>
|
/// <param name="min_power">最小功率</param>
|
/// <returns></returns>
|
public static bool CalcMinMaxValue(List<Yw.Geometry.Point2d> QH, List<Yw.Geometry.Point2d> QE, List<Yw.Geometry.Point2d> QP, ref double max_flow, ref double min_flow, ref double max_head, ref double min_head, ref double max_eff, ref double min_eff, ref double max_power, ref double min_power)
|
{
|
max_flow = 0.0;
|
min_flow = 1000.0;
|
max_head = 0.0;
|
min_head = 1000.0;
|
max_eff = 0.0;
|
min_eff = 1000.0;
|
max_power = 0.0;
|
min_power = 1000.0;
|
if (QH == null)
|
{
|
return false;
|
}
|
min_flow = QH.Min(x => x.X);
|
max_flow = QH.Max(x => x.X);
|
if (min_flow > max_flow)
|
{
|
return false;
|
}
|
min_head = QH.Min(x => x.Y);
|
max_head = QH.Max(x => x.Y);
|
if (QE != null && QE.Count > 0)
|
{
|
min_eff = QE.Min(x => x.Y);
|
max_eff = QE.Max(x => x.Y);
|
}
|
if (QP != null && QP.Count > 0)
|
{
|
min_power = QP.Min(x => x.Y);
|
max_power = QP.Max(x => x.Y);
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 计算坐标
|
/// </summary>
|
/// <param name="min_flow">最小流量</param>
|
/// <param name="max_flow">最大流量</param>
|
/// <param name="min_head">最小扬程</param>
|
/// <param name="max_head">最大扬程</param>
|
/// <param name="min_eff">最小效率</param>
|
/// <param name="max_eff">最大效率</param>
|
/// <param name="min_power">最小功率</param>
|
/// <param name="max_power">最大功率</param>
|
/// <returns></returns>
|
public static PumpCoordinate CalcCoordinate(double min_flow, double max_flow, double min_head, double max_head, double min_eff, double max_eff, double min_power, double max_power)
|
{
|
if (min_flow > max_flow - 0.01)
|
return null;
|
|
if (min_head > max_head - 0.01)
|
return null;
|
|
var validGridNumH = 6;
|
var coordinate_paras = new PumpCoordinate();
|
coordinate_paras.GridNumberX = 10;//10
|
coordinate_paras.GridNumberY = 18;//18
|
CalcCoordinateQ(min_flow, max_flow, ref coordinate_paras, coordinate_paras.GridNumberX);
|
CalcCoordinateH(min_head, max_head, validGridNumH, ref coordinate_paras, out double disMinH, out double disMaxH);
|
|
if (max_power > min_power + 0.01)
|
CalcCoordinateP(min_power, max_power, disMaxH, 0, ref coordinate_paras);
|
|
if (max_eff > min_eff + 0.01)
|
CalcCoordinateE(min_eff, max_eff, ref coordinate_paras);
|
|
return coordinate_paras;
|
}
|
|
#endregion
|
|
#region 计算对应线坐标
|
|
/// <summary>
|
/// 计算流量坐标
|
/// </summary>
|
/// <param name="min_flow">最小流量</param>
|
/// <param name="max_flow">最大流量</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
/// <param name="validGridNum">有效刻度点</param>
|
/// <param name="default_num">放大系数</param>
|
public static void CalcCoordinateQ(double min_flow, double max_flow, ref PumpCoordinate coordinate_paras, int validGridNum = 10, double default_num = 1.0)
|
{
|
var coordSpaceQ = GetOptimalSpaceMin(min_flow / default_num, max_flow / default_num, validGridNum, out double disMinQ, out double disMaxQ) * default_num;
|
coordSpaceQ = Math.Max(0.5, coordSpaceQ / default_num) * default_num;
|
if (coordSpaceQ == 8.0)
|
coordSpaceQ = 10.0;
|
|
disMinQ *= default_num;
|
//disMaxQ *= default_num;
|
var gridNumberX = 0;
|
|
double min_q = disMinQ;
|
while (min_q < max_flow)
|
{
|
gridNumberX++;
|
min_q = disMinQ + gridNumberX * coordSpaceQ;
|
}
|
|
if (gridNumberX <= 5)
|
{
|
coordSpaceQ *= 0.5;
|
gridNumberX *= 2;
|
}
|
|
coordinate_paras.CoordSpaceQ = coordSpaceQ;
|
coordinate_paras.CoordMinQ = disMinQ;
|
coordinate_paras.GridNumberX = gridNumberX;
|
}
|
|
/// <summary>
|
/// 计算扬程坐标 含过滤 (Eventech: CalcCoordinateH2)
|
/// </summary>
|
/// <param name="min_head">最小扬程</param>
|
/// <param name="max_head">最大扬程</param>
|
/// <param name="validGridNumH">有效扬程刻度数</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
/// <param name="disMinH">最小显示扬程</param>
|
/// <param name="disMaxH">最大显示扬程</param>
|
public static void CalcCoordinateH_Filter(double min_head, double max_head, int validGridNumH, ref PumpCoordinate coordinate_paras, out double disMinH, out double disMaxH)
|
{
|
if (max_head < 1.0)
|
{
|
disMinH = 0.0;
|
disMaxH = 1.0;
|
coordinate_paras.ResetCoordH(0.1, disMinH, disMaxH);
|
}
|
else if (max_head < 2.0)
|
{
|
disMinH = 0.0;
|
disMaxH = 2.0;
|
coordinate_paras.ResetCoordH(0.2, disMinH, disMaxH);
|
}
|
else if (max_head < 5.0)
|
{
|
disMinH = 0.0;
|
disMaxH = 5.0;
|
coordinate_paras.ResetCoordH(0.5, disMinH, disMaxH);
|
}
|
else if (max_head < 10.0)
|
{
|
disMinH = 0.0;
|
disMaxH = 10.0;
|
coordinate_paras.ResetCoordH(1.0, disMinH, disMaxH);
|
}
|
else if (max_head < 12.0)
|
{
|
coordinate_paras.CoordSpaceH = 1.0;
|
disMinH = 0.0;
|
disMaxH = 12.0;
|
coordinate_paras.ResetCoordH(1.0, disMinH, disMaxH);
|
}
|
else if (max_head < 15.0)
|
{
|
coordinate_paras.CoordSpaceH = 2.0;
|
disMinH = 0.0;
|
disMaxH = 16.0;
|
coordinate_paras.ResetCoordH(2.0, disMinH, disMaxH);
|
}
|
else if (max_head < 20.0)
|
{
|
coordinate_paras.CoordSpaceH = 2.0;
|
disMinH = 0.0;
|
disMaxH = 20.0;
|
coordinate_paras.ResetCoordH(2.0, disMinH, disMaxH);
|
}
|
else
|
{
|
CalcCoordinateH(min_head, max_head, validGridNumH, ref coordinate_paras, out disMinH, out disMaxH);
|
}
|
}
|
|
/// <summary>
|
/// 计算扬程坐标
|
/// </summary>
|
/// <param name="min_head">最小扬程</param>
|
/// <param name="max_head">最大扬程</param>
|
/// <param name="validGridNumH">有效扬程刻度数</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
/// <param name="disMinH">最小显示扬程</param>
|
/// <param name="disMaxH">最大显示扬程</param>
|
public static void CalcCoordinateH(double min_head, double max_head, int validGridNumH, ref PumpCoordinate coordinate_paras, out double disMinH, out double disMaxH)
|
{
|
var coordSpaceH = GetOptimalSpaceMax(min_head, max_head, validGridNumH, out disMinH, out disMaxH);
|
int endLineNoH = coordinate_paras.GridNumberY;
|
int stratLineNoH = endLineNoH;
|
|
double max_h = disMaxH;//判断条件
|
while (max_h > min_head * 0.98)
|
{
|
max_h -= coordSpaceH;
|
if (max_h < 0.0)
|
break;
|
stratLineNoH--;
|
}
|
|
coordinate_paras.CoordSpaceH = coordSpaceH;
|
coordinate_paras.EndLineNoH = endLineNoH;
|
coordinate_paras.StartLineNoH = stratLineNoH;
|
coordinate_paras.CoordMinH = disMaxH - endLineNoH * coordSpaceH;
|
}
|
|
/// <summary>
|
/// 计算功率坐标
|
/// </summary>
|
/// <param name="min_power">最小功率</param>
|
/// <param name="max_power">最大功率</param>
|
/// <param name="disMaxH">最大显示扬程</param>
|
/// <param name="downGridNum">最低点刻度</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
public static void CalcCoordinateP(double min_power, double max_power, double disMaxH, int downGridNum, ref PumpCoordinate coordinate_paras)
|
{
|
int default_num = 7;
|
int spaceNum = coordinate_paras.StartLineNoH - default_num - downGridNum;
|
if (spaceNum < 3)
|
spaceNum = 3;
|
|
var coordSpaceP = GetOptimalSpaceMax(min_power, max_power, spaceNum, out double disMinP, out double disMaxP);
|
int endLineNoP = coordinate_paras.StartLineNoH - default_num;
|
int stratLineNoP = endLineNoP;
|
|
double max_p = disMaxP;
|
//while (max_p > min_power * 0.98)
|
while (max_p > min_power)
|
{
|
max_p -= coordSpaceP;
|
if (max_p < 0.0)
|
break;
|
stratLineNoP--;
|
}
|
|
coordinate_paras.CoordSpaceP = coordSpaceP;
|
coordinate_paras.EndLineNoP = endLineNoP;
|
coordinate_paras.StartLineNoP = stratLineNoP;
|
|
//如果开始刻度低于最低点刻度 都往上加差值
|
if (coordinate_paras.StartLineNoP < downGridNum)
|
{
|
int diff_num = downGridNum - coordinate_paras.StartLineNoP;
|
coordinate_paras.EndLineNoP += diff_num;
|
coordinate_paras.StartLineNoP += diff_num;
|
}
|
|
|
coordinate_paras.CoordMinH = GetByPlacesLength(disMaxH - coordinate_paras.EndLineNoH * coordinate_paras.CoordSpaceH, 3);
|
coordinate_paras.CoordMinP = GetByPlacesLength(disMaxP - coordinate_paras.EndLineNoP * coordinate_paras.CoordSpaceP, 3);
|
}
|
|
/// <summary>
|
/// 计算效率坐标
|
/// </summary>
|
/// <param name="min_eff">最小效率</param>
|
/// <param name="max_eff">最大效率</param>
|
/// <param name="coordinate_paras">坐标Model</param>
|
public static void CalcCoordinateE(double min_eff, double max_eff, ref PumpCoordinate coordinate_paras)
|
{
|
int startLineNoE = coordinate_paras.StartLineNoH - 6;
|
if (max_eff <= 40.0)
|
{
|
coordinate_paras.StartLineNoE = startLineNoE;
|
coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 6;
|
coordinate_paras.CoordSpaceE = 5.0;
|
}
|
else if (max_eff <= 50.0)
|
{
|
coordinate_paras.StartLineNoE = startLineNoE - 5;
|
coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 10;
|
coordinate_paras.CoordSpaceE = 5.0;
|
}
|
else if (max_eff <= 60)
|
{
|
coordinate_paras.StartLineNoE = startLineNoE;
|
coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 6;
|
coordinate_paras.CoordSpaceE = 10.0;
|
}
|
else
|
{
|
coordinate_paras.StartLineNoE = startLineNoE ;
|
coordinate_paras.EndLineNoE = coordinate_paras.StartLineNoE + 5;
|
coordinate_paras.CoordSpaceE = 20.0;
|
}
|
coordinate_paras.CoordMinE = (-coordinate_paras.StartLineNoE) * coordinate_paras.CoordSpaceE;
|
}
|
|
#endregion
|
|
#region Space 间隔
|
/// <summary>
|
/// 获取最小的间隔
|
/// </summary>
|
/// <param name="minValue">最小值</param>
|
/// <param name="maxValue">最大值</param>
|
/// <param name="spaceNum">间隔数量</param>
|
/// <param name="minDisplay">最小显示参数</param>
|
/// <param name="maxDisplay">最大显示参数</param>
|
/// <returns></returns>
|
public static double GetOptimalSpaceMin(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
|
{
|
minDisplay = minValue;
|
maxDisplay = maxValue;
|
double num = maxValue - minValue;
|
if (num < 0.0 || spaceNum < 1)
|
{
|
return (maxValue - minValue) / 10.0;
|
}
|
|
double optimalSpace = GetOptimalSpace((maxValue - minValue) / spaceNum);
|
if (optimalSpace < 2.0)
|
{
|
minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
|
maxDisplay = minDisplay + spaceNum * optimalSpace;
|
}
|
else
|
{
|
minDisplay = Math.Floor(minValue / optimalSpace) * optimalSpace;
|
maxDisplay = minDisplay + spaceNum * optimalSpace;
|
}
|
|
return optimalSpace;
|
}
|
|
/// <summary>
|
/// 获取最大的间隔
|
/// </summary>
|
/// <param name="minValue">最小值</param>
|
/// <param name="maxValue">最大值</param>
|
/// <param name="spaceNum">间隔数量</param>
|
/// <param name="minDisplay">最小显示参数</param>
|
/// <param name="maxDisplay">最大显示参数</param>
|
/// <returns></returns>
|
public static double GetOptimalSpaceMax(double minValue, double maxValue, int spaceNum, out double minDisplay, out double maxDisplay)
|
{
|
minDisplay = minValue;
|
maxDisplay = maxValue;
|
double num = maxValue - minValue;
|
|
if (maxValue > 20)
|
{
|
if (num < 0.0 || spaceNum < 1)
|
{
|
return (maxValue - minValue) / 5.0;
|
}
|
}
|
else
|
{
|
if (num < 0.0 || spaceNum < 1)
|
{
|
return (maxValue - minValue) / 10.0;
|
}
|
}
|
|
double optimalSpace = GetOptimalSpace((maxValue - minValue) / spaceNum, true);
|
maxDisplay = Math.Ceiling(maxValue / optimalSpace) * optimalSpace;
|
minDisplay = maxDisplay - spaceNum * optimalSpace;
|
|
if (minDisplay > minValue)
|
{
|
var diff = minDisplay - minValue;
|
if (diff < optimalSpace)
|
{
|
minDisplay -= optimalSpace;
|
}
|
|
}
|
|
return optimalSpace;
|
}
|
|
/// <summary>
|
/// 获取最佳间隔 (精细取整)
|
/// </summary>
|
/// <param name="refSpace"> 间隔</param>
|
/// <returns></returns>
|
public static double GetOptimalSpace(double refSpace, bool IsAccurate = false)
|
{
|
if (refSpace < 1E-06)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 0.01)
|
{
|
double refSpace2 = refSpace * 100.0;
|
return GetOptimalSpace(refSpace2) / 100.0;
|
}
|
|
if (refSpace < 0.1)
|
{
|
double refSpace3 = refSpace * 10.0;
|
return GetOptimalSpace(refSpace3) / 10.0;
|
}
|
|
if (IsAccurate)
|
{
|
if (refSpace < 11.0)
|
{
|
if (refSpace < 1.35)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 2.2)
|
{
|
return 2.0;
|
}
|
|
if (refSpace < 5.5)
|
{
|
return 5.0;
|
}
|
|
if (refSpace < 8.5)
|
{
|
return 8.0;
|
}
|
|
return 10.0;
|
}
|
}
|
|
if (refSpace < 1.0)
|
{
|
if (refSpace < 0.15)
|
{
|
return 0.1;
|
}
|
|
if (refSpace < 0.22)
|
{
|
return 0.2;
|
}
|
|
if (refSpace < 0.6)
|
{
|
return 0.5;
|
}
|
|
return 1.0;
|
}
|
|
if (refSpace < 1.2)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 3.0)
|
{
|
if (refSpace < 1.2)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 2.3)
|
{
|
return 2.0;
|
}
|
|
return 3.0;
|
}
|
|
if (refSpace < 11.0)
|
{
|
if (refSpace < 1.35)
|
{
|
return 1.0;
|
}
|
|
if (refSpace < 2.2)
|
{
|
return 2.0;
|
}
|
|
if (refSpace < 5.5)
|
{
|
return 5.0;
|
}
|
|
if (refSpace < 8.5)
|
{
|
return 8.0;
|
}
|
|
return 10.0;
|
}
|
|
if (refSpace < 16.0)
|
{
|
return 15.0;
|
}
|
|
if (refSpace < 22.0)
|
{
|
return 20.0;
|
}
|
|
if (refSpace < 35.0)
|
{
|
return 25.0;
|
}
|
|
if (refSpace < 41.0)
|
{
|
return 40.0;
|
}
|
|
if (refSpace < 51.0)
|
{
|
return 50.0;
|
}
|
|
if (refSpace < 61.0)
|
{
|
return 60.0;
|
}
|
|
if (refSpace < 71.0)
|
{
|
return 70.0;
|
}
|
|
if (refSpace < 78.0)
|
{
|
return 75.0;
|
}
|
|
if (refSpace < 150.0)
|
{
|
return 100.0;
|
}
|
|
if (refSpace < 230.0)
|
{
|
return 200.0;
|
}
|
|
if (refSpace < 270.0)
|
{
|
return 250.0;
|
}
|
|
if (refSpace < 1500.0)
|
{
|
int num = (int)(refSpace / 100.0);
|
return num * 100;
|
}
|
|
int num2 = (int)(refSpace / 1000.0);
|
return num2 * 1000;
|
}
|
|
#endregion
|
|
#region 数字辅助方法
|
|
/// <summary>
|
/// 按指定长度获取
|
/// </summary>
|
public static double GetByPlacesLength(double value, int length)
|
{
|
int decimalPlacesLength = GetDecimalPlacesLength(value);
|
if (decimalPlacesLength > length)
|
{
|
return Math.Round(value, length);
|
}
|
return value;
|
}
|
|
/// <summary>
|
/// 获取小数点长度
|
/// </summary>
|
private static int GetDecimalPlacesLength(double value)
|
{
|
string text = value.ToString();
|
int num = text.IndexOf('.');
|
if (num >= 0)
|
{
|
return text.Length - num - 1;
|
}
|
return 0;
|
}
|
#endregion
|
|
}
|
}
|
