using NPOI.Util;
|
using Yw.Geometry;
|
|
namespace Yw.WinFrmUI.Phart
|
{
|
/// <summary>
|
/// 性能计算辅助类
|
/// </summary>
|
public static class PumpCalcHelper
|
{
|
#region 常规计算
|
|
#region 计算扬程
|
|
/// <summary>
|
/// 计算扬程
|
/// </summary>
|
/// <param name="q">瞬时流量 m³/h</param>
|
/// <param name="pr1">进口压力 mpa</param>
|
/// <param name="pr2">出口压力 mpa</param>
|
/// <param name="d1">进口口径 mm</param>
|
/// <param name="d2">出口口径 mm</param>
|
/// <param name="z1">进口标高 m</param>
|
/// <param name="z2">出口标高 m</param>
|
/// <returns>扬程 m</returns>
|
public static double CalculateH(double q, double pr1, double pr2, double d1, double d2, double z1, double z2)
|
{
|
var qa = q / 3600;
|
var pr1a = pr1 * 1000000;
|
var pr2a = pr2 * 1000000;
|
var d1a = d1 / 1000;
|
var d2a = d2 / 1000;
|
var v1 = qa * 4 / (Math.PI * Math.Pow(d1a, 2));
|
var v2 = qa * 4 / (Math.PI * Math.Pow(d2a, 2));
|
var distance = z2 - z1;
|
var pg = Constant.WaterDensity * Constant.g;
|
var g2 = 2 * Constant.g;
|
|
var h = (pr2a / pg - pr1a / pg) + (Math.Pow(v2, 2) / g2 - Math.Pow(v1, 2) / g2) + distance;
|
return h;
|
}
|
|
|
/// <summary>
|
/// 计算 OtherPress (测量扬程= 压差 + 表位差 + 流速)
|
/// </summary>
|
/// <param name="q">流量 m³/h </param>
|
/// <param name="inletPipeDia">进口管径 mm </param>
|
/// <param name="outletPipeDia">出口管径 mm </param>
|
/// <param name="inletElevation">进口标高 mm </param>
|
/// <param name="outletElevation">出口标高 mm </param>
|
/// <returns></returns>
|
public static double CalculateOtherPress(double? q, double? inletPipeDia, double? outletPipeDia, double? inletElevation, double? outletElevation)
|
{
|
if (q == null || q.Value < 0.05)
|
{
|
if (outletElevation == null || inletElevation == null)
|
return 0;
|
return outletElevation.Value - inletElevation.Value;
|
}
|
|
double flow = q.Value;
|
double inPipeV = 0;
|
if (inletPipeDia != null && inletPipeDia.Value > 0.1)
|
{
|
// 流速计算 pipeD =mm,pumpFlow=m3/p
|
inPipeV = Constant.OtherPressCoeff * flow / inletPipeDia.Value / inletPipeDia.Value;
|
}
|
|
double outPipeV = 0;
|
if (outletPipeDia != null && outletPipeDia.Value > 0.1)
|
{
|
// 流速计算 rPipeD =mm,rPumpFlow=m3/p
|
outPipeV = Constant.OtherPressCoeff * flow / outletPipeDia.Value / outletPipeDia.Value;
|
}
|
|
double differV = (outPipeV * outPipeV - inPipeV * inPipeV) / Constant.g / 2.0;
|
|
if (outletElevation == null || inletElevation == null)
|
return differV;
|
|
return differV + outletElevation.Value - inletElevation.Value;
|
}
|
|
#endregion
|
|
#region 计算效率
|
|
/// <summary>
|
/// 计算效率
|
/// </summary>
|
/// <param name="q"> 瞬时流量 m³/h</param>
|
/// <param name="h"> 扬程 m</param>
|
/// <param name="p"> 功率 kw</param>
|
/// <param name="ρ"> 密度 kg/m^3</param>
|
/// <param name="g"> 重力加速度 m/s^2</param>
|
/// <returns>百分数</returns>
|
public static double CalculateE(double q, double h, double p, double ρ, double g)
|
{
|
var qa = q / 3600;
|
var pa = p * 1000;
|
double e = 0;
|
if (pa < 0.1)
|
{
|
return e;
|
}
|
e = ρ * g * qa * h / pa;
|
return Math.Round(e * 100, 2);
|
}
|
|
/// <summary>
|
/// 计算效率
|
/// </summary>
|
/// <param name="q"> 瞬时流量 m³/h</param>
|
/// <param name="h"> 扬程 m</param>
|
/// <param name="p"> 功率 kw</param>
|
/// <returns>百分数</returns>
|
public static double CalculateE(double q, double h, double p)
|
{
|
return CalculateE(q, h, p, Constant.WaterDensity, Constant.g);
|
}
|
|
/// <summary>
|
/// 计算效率
|
/// </summary>
|
/// <param name="q"> 瞬时流量 m³/h</param>
|
/// <param name="h"> 扬程 m</param>
|
/// <param name="p"> 功率 kw</param>
|
/// <param name="ρ"> 密度 kg/m^3</param>
|
/// <returns>百分数</returns>
|
public static double CalculateE(double q, double h, double p, double ρ)
|
{
|
return CalculateE(q, h, p, ρ, Constant.g);
|
}
|
|
#endregion
|
|
#region 计算功率
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="q">瞬时流量 m³/h</param>
|
/// <param name="h">扬程 m</param>
|
/// <param name="e">效率 百分数</param>
|
/// <param name="ρ">密度kg/m³</param>
|
/// <param name="g">重力加速度 m/s²</param>
|
/// <returns>kw</returns>
|
public static double CalculateP(double q, double h, double e, double ρ, double g)
|
{
|
var qa = q / 3600;
|
var ea = e / 100;
|
double p = 0;
|
if (ea < 0.01)
|
{
|
return p;
|
}
|
p = ρ * g * qa * h / ea;
|
p = p / 1000;//换算成kw
|
if (p < 2)
|
{
|
return Math.Round(p, 4);
|
}
|
if (p < 30)
|
{
|
return Math.Round(p, 3);
|
}
|
if (p < 100)
|
{
|
return Math.Round(p, 2);
|
}
|
return Math.Round(p, 1);
|
|
}
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="q">瞬时流量 m³/h</param>
|
/// <param name="h">扬程 m</param>
|
/// <param name="e">效率 百分数</param>
|
/// <param name="ρ">密度kg/m³</param>
|
/// <returns>kw</returns>
|
public static double CalculateP(double q, double h, double e, double ρ)
|
{
|
return CalculateP(q, h, e, ρ, Constant.g);
|
}
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="q">瞬时流量 m³/h</param>
|
/// <param name="h">扬程 m</param>
|
/// <param name="e">效率 百分数</param>
|
/// <returns>kw</returns>
|
public static double CalculateP(double q, double h, double e)
|
{
|
return CalculateP(q, h, e, Constant.WaterDensity, Constant.g);
|
}
|
|
#endregion
|
|
#region Mpa<=>m
|
|
/// <summary>
|
/// Mpa=>m
|
/// </summary>
|
public static double Mpa2M(double mpa)
|
{
|
return mpa * Constant.WaterDensity / Constant.g;
|
}
|
|
/// <summary>
|
/// m=>Mpa
|
/// </summary>
|
public static double M2Mpa(double m)
|
{
|
return m * Constant.g / Constant.WaterDensity;
|
}
|
|
|
#endregion
|
|
#region 计算用电量
|
|
/// <summary>
|
/// 计算用电量
|
/// </summary>
|
/// <param name="p">功率kw</param>
|
/// <param name="t">时间h</param>
|
/// <returns>kw*h</returns>
|
public static double CalculateD(double p, double t)
|
{
|
return p * t;
|
}
|
|
#endregion
|
|
#region 计算累积流量
|
|
/// <summary>
|
/// 计算累积流量
|
/// </summary>
|
/// <param name="q">瞬时流量m³/h</param>
|
/// <param name="t">时间h</param>
|
/// <returns>m³</returns>
|
public static double CalculateQt(double q, double t)
|
{
|
return q * t;
|
}
|
|
#endregion
|
|
#region 计算能耗
|
|
/// <summary>
|
/// 计算千吨能耗
|
/// </summary>
|
/// <param name="p">功率kW</param>
|
/// <param name="q">瞬时流量m³/h</param>
|
/// <returns>kW·h/km³</returns>
|
public static double CalculateWP(double p, double q)
|
{
|
if (q < 0.1)
|
{
|
return default;
|
}
|
return p / q * 1000;
|
}
|
|
/// <summary>
|
/// 计算单位能耗
|
/// </summary>
|
/// <param name="p">功率kW</param>
|
/// <param name="q">瞬时流量m³/h</param>
|
/// <param name="h">扬程m</param>
|
/// <returns>kW·h/km³</returns>
|
public static double CalculateUWP(double p, double q, double h)
|
{
|
if (q < 0.1)
|
{
|
return default;
|
}
|
if (h < 0.1)
|
{
|
return default;
|
}
|
return p / q / h * 1000;
|
}
|
|
#endregion
|
|
#region 频率换算
|
|
/// <summary>
|
/// 根据频率计算流量
|
/// </summary>
|
/// <param name="q">瞬时流量 m³/h</param>
|
/// <param name="hz">频率</param>
|
/// <param name="hzr">额定频率</param>
|
/// <returns></returns>
|
public static double CalculateQByHz(double q, double hz, double hzr = 50)
|
{
|
if (hzr < 0.1)
|
{
|
return q;
|
}
|
if (hz < 0.1)
|
{
|
return q;
|
}
|
/* if (hz > hzr)
|
{
|
return q;
|
}*/
|
double f_ratio = hzr / hz;
|
|
return q * f_ratio;
|
}
|
|
/// <summary>
|
/// 根据频率计算扬程
|
/// </summary>
|
/// <param name="h">扬程 m</param>
|
/// <param name="hz">频率 </param>
|
/// <param name="hzr">额定频率</param>
|
/// <returns></returns>
|
public static double CalculateHByHz(double h, double hz, double hzr = 50)
|
{
|
if (hzr < 0.1)
|
{
|
return h;
|
}
|
if (hz < 0.1)
|
{
|
return h;
|
}
|
/* if (hz > hzr)
|
{
|
return h;
|
}*/
|
double f_ratio = hzr / hz;
|
return h * f_ratio * f_ratio;
|
}
|
|
/// <summary>
|
/// 根据频率计算 50hz功率
|
/// </summary>
|
/// <param name="p">功率 kw</param>
|
/// <param name="hz">频率 kw</param>
|
/// <param name="hzr">额定频率</param>
|
/// <returns></returns>
|
public static double CalculatePByHz(double p, double hz, double hzr = 50)
|
{
|
if (hzr < 0.1)
|
{
|
return p;
|
}
|
if (hz < 0.1)
|
{
|
return p;
|
}
|
/* if (hz > hzr)
|
{
|
return p;
|
}*/
|
double f_ratio = hzr / hz;
|
return p * f_ratio * f_ratio * f_ratio;
|
}
|
|
/// <summary>
|
/// 根据转速计算流量
|
/// </summary>
|
/// <param name="q">瞬时流量 m³/h</param>
|
/// <param name="n">转速 r/min</param>
|
/// <param name="nr">额定转速 r/min</param>
|
/// <returns></returns>
|
public static double CalculateQByN(double q, double n, double nr)
|
{
|
if (nr < 0.1)
|
{
|
return q;
|
}
|
if (n < 0.1)
|
{
|
return q;
|
}
|
double f_ratio = nr / n;
|
|
return q * f_ratio;
|
}
|
|
/// <summary>
|
/// 根据转速计算扬程
|
/// </summary>
|
/// <param name="h">扬程 m</param>
|
/// <param name="n">转速 r/min</param>
|
/// <param name="nr">额定转速 r/min</param>
|
/// <returns></returns>
|
public static double CalculateHByN(double h, double n, double nr)
|
{
|
if (nr < 0.1)
|
{
|
return h;
|
}
|
if (n < 0.1)
|
{
|
return h;
|
}
|
double f_ratio = nr / n;
|
|
return h * f_ratio * f_ratio;
|
}
|
|
/// <summary>
|
/// 根据转速计算功率
|
/// </summary>
|
/// <param name="p">功率 kw</param>
|
/// <param name="n">转速 r/min</param>
|
/// <param name="nr">额定转速 r/min</param>
|
/// <returns></returns>
|
public static double CalculatePByN(double p, double n, double nr)
|
{
|
if (nr < 0.1)
|
{
|
return p;
|
}
|
if (n < 0.1)
|
{
|
return p;
|
}
|
double f_ratio = nr / n;
|
|
return p * f_ratio * f_ratio * f_ratio;
|
}
|
|
#endregion
|
|
|
#endregion
|
|
#region 复杂计算
|
|
#region Simu
|
|
/// <summary>
|
/// 知道原始速度,以及原始的杨程H以及对应的变速后的杨程,求变速后的速度
|
/// </summary>
|
/// <param name="origin_"></param>
|
/// <param name="origin_h"></param>
|
/// <param name="change_h"></param>
|
/// <returns></returns>
|
public static double CalculateSimuByH(double origin_, double origin_h, double change_h)
|
{
|
double ratio = Math.Pow(origin_h / change_h, 1.0 / 2.0);
|
return origin_ / ratio;
|
}
|
|
/// <summary>
|
/// 知道原始速度,以及原始的流量Q以及对应的变速后的杨程,求变速后的速度
|
/// </summary>
|
/// <param name="origin_"></param>
|
/// <param name="origin_q"></param>
|
/// <param name="change_q"></param>
|
/// <returns></returns>
|
public static double CalculateSimuByQ(double origin_, double origin_q, double change_q)
|
{
|
double ratio = origin_q / change_q;
|
return origin_ / ratio;
|
}
|
#endregion
|
|
#region 相似换算
|
|
/// <summary>
|
/// 计算相似流量扬程曲线
|
/// </summary>
|
/// <param name="cubic_spline">三次样条曲线</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <param name="point_count">拟合点数量</param>
|
/// <returns></returns>
|
public static Yw.Geometry.CubicSpline2d CalculateSimilarQH(Yw.Geometry.CubicSpline2d cubic_spline, double origin_hz, double change_hz, int point_count = 12)
|
{
|
if (cubic_spline == null)
|
return null;
|
if (change_hz < 1)
|
return null;
|
|
var fit_points = cubic_spline.GetPointList(point_count);
|
var ratio = change_hz / origin_hz;
|
var similar_pt_list = new List<Yw.Geometry.Point2d>();
|
foreach (Yw.Geometry.Point2d fit_point in fit_points)
|
{
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y * ratio * ratio;
|
similar_pt_list.Add(similar_point);
|
}
|
|
return new Yw.Geometry.CubicSpline2d(similar_pt_list);
|
}
|
|
/// <summary>
|
/// 计算相似流量功率曲线
|
/// </summary>
|
/// <param name="cubic_spline">三次样条曲线</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <param name="point_count">拟合点数量</param>
|
/// <returns></returns>
|
public static Yw.Geometry.CubicSpline2d CalculateSimilarQP(Yw.Geometry.CubicSpline2d cubic_spline, double origin_hz, double change_hz, int point_count = 12)
|
{
|
if (cubic_spline == null)
|
return null;
|
if (change_hz < 1)
|
return null;
|
|
var fit_points = cubic_spline.GetPointList(point_count);
|
var ratio = change_hz / origin_hz;
|
var similar_pt_list = new List<Yw.Geometry.Point2d>();
|
foreach (Yw.Geometry.Point2d fit_point in fit_points)
|
{
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y * ratio * ratio * ratio;
|
similar_pt_list.Add(similar_point);
|
}
|
|
return new Yw.Geometry.CubicSpline2d(similar_pt_list);
|
}
|
|
/// <summary>
|
/// 计算相似流量效率曲线
|
/// </summary>
|
/// <param name="cubic_spline">三次样条曲线</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <param name="point_count">拟合点数量</param>
|
/// <returns></returns>
|
public static Yw.Geometry.CubicSpline2d CalculateSimilarQE(Yw.Geometry.CubicSpline2d cubic_spline, double origin_hz, double change_hz, int point_count = 12)
|
{
|
if (cubic_spline == null)
|
return null;
|
if (change_hz < 1)
|
return null;
|
|
var fit_points = cubic_spline.GetPointList(point_count);
|
var ratio = change_hz / origin_hz;
|
var similar_pt_list = new List<Yw.Geometry.Point2d>();
|
foreach (Yw.Geometry.Point2d fit_point in fit_points)
|
{
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y;
|
similar_pt_list.Add(similar_point);
|
}
|
return new Yw.Geometry.CubicSpline2d(similar_pt_list);
|
}
|
|
/// <summary>
|
/// 计算相似流量扬程曲线点
|
/// </summary>
|
/// <param name="fit_points">曲线点</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <param name="point_count">拟合点数量</param>
|
/// <returns></returns>
|
public static List<Yw.Geometry.Point2d> CalculateSimilarQH(List<Yw.Geometry.Point2d> fit_points, double origin_hz, double change_hz)
|
{
|
if (fit_points == null || !fit_points.Any())
|
return null;
|
if (change_hz < 1)
|
return null;
|
|
var ratio = change_hz / origin_hz;
|
var similar_pt_list = new List<Yw.Geometry.Point2d>();
|
foreach (Yw.Geometry.Point2d fit_point in fit_points)
|
{
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y * ratio * ratio;
|
similar_pt_list.Add(similar_point);
|
}
|
return similar_pt_list;
|
}
|
|
/// <summary>
|
/// 计算相似流量功率曲线点
|
/// </summary>
|
/// <param name="fit_points">曲线点</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <param name="point_count">拟合点数量</param>
|
/// <returns></returns>
|
public static List<Yw.Geometry.Point2d> CalculateSimilarQP(List<Yw.Geometry.Point2d> fit_points, double origin_hz, double change_hz)
|
{
|
if (fit_points == null || !fit_points.Any())
|
return null;
|
if (change_hz < 1)
|
return null;
|
|
var ratio = change_hz / origin_hz;
|
var similar_pt_list = new List<Yw.Geometry.Point2d>();
|
foreach (Yw.Geometry.Point2d fit_point in fit_points)
|
{
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y * ratio * ratio * ratio;
|
similar_pt_list.Add(similar_point);
|
}
|
return similar_pt_list;
|
}
|
|
/// <summary>
|
/// 计算相似流量效率曲线点
|
/// </summary>
|
/// <param name="fit_points">曲线点</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <param name="point_count">拟合点数量</param>
|
/// <returns></returns>
|
public static List<Yw.Geometry.Point2d> CalculateSimilarQE(List<Yw.Geometry.Point2d> fit_points, double origin_hz, double change_hz)
|
{
|
if (fit_points == null || !fit_points.Any())
|
return null;
|
if (change_hz < 1)
|
return null;
|
|
var ratio = change_hz / origin_hz;
|
var similar_pt_list = new List<Yw.Geometry.Point2d>();
|
foreach (Yw.Geometry.Point2d fit_point in fit_points)
|
{
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y;
|
similar_pt_list.Add(similar_point);
|
}
|
return similar_pt_list;
|
}
|
|
|
/// <summary>
|
/// 计算相似流量扬程点
|
/// </summary>
|
/// <param name="fit_point">点</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <returns></returns>
|
public static Yw.Geometry.Point2d CalculateSimilarQH(Yw.Geometry.Point2d fit_point, double origin_hz, double change_hz)
|
{
|
if (fit_point == null)
|
return null;
|
if (change_hz < 1)
|
return null;
|
var ratio = change_hz / origin_hz;
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y * ratio * ratio;
|
return similar_point;
|
}
|
|
/// <summary>
|
/// 计算相似流量功率点
|
/// </summary>
|
/// <param name="fit_point">点</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <returns></returns>
|
public static Yw.Geometry.Point2d CalculateSimilarQP(Yw.Geometry.Point2d fit_point, double origin_hz, double change_hz)
|
{
|
if (fit_point == null)
|
return null;
|
if (change_hz < 1)
|
return null;
|
var ratio = change_hz / origin_hz;
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y * ratio * ratio * ratio;
|
return similar_point;
|
}
|
|
/// <summary>
|
/// 计算相似流量效率点
|
/// </summary>
|
/// <param name="fit_point">点</param>
|
/// <param name="origin_hz">原始频率</param>
|
/// <param name="change_hz">换算频率</param>
|
/// <returns></returns>
|
public static Yw.Geometry.Point2d CalculateSimilarQE(Yw.Geometry.Point2d fit_point, double origin_hz, double change_hz)
|
{
|
if (fit_point == null)
|
return null;
|
if (change_hz < 1)
|
return null;
|
var ratio = change_hz / origin_hz;
|
var similar_point = new Yw.Geometry.Point2d();
|
similar_point.X = fit_point.X * ratio;
|
similar_point.Y = fit_point.Y;
|
|
return similar_point;
|
}
|
|
|
#endregion
|
|
#region 计算推荐参数
|
|
public enum eCalculatePumpType
|
{
|
单级单吸离心泵 = 1,
|
多级离心泵 = 2,
|
双吸离心泵 = 3,
|
化工泵 = 4,
|
渣浆泵 = 5,
|
长轴泵 = 6
|
}
|
|
//capacity
|
static double[] effq = new double[33] { 5, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 100, 150, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1500, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 };
|
//1 single stage seriesEntity eff
|
static double[] singleeff = new double[33] { 58.0, 64.0, 67.2, 69.4, 70.9, 72.0, 73.8, 74.9, 75.8, 76.5, 77.0, 77.6, 78.0, 79.8, 80.8, 82.0, 83.0, 83.7, 84.2, 84.7, 85.0, 85.3, 85.7, 86.6, 87.2, 88.0, 88.6, 89.0, 89.2, 89.5, 89.7, 89.9, 90.0 };
|
//2 multi stage seriesEntity eff
|
static double[] multieff = new double[26] { 55.4, 59.4, 61.8, 63.5, 64.8, 65.9, 67.5, 68.9, 69.9, 70.9, 71.5, 72.3, 72.9, 75.3, 76.9, 79.2, 80.6, 81.5, 82.2, 82.8, 83.1, 83.5, 83.9, 84.8, 85.1, 85.5 };
|
//1 correct eff
|
static double[] effcorrect1 = new double[19] { 32, 25.5, 20.6, 17.3, 14.7, 12.5, 10.5, 9.0, 7.5, 6.0, 5.0, 4.0, 3.2, 2.5, 2.0, 1.5, 1.0, 0.5, 0 };
|
//2 correct eff
|
static double[] effcorrect2 = new double[10] { 0, 0.3, 0.7, 1.0, 1.3, 1.7, 1.9, 2.2, 2.7, 3.0 };
|
static double[] effns1 = new double[19] { 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 110, 120 };
|
static double[] effns2 = new double[10] { 210, 220, 230, 240, 250, 260, 270, 280, 290, 300 };
|
|
|
/// <summary>
|
/// 根据泵类型计算推荐效率
|
/// </summary>
|
/// <param name="q">流量</param>
|
/// <param name="h">扬程</param>
|
/// <param name="n">转速</param>
|
/// <param name="pumpType">泵类型<see cref="eCalculatePumpType" /></param>
|
/// <returns></returns>
|
public static double CalculateEByPumpType(double q, double h, double n, int pumpType)
|
{
|
double ns = CalculateNs(q, h, n);
|
|
double eff, qjs1, qjs2, qjs3, effjs1, effjs2, effjs3, correct = 1;
|
int i = 0;
|
double dltE = 0.0;
|
|
double q0 = q;
|
double h0 = h;
|
|
//
|
double t = 1000;
|
if (pumpType == (int)eCalculatePumpType.单级单吸离心泵)
|
t = 10000;
|
if (pumpType == (int)eCalculatePumpType.多级离心泵)
|
t = 300000;
|
if (pumpType == (int)eCalculatePumpType.双吸离心泵)
|
t = 10000;
|
if (pumpType == (int)eCalculatePumpType.化工泵)
|
t = 10000;
|
if (pumpType == (int)eCalculatePumpType.渣浆泵)
|
t = 10000;
|
if (pumpType == (int)eCalculatePumpType.长轴泵)
|
t = 10000;
|
if (q0 > t)
|
{
|
i = effq.Length - 1;
|
}
|
else if (q0 >= 1.5 && q0 <= t)
|
{
|
i = 0;
|
for (i = 0; effq[i] <= q0; i++)
|
{
|
if (i + 1 == effq.Count())
|
{
|
break;
|
}
|
}
|
}
|
else
|
{
|
return -1;
|
}
|
if (i >= effq.Length)
|
i = effq.Length - 1;
|
|
if (q0 >= 10)
|
{
|
qjs1 = effq[i];
|
qjs2 = effq[i - 1];
|
qjs3 = effq[i - 2];
|
switch (pumpType)
|
{
|
case 1:
|
if (i >= singleeff.Length)
|
i = singleeff.Length - 1;
|
effjs1 = singleeff[i];
|
effjs2 = singleeff[i - 1];
|
effjs3 = singleeff[i - 2];
|
break;
|
case 2:
|
if (i >= multieff.Length)
|
i = multieff.Length - 1;
|
effjs1 = multieff[i];
|
effjs2 = multieff[i - 1];
|
effjs3 = multieff[i - 2];
|
break;
|
case 3:
|
if (i >= singleeff.Length)
|
i = singleeff.Length - 1;
|
effjs1 = singleeff[i];
|
effjs2 = singleeff[i - 1];
|
effjs3 = singleeff[i - 2];
|
dltE = -2;
|
break;
|
case 4:
|
if (i >= singleeff.Length)
|
i = singleeff.Length - 1;
|
effjs1 = singleeff[i];
|
effjs2 = singleeff[i - 1];
|
effjs3 = singleeff[i - 2];
|
dltE = 5;
|
break;
|
case 5:
|
effjs1 = singleeff[i];
|
effjs2 = singleeff[i - 1];
|
effjs3 = singleeff[i - 2];
|
dltE = 8;
|
break;
|
default:
|
effjs1 = singleeff[i];
|
effjs2 = singleeff[i - 1];
|
effjs3 = singleeff[i - 2];
|
dltE = 3.5;
|
break;
|
}
|
}
|
else
|
{
|
qjs1 = effq[2];
|
qjs2 = effq[1];
|
qjs3 = effq[0];
|
switch (pumpType)
|
{
|
case 1:
|
effjs1 = singleeff[2];
|
effjs2 = singleeff[1];
|
effjs3 = singleeff[0];
|
break;
|
case 2:
|
effjs1 = multieff[2];
|
effjs2 = multieff[1];
|
effjs3 = multieff[0];
|
break;
|
case 3:
|
effjs1 = singleeff[2];
|
effjs2 = singleeff[1];
|
effjs3 = singleeff[0];
|
dltE = -2;
|
break;
|
case 4:
|
effjs1 = singleeff[2];
|
effjs2 = singleeff[1];
|
effjs3 = singleeff[0];
|
dltE = 5;
|
break;
|
case 5:
|
effjs1 = singleeff[2];
|
effjs2 = singleeff[1];
|
effjs3 = singleeff[0];
|
dltE = 8;
|
break;
|
default:
|
effjs1 = singleeff[2];
|
effjs2 = singleeff[1];
|
effjs3 = singleeff[0];
|
dltE = 3.5;
|
break;
|
}
|
}
|
|
eff = (q0 - qjs2) * (q0 - qjs3) * effjs1 / ((qjs1 - qjs2) * (qjs1 - qjs3)) +
|
(q0 - qjs1) * (q0 - qjs3) * effjs2 / ((qjs2 - qjs1) * (qjs2 - qjs3)) +
|
(q0 - qjs1) * (q0 - qjs2) * effjs3 / ((qjs3 - qjs1) * (qjs3 - qjs2)) - dltE;
|
|
if ((ns < 120 && ns >= 20) || (ns < 300 && ns > 210))
|
{
|
if (ns < 120 && ns >= 20)
|
{
|
for (i = 0; effns1[i] <= ns; i++)
|
{
|
}
|
if (ns >= 25)
|
{
|
qjs1 = effns1[i];
|
qjs2 = effns1[i - 1];
|
qjs3 = effns1[i - 2];
|
effjs1 = effcorrect1[i];
|
effjs2 = effcorrect1[i - 1];
|
effjs3 = effcorrect1[i - 2];
|
}
|
else
|
{
|
qjs1 = effns1[i + 1];
|
qjs2 = effns1[i];
|
qjs3 = effns1[i - 1];
|
effjs1 = effcorrect1[i + 1];
|
effjs2 = effcorrect1[i];
|
effjs3 = effcorrect1[i - 1];
|
}
|
}
|
if (ns < 300 && ns > 210)
|
{
|
for (i = 0; effns2[i] <= ns; i++)
|
{
|
}
|
if (ns >= 220)
|
{
|
qjs1 = effns2[i];
|
qjs2 = effns2[i - 1];
|
qjs3 = effns2[i - 2];
|
effjs1 = effcorrect2[i];
|
effjs2 = effcorrect2[i - 1];
|
effjs3 = effcorrect2[i - 2];
|
}
|
else
|
{
|
qjs1 = effns2[i + 1];
|
qjs2 = effns2[i];
|
qjs3 = effns2[i - 1];
|
effjs1 = effcorrect2[i + 1];
|
effjs2 = effcorrect2[i];
|
effjs3 = effcorrect2[i - 1];
|
}
|
}
|
correct = (ns - qjs2) * (ns - qjs3) * effjs1 / ((qjs1 - qjs2) * (qjs1 - qjs3)) +
|
(ns - qjs1) * (ns - qjs3) * effjs2 / ((qjs2 - qjs1) * (qjs2 - qjs3)) +
|
(ns - qjs1) * (ns - qjs2) * effjs3 / ((qjs3 - qjs1) * (qjs3 - qjs2));
|
}
|
if (ns >= 300)
|
correct = 3.0;
|
if (ns < 20)
|
correct = 32.0;
|
if (ns >= 120 && ns <= 210)
|
correct = 0;
|
eff = eff - correct;
|
|
return eff;
|
}
|
|
//计算推荐NPSHr
|
public static double CalculateNPSHrByPumpType(double Q, double H, double n, int iPumpType)
|
{
|
double ns = CalculateNs(Q, H, n);
|
double S_Q = 10;
|
if (iPumpType == 3)
|
S_Q = Q / 2;
|
else
|
S_Q = Q;
|
|
double K = Math.Pow(ns, 1.3333) * 216 / 1000000;
|
return K * H;
|
}
|
|
#endregion
|
|
#region 计算比转速度
|
|
public static double CalculateNs(double Q, double H, double n)
|
{
|
return 3.65 * n * Math.Sqrt(Q / 3600) / Math.Pow(H, 0.75);
|
}
|
|
public static decimal CalculateNs(decimal Q, decimal H, decimal n)
|
{
|
return Convert.ToDecimal(3.65 * Convert.ToDouble(n) * Math.Sqrt(Convert.ToDouble(Q) / 3600) / Math.Pow(Convert.ToDouble(H), 0.75));
|
}
|
|
#endregion
|
|
#region 计算功率
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="qh_pt_list">流量扬程点</param>
|
/// <param name="qe_pt_list">流量效率点</param>
|
/// <returns>流量功率点</returns>
|
public static List<Yw.Geometry.Point2d> CalculateP(List<Yw.Geometry.Point2d> qh_pt_list, List<Yw.Geometry.Point2d> qe_pt_list)
|
{
|
if (qh_pt_list == null || qh_pt_list.Count() <= 2)
|
return null;
|
bool is_x_start_0 = qh_pt_list.First().X > 500 || qh_pt_list.First().X > qh_pt_list.Last().X * 0.2;
|
return CalculateP(qh_pt_list, qe_pt_list, Constant.WaterDensity, -1, is_x_start_0);
|
}
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="qh_pt_list">流量扬程点</param>
|
/// <param name="qe_pt_list">流量效率点</param>
|
/// <param name="midu">水的密度</param>
|
/// <param name="zeroPower">流量为0时的功率</param>
|
/// <param name="is_x_start_0">流量是否为0</param>
|
/// <returns></returns>
|
public static List<Yw.Geometry.Point2d> CalculateP(
|
List<Yw.Geometry.Point2d> qh_pt_list,
|
List<Yw.Geometry.Point2d> qe_pt_list,
|
double midu,
|
double zeroPower,
|
bool is_x_start_0)
|
{
|
if (qh_pt_list == null || qh_pt_list.Count < 3)
|
return null;
|
if (qe_pt_list == null || qe_pt_list.Count < 3)
|
return null;
|
|
var curve_qh = new Yw.Geometry.CubicSpline2d(qh_pt_list);
|
var curve_qe = new Yw.Geometry.CubicSpline2d(qe_pt_list);
|
|
var qp = CalculateP(curve_qh, curve_qe, midu, zeroPower, is_x_start_0);
|
return qp.GetPointList(qe_pt_list.Count());
|
}
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="fitQP">流量功率线拟合方式</param>
|
/// <param name="curve_qh">流量扬程线</param>
|
/// <param name="curve_qe">流量效率线</param>
|
/// <param name="midu">水的密度</param>
|
/// <param name="zeroPower">流量为0时的功率</param>
|
/// <param name="is_x_start_0">流量是否为0</param>
|
/// <returns></returns>
|
public static Yw.Geometry.CubicSpline2d CalculateP(Yw.Geometry.CubicSpline2d curve_qh, Yw.Geometry.CubicSpline2d curve_qe, double midu, double zeroPower, bool is_x_start_0)
|
{
|
if (curve_qh == null || curve_qe == null)
|
return null;
|
int point_count = 16;//点不能太多
|
var qh_pt_list = curve_qh.GetPointList(point_count);
|
if (qh_pt_list == null || qh_pt_list.Count < 3)
|
return null;
|
var qe_pt_list = curve_qe.GetPointList(point_count);
|
if (qe_pt_list == null || qe_pt_list.Count < 3)
|
return null;
|
|
List<Yw.Geometry.Point2d> qp_pt_list = new List<Yw.Geometry.Point2d>();
|
//间距
|
double min_flow = Math.Max(qh_pt_list.First().X, qe_pt_list.First().X);
|
double max_flow = Math.Min(qh_pt_list.Last().X, qe_pt_list.Last().X);
|
|
//
|
double Q, H, E, P;
|
double space = (max_flow - min_flow) / (point_count - 1);
|
|
//保证从0开始: 保证Q=0时,P不是计算出来的;
|
if (is_x_start_0)
|
{
|
for (int i = 5; i < point_count; i++)//前面几个点不要
|
{
|
Q = qe_pt_list.First().X + space * i;
|
E = curve_qe.GetPointY(Q);
|
H = curve_qh.GetPointY(Q);
|
if (H < 0.1 || E < 0.5)
|
continue;
|
|
P = CalculateP(Q, H, E, midu);
|
if (P < 2)
|
{
|
P = Math.Round(P, 3);
|
}
|
else if (P < 30)
|
{
|
P = Math.Round(P, 2);
|
}
|
else if (P < 100)
|
{
|
P = Math.Round(P, 1);
|
}
|
else
|
{
|
P = Math.Round(P, 0);
|
}
|
qp_pt_list.Add(new Yw.Geometry.Point2d(Q, P));
|
}
|
|
|
qp_pt_list = qp_pt_list.GetFitPointList(point_count);
|
if (qp_pt_list == null)
|
return null;
|
|
|
if (zeroPower > 0.1)
|
{
|
qp_pt_list.Insert(0, new Yw.Geometry.Point2d(0, zeroPower));
|
}
|
else
|
{
|
if (qp_pt_list[0].Y >= qp_pt_list[1].Y)
|
{
|
qp_pt_list[0].Y = qp_pt_list[1].Y * 0.95;
|
}
|
double startP = Yw.Geometry.LineHelper.GetYbyX(qp_pt_list[0].X, qp_pt_list[0].Y, qp_pt_list[1].X, qp_pt_list[1].Y, 0);
|
if (startP < 0.001)
|
startP = qp_pt_list[0].Y;
|
|
if (startP < 2)
|
{
|
startP = Math.Round(startP, 3);
|
}
|
else if (startP < 30)
|
{
|
startP = Math.Round(startP, 2);
|
}
|
else if (startP < 100)
|
{
|
startP = Math.Round(startP, 1);
|
}
|
else
|
{
|
startP = Math.Round(startP, 0);
|
}
|
|
qp_pt_list.Insert(0, new Yw.Geometry.Point2d(0, startP));
|
}
|
|
|
return new Yw.Geometry.CubicSpline2d(qp_pt_list);
|
}
|
else
|
{
|
for (int i = 0; i < point_count; i++)//前面几个点不要
|
{
|
Q = qe_pt_list.First().X + space * i;
|
E = curve_qe.GetPointY(Q);
|
H = curve_qh.GetPointY(Q);
|
if (H < 0.1 || E < 0.5)
|
continue;
|
|
P = CalculateP(Q, H, E, midu);
|
if (P < 2)
|
{
|
P = Math.Round(P, 3);
|
}
|
else if (P < 30)
|
{
|
P = Math.Round(P, 2);
|
}
|
else if (P < 100)
|
{
|
P = Math.Round(P, 1);
|
}
|
else
|
{
|
P = Math.Round(P, 0);
|
}
|
qp_pt_list.Add(new Yw.Geometry.Point2d(Q, P));
|
}
|
|
qp_pt_list = qp_pt_list.GetFitPointList(point_count);
|
if (qp_pt_list == null)
|
return null;
|
|
return new Yw.Geometry.CubicSpline2d(qp_pt_list);
|
|
}
|
}
|
|
#endregion
|
|
#region 计算效率
|
|
public static Yw.Geometry.CubicSpline2d CalculateE(Yw.Geometry.CubicSpline2d qh, Yw.Geometry.CubicSpline2d qp)
|
{
|
return CalculateE(qh, qp, Constant.WaterDensity);
|
}
|
|
public static Yw.Geometry.CubicSpline2d CalculateE(Yw.Geometry.CubicSpline2d qh, Yw.Geometry.CubicSpline2d qp, bool is_x_start_0)
|
{
|
return CalculateE(qh, qp, Constant.WaterDensity, is_x_start_0);
|
}
|
|
public static Yw.Geometry.CubicSpline2d CalculateE(Yw.Geometry.CubicSpline2d qh, Yw.Geometry.CubicSpline2d qp, double midu)
|
{
|
if (qh == null)
|
return null;
|
|
bool is_x_start_0 = true;
|
if (qh.MinX > 500 || qh.MinX > qh.MaxX * 0.1)
|
{
|
is_x_start_0 = false;
|
}
|
else
|
{
|
is_x_start_0 = true;
|
}
|
|
return CalculateE(qh, qp, midu, is_x_start_0);
|
}
|
|
public static Yw.Geometry.CubicSpline2d CalculateE(Yw.Geometry.CubicSpline2d qh, Yw.Geometry.CubicSpline2d qp, double midu, bool is_x_start_0)
|
{
|
if (qh == null)
|
return null;
|
if (qp == null)
|
return null;
|
int point_count = 12;
|
List<Yw.Geometry.Point2d> qe_pt_list = new List<Yw.Geometry.Point2d>();
|
List<Yw.Geometry.Point2d> qp_pt_list = qp.GetPointList(point_count);
|
|
double Q, H, Eff, Power;
|
var fitCurve = new Yw.Geometry.CubicSpline2d(qh);
|
for (int i = 0; i < qp_pt_list.Count; i++)
|
{
|
Q = qp_pt_list[i].X;
|
Power = qp_pt_list[i].Y;
|
H = fitCurve.GetPointY(Q);
|
Eff = CalculateE(Q, H, Power, midu);
|
qe_pt_list.Add(new Yw.Geometry.Point2d(Q, Eff));
|
}
|
|
//保证Q=0时,Eff=0;
|
if (is_x_start_0)
|
{
|
qe_pt_list[0] = new Yw.Geometry.Point2d(0, 0);
|
qe_pt_list = qe_pt_list.GetFitPointList();
|
qe_pt_list = qe_pt_list.AmendByZeroPointY(qe_pt_list[3].X, 0);
|
return new Yw.Geometry.CubicSpline2d(qe_pt_list);
|
}
|
else
|
{
|
return new Yw.Geometry.CubicSpline2d(qe_pt_list);
|
}
|
}
|
|
public static List<Yw.Geometry.Point2d> CalculateEpoint(
|
|
Yw.Geometry.CubicSpline2d qh,
|
Yw.Geometry.CubicSpline2d qp,
|
int point_count,
|
double midu)
|
{
|
if (qh == null)
|
return null;
|
if (qp == null)
|
return null;
|
|
List<Yw.Geometry.Point2d> qe_pt_list = new List<Yw.Geometry.Point2d>();
|
List<Yw.Geometry.Point2d> qp_pt_list = qp.GetPointList(point_count);
|
|
double Q, H, Eff, Power;
|
var fitCurve = qh.Copy();
|
for (int i = 0; i < qp_pt_list.Count; i++)
|
{
|
Q = qp_pt_list[i].X;
|
Power = qp_pt_list[i].Y;
|
H = fitCurve.GetPointY(Q);
|
Eff = CalculateE(Q, H, Power, midu);
|
|
qe_pt_list.Add(new Yw.Geometry.Point2d(Q, Eff));
|
}
|
|
bool is_x_start_0 = true;
|
if (qe_pt_list.First().X > 500 || qe_pt_list.First().X > qe_pt_list.Last().X * 0.1)
|
{
|
is_x_start_0 = false;
|
}
|
else
|
{
|
is_x_start_0 = true;
|
}
|
|
//保证Q=0时,Eff=0;
|
if (is_x_start_0)
|
{
|
qe_pt_list[0] = new Yw.Geometry.Point2d(0, 0);
|
qe_pt_list = qe_pt_list.GetFitPointList();
|
return qe_pt_list.AmendByZeroPointY(qe_pt_list[3].X, 0);
|
}
|
else
|
{
|
return qe_pt_list.GetFitPointList();
|
}
|
}
|
|
/// <summary>
|
/// 注意此方法 返回的点没有拟合
|
/// </summary>
|
/// <param name="qh_pt_list"></param>
|
/// <param name="qp_pt_list"></param>
|
/// <param name="midu"></param>
|
/// <param name="is_x_start_0"></param>
|
/// <returns></returns>
|
public static List<Yw.Geometry.Point2d> CalculateE_AlignPointP(
|
List<Yw.Geometry.Point2d> qh_pt_list,
|
List<Yw.Geometry.Point2d> qp_pt_list,
|
double midu, bool is_x_start_0)
|
{
|
if (qh_pt_list == null || qh_pt_list.Count < 3)
|
return null;
|
if (qp_pt_list == null || qp_pt_list.Count < 3)
|
return null;
|
|
List<Yw.Geometry.Point2d> qe_pt_list = new List<Yw.Geometry.Point2d>();
|
|
if (qh_pt_list.IsEqualValueX(qp_pt_list))
|
{ //x都一致
|
for (int i = 0; i < qp_pt_list.Count; i++)
|
{
|
double Q, H, Eff, Power;
|
Q = qp_pt_list[i].X;
|
Power = qp_pt_list[i].Y;
|
H = qh_pt_list[i].Y;
|
Eff = CalculateE(Q, H, Power, midu);
|
qe_pt_list.Add(new Yw.Geometry.Point2d(Q, Eff));
|
}
|
}
|
else
|
{
|
var fitCurve_QP = new Yw.Geometry.CubicSpline2d(qp_pt_list);
|
var fitCurve_QH = new Yw.Geometry.CubicSpline2d(qh_pt_list);
|
for (int i = 0; i < qp_pt_list.Count; i++)
|
{
|
double Q, H, Eff, Power;
|
Q = qp_pt_list[i].X;
|
Power = fitCurve_QP.GetPointY(Q);
|
H = fitCurve_QH.GetPointY(Q);
|
Eff = CalculateE(Q, H, Power, midu);
|
qe_pt_list.Add(new Yw.Geometry.Point2d(Q, Eff));
|
}
|
}
|
|
|
//qe_pt_list = FitHelper.GetPointListByExtend(qe_pt_list);
|
|
//保证Q=0时,Eff=0;
|
if (is_x_start_0)
|
{
|
qe_pt_list[0] = new Yw.Geometry.Point2d(0, 0);
|
}
|
|
return qe_pt_list;
|
}
|
|
#endregion
|
|
#region 功率效率换算
|
|
|
/// <summary>
|
/// 计算效率 对其功率
|
/// </summary>
|
public static List<Yw.Geometry.Point2d> CalculateELineByP(List<Yw.Geometry.Point2d> qh_pt_list, List<Yw.Geometry.Point2d> qp_pt_list, bool is_x_start_0)
|
{
|
if (qh_pt_list == null || qh_pt_list.Count < 3)
|
{
|
return null;
|
}
|
|
if (qp_pt_list == null || qp_pt_list.Count < 3)
|
{
|
return null;
|
}
|
|
List<Yw.Geometry.Point2d> list = new List<Yw.Geometry.Point2d>();
|
if (qh_pt_list.IsEqualValueX(qp_pt_list))
|
{
|
for (int i = 0; i < qp_pt_list.Count; i++)
|
{
|
double x = qp_pt_list[i].X;
|
double y = qp_pt_list[i].Y;
|
double y2 = qh_pt_list[i].Y;
|
double y3 = CalculateE(x, y2, y, Constant.WaterDensity);
|
list.Add(new Yw.Geometry.Point2d(x, y3));
|
}
|
}
|
else
|
{
|
var qp = new Yw.Geometry.CubicSpline2d(qp_pt_list);
|
var qh = new Yw.Geometry.CubicSpline2d(qh_pt_list);
|
for (int j = 0; j < qp_pt_list.Count; j++)
|
{
|
double x2 = qp_pt_list[j].X;
|
double fit_pointY = qp.GetPointY(x2);
|
double fit_pointY2 = qh.GetPointY(x2);
|
double y4 = CalculateE(x2, fit_pointY2, fit_pointY, Constant.WaterDensity);
|
list.Add(new Yw.Geometry.Point2d(x2, y4));
|
}
|
}
|
|
if (is_x_start_0)
|
{
|
list[0] = new Yw.Geometry.Point2d(0, 0);
|
}
|
|
return list;
|
}
|
|
|
/// <summary>
|
/// 计算效率 对其效率
|
/// </summary>
|
public static List<Yw.Geometry.Point2d> CalculateP_AlignPointE(List<Yw.Geometry.Point2d> qh_pt_list, List<Yw.Geometry.Point2d> qe_pt_list, double midu, double ref_zero_power, bool is_x_start_0)
|
{
|
if (qh_pt_list == null || qh_pt_list.Count < 3)
|
{
|
return null;
|
}
|
|
if (qe_pt_list == null || qe_pt_list.Count < 3)
|
{
|
return null;
|
}
|
|
List<Yw.Geometry.Point2d> list = new List<Yw.Geometry.Point2d>();
|
if (qh_pt_list.IsEqualValueX(qe_pt_list))
|
{
|
for (int i = 0; i < qe_pt_list.Count(); i++)
|
{
|
double x = qe_pt_list[i].X;
|
double y = qe_pt_list[i].Y;
|
double y2 = qh_pt_list[i].Y;
|
if (!(y2 < 0.1) && !(y < 0.5))
|
{
|
double num = CalculateP(x, y2, y, midu);
|
num = ((num < 2.0) ? Math.Round(num, 3) : ((num < 30.0) ? Math.Round(num, 2) : ((!(num < 100.0)) ? Math.Round(num, 0) : Math.Round(num, 1))));
|
list.Add(new Yw.Geometry.Point2d(x, num));
|
}
|
}
|
}
|
else
|
{
|
var qe = new Yw.Geometry.CubicSpline2d(qe_pt_list);
|
var qh = new Yw.Geometry.CubicSpline2d(qh_pt_list);
|
for (int j = 0; j < qe_pt_list.Count(); j++)
|
{
|
double x2 = qe_pt_list[j].X;
|
double fit_pointY = qe.GetPointY(x2);
|
double fit_pointY2 = qh.GetPointY(x2);
|
if (!(fit_pointY2 < 0.09) && !(fit_pointY < 0.5))
|
{
|
double num2 = CalculateP(x2, fit_pointY2, fit_pointY, midu);
|
num2 = ((num2 < 2.0) ? Math.Round(num2, 3) : ((num2 < 30.0) ? Math.Round(num2, 2) : ((!(num2 < 100.0)) ? Math.Round(num2, 0) : Math.Round(num2, 1))));
|
list.Add(new Yw.Geometry.Point2d(x2, num2));
|
}
|
}
|
}
|
|
if (is_x_start_0)
|
{
|
if (list[0].X < 1.0)
|
{
|
if (ref_zero_power > 0.0)
|
{
|
list[0].X = 0.0;
|
list[0].Y = ref_zero_power;
|
}
|
else
|
{
|
list.RemoveAt(0);
|
var fit_points = list.GetFitPointList();
|
if (fit_points[0].Y >= fit_points[1].Y)
|
{
|
fit_points[0].Y = fit_points[1].Y * 0.95;
|
}
|
|
double num3 = Yw.Geometry.LineHelper.GetYbyX(fit_points[0].X, fit_points[0].Y, fit_points[1].X, fit_points[1].Y, 0.0);
|
if (num3 < 0.001)
|
{
|
num3 = fit_points[0].Y;
|
}
|
|
num3 = ((num3 < 2.0) ? Math.Round(num3, 3) : ((num3 < 30.0) ? Math.Round(num3, 2) : ((!(num3 < 100.0)) ? Math.Round(num3, 0) : Math.Round(num3, 1))));
|
list.Insert(0, new Yw.Geometry.Point2d(0.0, num3));
|
}
|
}
|
else if (ref_zero_power > 0.0)
|
{
|
list.Insert(0, new Yw.Geometry.Point2d(0.0, ref_zero_power));
|
}
|
else
|
{
|
var fit_points2 = list.GetFitPointList();
|
if (fit_points2[0].Y >= fit_points2[1].Y)
|
{
|
fit_points2[0].Y = fit_points2[1].Y * 0.95;
|
}
|
|
double num4 = Yw.Geometry.LineHelper.GetYbyX(fit_points2[0].X, fit_points2[0].Y, fit_points2[1].X, fit_points2[1].Y, 0.0);
|
if (num4 < 0.001)
|
{
|
num4 = fit_points2[0].Y;
|
}
|
|
num4 = ((num4 < 2.0) ? Math.Round(num4, 3) : ((num4 < 30.0) ? Math.Round(num4, 2) : ((!(num4 < 100.0)) ? Math.Round(num4, 0) : Math.Round(num4, 1))));
|
list.Insert(0, new Yw.Geometry.Point2d(0.0, num4));
|
}
|
}
|
|
return list;
|
}
|
|
|
#endregion
|
|
#endregion
|
|
#region 曲线与H=K*Q^i的交点
|
|
/// <summary>
|
/// 根据相似点设置相似曲线,相似点(选择点)的x:流量y:杨程
|
/// </summary>
|
public static double GetSimuValue(Yw.Geometry.CubicSpline2d cubic_spline, Yw.Geometry.Point2d simular_pt, double origin_value, double extend_ratio = 1)
|
{
|
if (cubic_spline == null)
|
return -3;
|
if (simular_pt.X < 0.1 || simular_pt.Y < 0.1)
|
return -2;
|
if (simular_pt.X > cubic_spline.MaxX * extend_ratio * 1.5)
|
return -4;
|
|
Yw.Geometry.Point2d sect_pt = GetSectPoint(cubic_spline, simular_pt, extend_ratio);
|
if (sect_pt == null || sect_pt.IsZeroPoint())
|
return -5;
|
|
//计算相似点的转速/直径
|
return CalculateSimuByH(origin_value, sect_pt.Y, simular_pt.Y);
|
}
|
|
//ratioIgnore:作用 当simularPoint超出曲线范围时,曲线扩大的倍数
|
public static Yw.Geometry.Point2d GetSectPoint(Yw.Geometry.CubicSpline2d cubic_spline, Yw.Geometry.Point2d simular_pt, double ratioIgnore)
|
{
|
return GetSectPointGeneral(cubic_spline, simular_pt, 2, ratioIgnore);
|
}
|
|
public static Yw.Geometry.Point2d GetSectPointParabola(Yw.Geometry.CubicSpline2d cubic_spline, Yw.Geometry.Point2d simular_pt)
|
{
|
var sect_pt = new Yw.Geometry.Point2d(0, 0);
|
if (cubic_spline == null)
|
return sect_pt;
|
var pt_list = cubic_spline.GetPointListByXRatioRange(1, 1.2, 50);
|
return GetSectPointParabola(pt_list, simular_pt);
|
}
|
|
//通过点simular_pt和点(0,0)的直线,与曲线Curve的交点(没有,返回Point(0,0))
|
public static Yw.Geometry.Point2d GetSectPointLine(List<Yw.Geometry.Point2d> CurvePoints, Yw.Geometry.Point2d simular_pt)
|
{
|
Yw.Geometry.Point2d sect_pt = new Yw.Geometry.Point2d(0, 0);
|
if (CurvePoints == null || CurvePoints.Count < 2)
|
return sect_pt;
|
|
//计算直线的K
|
if (simular_pt.X < 1)
|
return sect_pt;
|
double a = simular_pt.Y / simular_pt.X;
|
if (a < 0.0001)
|
return sect_pt;
|
|
//与2点连成直线的交点,判断交点是否在2点之间,即可是曲线的交点
|
double b, c;
|
double x;
|
for (int i = 0; i < CurvePoints.Count - 1; i++)
|
{
|
LineHelper.GetKandB(CurvePoints[i], CurvePoints[i + 1], out b, out c);
|
|
/*解方程
|
* y=ax
|
* y=bx+c
|
*/
|
if (Math.Abs(a - b) < 0.001)
|
continue;
|
|
x = c / (a - b);
|
if (UtilsHelper.IsMiddle(CurvePoints[i].X, CurvePoints[i + 1].X, x))
|
{
|
sect_pt.X = x;
|
sect_pt.Y = a * x;
|
return sect_pt;
|
}
|
}
|
|
return sect_pt;
|
}
|
|
//通过点simular_pt和点(0,0)的抛物线,与曲线Curve的交点(没有,返回Point(0,0))
|
//曲线公式:H=K*Q^2
|
public static Yw.Geometry.Point2d GetSectPointParabola(List<Yw.Geometry.Point2d> pt_list, Yw.Geometry.Point2d simular_pt)
|
{
|
return ParabolaCurveHelper.GetSectPoint(pt_list, simular_pt, 0);
|
}
|
|
public static Yw.Geometry.Point2d GetSectPointLine(this Yw.Geometry.CubicSpline2d cubic_spline, Yw.Geometry.Point2d simular_pt)
|
{
|
Yw.Geometry.Point2d sect_pt = new Yw.Geometry.Point2d(0, 0);
|
if (cubic_spline == null)
|
return sect_pt;
|
|
//计算直线的K
|
if (simular_pt.X < 1)
|
return sect_pt;
|
double a = simular_pt.Y / simular_pt.X;
|
if (a < 0.0001)
|
return sect_pt;
|
|
//点越多越精确
|
return GetSectPointLine(cubic_spline.GetPointList(100), simular_pt);
|
}
|
|
//曲线H=K*Q^i 与曲线Curve的交点(没有,返回Point(0,0))
|
public static Yw.Geometry.Point2d GetSectPointGeneral(List<Yw.Geometry.Point2d> pt_list, Yw.Geometry.Point2d simular_pt, double index)
|
{
|
Yw.Geometry.Point2d sect_pt = new Yw.Geometry.Point2d(0, 0);
|
if (pt_list == null || pt_list.Count < 2)
|
return sect_pt;
|
|
if (simular_pt.X < 0.1)
|
return sect_pt;
|
|
if (Math.Abs(index - 1) < 0.01)
|
return GetSectPointLine(pt_list, simular_pt);
|
if (Math.Abs(index - 2) < 0.01)
|
return GetSectPointParabola(pt_list, simular_pt);
|
|
//计算系数K
|
double fixK = simular_pt.Y / Math.Pow(simular_pt.X, index);
|
if (fixK < 0.000001)
|
return sect_pt;
|
|
//思路是从simular_pt开始逐个增加0.1,直到k值最接近fixK
|
double space = (pt_list.Last().X - simular_pt.X) / 1200;
|
double x = simular_pt.X;
|
double y, k;
|
do
|
{
|
x = x + space;
|
y = 0;
|
var y_pt_list = pt_list.GetInterPointsY(x);
|
if (y_pt_list == null || !y_pt_list.Any())
|
{
|
break;
|
}
|
y = y_pt_list.Last();
|
k = y / Math.Pow(x, index);
|
} while (k > fixK);
|
|
sect_pt.X = x;
|
sect_pt.Y = y;
|
return sect_pt;
|
}
|
|
|
//ratioIgnore:作用 当simular_pt超出范围时,扩大的倍数
|
public static Yw.Geometry.Point2d GetSectPointGeneral(this Yw.Geometry.CubicSpline2d cubic_spline, Yw.Geometry.Point2d simular_pt, double index, double ratioIgnore)
|
{
|
Yw.Geometry.Point2d sect_pt = new Yw.Geometry.Point2d(0, 0);
|
if (cubic_spline == null)
|
return sect_pt;
|
|
if (simular_pt.X < 1)
|
return sect_pt;
|
var cubic_spline_ex = cubic_spline.Copy();
|
//检查是否在曲线的区域范围内
|
double max_flow = cubic_spline_ex.MaxX;
|
double max_head = cubic_spline_ex.GetPointY(max_flow);
|
double k1 = max_head / Math.Pow(max_flow, index);
|
double k2 = simular_pt.Y / Math.Pow(simular_pt.X, index);
|
if (k1 > k2)
|
{
|
cubic_spline_ex.MaxX = cubic_spline_ex.MaxX * ratioIgnore;//放大1.2倍
|
}
|
|
if (Math.Abs(index - 1) < 0.01)
|
return GetSectPointLine(cubic_spline_ex, simular_pt);
|
if (Math.Abs(index - 2) < 0.01)
|
return GetSectPointParabola(cubic_spline_ex, simular_pt);
|
|
//计算系数K
|
double fixK = simular_pt.Y / Math.Pow(simular_pt.X, index);
|
if (fixK < 0.000001)
|
return sect_pt;
|
|
//思路是从simular_pt开始逐个增加0.1,直到k值最接近fixK
|
double space = (cubic_spline_ex.MaxX - simular_pt.X) / 1000;
|
double x = simular_pt.X;
|
double y, k;
|
do
|
{
|
x = x + space;
|
y = cubic_spline_ex.GetPointY(x);
|
k = y / Math.Pow(x, index);
|
} while (k > fixK);
|
|
sect_pt.X = x;
|
sect_pt.Y = y;
|
return sect_pt;
|
}
|
|
#endregion 曲线与H=K*Q^i的交点 protect类型,给子类调用,怎么覆盖GetSectPoint
|
}
|
}
|
