using Yw.Hydro;
|
using Yw.EPAnet;
|
using System.Diagnostics.Metrics;
|
using Yw.Model;
|
using SqlSugar;
|
namespace Yw.WinFrmUI
|
{
|
/// <summary>
|
///
|
/// </summary>
|
public static class HydroCalcuResultExtensions
|
{
|
/// <summary>
|
/// 计算
|
/// </summary>
|
public static HydroCalcuResult Calcu(this Yw.Model.HydroModelInfo hydroInfo, string calcuMode = Yw.EPAnet.CalcuMode.Simple)
|
{
|
var network = hydroInfo.ToNetwork();
|
if (network == null)
|
{
|
return default;
|
}
|
var calcuResult = network.Calcu(calcuMode);
|
if (calcuResult == null)
|
{
|
return default;
|
}
|
return hydroInfo.GetCalcuResult(calcuResult);
|
}
|
|
/// <summary>
|
/// 获取计算结果
|
/// </summary>
|
public static HydroCalcuResult GetCalcuResult(this Yw.Model.HydroModelInfo hydroInfo, Yw.EPAnet.CalcuResult calcuResult)
|
{
|
if (hydroInfo == null)
|
{
|
return default;
|
}
|
if (calcuResult == null)
|
{
|
return default;
|
}
|
|
var allNodeList = hydroInfo.GetAllNodes();
|
var allLinkList = hydroInfo.GetAllLinks();
|
|
var hydroCalcuResult = new HydroCalcuResult(calcuResult);
|
var allCalcuResultVisualDict = hydroCalcuResult.GetVisualDict();
|
|
#region 水库
|
|
var allReservoirList = hydroInfo.Reservoirs;
|
if (allReservoirList != null && allReservoirList.Count > 0)
|
{
|
foreach (var reservoir in allReservoirList)
|
{
|
var calcuReservoirResult = allCalcuResultVisualDict?.GetValue(reservoir.Code) as HydroCalcuNodeResult;
|
if (calcuReservoirResult != null)
|
{
|
var calcuReservoirNewResult = new HydroCalcuReservoirResult(calcuReservoirResult);
|
calcuReservoirNewResult.CalcuL = calcuReservoirResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuReservoirResult);
|
hydroCalcuResult.NodeList.Add(calcuReservoirNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 水池
|
|
var allTankList = hydroInfo.Tanks;
|
if (allTankList != null && allTankList.Count > 0)
|
{
|
foreach (var tank in allTankList)
|
{
|
var calcuTankResult = allCalcuResultVisualDict?.GetValue(tank.Code) as HydroCalcuNodeResult;
|
if (calcuTankResult != null)
|
{
|
var calcuTankNewResult = new HydroCalcuTankResult(calcuTankResult);
|
calcuTankNewResult.CalcuL = calcuTankResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuTankResult);
|
hydroCalcuResult.NodeList.Add(calcuTankNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 水箱
|
|
var allWaterboxList = hydroInfo.Waterboxs;
|
if (allWaterboxList != null && allWaterboxList.Count > 0)
|
{
|
foreach (var waterbox in allWaterboxList)
|
{
|
var calcuWaterboxResult = allCalcuResultVisualDict?.GetValue(waterbox.Code) as HydroCalcuNodeResult;
|
if (calcuWaterboxResult != null)
|
{
|
var calcuWaterboxNewResult = new HydroCalcuWaterboxResult(calcuWaterboxResult);
|
calcuWaterboxNewResult.CalcuL = calcuWaterboxResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuWaterboxResult);
|
hydroCalcuResult.NodeList.Add(calcuWaterboxNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 连接节点
|
|
var allJunctionList = hydroInfo.Junctions;
|
if (allJunctionList != null && allJunctionList.Count > 0)
|
{
|
foreach (var junction in allJunctionList)
|
{
|
var calcuJunctionResult = allCalcuResultVisualDict?.GetValue(junction.Code) as HydroCalcuNodeResult;
|
if (calcuJunctionResult != null)
|
{
|
var calcuJunctionNewResult = new HydroCalcuJunctionResult(calcuJunctionResult);
|
calcuJunctionNewResult.CalcuPr = calcuJunctionResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuJunctionResult);
|
hydroCalcuResult.NodeList.Add(calcuJunctionNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 闷头
|
|
var allBluntheadList = hydroInfo.Bluntheads;
|
if (allBluntheadList != null && allBluntheadList.Count > 0)
|
{
|
foreach (var blunthead in allBluntheadList)
|
{
|
var calcuBluntheadResult = allCalcuResultVisualDict?.GetValue(blunthead.Code) as HydroCalcuNodeResult;
|
if (calcuBluntheadResult != null)
|
{
|
var calcuBluntheadNewResult = new HydroCalcuBluntheadResult(calcuBluntheadResult);
|
calcuBluntheadNewResult.CalcuPr = calcuBluntheadResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuBluntheadResult);
|
hydroCalcuResult.NodeList.Add(calcuBluntheadNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 弯头
|
|
var allElbowList = hydroInfo.Elbows;
|
if (allElbowList != null && allElbowList.Count > 0)
|
{
|
foreach (var elbow in allElbowList)
|
{
|
var calcuElbowResult = allCalcuResultVisualDict?.GetValue(elbow.Code) as HydroCalcuNodeResult;
|
if (calcuElbowResult != null)
|
{
|
var calcuElbowNewResult = new HydroCalcuElbowResult(calcuElbowResult);
|
calcuElbowNewResult.CalcuPr = calcuElbowResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuElbowResult);
|
hydroCalcuResult.NodeList.Add(calcuElbowNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 三通
|
|
var allThreelinkList = hydroInfo.Threelinks;
|
if (allThreelinkList != null && allThreelinkList.Count > 0)
|
{
|
foreach (var threelink in allThreelinkList)
|
{
|
var calcuThreelinkResult = allCalcuResultVisualDict?.GetValue(threelink.Code) as HydroCalcuNodeResult;
|
if (calcuThreelinkResult != null)
|
{
|
var calcuThreelinkNewResult = new HydroCalcuThreelinkResult(calcuThreelinkResult);
|
calcuThreelinkNewResult.CalcuPr = calcuThreelinkResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuThreelinkResult);
|
hydroCalcuResult.NodeList.Add(calcuThreelinkNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 四通
|
|
var allFourlinkList = hydroInfo.Fourlinks;
|
if (allFourlinkList != null && allFourlinkList.Count > 0)
|
{
|
foreach (var fourlink in allFourlinkList)
|
{
|
var calcuFourlinkResult = allCalcuResultVisualDict?.GetValue(fourlink.Code) as HydroCalcuNodeResult;
|
if (calcuFourlinkResult != null)
|
{
|
var calcuFourlinkNewResult = new HydroCalcuFourlinkResult(calcuFourlinkResult);
|
calcuFourlinkNewResult.CalcuPr = calcuFourlinkResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuFourlinkResult);
|
hydroCalcuResult.NodeList.Add(calcuFourlinkNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 消火栓
|
|
var allHydrantList = hydroInfo.Hydrants;
|
if (allHydrantList != null && allHydrantList.Count > 0)
|
{
|
foreach (var hydrant in allHydrantList)
|
{
|
var calcuHydrantResult = allCalcuResultVisualDict?.GetValue(hydrant.Code) as HydroCalcuNodeResult;
|
if (calcuHydrantResult != null)
|
{
|
var calcuHydrantNewResult = new HydroCalcuHydrantResult(calcuHydrantResult);
|
calcuHydrantNewResult.CalcuPr = calcuHydrantResult.CalcuPress;
|
|
var linkHydrantList = allLinkList?.Where(x => x.StartCode == hydrant.Code || x.EndCode == hydrant.Code).ToList();
|
if (linkHydrantList != null && linkHydrantList.Count > 0)
|
{
|
foreach (var linkHydrant in linkHydrantList)
|
{
|
var calcuLinkHydrantResult = allCalcuResultVisualDict?.GetValue(linkHydrant.Code) as HydroCalcuLinkResult;
|
if (calcuLinkHydrantResult != null)
|
{
|
if (calcuLinkHydrantResult.CalcuFlow.HasValue)
|
{
|
calcuHydrantNewResult.CalcuQ = Math.Abs(calcuLinkHydrantResult.CalcuFlow.Value);
|
break;
|
}
|
}
|
}
|
}
|
|
hydroCalcuResult.NodeList.Remove(calcuHydrantResult);
|
hydroCalcuResult.NodeList.Add(calcuHydrantNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 喷头
|
|
var allNozzleList = hydroInfo.Nozzles;
|
if (allNozzleList != null && allNozzleList.Count > 0)
|
{
|
foreach (var nozzle in allNozzleList)
|
{
|
var calcuNozzleResult = allCalcuResultVisualDict?.GetValue(nozzle.Code) as HydroCalcuNodeResult;
|
if (calcuNozzleResult != null)
|
{
|
var calcuNozzleNewResult = new HydroCalcuNozzleResult(calcuNozzleResult);
|
calcuNozzleNewResult.CalcuPr = calcuNozzleResult.CalcuPress;
|
|
var linkNozzleList = allLinkList?.Where(x => x.StartCode == nozzle.Code || x.EndCode == nozzle.Code).ToList();
|
if (linkNozzleList != null && linkNozzleList.Count > 0)
|
{
|
foreach (var linkNozzle in linkNozzleList)
|
{
|
var calcuLinkNozzleResult = allCalcuResultVisualDict?.GetValue(linkNozzle.Code) as HydroCalcuLinkResult;
|
if (calcuLinkNozzleResult != null)
|
{
|
if (calcuLinkNozzleResult.CalcuFlow.HasValue)
|
{
|
calcuNozzleNewResult.CalcuQ = Math.Abs(calcuLinkNozzleResult.CalcuFlow.Value);
|
break;
|
}
|
}
|
}
|
}
|
|
hydroCalcuResult.NodeList.Remove(calcuNozzleResult);
|
hydroCalcuResult.NodeList.Add(calcuNozzleNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 冷却塔
|
|
var allCoolingList = hydroInfo.Coolings;
|
if (allCoolingList != null && allCoolingList.Count > 0)
|
{
|
foreach (var cooling in allCoolingList)
|
{
|
var calcuCoolingResult = allCalcuResultVisualDict?.GetValue(cooling.Code) as HydroCalcuNodeResult;
|
if (calcuCoolingResult != null)
|
{
|
var calcuCoolingNewResult = new HydroCalcuCoolingResult(calcuCoolingResult);
|
calcuCoolingNewResult.CalcuPr = calcuCoolingResult.CalcuPress;
|
|
var linkCoolingList = allLinkList?.Where(x => x.StartCode == cooling.Code || x.EndCode == cooling.Code).ToList();
|
if (linkCoolingList != null && linkCoolingList.Count > 0)
|
{
|
foreach (var linkCooling in linkCoolingList)
|
{
|
var calcuLinkCoolingResult = allCalcuResultVisualDict?.GetValue(linkCooling.Code) as HydroCalcuLinkResult;
|
if (calcuLinkCoolingResult != null)
|
{
|
if (calcuLinkCoolingResult.CalcuFlow.HasValue)
|
{
|
calcuCoolingNewResult.CalcuQ = Math.Abs(calcuLinkCoolingResult.CalcuFlow.Value);
|
break;
|
}
|
}
|
}
|
}
|
|
hydroCalcuResult.NodeList.Remove(calcuCoolingResult);
|
hydroCalcuResult.NodeList.Add(calcuCoolingNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 水表
|
|
var allMeterList = hydroInfo.Meters;
|
if (allMeterList != null && allMeterList.Count > 0)
|
{
|
foreach (var meter in allMeterList)
|
{
|
var calcuMeterResult = allCalcuResultVisualDict?.GetValue(meter.Code) as HydroCalcuNodeResult;
|
if (calcuMeterResult != null)
|
{
|
var calcuMeterNewResult = new HydroCalcuMeterResult(calcuMeterResult);
|
calcuMeterNewResult.CalcuPr = calcuMeterResult.CalcuPress;
|
|
var linkMeterList = allLinkList?.Where(x => x.StartCode == meter.Code || x.EndCode == meter.Code).ToList();
|
if (linkMeterList != null && linkMeterList.Count > 0)
|
{
|
foreach (var linkMeter in linkMeterList)
|
{
|
var calcuLinkMeterResult = allCalcuResultVisualDict?.GetValue(linkMeter.Code) as HydroCalcuLinkResult;
|
if (calcuLinkMeterResult != null)
|
{
|
if (calcuLinkMeterResult.CalcuFlow.HasValue)
|
{
|
calcuMeterNewResult.CalcuQ = Math.Abs(calcuLinkMeterResult.CalcuFlow.Value);
|
break;
|
}
|
}
|
}
|
}
|
|
hydroCalcuResult.NodeList.Remove(calcuMeterResult);
|
hydroCalcuResult.NodeList.Add(calcuMeterNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 流量计
|
|
var allFlowmeterList = hydroInfo.Flowmeters;
|
if (allFlowmeterList != null && allFlowmeterList.Count > 0)
|
{
|
foreach (var flowmeter in allFlowmeterList)
|
{
|
var calcuFlowmeterResult = allCalcuResultVisualDict?.GetValue(flowmeter.Code) as HydroCalcuNodeResult;
|
if (calcuFlowmeterResult != null)
|
{
|
var calcuFlowmeterNewResult = new HydroCalcuFlowmeterResult(calcuFlowmeterResult);
|
calcuFlowmeterNewResult.CalcuPr = calcuFlowmeterResult.CalcuPress;
|
|
var linkFlowmeterList = allLinkList?.Where(x => x.StartCode == flowmeter.Code || x.EndCode == flowmeter.Code).ToList();
|
if (linkFlowmeterList != null && linkFlowmeterList.Count > 0)
|
{
|
foreach (var linkFlowmeter in linkFlowmeterList)
|
{
|
var calcuLinkFlowmeterResult = allCalcuResultVisualDict?.GetValue(linkFlowmeter.Code) as HydroCalcuLinkResult;
|
if (calcuLinkFlowmeterResult != null)
|
{
|
if (calcuLinkFlowmeterResult.CalcuFlow.HasValue)
|
{
|
calcuFlowmeterNewResult.CalcuQ = Math.Abs(calcuLinkFlowmeterResult.CalcuFlow.Value);
|
break;
|
}
|
}
|
}
|
}
|
|
hydroCalcuResult.NodeList.Remove(calcuFlowmeterResult);
|
hydroCalcuResult.NodeList.Add(calcuFlowmeterNewResult);
|
}
|
}
|
}
|
|
|
#endregion
|
|
#region 压力表
|
|
var allPressmeterList = hydroInfo.Pressmeters;
|
if (allPressmeterList != null && allPressmeterList.Count > 0)
|
{
|
foreach (var pressmeter in allPressmeterList)
|
{
|
var calcuPressmeterResult = allCalcuResultVisualDict?.GetValue(pressmeter.Code) as HydroCalcuNodeResult;
|
if (calcuPressmeterResult != null)
|
{
|
var calcuPressmeterNewResult = new HydroCalcuPressmeterResult(calcuPressmeterResult);
|
calcuPressmeterNewResult.CalcuPr = calcuPressmeterResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuPressmeterResult);
|
hydroCalcuResult.NodeList.Add(calcuPressmeterNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 管道
|
|
var allPipeList = hydroInfo.Pipes;
|
if (allPipeList != null && allPipeList.Count > 0)
|
{
|
foreach (var pipe in allPipeList)
|
{
|
var calcuPipeResult = allCalcuResultVisualDict?.GetValue(pipe.Code) as HydroCalcuLinkResult;
|
if (calcuPipeResult != null)
|
{
|
var calcuPipeNewResult = new HydroCalcuPipeResult(calcuPipeResult);
|
if (calcuPipeResult.CalcuFlow.HasValue)
|
{
|
calcuPipeNewResult.CalcuQ = Math.Abs(calcuPipeResult.CalcuFlow.Value);
|
var startPipeCode = calcuPipeResult.CalcuFlow.Value > 0 ? pipe.StartCode : pipe.EndCode;
|
var calcuStartPipeNodeResult = allCalcuResultVisualDict?.GetValue(startPipeCode) as HydroCalcuNodeResult;
|
if (calcuStartPipeNodeResult != null)
|
{
|
calcuPipeNewResult.CalcuPr1 = calcuStartPipeNodeResult.CalcuPress;
|
}
|
var endPipeCode = calcuPipeResult.CalcuFlow.Value > 0 ? pipe.EndCode : pipe.StartCode;
|
var calcuEndPipeNodeResult = allCalcuResultVisualDict?.GetValue(endPipeCode) as HydroCalcuNodeResult;
|
if (calcuEndPipeNodeResult != null)
|
{
|
calcuPipeNewResult.CalcuPr2 = calcuEndPipeNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuPipeResult);
|
hydroCalcuResult.LinkList.Add(calcuPipeNewResult);
|
}
|
}
|
}
|
|
|
#endregion
|
|
#region 过渡件
|
|
var allTranslationList = hydroInfo.Translations;
|
if (allTranslationList != null && allTranslationList.Count > 0)
|
{
|
foreach (var translation in allTranslationList)
|
{
|
var calcuTranslationResult = allCalcuResultVisualDict?.GetValue(translation.Code) as HydroCalcuLinkResult;
|
if (calcuTranslationResult != null)
|
{
|
var calcuTranslationNewResult = new HydroCalcuTranslationResult(calcuTranslationResult);
|
if (calcuTranslationResult.CalcuFlow.HasValue)
|
{
|
calcuTranslationNewResult.CalcuQ = Math.Abs(calcuTranslationResult.CalcuFlow.Value);
|
var startTranslationCode = calcuTranslationResult.CalcuFlow.Value > 0 ? translation.StartCode : translation.EndCode;
|
var calcuStartTranslationNodeResult = allCalcuResultVisualDict?.GetValue(startTranslationCode) as HydroCalcuNodeResult;
|
if (calcuStartTranslationNodeResult != null)
|
{
|
calcuTranslationNewResult.CalcuPr1 = calcuStartTranslationNodeResult.CalcuPress;
|
}
|
var endTranslationCode = calcuTranslationResult.CalcuFlow.Value > 0 ? translation.EndCode : translation.StartCode;
|
var calcuEndTranslationNodeResult = allCalcuResultVisualDict?.GetValue(endTranslationCode) as HydroCalcuNodeResult;
|
if (calcuEndTranslationNodeResult != null)
|
{
|
calcuTranslationNewResult.CalcuPr2 = calcuEndTranslationNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuTranslationResult);
|
hydroCalcuResult.LinkList.Add(calcuTranslationNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 水泵
|
|
var allPumpList = hydroInfo.Pumps;
|
if (allPumpList != null && allPumpList.Count > 0)
|
{
|
foreach (var pump in allPumpList)
|
{
|
var calcuPumpResult = allCalcuResultVisualDict?.GetValue(pump.Code) as HydroCalcuLinkResult;
|
if (calcuPumpResult != null)
|
{
|
var calcuPumpNewResult = new HydroCalcuPumpResult(calcuPumpResult);
|
if (calcuPumpResult.CalcuFlow.HasValue)
|
{
|
//流量
|
calcuPumpNewResult.CalcuQ = Math.Abs(calcuPumpResult.CalcuFlow.Value);
|
|
//进口压力
|
var startPumpCode = calcuPumpResult.CalcuFlow.Value > 0 ? pump.StartCode : pump.EndCode;
|
var startPumpNode = allNodeList?.Find(x => x.Code == startPumpCode);
|
if (startPumpNode != null)
|
{
|
var calcuStartPumpNodeResult = allCalcuResultVisualDict?.GetValue(startPumpCode) as HydroCalcuNodeResult;
|
if (calcuStartPumpNodeResult != null)
|
{
|
calcuPumpNewResult.CalcuPr1 = calcuStartPumpNodeResult.CalcuPress;
|
}
|
}
|
|
//出口压力
|
var endPumpCode = calcuPumpResult.CalcuFlow.Value > 0 ? pump.EndCode : pump.StartCode;
|
var endPumpNode = allNodeList?.Find(x => x.Code == endPumpCode);
|
if (endPumpNode != null)
|
{
|
var calcuEndPumpNodeResult = allCalcuResultVisualDict?.GetValue(endPumpCode) as HydroCalcuNodeResult;
|
if (calcuEndPumpNodeResult != null)
|
{
|
calcuPumpNewResult.CalcuPr2 = calcuEndPumpNodeResult.CalcuPress;
|
}
|
}
|
|
if (calcuPumpNewResult.CalcuQ > 0)
|
{
|
//扬程
|
if (calcuPumpNewResult.CalcuPr1.HasValue && calcuPumpNewResult.CalcuPr2.HasValue)
|
{
|
var pr1 = CalculationHelper.M2Mpa(calcuPumpNewResult.CalcuPr1.Value);
|
var pr2 = CalculationHelper.M2Mpa(calcuPumpNewResult.CalcuPr2.Value);
|
var d1 = pump.InletDiameter;
|
var d2 = pump.OutletDiameter;
|
var z1 = (startPumpNode as HydroJunctionInfo)?.Elev;
|
var z2 = (endPumpNode as HydroJunctionInfo)?.Elev;
|
calcuPumpNewResult.CalcuH = Yw.Pump.CalculationHelper.CalcuH(pr1, pr2, calcuPumpNewResult.CalcuQ.Value, d1, d2, z1, z2);
|
}
|
|
//功率
|
if (pump.LinkStatus == Yw.Hydro.PumpStatus.Open && pump.RatedN.HasValue)
|
{
|
var curveqp = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQP);
|
if (curveqp != null)
|
{
|
if (curveqp.CurveData != null && curveqp.CurveData.Count > 3)
|
{
|
var point2dList = curveqp.CurveData.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
|
var point2dSimularList = point2dList.GetQPPointListByN(pump.RatedN.Value, pump.RatedN.Value * pump.SpeedRatio);
|
var pumpCurveQp = new Yw.Pump.CurveQP(Yw.Ahart.eFeatType.Cubic, point2dSimularList);
|
calcuPumpNewResult.CalcuP = pumpCurveQp.FeatCurve.GetPointYUnlimited(calcuPumpNewResult.CalcuQ.Value);
|
}
|
}
|
}
|
|
//效率
|
if (calcuPumpNewResult.CalcuH.HasValue && calcuPumpNewResult.CalcuP.HasValue)
|
{
|
calcuPumpNewResult.CalcuE = Yw.Pump.CalculationHelper.CalcuE(calcuPumpNewResult.CalcuQ.Value, calcuPumpNewResult.CalcuH.Value, calcuPumpNewResult.CalcuP.Value);
|
if (calcuPumpNewResult.CalcuE.Value > 95)
|
{
|
calcuPumpNewResult.CalcuE = 95;
|
}
|
}
|
|
}
|
|
}
|
hydroCalcuResult.LinkList.Remove(calcuPumpResult);
|
hydroCalcuResult.LinkList.Add(calcuPumpNewResult);
|
|
switch (pump.LinkStatus)
|
{
|
case Yw.Hydro.PumpStatus.Open:
|
{
|
if (calcuPumpNewResult.CalcuFlow.HasValue)
|
{
|
if (calcuPumpNewResult.CalcuFlow.Value <= 0)
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = pump.Code,
|
Message = $"[{pump.Name}]不满足当前工况 "
|
});
|
}
|
}
|
else
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = pump.Code,
|
Message = $"[{pump.Name}]流量计算失败 "
|
});
|
}
|
}
|
break;
|
case Yw.Hydro.PumpStatus.Closed:
|
{
|
if (calcuPumpNewResult.CalcuFlow.HasValue)
|
{
|
if (calcuPumpNewResult.CalcuFlow.Value > 0)
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = pump.Code,
|
Message = $"[{pump.Name}]不满足当前工况 "
|
});
|
}
|
}
|
else
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = pump.Code,
|
Message = $"[{pump.Name}]流量计算失败 "
|
});
|
}
|
}
|
break;
|
default: break;
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 阀门
|
|
var allValveList = hydroInfo.Valves;
|
if (allValveList != null && allValveList.Count > 0)
|
{
|
foreach (var valve in allValveList)
|
{
|
var calcuValveResult = allCalcuResultVisualDict?.GetValue(valve.Code) as HydroCalcuLinkResult;
|
if (calcuValveResult != null)
|
{
|
var calcuValveNewResult = new HydroCalcuValveResult(calcuValveResult);
|
if (calcuValveResult.CalcuFlow.HasValue)
|
{
|
calcuValveNewResult.CalcuQ = Math.Abs(calcuValveResult.CalcuFlow.Value);
|
var startValveCode = calcuValveResult.CalcuFlow.Value > 0 ? valve.StartCode : valve.EndCode;
|
var calcuStartValveNodeResult = allCalcuResultVisualDict?.GetValue(startValveCode) as HydroCalcuNodeResult;
|
if (calcuStartValveNodeResult != null)
|
{
|
calcuValveNewResult.CalcuPr1 = calcuStartValveNodeResult.CalcuPress;
|
}
|
var endValveCode = calcuValveResult.CalcuFlow.Value > 0 ? valve.EndCode : valve.StartCode;
|
var calcuEndValveNodeResult = allCalcuResultVisualDict?.GetValue(endValveCode) as HydroCalcuNodeResult;
|
if (calcuEndValveNodeResult != null)
|
{
|
calcuValveNewResult.CalcuPr2 = calcuEndValveNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuValveResult);
|
hydroCalcuResult.LinkList.Add(calcuValveNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 换热器
|
|
var allExchangerList = hydroInfo.Exchangers;
|
if (allExchangerList != null && allExchangerList.Count > 0)
|
{
|
foreach (var exchanger in allExchangerList)
|
{
|
var calcuExchangerResult = allCalcuResultVisualDict?.GetValue(exchanger.Code) as HydroCalcuLinkResult;
|
if (calcuExchangerResult != null)
|
{
|
var calcuExchangerNewResult = new HydroCalcuExchangerResult(calcuExchangerResult);
|
if (calcuExchangerResult.CalcuFlow.HasValue)
|
{
|
calcuExchangerNewResult.CalcuQ = Math.Abs(calcuExchangerResult.CalcuFlow.Value);
|
var startExchangerCode = calcuExchangerResult.CalcuFlow.Value > 0 ? exchanger.StartCode : exchanger.EndCode;
|
var calcuStartExchangerNodeResult = allCalcuResultVisualDict?.GetValue(startExchangerCode) as HydroCalcuNodeResult;
|
if (calcuStartExchangerNodeResult != null)
|
{
|
calcuExchangerNewResult.CalcuPr1 = calcuStartExchangerNodeResult.CalcuPress;
|
}
|
var endExchangerCode = calcuExchangerResult.CalcuFlow.Value > 0 ? exchanger.EndCode : exchanger.StartCode;
|
var calcuEndExchangerNodeResult = allCalcuResultVisualDict?.GetValue(endExchangerCode) as HydroCalcuNodeResult;
|
if (calcuEndExchangerNodeResult != null)
|
{
|
calcuExchangerNewResult.CalcuPr2 = calcuEndExchangerNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuExchangerResult);
|
hydroCalcuResult.LinkList.Add(calcuExchangerNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 压缩机
|
|
var allCompressorList = hydroInfo.Compressors;
|
if (allCompressorList != null && allCompressorList.Count > 0)
|
{
|
foreach (var compressor in allCompressorList)
|
{
|
var calcuCompressorResult = allCalcuResultVisualDict?.GetValue(compressor.Code) as HydroCalcuLinkResult;
|
if (calcuCompressorResult != null)
|
{
|
var calcuCompressorNewResult = new HydroCalcuCompressorResult(calcuCompressorResult);
|
if (calcuCompressorResult.CalcuFlow.HasValue)
|
{
|
calcuCompressorNewResult.CalcuQ = Math.Abs(calcuCompressorResult.CalcuFlow.Value);
|
var startCompressorCode = calcuCompressorResult.CalcuFlow.Value > 0 ? compressor.StartCode : compressor.EndCode;
|
var calcuStartCompressorNodeResult = allCalcuResultVisualDict?.GetValue(startCompressorCode) as HydroCalcuNodeResult;
|
if (calcuStartCompressorNodeResult != null)
|
{
|
calcuCompressorNewResult.CalcuPr1 = calcuStartCompressorNodeResult.CalcuPress;
|
}
|
var endCompressorCode = calcuCompressorResult.CalcuFlow.Value > 0 ? compressor.EndCode : compressor.StartCode;
|
var calcuEndCompressorNodeResult = allCalcuResultVisualDict?.GetValue(endCompressorCode) as HydroCalcuNodeResult;
|
if (calcuEndCompressorNodeResult != null)
|
{
|
calcuCompressorNewResult.CalcuPr2 = calcuEndCompressorNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuCompressorResult);
|
hydroCalcuResult.LinkList.Add(calcuCompressorNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
return hydroCalcuResult;
|
}
|
|
|
|
|
}
|
}
|
