From e37b6f2ca026097b83da3ec989cb0d454cceddad Mon Sep 17 00:00:00 2001
From: lixiaojun <1287241240@qq.com>
Date: 星期四, 19 十二月 2024 14:13:22 +0800
Subject: [PATCH] 压力表整改
---
WinFrmUI/Yw.WinFrmUI.Hydro.Core/03-calcu/01-result/HydroCalcuResultExtensions.cs | 644 +++++++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 588 insertions(+), 56 deletions(-)
diff --git a/WinFrmUI/Yw.WinFrmUI.Hydro.Core/03-calcu/01-result/HydroCalcuResultExtensions.cs b/WinFrmUI/Yw.WinFrmUI.Hydro.Core/03-calcu/01-result/HydroCalcuResultExtensions.cs
index e153d6a..f9ceb75 100644
--- a/WinFrmUI/Yw.WinFrmUI.Hydro.Core/03-calcu/01-result/HydroCalcuResultExtensions.cs
+++ b/WinFrmUI/Yw.WinFrmUI.Hydro.Core/03-calcu/01-result/HydroCalcuResultExtensions.cs
@@ -1,5 +1,8 @@
锘縰sing Yw.Hydro;
using Yw.EPAnet;
+using System.Diagnostics.Metrics;
+using Yw.Model;
+using SqlSugar;
namespace Yw.WinFrmUI
{
/// <summary>
@@ -39,44 +42,365 @@
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)
{
- var allLinkList = hydroInfo.GetAllLinks();
foreach (var flowmeter in allFlowmeterList)
{
var calcuFlowmeterResult = allCalcuResultVisualDict?.GetValue(flowmeter.Code) as HydroCalcuNodeResult;
if (calcuFlowmeterResult != null)
{
var calcuFlowmeterNewResult = new HydroCalcuFlowmeterResult(calcuFlowmeterResult);
- var calcuFlowmeterLinkResultList = new List<HydroCalcuLinkResult>();
- var flowmeterLinkList = allLinkList?.Where(x => x.StartCode == flowmeter.Code || x.EndCode == flowmeter.Code).ToList();
- if (flowmeterLinkList != null && flowmeterLinkList.Count > 0)
+ 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 flowmeterLink in flowmeterLinkList)
+ foreach (var linkFlowmeter in linkFlowmeterList)
{
- var calcuFlowmeterLinkResult = allCalcuResultVisualDict?.GetValue(flowmeterLink.Code) as HydroCalcuLinkResult;
- if (calcuFlowmeterLinkResult != null)
+ var calcuLinkFlowmeterResult = allCalcuResultVisualDict?.GetValue(linkFlowmeter.Code) as HydroCalcuLinkResult;
+ if (calcuLinkFlowmeterResult != null)
{
- calcuFlowmeterLinkResultList.Add(calcuFlowmeterLinkResult);
+ if (calcuLinkFlowmeterResult.CalcuFlow.HasValue)
+ {
+ calcuFlowmeterNewResult.CalcuQ = Math.Abs(calcuLinkFlowmeterResult.CalcuFlow.Value);
+ break;
+ }
}
}
}
- if (calcuFlowmeterLinkResultList.Exists(x => x.CalcuFlow.HasValue))
- {
- calcuFlowmeterNewResult.CalcuQ = calcuFlowmeterLinkResultList.Where(x => x.CalcuFlow.HasValue).Average(x => x.CalcuFlow.Value);
- }
+
hydroCalcuResult.NodeList.Remove(calcuFlowmeterResult);
hydroCalcuResult.NodeList.Add(calcuFlowmeterNewResult);
}
}
}
- //鍘嬪姏琛�
+
+ #endregion
+
+ #region 鍘嬪姏琛�
+
var allPressmeterList = hydroInfo.Pressmeters;
if (allPressmeterList != null && allPressmeterList.Count > 0)
{
@@ -93,7 +417,83 @@
}
}
- //姘存车
+ #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)
{
@@ -103,56 +503,77 @@
if (calcuPumpResult != null)
{
var calcuPumpNewResult = new HydroCalcuPumpResult(calcuPumpResult);
- calcuPumpNewResult.CalcuQ = calcuPumpResult.CalcuFlow;
- if (calcuPumpNewResult.CalcuQ.HasValue)
+ if (calcuPumpResult.CalcuFlow.HasValue)
{
- if (calcuPumpNewResult.CalcuQ.Value > 0)
+ //娴侀噺
+ 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 calcuNodeStartResult = allCalcuResultVisualDict?.GetValue(pump.StartCode) as HydroCalcuNodeResult;
- var calcuNodeEndResult = allCalcuResultVisualDict?.GetValue(pump.EndCode) as HydroCalcuNodeResult;
- if (calcuNodeStartResult != null && calcuNodeEndResult != null)
+ var calcuStartPumpNodeResult = allCalcuResultVisualDict?.GetValue(startPumpCode) as HydroCalcuNodeResult;
+ if (calcuStartPumpNodeResult != null)
{
- if (calcuNodeStartResult.CalcuPress.HasValue && calcuNodeEndResult.CalcuPress.HasValue)
+ 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)
{
- calcuPumpNewResult.CalcuH = Math.Abs(calcuNodeStartResult.CalcuPress.Value - calcuNodeEndResult.CalcuPress.Value);
- }
- 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)
{
- 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(eFeatType.Cubic, point2dSimularList);
- var curveQpRange = pumpCurveQp.FeatCurve.GetXRange();
- double minExtend = 1;
- double maxExtend = 1;
- if (calcuPumpNewResult.CalcuQ.Value < curveQpRange.MinX)
- {
- var minExtendTemp = Math.Floor(calcuPumpNewResult.CalcuQ.Value / curveQpRange.MinX * 10d);
- minExtend = minExtendTemp / 10d;
- }
- if (calcuPumpNewResult.CalcuQ.Value > curveQpRange.MaxX)
- {
- var maxExtendTemp = Math.Ceiling(calcuPumpNewResult.CalcuQ.Value / curveQpRange.MaxX * 10d);
- maxExtend = maxExtendTemp / 10d;
- }
- calcuPumpNewResult.CalcuP = pumpCurveQp.FeatCurve.GetPointYExtend(calcuPumpNewResult.CalcuQ.Value, minExtend, maxExtend);
- }
- }
- }
- 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 > 100)
- {
- calcuPumpNewResult.CalcuE = 100;
+ 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);
@@ -211,10 +632,121 @@
}
}
+ #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;
}
+
}
}
--
Gitblit v1.9.3