using DevExpress.Pdf.ContentGeneration.Fonts;
|
using NPOI.SS.Formula.Functions;
|
using SqlSugar;
|
using System.Diagnostics.Metrics;
|
using Yw.EPAnet;
|
using Yw.Hydro;
|
using Yw.Model;
|
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.MinorLoss,
|
bool isHead = false,
|
List<Yw.Vmo.HydroEvaluationVmo> allEvaluationList = null
|
)
|
{
|
var network = hydroInfo.ToNetwork();
|
if (network == null)
|
{
|
return default;
|
}
|
var calcuResult = network.Calcu(calcuMode);
|
if (calcuResult == null)
|
{
|
return default;
|
}
|
return hydroInfo.GetCalcuResult(calcuResult, isHead, allEvaluationList);
|
}
|
|
/// <summary>
|
/// 获取计算结果
|
/// </summary>
|
public static HydroCalcuResult GetCalcuResult
|
(
|
this Yw.Model.HydroModelInfo hydroInfo,
|
Yw.EPAnet.CalcuResult calcuResult,
|
bool isHead = false,
|
List<Yw.Vmo.HydroEvaluationVmo> allEvaluationList = null
|
)
|
{
|
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 allMinorLossEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.MinorLoss).ToList();
|
//压差
|
var allPressDiffEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.PressDiff).ToList();
|
//千米沿程损失
|
var allFrictionLossKmEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.FrictionLossKm).ToList();
|
//运行流量
|
var allFlowRunEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.FlowRun).ToList();
|
//压力
|
var allPressEvaluationList = allEvaluationList?.Where(x => x.EvaluateType == Yw.Hydro.EvaluateType.Press).ToList();
|
|
#endregion
|
|
#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 = isHead ? calcuJunctionResult.CalcuHead : 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 = isHead ? calcuBluntheadResult.CalcuHead : calcuBluntheadResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuBluntheadResult);
|
hydroCalcuResult.NodeList.Add(calcuBluntheadNewResult);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 弯头
|
|
var allElbowList = hydroInfo.Elbows;
|
if (allElbowList != null && allElbowList.Count > 0)
|
{
|
var allElbowMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Elbow).ToList();
|
foreach (var elbow in allElbowList)
|
{
|
var calcuElbowResult = allCalcuResultVisualDict?.GetValue(elbow.Code) as HydroCalcuNodeResult;
|
if (calcuElbowResult != null)
|
{
|
var calcuElbowNewResult = new HydroCalcuElbowResult(calcuElbowResult);
|
calcuElbowNewResult.CalcuPr = isHead ? calcuElbowResult.CalcuHead : calcuElbowResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuElbowResult);
|
hydroCalcuResult.NodeList.Add(calcuElbowNewResult);
|
if (calcuElbowNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allElbowMinorLossEvaluationList != null && allElbowMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var elbowMinorLossEvaluation in allElbowMinorLossEvaluationList)
|
{
|
if (elbowMinorLossEvaluation.IsMeet(calcuElbowNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = elbow.Code,
|
Message = $"[{elbow.Name}]{elbowMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 三通
|
|
var allThreelinkList = hydroInfo.Threelinks;
|
if (allThreelinkList != null && allThreelinkList.Count > 0)
|
{
|
var allTreelinkMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Threelink).ToList();
|
foreach (var threelink in allThreelinkList)
|
{
|
var calcuThreelinkResult = allCalcuResultVisualDict?.GetValue(threelink.Code) as HydroCalcuNodeResult;
|
if (calcuThreelinkResult != null)
|
{
|
var calcuThreelinkNewResult = new HydroCalcuThreelinkResult(calcuThreelinkResult);
|
calcuThreelinkNewResult.CalcuPr = isHead ? calcuThreelinkResult.CalcuHead : calcuThreelinkResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuThreelinkResult);
|
hydroCalcuResult.NodeList.Add(calcuThreelinkNewResult);
|
if (calcuThreelinkNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allTreelinkMinorLossEvaluationList != null && allTreelinkMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var threelinkMinorLossEvaluation in allTreelinkMinorLossEvaluationList)
|
{
|
if (threelinkMinorLossEvaluation.IsMeet(calcuThreelinkNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = threelink.Code,
|
Message = $"[{threelink.Name}]{threelinkMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 四通
|
|
var allFourlinkList = hydroInfo.Fourlinks;
|
if (allFourlinkList != null && allFourlinkList.Count > 0)
|
{
|
var allFourlinkMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Fourlink).ToList();
|
foreach (var fourlink in allFourlinkList)
|
{
|
var calcuFourlinkResult = allCalcuResultVisualDict?.GetValue(fourlink.Code) as HydroCalcuNodeResult;
|
if (calcuFourlinkResult != null)
|
{
|
var calcuFourlinkNewResult = new HydroCalcuFourlinkResult(calcuFourlinkResult);
|
calcuFourlinkNewResult.CalcuPr = isHead ? calcuFourlinkResult.CalcuHead : calcuFourlinkResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuFourlinkResult);
|
hydroCalcuResult.NodeList.Add(calcuFourlinkNewResult);
|
if (calcuFourlinkNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allFourlinkMinorLossEvaluationList != null && allFourlinkMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var fourlinkMinorLossEvaluation in allFourlinkMinorLossEvaluationList)
|
{
|
if (fourlinkMinorLossEvaluation.IsMeet(calcuFourlinkNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = fourlink.Code,
|
Message = $"[{fourlink.Name}]{fourlinkMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 消火栓
|
|
var allHydrantList = hydroInfo.Hydrants;
|
if (allHydrantList != null && allHydrantList.Count > 0)
|
{
|
var allHydrantMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Hydrant).ToList();
|
foreach (var hydrant in allHydrantList)
|
{
|
var calcuHydrantResult = allCalcuResultVisualDict?.GetValue(hydrant.Code) as HydroCalcuNodeResult;
|
if (calcuHydrantResult != null)
|
{
|
var calcuHydrantNewResult = new HydroCalcuHydrantResult(calcuHydrantResult);
|
calcuHydrantNewResult.CalcuPr = isHead ? calcuHydrantResult.CalcuHead : 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);
|
|
if (calcuHydrantNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allHydrantMinorLossEvaluationList != null && allHydrantMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var hydrantMinorLossEvaluation in allHydrantMinorLossEvaluationList)
|
{
|
if (hydrantMinorLossEvaluation.IsMeet(calcuHydrantNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = hydrant.Code,
|
Message = $"[{hydrant.Name}]{hydrantMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 喷头
|
|
var allNozzleList = hydroInfo.Nozzles;
|
if (allNozzleList != null && allNozzleList.Count > 0)
|
{
|
var allNozzleMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Nozzle).ToList();
|
foreach (var nozzle in allNozzleList)
|
{
|
var calcuNozzleResult = allCalcuResultVisualDict?.GetValue(nozzle.Code) as HydroCalcuNodeResult;
|
if (calcuNozzleResult != null)
|
{
|
var calcuNozzleNewResult = new HydroCalcuNozzleResult(calcuNozzleResult);
|
calcuNozzleNewResult.CalcuPr = isHead ? calcuNozzleResult.CalcuHead : 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);
|
|
if (calcuNozzleNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allNozzleMinorLossEvaluationList != null && allNozzleMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var nozzleMinorLossEvaluation in allNozzleMinorLossEvaluationList)
|
{
|
if (nozzleMinorLossEvaluation.IsMeet(calcuNozzleNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = nozzle.Code,
|
Message = $"[{nozzle.Name}]{nozzleMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 冷却塔
|
|
var allCoolingList = hydroInfo.Coolings;
|
if (allCoolingList != null && allCoolingList.Count > 0)
|
{
|
var allCoolingMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Cooling).ToList();
|
var allCoolingPressDiffEvaluationList = allPressDiffEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Cooling).ToList();
|
foreach (var cooling in allCoolingList)
|
{
|
var calcuCoolingResult = allCalcuResultVisualDict?.GetValue(cooling.Code) as HydroCalcuNodeResult;
|
if (calcuCoolingResult != null)
|
{
|
var calcuCoolingNewResult = new HydroCalcuCoolingResult(calcuCoolingResult);
|
calcuCoolingNewResult.CalcuPr = isHead ? calcuCoolingResult.CalcuHead : 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);
|
if (calcuCoolingNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allCoolingMinorLossEvaluationList != null && allCoolingMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var coolingMinorLossEvaluation in allCoolingMinorLossEvaluationList)
|
{
|
if (coolingMinorLossEvaluation.IsMeet(calcuCoolingNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = cooling.Code,
|
Message = $"[{cooling.Name}]{coolingMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
if (calcuCoolingNewResult.CalcuPress.HasValue)
|
{
|
if (allCoolingPressDiffEvaluationList != null && allCoolingPressDiffEvaluationList.Count > 0)
|
{
|
var coolingPressDiff = calcuCoolingNewResult.CalcuPress.Value - cooling.LowerLimit;
|
foreach (var coolingPressDiffEvaluation in allCoolingPressDiffEvaluationList)
|
{
|
if (coolingPressDiffEvaluation.IsMeet(coolingPressDiff))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = cooling.Code,
|
Message = $"[{cooling.Name}]{coolingPressDiffEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 水表
|
|
var allMeterList = hydroInfo.Meters;
|
if (allMeterList != null && allMeterList.Count > 0)
|
{
|
var allMeterMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Meter).ToList();
|
foreach (var meter in allMeterList)
|
{
|
var calcuMeterResult = allCalcuResultVisualDict?.GetValue(meter.Code) as HydroCalcuNodeResult;
|
if (calcuMeterResult != null)
|
{
|
var calcuMeterNewResult = new HydroCalcuMeterResult(calcuMeterResult);
|
calcuMeterNewResult.CalcuPr = isHead ? calcuMeterResult.CalcuHead : 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);
|
if (calcuMeterNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allMeterMinorLossEvaluationList != null && allMeterMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var meterMinorLossEvaluation in allMeterMinorLossEvaluationList)
|
{
|
if (meterMinorLossEvaluation.IsMeet(calcuMeterNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = meter.Code,
|
Message = $"[{meter.Name}]{meterMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 流量计
|
|
var allFlowmeterList = hydroInfo.Flowmeters;
|
if (allFlowmeterList != null && allFlowmeterList.Count > 0)
|
{
|
var allFlowmeterMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Flowmeter).ToList();
|
foreach (var flowmeter in allFlowmeterList)
|
{
|
var calcuFlowmeterResult = allCalcuResultVisualDict?.GetValue(flowmeter.Code) as HydroCalcuNodeResult;
|
if (calcuFlowmeterResult != null)
|
{
|
var calcuFlowmeterNewResult = new HydroCalcuFlowmeterResult(calcuFlowmeterResult);
|
calcuFlowmeterNewResult.CalcuPr = isHead ? calcuFlowmeterResult.CalcuHead : 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);
|
if (calcuFlowmeterNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allFlowmeterMinorLossEvaluationList != null && allFlowmeterMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var flowmeterMinorLossEvaluation in allFlowmeterMinorLossEvaluationList)
|
{
|
if (flowmeterMinorLossEvaluation.IsMeet(calcuFlowmeterNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = flowmeter.Code,
|
Message = $"[{flowmeter.Name}]{flowmeterMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
#endregion
|
|
#region 压力表
|
|
var allPressmeterList = hydroInfo.Pressmeters;
|
if (allPressmeterList != null && allPressmeterList.Count > 0)
|
{
|
var allPressmeterMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Pressmeter).ToList();
|
foreach (var pressmeter in allPressmeterList)
|
{
|
var calcuPressmeterResult = allCalcuResultVisualDict?.GetValue(pressmeter.Code) as HydroCalcuNodeResult;
|
if (calcuPressmeterResult != null)
|
{
|
var calcuPressmeterNewResult = new HydroCalcuPressmeterResult(calcuPressmeterResult);
|
calcuPressmeterNewResult.CalcuPr = isHead ? calcuPressmeterResult.CalcuHead : calcuPressmeterResult.CalcuPress;
|
hydroCalcuResult.NodeList.Remove(calcuPressmeterResult);
|
hydroCalcuResult.NodeList.Add(calcuPressmeterNewResult);
|
if (calcuPressmeterNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allPressmeterMinorLossEvaluationList != null && allPressmeterMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var pressmeterMinorLossEvaluation in allPressmeterMinorLossEvaluationList)
|
{
|
if (pressmeterMinorLossEvaluation.IsMeet(calcuPressmeterNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = pressmeter.Code,
|
Message = $"[{pressmeter.Name}]{pressmeterMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 管道
|
|
var allPipeList = hydroInfo.Pipes;
|
if (allPipeList != null && allPipeList.Count > 0)
|
{
|
var allPipeFrictionLossKmEvaluationList = allFrictionLossKmEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Pipe).ToList();
|
allPipeFrictionLossKmEvaluationList = null;//测试代码
|
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 = isHead ? calcuStartPipeNodeResult.CalcuHead : calcuStartPipeNodeResult.CalcuPress;
|
}
|
var endPipeCode = calcuPipeResult.CalcuFlow.Value > 0 ? pipe.EndCode : pipe.StartCode;
|
var calcuEndPipeNodeResult = allCalcuResultVisualDict?.GetValue(endPipeCode) as HydroCalcuNodeResult;
|
if (calcuEndPipeNodeResult != null)
|
{
|
calcuPipeNewResult.CalcuPr2 = isHead ? calcuEndPipeNodeResult.CalcuHead : calcuEndPipeNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuPipeResult);
|
hydroCalcuResult.LinkList.Add(calcuPipeNewResult);
|
if (calcuPipeNewResult.CalcuFrictionLoss.HasValue)
|
{
|
if (pipe.Length > 0)
|
{
|
if (allPipeFrictionLossKmEvaluationList != null && allPipeFrictionLossKmEvaluationList.Count > 0)
|
{
|
var pipeFrictionLossKm = calcuPipeNewResult.CalcuFrictionLoss.Value / pipe.Length * 1000;
|
foreach (var pipeFrictionLossKmEvaluation in allPipeFrictionLossKmEvaluationList)
|
{
|
if (pipeFrictionLossKmEvaluation.IsMeet(pipeFrictionLossKm))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = pipe.Code,
|
Message = $"[{pipe.Name}]{pipeFrictionLossKmEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
#endregion
|
|
#region 过渡件
|
|
var allTranslationList = hydroInfo.Translations;
|
if (allTranslationList != null && allTranslationList.Count > 0)
|
{
|
var allTranslationMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Translation).ToList();
|
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 = isHead ? calcuStartTranslationNodeResult.CalcuHead : calcuStartTranslationNodeResult.CalcuPress;
|
}
|
var endTranslationCode = calcuTranslationResult.CalcuFlow.Value > 0 ? translation.EndCode : translation.StartCode;
|
var calcuEndTranslationNodeResult = allCalcuResultVisualDict?.GetValue(endTranslationCode) as HydroCalcuNodeResult;
|
if (calcuEndTranslationNodeResult != null)
|
{
|
calcuTranslationNewResult.CalcuPr2 = isHead ? calcuEndTranslationNodeResult.CalcuHead : calcuEndTranslationNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuTranslationResult);
|
hydroCalcuResult.LinkList.Add(calcuTranslationNewResult);
|
if (calcuTranslationNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allTranslationMinorLossEvaluationList != null && allTranslationMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var translationMinorLossEvaluation in allTranslationMinorLossEvaluationList)
|
{
|
if (translationMinorLossEvaluation.IsMeet(calcuTranslationNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = translation.Code,
|
Message = $"[{translation.Name}]{translationMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 水泵
|
|
var allPumpList = hydroInfo.Pumps;
|
if (allPumpList != null && allPumpList.Count > 0)
|
{
|
var allPumpFlowRunEvaluationList = allFlowRunEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Pump).ToList();
|
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 = isHead ? calcuStartPumpNodeResult.CalcuHead : 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 = isHead ? calcuEndPumpNodeResult.CalcuHead : 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);
|
double? d1 = pump.InletDiameter < 1 ? null : pump.InletDiameter;
|
double? d2 = pump.OutletDiameter < 1 ? null : pump.OutletDiameter;
|
double? z1 = (startPumpNode as HydroJunctionInfo)?.Elev;
|
double? 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)
|
{
|
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, pump.RatedN * 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);
|
|
if (pump.LinkStatus == Yw.Hydro.PumpStatus.Open)
|
{
|
if (calcuPumpNewResult.CalcuFlow.HasValue)
|
{
|
if (allPumpFlowRunEvaluationList != null && allPumpFlowRunEvaluationList.Count > 0)
|
{
|
foreach (var pumpFlowRunEvaluation in allPumpFlowRunEvaluationList)
|
{
|
if (pumpFlowRunEvaluation.IsMeet(calcuPumpNewResult.CalcuFlow.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = pump.Code,
|
Message = $"[{pump.Name}]{pumpFlowRunEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 阀门
|
|
var allValveList = hydroInfo.Valves;
|
if (allValveList != null && allValveList.Count > 0)
|
{
|
var allValveMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Valve).ToList();
|
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 = isHead ? calcuStartValveNodeResult.CalcuHead : calcuStartValveNodeResult.CalcuPress;
|
}
|
var endValveCode = calcuValveResult.CalcuFlow.Value > 0 ? valve.EndCode : valve.StartCode;
|
var calcuEndValveNodeResult = allCalcuResultVisualDict?.GetValue(endValveCode) as HydroCalcuNodeResult;
|
if (calcuEndValveNodeResult != null)
|
{
|
calcuValveNewResult.CalcuPr2 = isHead ? calcuEndValveNodeResult.CalcuHead : calcuEndValveNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuValveResult);
|
hydroCalcuResult.LinkList.Add(calcuValveNewResult);
|
if (calcuValveNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allValveMinorLossEvaluationList != null && allValveMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var valveMinorLossEvaluation in allValveMinorLossEvaluationList)
|
{
|
if (valveMinorLossEvaluation.IsMeet(calcuValveNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = valve.Code,
|
Message = $"[{valve.Name}]{valveMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 换热器
|
|
var allExchangerList = hydroInfo.Exchangers;
|
if (allExchangerList != null && allExchangerList.Count > 0)
|
{
|
var allExchangerMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Exchanger).ToList();
|
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 = isHead ? calcuStartExchangerNodeResult.CalcuHead : calcuStartExchangerNodeResult.CalcuPress;
|
}
|
var endExchangerCode = calcuExchangerResult.CalcuFlow.Value > 0 ? exchanger.EndCode : exchanger.StartCode;
|
var calcuEndExchangerNodeResult = allCalcuResultVisualDict?.GetValue(endExchangerCode) as HydroCalcuNodeResult;
|
if (calcuEndExchangerNodeResult != null)
|
{
|
calcuExchangerNewResult.CalcuPr2 = isHead ? calcuEndExchangerNodeResult.CalcuHead : calcuEndExchangerNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuExchangerResult);
|
hydroCalcuResult.LinkList.Add(calcuExchangerNewResult);
|
|
if (calcuExchangerNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allExchangerMinorLossEvaluationList != null && allExchangerMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var exchangerMinorLossEvaluation in allExchangerMinorLossEvaluationList)
|
{
|
if (exchangerMinorLossEvaluation.IsMeet(calcuExchangerNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = exchanger.Code,
|
Message = $"[{exchanger.Name}]{exchangerMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 压缩机
|
|
var allCompressorList = hydroInfo.Compressors;
|
if (allCompressorList != null && allCompressorList.Count > 0)
|
{
|
var allCompressorMinorLossEvaluationList = allMinorLossEvaluationList?.Where(x => x.Catalog == Yw.Hydro.ParterCatalog.Compressor).ToList();
|
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 = isHead ? calcuStartCompressorNodeResult.CalcuHead : calcuStartCompressorNodeResult.CalcuPress;
|
}
|
var endCompressorCode = calcuCompressorResult.CalcuFlow.Value > 0 ? compressor.EndCode : compressor.StartCode;
|
var calcuEndCompressorNodeResult = allCalcuResultVisualDict?.GetValue(endCompressorCode) as HydroCalcuNodeResult;
|
if (calcuEndCompressorNodeResult != null)
|
{
|
calcuCompressorNewResult.CalcuPr2 = isHead ? calcuEndCompressorNodeResult.CalcuHead : calcuEndCompressorNodeResult.CalcuPress;
|
}
|
}
|
|
hydroCalcuResult.LinkList.Remove(calcuCompressorResult);
|
hydroCalcuResult.LinkList.Add(calcuCompressorNewResult);
|
|
if (calcuCompressorNewResult.CalcuMinorLoss.HasValue)
|
{
|
if (allCompressorMinorLossEvaluationList != null && allCompressorMinorLossEvaluationList.Count > 0)
|
{
|
foreach (var compressorMinorLossEvaluation in allCompressorMinorLossEvaluationList)
|
{
|
if (compressorMinorLossEvaluation.IsMeet(calcuCompressorNewResult.CalcuMinorLoss.Value))
|
{
|
hydroCalcuResult.WainingList.Add(new HydroCalcuWarning()
|
{
|
Code = compressor.Code,
|
Message = $"[{compressor.Name}]{compressorMinorLossEvaluation.EvaluateContent}"
|
});
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
return hydroCalcuResult;
|
}
|
|
|
|
|
}
|
}
|
