HStation/XHS.V1.0.git

			@@ -1,5 +1,8 @@
			using 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,57 +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)
			{
			var calcuNodeStartResult = allCalcuResultVisualDict?.GetValue(pump.StartCode) as HydroCalcuNodeResult;
			var calcuNodeEndResult = allCalcuResultVisualDict?.GetValue(pump.EndCode) as HydroCalcuNodeResult;
			if (calcuNodeStartResult != null && calcuNodeEndResult != null)
			{
			//流量
			calcuPumpNewResult.CalcuQ = Math.Abs(calcuPumpResult.CalcuFlow.Value);

			if (calcuNodeStartResult.CalcuPress.HasValue && calcuNodeEndResult.CalcuPress.HasValue)
			//进口压力
			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)
			{
			calcuPumpNewResult.CalcuH = Math.Abs(calcuNodeStartResult.CalcuPress.Value - calcuNodeEndResult.CalcuPress.Value);
			//var curveqh = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQH);
			//if (curveqh != null)
			//{
			// if (curveqh.CurveData != null && curveqh.CurveData.Count > 3)
			// {
			// var point2dList = curveqh.CurveData.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
			// var point2dSimularList = point2dList.GetQHPointListByN(pump.RatedN.Value, pump.RatedN.Value * pump.SpeedRatio);
			// var pumpCurveQh = new Yw.Pump.CurveQH(eFeatType.Cubic, point2dSimularList);
			// var curveQhRange = pumpCurveQh.FeatCurve.GetXRange();
			// var h = pumpCurveQh.FeatCurve.GetPointYUnlimited(calcuPumpNewResult.CalcuQ.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(Yw.Ahart.eFeatType.Cubic, point2dSimularList);
			var curveQpRange = pumpCurveQp.FeatCurve.GetXRange();
			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 > 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);
			@@ -212,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;
			}




			}
			}