namespace IStation.Curve
|
{
|
/// <summary>
|
/// 泵计算辅助类
|
/// </summary>
|
public class PumpCalculateHelper
|
{
|
#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="originSpeend"></param>
|
/// <param name="originH"></param>
|
/// <param name="changeH"></param>
|
/// <returns></returns>
|
public static double CalculateSimuByH(double originSpeend, double originH, double changeH)
|
{
|
double ratio = Math.Pow(originH / changeH, 1.0 / 2.0);
|
return originSpeend / ratio;
|
}
|
|
/// <summary>
|
/// 知道原始速度,以及原始的流量Q以及对应的变速后的杨程,求变速后的速度
|
/// </summary>
|
/// <param name="originSpeend"></param>
|
/// <param name="originQ"></param>
|
/// <param name="changeQ"></param>
|
/// <returns></returns>
|
public static double CalculateSimuByQ(double originSpeend, double originQ, double changeQ)
|
{
|
double ratio = originQ / changeQ;
|
return originSpeend / ratio;
|
}
|
#endregion
|
|
#region 相似换算
|
|
/// <summary>
|
/// 计算相似流量扬程曲线
|
/// </summary>
|
/// <param name="express">表达式</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <param name="pointNumber">拟合点数量</param>
|
/// <returns></returns>
|
public static CurveExpress CalculateSimilarQH(CurveExpress express, double originHz, double changeHz, int pointNumber = 12)
|
{
|
if (express == null)
|
return null;
|
if (changeHz < 1)
|
return null;
|
List<CurvePoint> fitPoints = null;
|
if (express.DefinePoints != null && express.DefinePoints.Any())
|
fitPoints = express.DefinePoints;
|
else
|
fitPoints = FitHelper.GetFitPoints(express, pointNumber);
|
|
var ratio = changeHz / originHz;
|
var similarPoints = new List<CurvePoint>();
|
foreach (CurvePoint fitPoint in fitPoints)
|
{
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y * ratio * ratio;
|
similarPoints.Add(similarPoint);
|
}
|
|
return FitHelper.BuildCurveExpress(similarPoints, express.FitType);
|
}
|
|
/// <summary>
|
/// 计算相似流量功率曲线
|
/// </summary>
|
/// <param name="curvePoints">表达式</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <param name="pointNumber">拟合点数量</param>
|
/// <returns></returns>
|
public static CurveExpress CalculateSimilarQP(CurveExpress curvePoints, double originHz, double changeHz, int pointNumber = 12)
|
{
|
if (curvePoints == null)
|
return null;
|
if (changeHz < 1)
|
return null;
|
List<CurvePoint> fitPoints = null;
|
if (curvePoints.DefinePoints != null && curvePoints.DefinePoints.Any())
|
fitPoints = curvePoints.DefinePoints;
|
else
|
fitPoints = FitHelper.GetFitPoints(curvePoints, pointNumber);
|
|
var ratio = changeHz / originHz;
|
var similarPoints = new List<CurvePoint>();
|
foreach (CurvePoint fitPoint in fitPoints)
|
{
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y * ratio * ratio * ratio;
|
similarPoints.Add(similarPoint);
|
}
|
return FitHelper.BuildCurveExpress(similarPoints, curvePoints.FitType);
|
}
|
|
/// <summary>
|
/// 计算相似流量效率曲线
|
/// </summary>
|
/// <param name="curvePoints">表达式</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <param name="pointNumber">拟合点数量</param>
|
/// <returns></returns>
|
public static CurveExpress CalculateSimilarQE(CurveExpress curvePoints, double originHz, double changeHz, int pointNumber = 12)
|
{
|
if (curvePoints == null)
|
return null;
|
if (changeHz < 1)
|
return null;
|
List<CurvePoint> fitPoints = null;
|
if (curvePoints.DefinePoints != null && curvePoints.DefinePoints.Any())
|
fitPoints = curvePoints.DefinePoints;
|
else
|
fitPoints = FitHelper.GetFitPoints(curvePoints, pointNumber);
|
|
var ratio = changeHz / originHz;
|
var similarPoints = new List<CurvePoint>();
|
foreach (CurvePoint fitPoint in fitPoints)
|
{
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y;
|
similarPoints.Add(similarPoint);
|
}
|
return FitHelper.BuildCurveExpress(similarPoints, curvePoints.FitType);
|
}
|
|
/// <summary>
|
/// 计算相似流量扬程曲线点
|
/// </summary>
|
/// <param name="fitPoints">曲线点</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <param name="pointNumber">拟合点数量</param>
|
/// <returns></returns>
|
public static List<CurvePoint> CalculateSimilarQH(List<CurvePoint> fitPoints, double originHz, double changeHz)
|
{
|
if (fitPoints == null || !fitPoints.Any())
|
return null;
|
if (changeHz < 1)
|
return null;
|
|
var ratio = changeHz / originHz;
|
var similarPoints = new List<CurvePoint>();
|
foreach (CurvePoint fitPoint in fitPoints)
|
{
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y * ratio * ratio;
|
similarPoints.Add(similarPoint);
|
}
|
return similarPoints;
|
}
|
|
/// <summary>
|
/// 计算相似流量功率曲线点
|
/// </summary>
|
/// <param name="fitPoints">曲线点</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <param name="pointNumber">拟合点数量</param>
|
/// <returns></returns>
|
public static List<CurvePoint> CalculateSimilarQP(List<CurvePoint> fitPoints, double originHz, double changeHz)
|
{
|
if (fitPoints == null || !fitPoints.Any())
|
return null;
|
if (changeHz < 1)
|
return null;
|
|
var ratio = changeHz / originHz;
|
var similarPoints = new List<CurvePoint>();
|
foreach (CurvePoint fitPoint in fitPoints)
|
{
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y * ratio * ratio * ratio;
|
similarPoints.Add(similarPoint);
|
}
|
return similarPoints;
|
}
|
|
/// <summary>
|
/// 计算相似流量效率曲线点
|
/// </summary>
|
/// <param name="fitPoints">曲线点</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <param name="pointNumber">拟合点数量</param>
|
/// <returns></returns>
|
public static List<CurvePoint> CalculateSimilarQE(List<CurvePoint> fitPoints, double originHz, double changeHz)
|
{
|
if (fitPoints == null || !fitPoints.Any())
|
return null;
|
if (changeHz < 1)
|
return null;
|
|
var ratio = changeHz / originHz;
|
var similarPoints = new List<CurvePoint>();
|
foreach (CurvePoint fitPoint in fitPoints)
|
{
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y;
|
similarPoints.Add(similarPoint);
|
}
|
return similarPoints;
|
}
|
|
|
/// <summary>
|
/// 计算相似流量扬程点
|
/// </summary>
|
/// <param name="fitPoint">点</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <returns></returns>
|
public static CurvePoint CalculateSimilarQH(CurvePoint fitPoint, double originHz, double changeHz)
|
{
|
if (fitPoint == null)
|
return null;
|
if (changeHz < 1)
|
return null;
|
var ratio = changeHz / originHz;
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y * ratio * ratio;
|
return similarPoint;
|
}
|
|
/// <summary>
|
/// 计算相似流量功率点
|
/// </summary>
|
/// <param name="express">点</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <returns></returns>
|
public static CurvePoint CalculateSimilarQP(CurvePoint fitPoint, double originHz, double changeHz)
|
{
|
if (fitPoint == null)
|
return null;
|
if (changeHz < 1)
|
return null;
|
var ratio = changeHz / originHz;
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y * ratio * ratio * ratio;
|
return similarPoint;
|
}
|
|
/// <summary>
|
/// 计算相似流量效率点
|
/// </summary>
|
/// <param name="express">点</param>
|
/// <param name="originHz">原始频率</param>
|
/// <param name="changeHz">换算频率</param>
|
/// <returns></returns>
|
public static CurvePoint CalculateSimilarQE(CurvePoint fitPoint, double originHz, double changeHz)
|
{
|
if (fitPoint == null)
|
return null;
|
if (changeHz < 1)
|
return null;
|
var ratio = changeHz / originHz;
|
var similarPoint = new CurvePoint();
|
similarPoint.X = fitPoint.X * ratio;
|
similarPoint.Y = fitPoint.Y;
|
|
return similarPoint;
|
}
|
#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 计算推荐参数
|
|
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 计算功率
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="ptQHs">流量扬程点</param>
|
/// <param name="ptQEs">流量效率点</param>
|
/// <returns>流量功率点</returns>
|
public static List<CurvePoint> CalculateP(List<CurvePoint> ptQHs, List<CurvePoint> ptQEs)
|
{
|
if (ptQHs == null || ptQHs.Count() <= 2)
|
return null;
|
bool isXStartZero = ptQHs.First().X > 500 || ptQHs.First().X > ptQHs.Last().X * 0.2;
|
return CalculateP(eFitType.CubicCurve, eFitType.CubicCurve, eFitType.CubicCurve, ptQHs, ptQEs, Constant.WaterDensity, -1, isXStartZero);
|
}
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="fitQH">流量扬程线拟合方式</param>
|
/// <param name="fitQE">流量效率线拟合方式</param>
|
/// <param name="fitQP">流量功率线拟合方式</param>
|
/// <param name="ptQHs">流量扬程点</param>
|
/// <param name="ptQEs">流量效率点</param>
|
/// <param name="midu">水的密度</param>
|
/// <param name="zeroPower">流量为0时的功率</param>
|
/// <param name="isXStartZero">流量是否为0</param>
|
/// <returns></returns>
|
public static List<CurvePoint> CalculateP(
|
eFitType fitQH,
|
eFitType fitQE,
|
eFitType fitQP,
|
List<CurvePoint> ptQHs,
|
List<CurvePoint> ptQEs,
|
double midu,
|
double zeroPower,
|
bool isXStartZero)
|
{
|
if (ptQHs == null || ptQHs.Count < 3)
|
return null;
|
if (ptQEs == null || ptQEs.Count < 3)
|
return null;
|
|
var curveQH = FitHelper.BuildCurveExpress(ptQHs, fitQH);
|
var curveQE = FitHelper.BuildCurveExpress(ptQEs, fitQE);
|
|
var curveQP = CalculateP(fitQP, curveQH, curveQE, midu, zeroPower, isXStartZero);
|
return curveQP.GetFitPoints(ptQEs.Count());
|
}
|
|
/// <summary>
|
/// 计算功率
|
/// </summary>
|
/// <param name="fitQP">流量功率线拟合方式</param>
|
/// <param name="curveQH">流量扬程线</param>
|
/// <param name="curveQE">流量效率线</param>
|
/// <param name="midu">水的密度</param>
|
/// <param name="zeroPower">流量为0时的功率</param>
|
/// <param name="isXStartZero">流量是否为0</param>
|
/// <returns></returns>
|
public static CurveExpress CalculateP(eFitType fitQP, CurveExpress curveQH, CurveExpress curveQE, double midu, double zeroPower, bool isXStartZero)
|
{
|
if (curveQH == null || curveQE == null)
|
return null;
|
int pointNumber = 16;//点不能太多
|
var ptQHs = curveQH.GetFitPoints(pointNumber);
|
if (ptQHs == null || ptQHs.Count < 3)
|
return null;
|
var ptQEs = curveQE.GetFitPoints(pointNumber);
|
if (ptQEs == null || ptQEs.Count < 3)
|
return null;
|
|
List<CurvePoint> pointQP = new List<CurvePoint>();
|
//间距
|
double minQ = Math.Max(ptQHs.First().X, ptQEs.First().X);
|
double maxQ = Math.Min(ptQHs.Last().X, ptQEs.Last().X);
|
|
//
|
double Q, H, E, P;
|
double space = (maxQ - minQ) / (pointNumber - 1);
|
|
//保证从0开始: 保证Q=0时,P不是计算出来的;
|
if (isXStartZero)
|
{
|
for (int i = 5; i < pointNumber; i++)//前面几个点不要
|
{
|
Q = ptQEs.First().X + space * i;
|
E = curveQE.GetFitPointY(Q);
|
H = curveQH.GetFitPointY(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);
|
}
|
pointQP.Add(new CurvePoint(Q, P));
|
}
|
|
pointQP = FitHelper.GetFitPoints(pointQP, fitQP, pointNumber);
|
if (pointQP == null)
|
return null;
|
|
|
if (zeroPower > 0.1)
|
{
|
pointQP.Insert(0, new CurvePoint(0, zeroPower));
|
}
|
else
|
{
|
if (pointQP[0].Y >= pointQP[1].Y)
|
{
|
pointQP[0].Y = pointQP[1].Y * 0.95;
|
}
|
double startP = CurveLineHelper.GetYbyX(pointQP[0].X, pointQP[0].Y, pointQP[1].X, pointQP[1].Y, 0);
|
if (startP < 0.001)
|
startP = pointQP[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);
|
}
|
|
pointQP.Insert(0, new CurvePoint(0, startP));
|
}
|
|
|
return FitHelper.BuildCurveExpress(pointQP, fitQP);
|
}
|
else
|
{
|
for (int i = 0; i < pointNumber; i++)//前面几个点不要
|
{
|
Q = ptQEs.First().X + space * i;
|
E = curveQE.GetFitPointY(Q);
|
H = curveQH.GetFitPointY(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);
|
}
|
pointQP.Add(new CurvePoint(Q, P));
|
}
|
|
pointQP = FitHelper.GetFitPoints(pointQP, fitQP, pointNumber);
|
if (pointQP == null)
|
return null;
|
|
return FitHelper.BuildCurveExpress(pointQP, fitQP);
|
|
}
|
|
}
|
|
#endregion
|
|
#region 计算效率
|
|
public static CurveExpress CalculateE(eFitType fitType, CurveExpress expressQH, CurveExpress expressQP)
|
{
|
return CalculateE(fitType, expressQH, expressQP, Constant.WaterDensity);
|
}
|
public static CurveExpress CalculateE(CurveExpress expressQH, CurveExpress expressQP)
|
{
|
return CalculateE(expressQH, expressQP, Constant.WaterDensity);
|
}
|
public static CurveExpress CalculateE(CurveExpress expressQH, CurveExpress expressQP, bool isXStartZero)
|
{
|
return CalculateE(expressQH, expressQP, Constant.WaterDensity, isXStartZero);
|
}
|
|
public static CurveExpress CalculateE(CurveExpress expressQH, CurveExpress expressQP, double midu)
|
{
|
if (expressQH == null)
|
return null;
|
return CalculateE(expressQH.FitType, expressQH, expressQP, midu);
|
}
|
public static CurveExpress CalculateE(CurveExpress expressQH, CurveExpress expressQP, double midu, bool isXStartZero)
|
{
|
if (expressQH == null)
|
return null;
|
return CalculateE(expressQH.FitType, expressQH, expressQP, midu, isXStartZero);
|
}
|
|
public static CurveExpress CalculateE(eFitType fitTypeQE, CurveExpress expressQH, CurveExpress expressQP, double midu)
|
{
|
if (expressQH == null)
|
return null;
|
|
bool isXStartZero = true;
|
if (expressQH.Min > 500 || expressQH.Min > expressQH.Max * 0.1)
|
{
|
isXStartZero = false;
|
}
|
else
|
{
|
isXStartZero = true;
|
}
|
|
return CalculateE(fitTypeQE, expressQH, expressQP, midu, isXStartZero);
|
}
|
|
public static CurveExpress CalculateE(eFitType fitTypeQE, CurveExpress expressQH, CurveExpress expressQP, double midu, bool isXStartZero)
|
{
|
if (expressQH == null)
|
return null;
|
if (expressQP == null)
|
return null;
|
int PointNumber = 12;
|
List<CurvePoint> pointQE = new List<CurvePoint>();
|
List<CurvePoint> pointQP = FitHelper.GetFitPoints(expressQP, PointNumber);
|
|
double Q, H, Eff, Power;
|
FitHelper fitCurve = new FitHelper(expressQH);
|
for (int i = 0; i < pointQP.Count; i++)
|
{
|
Q = pointQP[i].X;
|
Power = pointQP[i].Y;
|
H = fitCurve.GetFitPointY(Q);
|
Eff = CalculateE(Q, H, Power, midu);
|
pointQE.Add(new CurvePoint(Q, Eff));
|
}
|
|
//保证Q=0时,Eff=0;
|
if (isXStartZero)
|
{
|
pointQE[0] = new CurvePoint(0, 0);
|
var fitCurve1 = FitHelper.GetFitPoints(pointQE, fitTypeQE, pointQE.Count());
|
pointQE = AmendCurveHelper.ByZeroPointY(fitCurve1, pointQE[3].X, 0);
|
return FitHelper.BuildCurveExpress(pointQE, fitTypeQE);
|
}
|
else
|
{
|
return FitHelper.BuildCurveExpress(pointQE, fitTypeQE);
|
}
|
}
|
|
|
public static List<CurvePoint> CalculateEpoint(
|
eFitType CurveFitTypeQE,
|
CurveExpress expressQH,
|
CurveExpress expressQP,
|
int PointNumber,
|
double midu)
|
{
|
if (expressQH == null)
|
return null;
|
if (expressQP == null)
|
return null;
|
|
List<CurvePoint> pointQE = new List<CurvePoint>();
|
List<CurvePoint> pointQP = FitHelper.GetFitPoints(expressQP, PointNumber);
|
|
double Q, H, Eff, Power;
|
FitHelper fitCurve = new FitHelper(expressQH);
|
for (int i = 0; i < pointQP.Count; i++)
|
{
|
Q = pointQP[i].X;
|
Power = pointQP[i].Y;
|
H = fitCurve.GetFitPointY(Q);
|
Eff = CalculateE(Q, H, Power, midu);
|
|
pointQE.Add(new CurvePoint(Q, Eff));
|
}
|
|
bool isXStartZero = true;
|
if (pointQE.First().X > 500 || pointQE.First().X > pointQE.Last().X * 0.1)
|
{
|
isXStartZero = false;
|
}
|
else
|
{
|
isXStartZero = true;
|
}
|
|
//保证Q=0时,Eff=0;
|
if (isXStartZero)
|
{
|
pointQE[0] = new CurvePoint(0, 0);
|
var fitCurve1 = FitHelper.GetFitPoints(pointQE, CurveFitTypeQE, pointQE.Count());
|
return AmendCurveHelper.ByZeroPointY(fitCurve1, pointQE[3].X, 0);
|
}
|
else
|
{
|
return FitHelper.GetFitPoints(pointQE, CurveFitTypeQE, pointQE.Count());
|
}
|
}
|
|
|
//注意此方法 返回的点没有拟合
|
public static List<CurvePoint> CalculateE_AlignPointP(
|
List<CurvePoint> pointQH,
|
List<CurvePoint> pointQP,
|
double midu, bool isXStartZero)
|
{
|
return CalculateE_AlignPointP(
|
eFitType.CubicCurve,
|
eFitType.CubicCurve,
|
eFitType.CubicCurve,
|
pointQH, pointQP, midu, isXStartZero);
|
}
|
|
public static List<CurvePoint> CalculateE_AlignPointP(
|
eFitType CurveFitTypeQH,
|
eFitType CurveFitTypeQE,
|
eFitType CurveFitTypeQP,
|
List<CurvePoint> pointQH,
|
List<CurvePoint> pointQP,
|
double midu, bool isXStartZero)
|
{
|
if (pointQH == null || pointQH.Count < 3)
|
return null;
|
if (pointQP == null || pointQP.Count < 3)
|
return null;
|
|
List<CurvePoint> pointQE = new List<CurvePoint>();
|
|
if (pointQH.IsEqualValueX(pointQP))
|
{//x都一致
|
for (int i = 0; i < pointQP.Count; i++)
|
{
|
double Q, H, Eff, Power;
|
Q = pointQP[i].X;
|
Power = pointQP[i].Y;
|
H = pointQH[i].Y;
|
Eff = CalculateE(Q, H, Power, midu);
|
pointQE.Add(new CurvePoint(Q, Eff));
|
}
|
}
|
else
|
{
|
FitHelper fitCurve_QP = new FitHelper(pointQP, CurveFitTypeQP);
|
FitHelper fitCurve_QH = new FitHelper(pointQH, CurveFitTypeQH);
|
for (int i = 0; i < pointQP.Count; i++)
|
{
|
double Q, H, Eff, Power;
|
Q = pointQP[i].X;
|
Power = fitCurve_QP.GetFitPointY(Q);
|
H = fitCurve_QH.GetFitPointY(Q);
|
Eff = CalculateE(Q, H, Power, midu);
|
pointQE.Add(new CurvePoint(Q, Eff));
|
}
|
}
|
|
|
//pointQE = FitHelper.GetFitPointsByExtend(pointQE);
|
|
//保证Q=0时,Eff=0;
|
if (isXStartZero)
|
{
|
pointQE[0] = new CurvePoint(0, 0);
|
}
|
|
return pointQE;
|
}
|
|
#endregion
|
|
#region 功率效率换算
|
/// <summary>
|
/// 计算效率 对其功率
|
/// </summary>
|
public static List<CurvePoint> CalculateELineByP(List<CurvePoint> ptQHs, List<CurvePoint> ptQPs, bool isXStartZero)
|
{
|
return CalculateELineByP(eFitType.CubicCurve, eFitType.CubicCurve, ptQHs, ptQPs, isXStartZero);
|
}
|
|
/// <summary>
|
/// 计算效率 对其功率
|
/// </summary>
|
public static List<CurvePoint> CalculateELineByP(eFitType fitTypeQH, eFitType fitTypeQP, List<CurvePoint> ptQHs, List<CurvePoint> ptQPs, bool isXStartZero)
|
{
|
if (ptQHs == null || ptQHs.Count < 3)
|
{
|
return null;
|
}
|
|
if (ptQPs == null || ptQPs.Count < 3)
|
{
|
return null;
|
}
|
|
List<CurvePoint> list = new List<CurvePoint>();
|
if (ptQHs.IsEqualValueX(ptQPs))
|
{
|
for (int i = 0; i < ptQPs.Count; i++)
|
{
|
double x = ptQPs[i].X;
|
double y = ptQPs[i].Y;
|
double y2 = ptQHs[i].Y;
|
double y3 = CalculateE(x, y2, y, Constant.WaterDensity);
|
list.Add(new CurvePoint(x, y3));
|
}
|
}
|
else
|
{
|
FitHelper fitCurveHelper = new FitHelper(ptQPs, fitTypeQP);
|
FitHelper fitCurveHelper2 = new FitHelper(ptQHs, fitTypeQH);
|
for (int j = 0; j < ptQPs.Count; j++)
|
{
|
double x2 = ptQPs[j].X;
|
double fitPointY = fitCurveHelper.GetFitPointY(x2);
|
double fitPointY2 = fitCurveHelper2.GetFitPointY(x2);
|
double y4 = CalculateE(x2, fitPointY2, fitPointY, Constant.WaterDensity);
|
list.Add(new CurvePoint(x2, y4));
|
}
|
}
|
|
if (isXStartZero)
|
{
|
list[0] = new CurvePoint(0, 0);
|
}
|
|
return list;
|
}
|
|
/// <summary>
|
/// 计算效率 对其效率
|
/// </summary>
|
public static List<CurvePoint> CalculateP_AlignPointE(eFitType fitTypeQH, eFitType fitTypeQE, List<CurvePoint> ptQHs, List<CurvePoint> ptQEs, double midu, double ref_zero_power, bool isXStartZero)
|
{
|
if (ptQHs == null || ptQHs.Count < 3)
|
{
|
return null;
|
}
|
|
if (ptQEs == null || ptQEs.Count < 3)
|
{
|
return null;
|
}
|
|
|
List<CurvePoint> list = new List<CurvePoint>();
|
if (ptQHs.IsEqualValueX(ptQEs))
|
{
|
for (int i = 0; i < ptQEs.Count(); i++)
|
{
|
double x = ptQEs[i].X;
|
double y = ptQEs[i].Y;
|
double y2 = ptQHs[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 CurvePoint(x, num));
|
}
|
}
|
}
|
else
|
{
|
FitHelper fitCurveHelper = new FitHelper(ptQEs, fitTypeQE);
|
FitHelper fitCurveHelper2 = new FitHelper(ptQHs, fitTypeQH);
|
for (int j = 0; j < ptQEs.Count(); j++)
|
{
|
if (j == ptQEs.Count() - 2)
|
{
|
//测试代码
|
}
|
double x2 = ptQEs[j].X;
|
double fitPointY = fitCurveHelper.GetFitPointY(x2);
|
double fitPointY2 = fitCurveHelper2.GetFitPointY(x2);
|
if (!(fitPointY2 < 0.09) && !(fitPointY < 0.5))
|
{
|
double num2 = CalculateP(x2, fitPointY2, fitPointY, 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 CurvePoint(x2, num2));
|
}
|
}
|
}
|
|
if (isXStartZero)
|
{
|
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 fitPoints = FitHelper.GetFitPoints(list);
|
if (fitPoints[0].Y >= fitPoints[1].Y)
|
{
|
fitPoints[0].Y = fitPoints[1].Y * 0.95;
|
}
|
|
double num3 = CurveLineHelper.GetYbyX(fitPoints[0].X, fitPoints[0].Y, fitPoints[1].X, fitPoints[1].Y, 0.0);
|
if (num3 < 0.001)
|
{
|
num3 = fitPoints[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 CurvePoint(0.0, num3));
|
}
|
}
|
else if (ref_zero_power > 0.0)
|
{
|
list.Insert(0, new CurvePoint(0.0, ref_zero_power));
|
}
|
else
|
{
|
var fitPoints2 = FitHelper.GetFitPoints(list);
|
if (fitPoints2[0].Y >= fitPoints2[1].Y)
|
{
|
fitPoints2[0].Y = fitPoints2[1].Y * 0.95;
|
}
|
|
double num4 = CurveLineHelper.GetYbyX(fitPoints2[0].X, fitPoints2[0].Y, fitPoints2[1].X, fitPoints2[1].Y, 0.0);
|
if (num4 < 0.001)
|
{
|
num4 = fitPoints2[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 CurvePoint(0.0, num4));
|
}
|
}
|
|
return list;
|
}
|
|
|
/// <summary>
|
/// 计算效率 对其效率
|
/// </summary>
|
public static List<CurvePoint> CalculateP_AlignPointE(List<CurvePoint> ptQHs, List<CurvePoint> ptQEs, double midu, double ref_zero_power, bool isXStartZero)
|
{
|
if (ptQHs == null || ptQHs.Count < 3)
|
{
|
return null;
|
}
|
|
if (ptQEs == null || ptQEs.Count < 3)
|
{
|
return null;
|
}
|
|
|
List<CurvePoint> list = new List<CurvePoint>();
|
if (ptQHs.IsEqualValueX(ptQEs))
|
{
|
for (int i = 0; i < ptQEs.Count(); i++)
|
{
|
double x = ptQEs[i].X;
|
double y = ptQEs[i].Y;
|
double y2 = ptQHs[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 CurvePoint(x, num));
|
}
|
}
|
}
|
else
|
{
|
FitHelper fitCurveHelper = new FitHelper(ptQEs);
|
FitHelper fitCurveHelper2 = new FitHelper(ptQHs);
|
for (int j = 0; j < ptQEs.Count(); j++)
|
{
|
double x2 = ptQEs[j].X;
|
double fitPointY = fitCurveHelper.GetFitPointY(x2);
|
double fitPointY2 = fitCurveHelper2.GetFitPointY(x2);
|
if (!(fitPointY2 < 0.1) && !(fitPointY < 0.5))
|
{
|
double num2 = CalculateP(x2, fitPointY2, fitPointY, 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 CurvePoint(x2, num2));
|
}
|
}
|
}
|
|
if (isXStartZero)
|
{
|
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 fitPoints = FitHelper.GetFitPoints(list);
|
if (fitPoints[0].Y >= fitPoints[1].Y)
|
{
|
fitPoints[0].Y = fitPoints[1].Y * 0.95;
|
}
|
|
double num3 = CurveLineHelper.GetYbyX(fitPoints[0].X, fitPoints[0].Y, fitPoints[1].X, fitPoints[1].Y, 0.0);
|
if (num3 < 0.001)
|
{
|
num3 = fitPoints[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 CurvePoint(0.0, num3));
|
}
|
}
|
else if (ref_zero_power > 0.0)
|
{
|
list.Insert(0, new CurvePoint(0.0, ref_zero_power));
|
}
|
else
|
{
|
var fitPoints2 = FitHelper.GetFitPoints(list);
|
if (fitPoints2[0].Y >= fitPoints2[1].Y)
|
{
|
fitPoints2[0].Y = fitPoints2[1].Y * 0.95;
|
}
|
|
double num4 = CurveLineHelper.GetYbyX(fitPoints2[0].X, fitPoints2[0].Y, fitPoints2[1].X, fitPoints2[1].Y, 0.0);
|
if (num4 < 0.001)
|
{
|
num4 = fitPoints2[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 CurvePoint(0.0, num4));
|
}
|
}
|
|
return list;
|
}
|
#endregion
|
|
#endregion
|
}
|
}
|
