HStation/XHS.V1.0.git

			@@ -1,16 +1,22 @@
			global using Yw.EPAnet;
			using DevExpress.CodeParser;
			using DevExpress.Diagram.Core.Native;
			using DevExpress.Mvvm.Native;
			using DevExpress.Office.Utils;
			using DevExpress.PivotGrid.QueryMode.TuplesTree;
			using DevExpress.Utils.Extensions;
			using DevExpress.Xpo.Helpers;
			using DevExpress.XtraBars.Ribbon;
			using DevExpress.XtraRichEdit.Layout;
			using DevExpress.XtraSpreadsheet.Commands;
			using HStation.WinFrmUI.PhartRelation;
			using NetTaste;
			using NPOI.SS.Formula.Functions;
			using System.Diagnostics;
			using System.Windows.Media;
			using System.Windows.Media.Media3D;
			using Yw.Hydro;
			using Yw.Model;
			using Yw.Pump;
			using Yw.Vmo;
			using Yw.WinFrmUI.Bimface;
			@@ -78,11 +84,15 @@
			ShowBimfaceCtrl();
			ShowQ3dCtrl();
			ShowPropertyCtrl();
			}

			private void InitialUI()
			{
			InitialCurrentWorking();
			}


			#region Bimface
			#region BIM控件

			//bimface控件
			private XhsProjectSimulationBimfaceCtrl _bimfaceCtrl = null;
			@@ -94,13 +104,14 @@
			{
			_bimfaceCtrl = new XhsProjectSimulationBimfaceCtrl();
			_bimfaceCtrl.Dock = DockStyle.Fill;
			await _bimfaceCtrl.InitialData(_project, _projectSite, () => _hydroInfo);
			await _bimfaceCtrl.InitialData(_project, _projectSite);
			_bimfaceCtrl.LoadCompletedEvent += () =>
			{//view加载完成事件
			if (_hydroInfo == null)
			{
			return;
			}
			InitialUI();
			};
			_bimfaceCtrl.HydroMouseLeftClickEvent += (obj) =>
			{//鼠标左键点击事件
			@@ -108,7 +119,7 @@
			{
			return;
			}
			_selectedVisual = obj;
			//_selectedVisual = obj;
			ShowSelectedProperty();
			};
			}
			@@ -130,7 +141,7 @@

			#endregion

			#region Q3d
			#region Q3d控件

			//Q3d 控件
			private XhsProjectSimulationQ3dCtrl _q3dCtrl = null;
			@@ -167,6 +178,314 @@

			#endregion

			#region 可见列表

			//所有可视字典
			private Dictionary<string, HydroVisualInfo> _allVisualDict = null;

			//获取可视字典
			private Dictionary<string, HydroVisualInfo> GetVisualDict()
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			if (_allVisualDict == null)
			{
			_allVisualDict = new Dictionary<string, HydroVisualInfo>();
			var allVisualList = _hydroInfo.GetAllVisuals();
			allVisualList?.ForEach(x => _allVisualDict.Add(x.Code, x));
			}
			return _allVisualDict;
			}

			//获取可视列表
			private List<HydroVisualInfo> GetVisualList()
			{
			var allVisualDict = GetVisualDict();
			return allVisualDict?.Values.ToList();
			}

			//获取节点列表
			private List<HydroNodeInfo> GetNodeList()
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			return _hydroInfo.GetAllNodes();
			}

			//获取管段列表
			private List<HydroLinkInfo> GetLinkList()
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			return _hydroInfo.GetAllLinks();
			}

			//获取可视构件
			private HydroVisualInfo GetVisual(string code)
			{
			var allVisualDict = GetVisualDict();
			if (allVisualDict == null)
			{
			return default;
			}
			if (allVisualDict.ContainsKey(code))
			{
			return allVisualDict[code];
			}
			return default;
			}

			#endregion

			#region 计算结果

			//计算结果
			private HydroCalcuResult _calcuResult = null;

			//获取计算结果
			private HydroCalcuResult GetCalcuResult(string calcuMode, bool needCalcuAgain = false)
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			if (needCalcuAgain)
			{
			_calcuResult = _hydroInfo.Calcu(calcuMode);
			}
			if (_calcuResult == null)
			{
			_calcuResult = _hydroInfo.Calcu(calcuMode);
			}
			return _calcuResult;
			}

			//获取可视组件计算结果列表
			private List<HydroCalcuVisualResult> GetCalcuVisualResultList(string calcuMode, bool needCalcuAgain = false)
			{
			var calcuResult = GetCalcuResult(calcuMode, needCalcuAgain);
			if (calcuResult == null)
			{
			return default;
			}
			if (!calcuResult.Succeed)
			{
			return default;
			}
			return calcuResult.GetVisualList();
			}

			//获取节点计算结果列表
			private List<HydroCalcuNodeResult> GetCalcuNodeResultList(string calcuMode, bool needCalcuAgain = false)
			{
			var calcuResult = GetCalcuResult(calcuMode, needCalcuAgain);
			if (calcuResult == null)
			{
			return default;
			}
			if (!calcuResult.Succeed)
			{
			return default;
			}
			return calcuResult.NodeList;
			}

			//获取管段计算结果列表
			private List<HydroCalcuLinkResult> GetCalcuLinkResultList(string calcuMode, bool needCalcuAgain = false)
			{
			var calcuResult = GetCalcuResult(calcuMode, needCalcuAgain);
			if (calcuResult == null)
			{
			return default;
			}
			if (!calcuResult.Succeed)
			{
			return default;
			}
			return calcuResult.LinkList;
			}

			//所有可见计算字典
			private Dictionary<string, HydroCalcuVisualResult> _allCalcuVisualDict = null;

			//获取可见计算字典
			private Dictionary<string, HydroCalcuVisualResult> GetCalcuVisualDict(string calcuMode, bool needCalcuAgain = false)
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			var allCalcuVisualResultList = GetCalcuVisualResultList(calcuMode, needCalcuAgain);
			if (needCalcuAgain)
			{
			_allCalcuVisualDict = new Dictionary<string, HydroCalcuVisualResult>();
			allCalcuVisualResultList?.ForEach(x => _allCalcuVisualDict.Add(x.Code, x));
			}
			if (_allCalcuVisualDict == null)
			{
			_allCalcuVisualDict = new Dictionary<string, HydroCalcuVisualResult>();
			allCalcuVisualResultList?.ForEach(x => _allCalcuVisualDict.Add(x.Code, x));
			}
			return _allCalcuVisualDict;
			}

			//获取可见计算结果
			private HydroCalcuVisualResult GetCalcuVisualResult(string code, string calcuMode = Yw.EPAnet.CalcuMode.MinorLoss, bool needCalcuAgain = false)
			{
			var allCalcuVisualDict = GetCalcuVisualDict(calcuMode, needCalcuAgain);
			if (allCalcuVisualDict == null \|\| allCalcuVisualDict.Count < 1)
			{
			return default;
			}
			if (allCalcuVisualDict.ContainsKey(code))
			{
			return allCalcuVisualDict[code];
			}
			return default;
			}

			//获取可见计算结果
			private HydroCalcuVisualResult GetCalcuVisualResult(Yw.Model.HydroVisualInfo visual, string calcuMode = Yw.EPAnet.CalcuMode.MinorLoss, bool needCalcuAgain = false)
			{
			return GetCalcuVisualResult(visual?.Code, calcuMode, needCalcuAgain);
			}

			#endregion

			#region 视图列表

			//所有可见视图字典
			private Dictionary<string, HydroVisualViewModel> _allVisualViewModelDict = null;

			//获取可见视图字典
			private Dictionary<string, HydroVisualViewModel> GetVisualViewModelDict()
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			if (_allVisualViewModelDict == null)
			{
			_allVisualViewModelDict = new Dictionary<string, HydroVisualViewModel>();
			var allVisualDict = GetVisualDict();
			if (allVisualDict != null && allVisualDict.Count > 0)
			{
			foreach (var visualKeyValue in allVisualDict)
			{
			var vm = HydroVisualViewModelBuilder.CreateVisualViewModel(visualKeyValue.Value, _hydroInfo);
			var calcuVisualResult = GetCalcuVisualResult(visualKeyValue.Key);
			if (calcuVisualResult != null)
			{
			vm.UpdateCalcuProperty(calcuVisualResult);
			}
			_allVisualViewModelDict.Add(visualKeyValue.Key, vm);
			}
			}
			}
			return _allVisualViewModelDict;
			}

			//获取可见视图列表
			private List<HydroVisualViewModel> GetVisualViewModelList()
			{
			var allVisualViewModelDict = GetVisualViewModelDict();
			return allVisualViewModelDict?.Values.ToList();
			}

			//更新可见视图属性
			private void UpdateVisualViewModelProperty()
			{
			var allVisualViewModelList = GetVisualViewModelList();
			allVisualViewModelList?.ForEach(x => x.UpdateProperty());
			}

			//更新可见视图属性
			private void UpdateVisualViewModelProperty(string code)
			{
			var allVisualViewModelDict = GetVisualViewModelDict();
			if (allVisualViewModelDict != null && allVisualViewModelDict.Count > 0)
			{
			if (allVisualViewModelDict.ContainsKey(code))
			{
			allVisualViewModelDict[code].UpdateProperty();
			}
			}
			}

			//更新可见视图属性
			private void UpdateVisualViewModelProperty(List<string> codes)
			{
			codes?.ForEach(x => UpdateVisualViewModelProperty(x));
			}

			//更新可见视图属性
			private void UpdateVisualViewModelProperty(List<HydroVisualInfo> visualList)
			{
			visualList?.ForEach(x => UpdateVisualViewModelProperty(x.Code));
			}

			//更新可见视图计算属性
			private void UpdateVisualViewModelCalcuProperty()
			{
			var allVisualViewModelDict = GetVisualViewModelDict();
			if (allVisualViewModelDict != null && allVisualViewModelDict.Count > 0)
			{
			foreach (var visualViewModelKeyValue in allVisualViewModelDict)
			{
			var calcuVisualResult = GetCalcuVisualResult(visualViewModelKeyValue.Key);
			if (calcuVisualResult != null)
			{
			visualViewModelKeyValue.Value.UpdateCalcuProperty(calcuVisualResult);
			}
			}
			}
			}

			//获取可见视图
			private HydroVisualViewModel GetVisualViewModel(string code)
			{
			if (string.IsNullOrEmpty(code))
			{
			return default;
			}
			var allVisualViewModelList = GetVisualViewModelList();
			return allVisualViewModelList?.Find(x => x.Code == code);
			}

			//获取可见视图
			private HydroVisualViewModel GetVisualViewModel(Yw.Model.HydroVisualInfo visual)
			{
			return GetVisualViewModel(visual?.Code);
			}

			#endregion

			#region 选择构件

			//选择构件
			private Yw.Model.HydroVisualInfo _selectedVisual = null;

			//选择构件
			private Yw.Model.HydroVisualInfo SelectedVisual
			{
			get { return _selectedVisual; }
			set
			{

			_selectedVisual = value;
			this.barBtnSetMonitor.Enabled = _selectedVisual != null;
			}
			}


			#endregion

			#region 属性控件

			//属性控件
			@@ -179,40 +498,42 @@
			{
			_propertyCtrl = new XhsProjectSimulationPropertyCtrl();
			_propertyCtrl.Dock = DockStyle.Fill;
			_propertyCtrl.InitialData(() => _hydroInfo, () => GetCalcuResultList());
			_propertyCtrl.BlinkLinkParterEvent += async (code, linkCode) =>
			{ //强调连接组件
			if (string.IsNullOrEmpty(code))
			_propertyCtrl.HydroViewEvent += (visual) =>
			{
			if (visual == null)
			{
			return;
			}
			if (string.IsNullOrEmpty(linkCode))
			{
			return;
			}
			_bimfaceCtrl?.ZoomToComponent(visual.Code);
			};
			_propertyCtrl.BlinkLinkNodeEvent += async (link, linkNodeCode) =>
			{ //强调连接节点
			if (_hydroInfo == null)
			{
			return;
			}
			var allVisualList = _hydroInfo.GetAllVisuals();
			if (allVisualList == null \|\| allVisualList.Count < 1)
			if (link == null)
			{
			return;
			}
			var linkParter = allVisualList.Find(x => x.Code == linkCode);
			if (linkParter == null)
			if (string.IsNullOrEmpty(linkNodeCode))
			{
			return;
			}
			var linkNode = GetVisual(linkNodeCode);
			if (linkNode == null)
			{
			return;
			}
			var blinkCodes = new List<string>();
			if (linkParter.GetType() == typeof(Yw.Model.HydroJunctionInfo))
			if (linkNode.GetType() == typeof(HydroJunctionInfo))
			{
			var allLinkList = _hydroInfo.GetAllLinks();
			var allLinkList = GetLinkList();
			if (allLinkList == null \|\| allLinkList.Count < 1)
			{
			return;
			}
			var linkList = allLinkList.Where(x => (x.StartCode == linkParter.Code \|\| x.EndCode == linkParter.Code) && x.Code != code).ToList();
			var linkList = allLinkList.Where(x => (x.StartCode == linkNodeCode \|\| x.EndCode == linkNodeCode) && x.Code != linkNodeCode).ToList();
			if (linkList == null \|\| linkList.Count < 1)
			{
			return;
			@@ -221,21 +542,13 @@
			}
			else
			{
			blinkCodes.Add(linkCode);
			blinkCodes.Add(linkNodeCode);
			}

			await _bimfaceCtrl?.ClearBlinkComponents();
			await _bimfaceCtrl?.SetBlinkComponents(blinkCodes);
			await Task.Delay(5000);
			await _bimfaceCtrl?.ClearBlinkComponents();
			};

			_propertyCtrl.ViewParterEvent += (parter) =>
			{
			if (parter == null)
			{
			return;
			}
			_bimfaceCtrl?.ZoomToComponent(parter.Code);
			};
			_propertyCtrl.PropertyValueChangedEvent += (visual) =>
			{
			@@ -244,24 +557,24 @@
			return;
			}
			UpdateVisualListCtrl();
			ApplyGradingResultList(visual);
			//ApplyGradingResultList(visual);
			};
			_propertyCtrl.MarkPropertyValueChangedEvent += (visual) =>
			{
			//标注属性发生改变
			//判断当前是否有标注展示，若有则更新标注，最好是更新单个标注
			UpdateMark(visual);
			//UpdateMark(visual);
			};
			_propertyCtrl.GradingPropertyValueChangedEvent += (parter) =>
			{
			//分级属性发生改变
			//判断当前是否有分级展示，若有则更新分级，最好是更新单个分级
			};
			_propertyCtrl.FlowDirectionPropertyValueChangedEvent += (visual) =>
			_propertyCtrl.FlowEffectPropertyValueChangedEvent += (visual) =>
			{
			//流向属性发生改变
			//判断流向是否加载，如果加载则更新流向，最好是更新单个流向
			UpdateFlowEffect(visual);
			//UpdateFlowEffect(visual);
			};

			}
			@@ -339,6 +652,21 @@
			_propertyCtrl?.UpdateRows();
			}

			//设置属性控件
			private void SetPropertyCtrl(Yw.Model.HydroVisualInfo visual)
			{
			if (visual == null)
			{

			}
			}

			//更新属性控件
			private void UpdatePropertyCtrl()
			{
			_propertyCtrl?.UpdateRows();
			}

			#endregion

			#region 自动匹配
			@@ -390,7 +718,7 @@
			}
			this.controlContainerBottom.Controls.Clear();
			var matchingListCtrl = GetMatchingListCtrl();
			var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetCalcuResultList());
			var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false));
			matchingListCtrl.SetBindingData(input);
			this.controlContainerBottom.Controls.Add(matchingListCtrl);
			this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
			@@ -400,7 +728,7 @@

			#endregion

			#region 未匹配列表
			#region 未匹列表

			//获取未匹配列表控件
			private XhsProjectSimulationUnMatchingListCtrl GetUnMatchingListCtrl()
			@@ -920,99 +1248,6 @@

			#endregion

			#region 并联分析

			//并联分析
			private void barBtnAnaly_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			if (_hydroInfo == null)
			{
			return;
			}
			if (_hydroInfo.Pumps == null \|\| _hydroInfo.Pumps.Count < 1)
			{
			return;
			}
			var allCalcuResultList = GetCalcuResultList();
			var vmList = new List<XhsSinglePumpViewModel>();
			foreach (var pump in _hydroInfo.Pumps)
			{
			if (!pump.RatedN.HasValue)
			{
			continue;
			}
			var qh = _hydroInfo.Curves?.Find(t => t.Code == pump.CurveQH)?.CurveData;
			var qe = _hydroInfo.Curves?.Find(t => t.Code == pump.CurveQE)?.CurveData;
			var qp = _hydroInfo.Curves?.Find(t => t.Code == pump.CurveQP)?.CurveData;
			if (qh == null)
			{
			continue;
			}

			var qhPtList = qh.Select(x => new XhsSplinePointViewModel(x.X, x.Y)).ToList();
			var qePtList = qe?.Select(x => new XhsSplinePointViewModel(x.X, x.Y)).ToList();
			var qpPtList = qp?.Select(x => new XhsSplinePointViewModel(x.X, x.Y)).ToList();

			var vm = new XhsSinglePumpViewModel();
			vmList.Add(vm);
			vm.ID = pump.ID;
			vm.Name = pump.Name;
			vm.Code = pump.Code;
			vm.IsBp = true;
			vm.RunStatus = pump.LinkStatus == Yw.Hydro.LinkStatus.Open;
			vm.RatedHz = pump.RatedHz;
			vm.CurrentHz = Math.Round(pump.RatedHz * pump.SpeedRatio, 1);
			vm.RatedSpeed = pump.RatedN.Value;
			vm.CurrentSpeed = Math.Round(pump.RatedN.Value * pump.SpeedRatio);
			vm.CurveQH = qhPtList;
			vm.CurveQE = qePtList;
			vm.CurveQP = qpPtList;

			if (allCalcuResultList != null && allCalcuResultList.Count > 0)
			{
			var calcuResult = allCalcuResultList.Find(x => x.Code == pump.Code) as HydroCalcuLinkResult;
			if (calcuResult != null)
			{
			if (calcuResult.CalcuFlow.HasValue)
			{
			vm.CalcuQ = Math.Abs(calcuResult.CalcuFlow.Value);
			}

			var calcuResultStart = allCalcuResultList.Find(x => x.Code == pump.StartCode) as HydroCalcuNodeResult;
			var calcuResultEnd = allCalcuResultList.Find(x => x.Code == pump.EndCode) as HydroCalcuNodeResult;
			if (calcuResultStart != null && calcuResultEnd != null)
			{
			if (calcuResultStart.CalcuHead.HasValue && calcuResultEnd.CalcuHead.HasValue)
			{
			vm.CalcuH = Math.Round(Math.Abs(calcuResultStart.CalcuHead.Value - calcuResultEnd.CalcuHead.Value), 4);
			}
			}
			}
			}

			}

			var dlg = new PumpParallelAnalyDlg();
			dlg.SetBindingData(vmList);
			dlg.ReloadDataEvent += (list) =>
			{
			list?.ForEach(x =>
			{
			var pump = _hydroInfo.Pumps?.Find(t => t.Code == x.Code);
			if (pump != null)
			{
			pump.LinkStatus = x.RunStatus ? Yw.Hydro.PumpStatus.Open : Yw.Hydro.PumpStatus.Closed;
			pump.SpeedRatio = Math.Round(x.CurrentHz / pump.RatedHz, 1);
			}
			});
			ShowSelectedProperty();
			return true;
			};
			dlg.ShowDialog();
			}

			#endregion

			#region 构件查询

			//查询组件
			@@ -1381,7 +1616,7 @@
			}
			var allGradingList = await GetGradingList();
			var allGradingApplyList = GetGradingApplyList();
			var allCalcuResultList = GetCalcuResultList();
			var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
			if (!useCache)
			{
			_allGradingResultList = HydroGradingHelper.GetResultList(_hydroInfo, allGradingList, allGradingApplyList, allCalcuResultList);
			@@ -1435,7 +1670,7 @@
			var allGradingList = await GetGradingList();
			var allGradingApplyList = GetGradingApplyList();
			var allGradingResultList = await GetGradingResultList(true);
			var allCalcuResultList = GetCalcuResultList(true);
			var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
			var oldResult = allGradingResultList?.Find(x => x.Code == visual.Code);
			if (oldResult != null)
			{
			@@ -1533,7 +1768,7 @@
			if (_allFlowEffectList == null)
			{
			_allFlowEffectList = new List<LogicFlowEffect>();
			var allCalcuResultList = GetCalcuResultList();
			var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
			if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
			{
			foreach (var parter in _hydroInfo.Pipes)
			@@ -1656,7 +1891,7 @@
			flowEffect.SpeedY = -0.1;
			}

			var allCalcuResultList = GetCalcuResultList();
			var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
			var calcuResult = allCalcuResultList?.Find(x => x.Code == visual.Code) as HydroCalcuLinkResult;
			if (calcuResult != null)
			{
			@@ -1680,166 +1915,7 @@

			#endregion

			#region 选择构件

			//选择构件
			private Yw.Model.HydroVisualInfo _selectedVisual = null;

			//选择构件
			private Yw.Model.HydroVisualInfo SelectedVisual
			{
			get { return _selectedVisual; }
			set
			{
			_selectedVisual = value;
			if (_selectedVisual == null)
			{
			this.barBtnSetMonitor.Enabled = false;
			}
			else
			{
			this.barBtnSetMonitor.Enabled = true;
			}
			}
			}

			#endregion

			#region 构件明细

			#region 构件列表

			//所有构件视图列表
			private List<HydroVisualViewModel> _allVisualViewModelList = null;

			//获取构件视图列表
			private List<HydroVisualViewModel> GetVisualViewModelList()
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			if (_allVisualViewModelList == null)
			{
			_allVisualViewModelList = new List<HydroVisualViewModel>();
			var allVisualList = _hydroInfo.GetAllVisuals();
			if (allVisualList != null && allVisualList.Count > 0)
			{
			var allCalcuResultList = GetCalcuResultList();
			allVisualList.ForEach(x =>
			{
			var vm = HydroVisualViewModelBuilder.CreateVisualViewModel(x, _hydroInfo);
			var calcuResult = allCalcuResultList?.Find(x => x.Code == x.Code);
			if (calcuResult != null)
			{
			vm.UpdateCalcuProperty(calcuResult);
			}
			_allVisualViewModelList.Add(vm);
			});
			}
			}
			return _allVisualViewModelList;
			}

			//更新可见视图属性
			private void UpdateVisualViewModelProperty()
			{
			var allVisualViewModelList = GetVisualViewModelList();
			if (allVisualViewModelList != null && allVisualViewModelList.Count > 0)
			{
			allVisualViewModelList.ForEach(x =>
			{
			x.UpdateProperty();
			});
			}
			}

			//更新可见视图属性
			private void UpdateVisualViewModelProperty(List<string> codes)
			{
			if (codes == null \|\| codes.Count < 1)
			{
			return;
			}
			var allVisualViewModelList = GetVisualViewModelList();
			if (allVisualViewModelList != null && allVisualViewModelList.Count > 0)
			{
			allVisualViewModelList.ForEach(x =>
			{
			if (codes.Contains(x.Code))
			{
			x.UpdateProperty();
			}
			});
			}
			}

			//更新可见视图属性
			private void UpdateVisualViewModelProperty(List<Yw.Model.HydroVisualInfo> visualList)
			{
			if (visualList == null \|\| visualList.Count < 1)
			{
			return;
			}
			var allVisualViewModelList = GetVisualViewModelList();
			if (allVisualViewModelList != null && allVisualViewModelList.Count > 0)
			{
			allVisualViewModelList.ForEach(x =>
			{
			if (visualList.Exists(t => t.Code == x.Code))
			{
			x.UpdateProperty();
			}
			});
			}
			}

			//更新可见视图计算属性
			private void UpdateVisualViewModelCalcuProperty()
			{
			var allVisualViewModelList = GetVisualViewModelList();
			if (allVisualViewModelList != null && allVisualViewModelList.Count > 0)
			{
			var allCalcuResultList = GetCalcuResultList();
			if (allCalcuResultList != null && allCalcuResultList.Count > 0)
			{
			allVisualViewModelList.ForEach(x =>
			{
			var calcuResult = allCalcuResultList.Find(t => t.Code == x.Code);
			if (calcuResult != null)
			{
			x.UpdateCalcuProperty(calcuResult);
			}
			});
			}
			}
			}

			//获取构件视图
			private HydroVisualViewModel GetVisualViewModel(string code)
			{
			if (string.IsNullOrEmpty(code))
			{
			return default;
			}
			var allVisualViewModelList = GetVisualViewModelList();
			return allVisualViewModelList?.Find(x => x.Code == code);
			}

			//获取可见视图
			private HydroVisualViewModel GetVisualViewModel(Yw.Model.HydroVisualInfo visual)
			{
			if (visual == null)
			{
			return default;
			}
			var allVisualViewModelList = GetVisualViewModelList();
			return allVisualViewModelList?.Find(x => x.Code == visual.Code);
			}

			#endregion

			#region 构件明细控件
			#region 构件控件

			//构件明细控件
			private Yw.WinFrmUI.HydroVisualListCtrl _visualListCtrl = null;
			@@ -1900,7 +1976,7 @@
			var visualListCtrl = GetVisualListCtrl();
			var allVisualViewModelList = GetVisualViewModelList();
			visualListCtrl.SetBindingData(allVisualViewModelList);
			var allCalcuResultList = GetCalcuResultList();
			var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
			if (allCalcuResultList == null \|\| allCalcuResultList.Count < 1)
			{
			visualListCtrl.SetNormalView();
			@@ -1934,16 +2010,12 @@

			#endregion

			#endregion

			#region 监测列表

			#region 测点列表

			//所有监测点列表
			//所有监测列表
			private List<HydroMonitorVmo> _allMonitorList = null;

			//获取监测点列表
			//获取监测列表
			private async Task<List<HydroMonitorVmo>> GetMonitorList()
			{
			if (_hydroInfo == null)
			@@ -1961,14 +2033,10 @@
			return _allMonitorList;
			}

			//更新监测点列表
			//更新监测列表
			private async void UpdateMonitorList(string code)
			{
			if (_hydroInfo == null)
			{
			return;
			}
			if (string.IsNullOrEmpty(code))
			{
			return;
			}
			@@ -2026,6 +2094,10 @@
			}

			#endregion

			#region 监测列表



			#region 监测值列表

			@@ -2175,8 +2247,6 @@

			#endregion

			#region 水力检查

			#region 检查结果

			//检查结果缓存
			@@ -2260,41 +2330,10 @@
			this.docPnlBottom.Height = 350;
			}

			#endregion

			//检查
			private void barBtnCheck_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			ShowCheckCtrl(true);
			}

			#endregion

			#region EPA计算结果

			//EPA计算结果
			private Yw.EPAnet.CalcuResult _epaCalcuResult = null;

			//获取EPA计算结果
			//CalcuMode 在 Yw.EPANet.Calcu.Core 中定义
			//NeedCalcuAgain 是否需要重新计算
			private Yw.EPAnet.CalcuResult GetEpaCalcuResult(string calcuMode, bool needCalcuAgain = false)
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			if (needCalcuAgain)
			{
			var network = _hydroInfo.ToNetwork();
			_epaCalcuResult = network.Calcu(calcuMode);
			}
			if (_epaCalcuResult == null)
			{
			var network = _hydroInfo.ToNetwork();
			_epaCalcuResult = network.Calcu(calcuMode);
			}
			return _epaCalcuResult;
			}

			#endregion
			@@ -2316,7 +2355,7 @@
			}

			//显示计算失败控件
			private void ShowCalcuFailedCtrl(Yw.EPAnet.CalcuResult calcuResult)
			private void ShowCalcuFailedCtrl(HydroCalcuResult calcuResult)
			{
			if (_hydroInfo == null)
			{
			@@ -2330,6 +2369,7 @@
			{
			return;
			}

			var calcuFailedCtrl = GetCalcuFailedCtrl();
			calcuFailedCtrl.SetBindingData(calcuResult.FailedList);
			this.controlContainerBottom.Controls.Clear();
			@@ -2342,9 +2382,8 @@
			//显示计算失败控件
			private void ShowCalcuFailedCtrl()
			{
			ShowCalcuFailedCtrl(_epaCalcuResult);
			ShowCalcuFailedCtrl(_calcuResult);
			}


			#endregion

			@@ -2365,32 +2404,39 @@
			if (!checkResult.Succeed)
			{
			ShowCheckCtrl(false);
			TipFormHelper.ShowWarn("检查失败导致无法进行试算，停止修复！");
			TipFormHelper.ShowWarn("检查失败导致无法进行试算，停止管网修复！");
			return;
			}
			var calcuResult = GetEpaCalcuResult(Yw.EPAnet.CalcuMode.Simple, true);
			if (calcuResult == null \|\| !calcuResult.Succeed)
			var calcuResult = _hydroInfo.Calcu(Yw.EPAnet.CalcuMode.Simple);
			if (calcuResult == null)
			{
			return;
			}
			if (!calcuResult.Succeed)
			{
			ShowCalcuFailedCtrl(calcuResult);
			TipFormHelper.ShowWarn("试算失败，停止修复！");
			TipFormHelper.ShowWarn("试算失败，停止管网修复！");
			return;
			}

			var allLinks = _hydroInfo.GetAllLinks();
			if (allLinks != null && allLinks.Count < 1)
			{
			TipFormHelper.ShowError("模型中未包含管段信息，停止修复！");
			TipFormHelper.ShowError("模型中未包含管段信息，停止管网修复！");
			return;
			}
			int count = 0;
			foreach (var link in allLinks)
			{
			var calcuLink = calcuResult.LinkList?.Find(x => x.Id == link.Code);
			var calcuLink = calcuResult.LinkList?.Find(x => x.Code == link.Code);
			if (calcuLink == null)
			{
			continue;
			}
			if (calcuLink.Flow < 0)
			if (!calcuLink.CalcuFlow.HasValue)
			{
			continue;
			}
			if (calcuLink.CalcuFlow.Value < 0)
			{
			var tempCode = link.StartCode;
			link.StartCode = link.EndCode;
			@@ -2412,7 +2458,7 @@

			#endregion

			#region 导出INP文件
			#region 导出INP

			//导出INP文件
			private void barBtnExportInp_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			@@ -2520,17 +2566,67 @@
			//所有工况列表
			private List<HydroWorkingVmo> _allWorkingList = null;

			//获取工况列表
			private async Task<List<HydroWorkingVmo>> GetWorkingList()
			{
			if (_allWorkingList == null)
			{
			_allWorkingList = await BLLFactory<Yw.BLL.HydroWorking>.Instance.GetByModelID(_hydroInfo.ID);
			if (_allWorkingList == null)
			{
			_allWorkingList = new List<HydroWorkingVmo>();
			}
			}
			return _allWorkingList;
			}

			//所有工况元组列表
			private Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult> _allWorkingTupleList = null;
			private List<Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>> _allWorkingTupleList = null;

			//获取工况元组列表
			private async Task<List<Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>>> GetWorkingTupleList()
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			if (_allWorkingTupleList == null)
			{
			_allWorkingTupleList = new List<Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>>();
			var allWorkingList = await GetWorkingList();
			if (allWorkingList.Count > 0)
			{
			allWorkingList.ForEach(x =>
			{
			var checkResult = _hydroInfo.Check();
			HydroCalcuResult calcuResult = null;
			if (checkResult != null && checkResult.Succeed)
			{
			calcuResult = _hydroInfo.Calcu(Yw.EPAnet.CalcuMode.MinorLoss);
			}
			_allWorkingTupleList.Add(new Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>(x, checkResult, calcuResult));
			});
			}
			}
			return _allWorkingTupleList;
			}

			//添加工况元组
			private async void AppendWorkingTuple(HydroWorkingVmo working, HydroCheckResult check, HydroCalcuResult calcu)
			{
			var allWorkingTupleList = await GetWorkingTupleList();
			allWorkingTupleList.Add(new Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>(working, check, calcu));
			}





			#region 工况

			//移除工况元组
			private async void RemoveWorkingTuple(HydroWorkingVmo working)
			{
			var allWorkingTupleList = await GetWorkingTupleList();
			if (allWorkingTupleList.Count > 0)
			{
			allWorkingTupleList.RemoveAll(x => x.Item1.ID == working.ID);
			}
			}

			//显示工况计算窗体
			private void ShowWorkingCalcuDlg()
			@@ -2551,11 +2647,28 @@
			{
			return;
			}
			var allWorkingList = await GetWorkingList();
			var vmo = new HydroWorkingVmo();
			vmo.ModelID = _hydroInfo.ID;
			vmo.Name = working.Name;
			vmo.WorkingInfo = JsonHelper.Object2Json(working.WorkingInfo);
			vmo.MonitorInfo = JsonHelper.Object2Json(working.MonitorInfo);
			vmo.SortCode = allWorkingList.Count < 1 ? 1 : allWorkingList.Max(x => x.SortCode) + 1;
			vmo.Description = working.Description;
			vmo.ID = await BLLFactory<Yw.BLL.HydroWorking>.Instance.Insert(vmo);
			if (vmo.ID < 1)
			{
			TipFormHelper.ShowError("创建工况失败，计算取消！");
			return;
			}
			allWorkingList.Add(vmo);

			_hydroInfo.UpdateWorkingInfo(working.WorkingInfo);
			//校验
			_checkResult = _hydroInfo.Check();
			if (!_checkResult.Succeed)
			{
			_allWorkingTupleList.Add(new Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>(vmo, _checkResult, null));
			ShowCheckCtrl();
			TipFormHelper.ShowWarn("校验失败，请检查后重试");
			return;
			@@ -2565,19 +2678,18 @@


			//await Task.Delay(5000);
			_calcuResult = _hydroInfo.Calcu(Yw.EPAnet.CalcuMode.MinorLoss);

			var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
			_epaCalcuResult = netWork.CalcuMinorLoss();

			WaitFormHelper.HideWaitForm();
			if (_epaCalcuResult.Succeed)
			if (_calcuResult.Succeed)
			{
			GetCalcuResultList(false);
			_allWorkingTupleList.Add(new Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>(vmo, _checkResult, _calcuResult));
			UpdateVisualViewModelProperty();
			UpdateVisualViewModelCalcuProperty();
			UpdateVisualListCtrl();
			UpdateSelectedProperty();
			await _bimfaceCtrl?.SetLogicCalcuCustomLabels(_epaCalcuResult);
			//await _bimfaceCtrl?.SetLogicCalcuCustomLabelsCalcuResult(_calcuResult);
			TipFormHelper.ShowSucceed("计算成功！");
			var codes = _hydroInfo.Pumps.Select(x => x.Code).ToList();
			await _bimfaceCtrl?.ZoomAndSelectComponents(codes);
			@@ -2595,182 +2707,6 @@
			dlg.ShowDialog();
			}

			#endregion



			#region 计算结果

			//所有计算结果列表
			private List<HydroCalcuVisualResult> _allCalcuResultList = null;

			//获取计算结果
			//true 使用缓存，false 不使用缓存
			private List<HydroCalcuVisualResult> GetCalcuResultList(bool isCache = true)
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			if (_epaCalcuResult == null)
			{
			return default;
			}
			if (!_epaCalcuResult.Succeed)
			{
			return default;
			}
			if (isCache)
			{
			return _allCalcuResultList;
			}

			_allCalcuResultList = new List<HydroCalcuVisualResult>();

			//节点
			var allNodeList = _hydroInfo.GetAllNodes();
			if (allNodeList != null && allNodeList.Count > 0)
			{
			foreach (var node in allNodeList)
			{
			var calcuNode = _epaCalcuResult.NodeList?.Find(x => x.Id == node.Code);
			if (calcuNode != null)
			{
			var calcuResult = new HydroCalcuNodeResult()
			{
			Code = node.Code,
			CalcuPress = calcuNode.Press,
			CalcuHead = calcuNode.Head,
			CalcuDemand = calcuNode.Demand
			};
			_allCalcuResultList.Add(calcuResult);
			}
			}
			}

			//管段
			var allLinkList = _hydroInfo.GetAllLinks();
			if (allLinkList != null && allLinkList.Count > 0)
			{
			foreach (var link in allLinkList)
			{
			var calcuLink = _epaCalcuResult.LinkList?.Find(x => x.Id == link.Code);
			if (calcuLink != null)
			{
			var calcuResult = new HydroCalcuLinkResult()
			{
			Code = link.Code,
			CalcuFlow = calcuLink.Flow,
			CalcuVelocity = calcuLink.Velocity,
			CalcuHeadLoss = calcuLink.Headloss
			};
			_allCalcuResultList.Add(calcuResult);
			}
			}
			}

			//流量计
			var allFlowmeterList = _hydroInfo.Flowmeters;
			if (allFlowmeterList != null && allFlowmeterList.Count > 0)
			{
			foreach (var flowmeter in allFlowmeterList)
			{
			var calcuFlowmeterResult = _allCalcuResultList.Find(x => x.Code == 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)
			{
			foreach (var flowmeterLink in flowmeterLinkList)
			{
			var calcuFlowmeterLinkResult = _allCalcuResultList.Find(x => x.Code == flowmeterLink.Code) as HydroCalcuLinkResult;
			if (calcuFlowmeterLinkResult != null)
			{
			calcuFlowmeterLinkResultList.Add(calcuFlowmeterLinkResult);
			}
			}
			}
			if (calcuFlowmeterLinkResultList.Exists(x => x.CalcuFlow.HasValue))
			{
			calcuFlowmeterNewResult.CalcuQ = calcuFlowmeterLinkResultList.Where(x => x.CalcuFlow.HasValue).Average(x => x.CalcuFlow.Value);
			}
			_allCalcuResultList.Remove(calcuFlowmeterResult);
			_allCalcuResultList.Add(calcuFlowmeterNewResult);
			}
			}
			}

			//压力表
			var allPressmeterList = _hydroInfo.Pressmeters;
			if (allPressmeterList != null && allPressmeterList.Count > 0)
			{
			foreach (var pressmeter in allPressmeterList)
			{
			var calcuPressmeterResult = _allCalcuResultList.Find(x => x.Code == pressmeter.Code) as HydroCalcuNodeResult;
			if (calcuPressmeterResult != null)
			{
			var calcuPressmeterNewResult = new HydroCalcuPressmeterResult(calcuPressmeterResult);
			calcuPressmeterNewResult.CalcuPr = calcuPressmeterResult.CalcuPress;
			_allCalcuResultList.Remove(calcuPressmeterResult);
			_allCalcuResultList.Add(calcuPressmeterNewResult);
			}
			}
			}

			//水泵
			var allPumpList = _hydroInfo.Pumps;
			if (allPumpList != null && allPumpList.Count > 0)
			{
			foreach (var pump in allPumpList)
			{
			var calcuPumpResult = _allCalcuResultList.Find(x => x.Code == pump.Code) as HydroCalcuLinkResult;
			if (calcuPumpResult != null)
			{
			var calcuPumpNewResult = new HydroCalcuPumpResult(calcuPumpResult);
			calcuPumpNewResult.CalcuQ = calcuPumpResult.CalcuFlow;
			if (calcuPumpNewResult.CalcuQ.HasValue)
			{
			var calcuNodeStartResult = _allCalcuResultList.Find(x => x.Code == pump.StartCode) as HydroCalcuNodeResult;
			var calcuNodeEndResult = _allCalcuResultList.Find(x => x.Code == pump.EndCode) as HydroCalcuNodeResult;
			if (calcuNodeStartResult != null && calcuNodeEndResult != null)
			{
			if (calcuNodeStartResult.CalcuPress.HasValue && calcuNodeEndResult.CalcuPress.HasValue)
			{
			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)
			{
			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);
			calcuPumpNewResult.CalcuP = pumpCurveQp.FeatCurve.GetPointY(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);
			}
			}
			}
			_allCalcuResultList.Remove(calcuPumpResult);
			_allCalcuResultList.Add(calcuPumpNewResult);
			}
			}
			}

			return _allCalcuResultList;
			}

			#endregion

			//水力计算
			private void barBtnHydroCalcu_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			@@ -2779,12 +2715,362 @@

			#endregion

			#region 计算标签

			//计算标签是否显示
			private bool _isCalcuLabelsVisible = false;

			//所有计算标签
			private List<LogicCalcuCustomLabel> _allCalcuLabels = null;

			//获取计算标签
			private List<LogicCalcuCustomLabel> GetCalcuLabels()
			{
			if (_hydroInfo == null)
			{
			return default;
			}
			var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
			if (allCalcuResultList == null \|\| allCalcuResultList.Count < 1)
			{
			return default;
			}
			var list = new List<LogicCalcuCustomLabel>();

			_hydroInfo.Pumps?.ForEach(x =>
			{
			var hz = Math.Round(x.RatedHz * x.SpeedRatio);
			var calcuPumpResult = GetCalcuVisualResult(x.Code) as HydroCalcuLinkResult;
			if (calcuPumpResult != null)
			{
			var calcuPumpStartResult = GetCalcuVisualResult(x.StartCode) as HydroCalcuNodeResult;
			var calcuPumpEndResult = GetCalcuVisualResult(x.EndCode) as HydroCalcuNodeResult;
			var pumpCustomLabel = new LogicCalcuCustomLabel();
			pumpCustomLabel.Id = x.Code;
			pumpCustomLabel.Distance = 20000;
			pumpCustomLabel.Data = new List<LogicCalcuCustomLabelItem>()
			{
			new LogicCalcuCustomLabelItem(){ Name="状态",Value=HydroLinkStatusHelper.GetStatusName(x.LinkStatus),Unit=string.Empty},
			new LogicCalcuCustomLabelItem(){ Name="频率",Value=hz.ToString(),Unit=string.Empty},
			new LogicCalcuCustomLabelItem(){ Name="流量",Value=Math.Round(calcuPumpResult.CalcuFlow.Value,1).ToString(),Unit="m³/h"},
			new LogicCalcuCustomLabelItem(){ Name="进口压力",Value=Math.Round(calcuPumpStartResult.CalcuHead.Value,4).ToString(),Unit="m"},
			new LogicCalcuCustomLabelItem(){ Name="出口压力",Value=Math.Round(calcuPumpEndResult.CalcuHead.Value,4).ToString(),Unit="m"},
			};
			list.Add(pumpCustomLabel);
			}
			});

			_hydroInfo.GetAllEmitters()?.ForEach(x =>
			{
			var calcuEmitter = GetCalcuVisualResult(x.Code) as HydroCalcuNodeResult;
			var emitterCustomLabel = new LogicCalcuCustomLabel();
			emitterCustomLabel.Id = x.Code;
			emitterCustomLabel.Distance = 30000;
			emitterCustomLabel.Data = new List<LogicCalcuCustomLabelItem>()
			{
			new LogicCalcuCustomLabelItem(){ Name="流量",Value=Math.Round(calcuEmitter.CalcuDemand.Value,1).ToString(),Unit="m³/h"},
			new LogicCalcuCustomLabelItem(){ Name="压力",Value=Math.Round(calcuEmitter.CalcuDemand.Value,4).ToString(),Unit="m"}
			};
			list.Add(emitterCustomLabel);
			});
			return list;
			}

			//设置计算标签
			private void SetCalcuLabels()
			{
			if (_isCalcuLabelsVisible)
			{
			var allCalcuLabels = GetCalcuLabels();
			_bimfaceCtrl?.SetLogicCalcuCustomLabels(allCalcuLabels);
			}
			else
			{
			_bimfaceCtrl?.ClearLogicCalcuCustomLabels();
			}
			}

			//设置计算标签是否显示
			private void barCkCalcuLabels_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			_isCalcuLabelsVisible = this.barCkCalcuLabels.Checked;
			}

			#endregion

			#region 当前工况

			//当前工况
			private Yw.Vmo.HydroWorkingVmo _currentWorking = null;

			//初始化当前工况
			private async void InitialCurrentWorking()
			{
			var allWorkingList = await GetWorkingList();
			this.repositoryItemImageComboBox1.Items.BeginUpdate();
			this.repositoryItemImageComboBox1.Items.Clear();
			if (allWorkingList != null && allWorkingList.Count > 0)
			{
			allWorkingList.ForEach(x => this.repositoryItemImageComboBox1.Items.Add(x.Name, x, -1));
			this.barEditCurrentWorking.EditValue = allWorkingList.Last();
			}
			this.repositoryItemImageComboBox1.Items.EndUpdate();
			}

			//增加当前工况
			private void AppendCurrentWorking(HydroWorkingVmo working)
			{
			this.repositoryItemImageComboBox1.Items.BeginUpdate();
			this.repositoryItemImageComboBox1.Items.Add(working.Name, working, -1);
			this.repositoryItemImageComboBox1.Items.EndUpdate();
			this.barEditCurrentWorking.EditValue = working;
			}

			//设置当前工况
			private async void SetCurrentWorking(HydroWorkingVmo working)
			{
			if (working == null)
			{
			return;
			}
			this.barEditCurrentWorking.EditValue = working;
			_currentWorking = working;
			var allWorkingTupleList = await GetWorkingTupleList();
			var tuple = allWorkingTupleList?.Find(x => x.Item1.ID == working.ID);
			if (tuple == null)
			{
			return;
			}
			_checkResult = tuple.Item2;
			_calcuResult = tuple.Item3;
			}

			//当前工况发生改变
			private void barEditCurrentWorking_EditValueChanged(object sender, EventArgs e)
			{
			var working = this.barEditCurrentWorking.EditValue as HydroWorkingVmo;
			SetCurrentWorking(working);
			}

			#endregion

			#region 工况控件

			//工况控件
			private HydroWorkingTreeCtrl _workingCtrl = null;

			//获取工况控件
			private async Task<HydroWorkingTreeCtrl> GetWorkingCtrl()
			{
			if (_workingCtrl == null)
			{
			_workingCtrl = new HydroWorkingTreeCtrl();
			_workingCtrl.Dock = DockStyle.Fill;
			var allWorkingList = await GetWorkingList();
			_workingCtrl.SetBindingData(allWorkingList);
			_workingCtrl.FocusedChangedEvent += (vmo) =>
			{

			};
			}
			return _workingCtrl;
			}

			//工况控件是否可见
			private bool IsWorkingCtrlVisible
			{
			get
			{
			if (this.docPnlRight.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
			{
			if (this.controlContainerRight.Controls.Count > 0)
			{
			if (this.controlContainerRight.Controls[0] is HydroWorkingTreeCtrl)
			{
			return true;
			}
			}
			}
			return false;
			}
			}

			//显示工况控件
			private async void ShowWorkingCtrl()
			{
			if (IsWorkingCtrlVisible)
			{
			return;
			}
			var workingCtrl = await GetWorkingCtrl();
			this.controlContainerRight.Controls.Clear();
			this.controlContainerRight.Controls.Add(workingCtrl);
			this.docPnlRight.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
			this.docPnlRight.Text = "工况";
			this.docPnlRight.Width = 300;
			}

			//隐藏工况控件
			private void HideWorkingCtrl()
			{
			if (IsWorkingCtrlVisible)
			{
			this.docPnlRight.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Hidden;
			}
			}

			//更新工况控件
			private async void UpdateWorkingCtrl()
			{
			var workingCtrl = await GetWorkingCtrl();
			var allWorkingList = await GetWorkingList();
			workingCtrl.SetBindingData(allWorkingList);
			}

			//工况列表点击
			private void barBtnWorkingList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			ShowWorkingCtrl();
			}

			#endregion

			#region 工况评估


			private void barBtnWorkingEvaluation_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			XtraMessageBox.Show("正在开发中，敬请期待！");
			}

			#endregion

			#region 工况并联

			//并联分析
			private void barBtnAnaly_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			if (_hydroInfo == null)
			{
			return;
			}
			if (_hydroInfo.Pumps == null \|\| _hydroInfo.Pumps.Count < 1)
			{
			return;
			}
			var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
			var vmList = new List<XhsSinglePumpViewModel>();
			foreach (var pump in _hydroInfo.Pumps)
			{
			if (!pump.RatedN.HasValue)
			{
			continue;
			}
			var qh = _hydroInfo.Curves?.Find(t => t.Code == pump.CurveQH)?.CurveData;
			var qe = _hydroInfo.Curves?.Find(t => t.Code == pump.CurveQE)?.CurveData;
			var qp = _hydroInfo.Curves?.Find(t => t.Code == pump.CurveQP)?.CurveData;
			if (qh == null)
			{
			continue;
			}

			var qhPtList = qh.Select(x => new XhsSplinePointViewModel(x.X, x.Y)).ToList();
			var qePtList = qe?.Select(x => new XhsSplinePointViewModel(x.X, x.Y)).ToList();
			var qpPtList = qp?.Select(x => new XhsSplinePointViewModel(x.X, x.Y)).ToList();

			var vm = new XhsSinglePumpViewModel();
			vmList.Add(vm);
			vm.ID = pump.ID;
			vm.Name = pump.Name;
			vm.Code = pump.Code;
			vm.IsBp = true;
			vm.RunStatus = pump.LinkStatus == Yw.Hydro.LinkStatus.Open;
			vm.RatedHz = pump.RatedHz;
			vm.CurrentHz = Math.Round(pump.RatedHz * pump.SpeedRatio, 1);
			vm.RatedSpeed = pump.RatedN.Value;
			vm.CurrentSpeed = Math.Round(pump.RatedN.Value * pump.SpeedRatio);
			vm.CurveQH = qhPtList;
			vm.CurveQE = qePtList;
			vm.CurveQP = qpPtList;

			if (allCalcuResultList != null && allCalcuResultList.Count > 0)
			{
			var calcuResult = allCalcuResultList.Find(x => x.Code == pump.Code) as HydroCalcuLinkResult;
			if (calcuResult != null)
			{
			if (calcuResult.CalcuFlow.HasValue)
			{
			vm.CalcuQ = Math.Abs(calcuResult.CalcuFlow.Value);
			}

			var calcuResultStart = allCalcuResultList.Find(x => x.Code == pump.StartCode) as HydroCalcuNodeResult;
			var calcuResultEnd = allCalcuResultList.Find(x => x.Code == pump.EndCode) as HydroCalcuNodeResult;
			if (calcuResultStart != null && calcuResultEnd != null)
			{
			if (calcuResultStart.CalcuHead.HasValue && calcuResultEnd.CalcuHead.HasValue)
			{
			vm.CalcuH = Math.Round(Math.Abs(calcuResultStart.CalcuHead.Value - calcuResultEnd.CalcuHead.Value), 4);
			}
			}
			}
			}

			}

			var dlg = new PumpParallelAnalyDlg();
			dlg.SetBindingData(vmList);
			dlg.ReloadDataEvent += (list) =>
			{
			list?.ForEach(x =>
			{
			var pump = _hydroInfo.Pumps?.Find(t => t.Code == x.Code);
			if (pump != null)
			{
			pump.LinkStatus = x.RunStatus ? Yw.Hydro.PumpStatus.Open : Yw.Hydro.PumpStatus.Closed;
			pump.SpeedRatio = Math.Round(x.CurrentHz / pump.RatedHz, 1);
			}
			});
			ShowSelectedProperty();
			return true;
			};
			dlg.ShowDialog();
			}

			#endregion

			#region 工况能效

			private void barBtnWorkingPower_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			XtraMessageBox.Show("正在开发中，敬请期待！");
			}

			#endregion

			#region 损失曲线

			private void barBtnWorkingLossCurve_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			XtraMessageBox.Show("正在开发中，敬请期待！");
			}

			#endregion

			#region 损失比例

			private void barBtnWorkingLossScale_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			XtraMessageBox.Show("正在开发中，敬请期待！");
			}

			#endregion

			#region 综合分析
			private void barBtnWorkingAnaly_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
			{
			XtraMessageBox.Show("正在开发中，敬请期待！");
			}
			#endregion