From c390474980cea47189c1fcc962315b9867c9e2ce Mon Sep 17 00:00:00 2001
From: lixiaojun <1287241240@qq.com>
Date: 星期日, 17 十一月 2024 16:03:18 +0800
Subject: [PATCH] 颜色分级梳理

---
 WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs | 2697 ++++++++++++++++++++++++++++++++++++++---------------------
 1 files changed, 1,735 insertions(+), 962 deletions(-)

diff --git a/WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs b/WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs
index 4279474..71f3b2f 100644
--- a/WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs
+++ b/WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs
@@ -1,9 +1,16 @@
 锘縢lobal using Yw.EPAnet;
 using DevExpress.Mvvm.Native;
+using DevExpress.Office.Utils;
+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 System.Diagnostics;
+using System.Windows.Media;
 using System.Windows.Media.Media3D;
+using Yw.Hydro;
 using Yw.Pump;
 using Yw.Vmo;
 using Yw.WinFrmUI.Bimface;
@@ -26,9 +33,7 @@
         private HStation.Vmo.XhsProjectSiteVmo _projectSite = null;//椤圭洰绔�
         private Yw.Model.HydroModelInfo _hydroInfo = null;//姘村姏淇℃伅
 
-        private Yw.Model.HydroParterInfo _parter = null;
-        private Yw.WinFrmUI.HydroCheckResult _checkResult = null;
-        private Yw.EPAnet.CalcuResult _calcuResult = null;
+
 
         /// <summary>
         /// 缁戝畾鏁版嵁
@@ -76,6 +81,7 @@
 
         }
 
+
         #region Bimface
 
         //bimface鎺т欢
@@ -102,8 +108,8 @@
                     {
                         return;
                     }
-                    _parter = obj;
-                    ShowProperty();
+                    _selectedVisual = obj;
+                    ShowSelectedProperty();
                 };
             }
             return _bimfaceCtrl;
@@ -115,6 +121,11 @@
             var bimfaceCtrl = await GetBimfaceCtrl();
             this.tabPageBimface.Controls.Clear();
             this.tabPageBimface.Controls.Add(bimfaceCtrl);
+        }
+
+        private void SelectBimfaceParter()
+        {
+
         }
 
         #endregion
@@ -138,9 +149,9 @@
                     {
                         return;
                     }
-                    var allParterList = _hydroInfo.GetAllParters();
-                    _parter = allParterList?.Find(x => x.Code == obj?.FirstOrDefault());
-                    ShowProperty();
+                    var allParterList = _hydroInfo.GetAllVisuals();
+                    _selectedVisual = allParterList?.Find(x => x.Code == obj?.FirstOrDefault());
+                    ShowSelectedProperty();
                 };
             }
             return _q3dCtrl;
@@ -156,7 +167,7 @@
 
         #endregion
 
-        #region 鏋勪欢灞炴��
+        #region 灞炴�ф帶浠�
 
         //灞炴�ф帶浠�
         private XhsProjectSimulationPropertyCtrl _propertyCtrl = null;
@@ -217,13 +228,72 @@
                     await Task.Delay(5000);
                     await _bimfaceCtrl?.ClearBlinkComponents();
                 };
+
+                _propertyCtrl.ViewParterEvent += (parter) =>
+                {
+                    if (parter == null)
+                    {
+                        return;
+                    }
+                    _bimfaceCtrl?.ZoomToComponent(parter.Code);
+                };
+                _propertyCtrl.PropertyValueChangedEvent += (visual) =>
+                {
+                    if (visual == null)
+                    {
+                        return;
+                    }
+                    UpdateVisualListCtrl();
+                    ApplyGradingResultList(visual);
+                };
+                _propertyCtrl.MarkPropertyValueChangedEvent += (visual) =>
+                {
+                    //鏍囨敞灞炴�у彂鐢熸敼鍙�
+                    //鍒ゆ柇褰撳墠鏄惁鏈夋爣娉ㄥ睍绀猴紝鑻ユ湁鍒欐洿鏂版爣娉紝鏈�濂芥槸鏇存柊鍗曚釜鏍囨敞
+                    UpdateMark(visual);
+                };
+                _propertyCtrl.GradingPropertyValueChangedEvent += (parter) =>
+                {
+                    //鍒嗙骇灞炴�у彂鐢熸敼鍙�
+                    //鍒ゆ柇褰撳墠鏄惁鏈夊垎绾у睍绀猴紝鑻ユ湁鍒欐洿鏂板垎绾э紝鏈�濂芥槸鏇存柊鍗曚釜鍒嗙骇
+                };
+                _propertyCtrl.FlowDirectionPropertyValueChangedEvent += (visual) =>
+                {
+                    //娴佸悜灞炴�у彂鐢熸敼鍙�
+                    //鍒ゆ柇娴佸悜鏄惁鍔犺浇锛屽鏋滃姞杞藉垯鏇存柊娴佸悜锛屾渶濂芥槸鏇存柊鍗曚釜娴佸悜
+                    UpdateFlowEffect(visual);
+                };
+
             }
             return _propertyCtrl;
         }
 
-        //鏄剧ず灞炴�ч潰鏉�
+        //灞炴�ф帶浠舵槸鍚﹀彲瑙�
+        private bool IsPropertyCtrlVisible
+        {
+            get
+            {
+                if (this.docPnlRight.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
+                {
+                    if (this.controlContainerRight.Controls.Count > 0)
+                    {
+                        if (this.controlContainerRight.Controls[0] is XhsProjectSimulationPropertyCtrl)
+                        {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+
+        //鏄剧ず灞炴�ф帶浠�
         private void ShowPropertyCtrl()
         {
+            if (IsPropertyCtrlVisible)
+            {
+                return;
+            }
             var propertyCtrl = GetPropertyCtrl();
             this.controlContainerRight.Controls.Clear();
             this.controlContainerRight.Controls.Add(propertyCtrl);
@@ -232,39 +302,41 @@
             this.docPnlRight.Width = 300;
         }
 
-        //灞炴�ч潰鏉挎寜閽�
-        private void barBtnProperty_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        //鏄剧ず閫夋嫨灞炴��
+        private void ShowSelectedProperty()
         {
-            ShowPropertyCtrl();
+            ShowSelectedProperty(_selectedVisual);
         }
 
-        //鏄剧ず灞炴��
-        private void ShowProperty()
+        //鏄剧ず閫夋嫨灞炴��
+        private void ShowSelectedProperty(Yw.Model.HydroVisualInfo visual)
         {
             if (_hydroInfo == null)
             {
                 return;
             }
-            if (this.docPnlRight.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Hidden)
+            ShowPropertyCtrl();
+            _selectedVisual = visual;
+            if (_selectedVisual == null)
             {
-                ShowPropertyCtrl();
-            }
-            if (_parter == null)
-            {
-                _propertyCtrl?.SelectParter(null);
+                _propertyCtrl.SelectedObject = null;
                 return;
             }
-            _propertyCtrl?.SelectParter(_parter.Code);
+            _propertyCtrl.SelectedObject = GetVisualViewModel(_selectedVisual);
+        }
 
-            var allCalcuResultList = GetCalcuResultList();
-            if (allCalcuResultList != null && allCalcuResultList.Count > 0)
+        //鏇存柊閫夋嫨灞炴��
+        private void UpdateSelectedProperty()
+        {
+            if (!IsPropertyCtrlVisible)
             {
-                var calcuResult = allCalcuResultList.Find(x => x.Code == _parter.Code);
-                if (calcuResult != null)
-                {
-                    _propertyCtrl?.UpdateCalcuProperty(calcuResult);
-                }
+                return;
             }
+            if (_selectedVisual == null)
+            {
+                return;
+            }
+            _propertyCtrl?.UpdateRows();
         }
 
         #endregion
@@ -284,15 +356,15 @@
                     {
                         return;
                     }
-                    var allParterList = _hydroInfo.GetAllParters();
-                    _parter = allParterList?.Find(x => x.Code == code);
+                    var allParterList = _hydroInfo.GetAllVisuals();
+                    _selectedVisual = allParterList?.Find(x => x.Code == code);
                     var elementIds = new List<string>();
-                    if (_parter != null)
+                    if (_selectedVisual != null)
                     {
-                        elementIds.Add(_parter.Code);
+                        elementIds.Add(_selectedVisual.Code);
                     }
                     await _bimfaceCtrl?.ZoomAndSelectComponents(elementIds);
-                    ShowProperty();
+                    ShowSelectedProperty();
                 };
                 _matchingListCtrl.ApplyMatchingEvent += (output) =>
                 {
@@ -347,18 +419,18 @@
                     {
                         return;
                     }
-                    var allParterList = _hydroInfo.GetAllParters();
-                    _parter = allParterList?.Find(x => x.Code == parter.Code);
+                    var allParterList = _hydroInfo.GetAllVisuals();
+                    _selectedVisual = allParterList?.Find(x => x.Code == parter.Code);
                     var elementIds = new List<string>() { parter.Code };
                     await _bimfaceCtrl?.ZoomAndSelectComponents(elementIds);
-                    ShowProperty();
+                    ShowSelectedProperty();
                 };
                 _unMatchingListCtrl.ViewModelEvent += async (parters) =>//鏌ョ湅妯″瀷
                 {
                     var codes = parters?.Select(x => x.Code).Distinct().ToList();
                     await _bimfaceCtrl?.ZoomAndSelectComponents(codes);
-                    _parter = null;
-                    ShowProperty();
+                    _selectedVisual = null;
+                    ShowSelectedProperty();
                 };
             }
             return _unMatchingListCtrl;
@@ -386,8 +458,11 @@
 
         #region 涓�閿樉闅�
 
+        //鏄鹃殣缂栫爜鍒楄〃
+        private List<string> _fastShowHiddenCodeList = null;
+
         //涓�閿樉闅�
-        private async Task FastShowHidden()
+        private async void FastShowHidden()
         {
             if (_hydroInfo == null)
             {
@@ -409,82 +484,10 @@
             }
         }
 
-        //鏄鹃殣缂栫爜鍒楄〃
-        private List<string> _fastShowHiddenCodeList = null;
-
         //瑙﹀彂涓�閿樉闅�
-        private async void barBtnFastShowHidden_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        private void barBtnFastShowHidden_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
         {
-            await FastShowHidden();
-        }
-
-        #endregion
-
-        #region 姘村姏鏍￠獙
-
-        //鏍￠獙鎺т欢
-        private XhsProjectSimulationHydroCheckResultCtrl _checkCtrl = null;
-
-        //鑾峰彇鏍￠獙鎺т欢
-        private XhsProjectSimulationHydroCheckResultCtrl GetCheckCtrl()
-        {
-            if (_checkCtrl == null)
-            {
-                _checkCtrl = new XhsProjectSimulationHydroCheckResultCtrl();
-                _checkCtrl.Dock = DockStyle.Fill;
-                _checkCtrl.HydroClickEvent += async (code) =>
-                {
-                    if (_hydroInfo == null)
-                    {
-                        return;
-                    }
-                    var elementIds = new List<string>();
-                    if (string.IsNullOrEmpty(code))
-                    {
-                        _parter = null;
-                    }
-                    else
-                    {
-                        var allParterList = _hydroInfo.GetAllParters();
-                        _parter = allParterList?.Find(x => x.Code == code);
-                        if (_parter != null)
-                        {
-                            elementIds.Add(_parter.Code);
-                        }
-                    }
-                    await _bimfaceCtrl?.ZoomAndSelectComponents(elementIds);
-                    ShowProperty();
-                };
-            }
-            return _checkCtrl;
-        }
-
-        //鏄剧ず妫�鏌ユ帶浠�
-        private void ShowCheckCtrl()
-        {
-            if (_checkResult == null)
-            {
-                return;
-            }
-            var checkCtrl = GetCheckCtrl();
-            checkCtrl.SetBindingData(_checkResult);
-            this.controlContainerBottom.Controls.Clear();
-            this.controlContainerBottom.Controls.Add(checkCtrl);
-            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
-            this.docPnlBottom.Text = "妫�鏌ョ粨鏋�";
-            this.docPnlBottom.Height = 350;
-
-        }
-
-        //姘村姏妫�鏌�
-        private void barBtnHydroCheck_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            _checkResult = _hydroInfo.Check();
-            ShowCheckCtrl();
+            FastShowHidden();
         }
 
         #endregion
@@ -498,7 +501,17 @@
             {
                 return;
             }
+            Stopwatch sw = new Stopwatch();
+            sw.Start();
+
+
             var id = await BLLFactory<Yw.BLL.HydroModelInfo>.Instance.Save(_hydroInfo);
+
+            //鑰楁椂宸ㄥぇ鐨勪唬鐮�  
+
+            sw.Stop();
+            TimeSpan ts2 = sw.Elapsed;
+            Console.WriteLine("Stopwatch鎬诲叡鑺辫垂{0}ms.", ts2.TotalMilliseconds);
             if (id < 1)
             {
                 TipFormHelper.ShowError("淇濆瓨澶辫触锛�");
@@ -510,79 +523,6 @@
 
         #endregion
 
-        #region 鏋勪欢鏄庣粏
-
-        //鏋勪欢鏄庣粏鎺т欢
-        private Yw.WinFrmUI.HydroParterListCtrl _parterListCtrl = null;
-
-        //鑾峰彇鏋勪欢鏄庣粏鎺т欢
-        private Yw.WinFrmUI.HydroParterListCtrl GetParterListCtrl()
-        {
-            if (_parterListCtrl == null)
-            {
-                _parterListCtrl = new HydroParterListCtrl();
-                _parterListCtrl.Dock = DockStyle.Fill;
-                _parterListCtrl.HydroClickEvent += async (parter) =>
-                {
-                    if (_hydroInfo == null)
-                    {
-                        return;
-                    }
-                    var allParterList = _hydroInfo.GetAllParters();
-                    _parter = allParterList?.Find(x => x.Code == parter.Code);
-                    await _bimfaceCtrl?.ZoomAndSelectComponents(new List<string>() { _parter.Code });
-                    ShowProperty();
-                };
-            }
-            return _parterListCtrl;
-        }
-
-        //鏄剧ず鏋勪欢鏄庣粏鎺т欢
-        private void ShowParterListCtrl()
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            var parterListCtrl = GetParterListCtrl();
-            parterListCtrl.SetBindingData(_hydroInfo, GetCalcuResultList());
-            this.controlContainerBottom.Controls.Clear();
-            this.controlContainerBottom.Controls.Add(parterListCtrl);
-            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
-            this.docPnlBottom.Text = "鏋勪欢鏄庣粏";
-            this.docPnlBottom.Height = 350;
-        }
-
-        //鏋勪欢鏄庣粏
-        private void barBtnHydroParterList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            ShowParterListCtrl();
-        }
-
-        #endregion
-
-        #region INP瀵煎嚭
-
-        //瀵煎嚭姘村姏INP鏂囦欢
-        private void barBtnHydroExportInp_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            var fileName = Yw.WinFrmUI.FileDialogHelper.SaveInp("瀵煎嚭Inp鏂囦欢");
-            if (string.IsNullOrEmpty(fileName))
-            {
-                return;
-            }
-            var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
-            var result = netWork.ToInpString();
-            File.WriteAllText(fileName, result);
-            TipFormHelper.ShowSucceed("瀵煎嚭鎴愬姛");
-        }
-
-        #endregion INP瀵煎嚭
-
         #region 鎵归噺閰嶇疆
 
         //娉ㄥ唽鎵归噺閰嶇疆浜嬩欢
@@ -591,52 +531,95 @@
             //姘村簱
             this.barBtnSetReservoirList.ItemClick += delegate
             {
-                var dlg = new HydroReservoirBulkSetListDlg();
-                dlg.ShowDialog();
+                //var dlg = new HydroReservoirBulkSetListDlg();
+                //dlg.ShowDialog();
             };
             //姘存睜
             this.barBtnSetTankList.ItemClick += delegate
             {
-                var dlg = new HydroTankBulkSetListDlg();
-                dlg.ShowDialog();
+                //var dlg = new HydroTankBulkSetListDlg();
+                //dlg.ShowDialog();
             };
             //姘寸
             this.barBtnSetWaterboxList.ItemClick += delegate
             {
-                if (_hydroInfo == null)
-                {
-                    return;
-                }
-                var dlg = new HydroWaterboxBulkSetListDlg();
-                dlg.SetBindingData(_hydroInfo);
-                dlg.ShowDialog();
+                //if (_hydroInfo == null)
+                //{
+                //    return;
+                //}
+                //var dlg = new SetHydroWaterboxListDlg();
+                //dlg.SetBindingData(_hydroInfo);
+                //dlg.HydroClickEvent += async (obj) =>
+                //{
+                //    if (obj == null)
+                //    {
+                //        return;
+                //    }
+                //    _selectedParter = obj;
+                //    await _bimfaceCtrl?.ZoomAndSelectComponent(obj.Code);
+                //    ShowProperty();
+                //};
+                //dlg.HydroChangedEvent += (obj) =>
+                //{
+
+                //};
+                //dlg.ShowDialog();
             };
             //杩炴帴鑺傜偣
             this.barBtnSetJunctionList.ItemClick += delegate
             {
-                var dlg = new HydroJunctionBulkSetListDlg();
-                dlg.ShowDialog();
+                //var dlg = new HydroJunctionBulkSetListDlg();
+                //dlg.ShowDialog();
             };
             //闂峰ご
             this.barBtnSetBluntheadList.ItemClick += delegate
             {
-                if (_hydroInfo == null)
-                {
-                    return;
-                }
-                var dlg = new HydroBluntheadBulkSetListDlg();
-                dlg.ShowDialog();
+                //if (_hydroInfo == null)
+                //{
+                //    return;
+                //}
+                //var dlg = new SetHydroBluntheadListDlg();
+                //dlg.SetBindingData(_hydroInfo);
+                //dlg.HydroClickEvent += async (obj) =>
+                //{
+                //    if (obj == null)
+                //    {
+                //        return;
+                //    }
+                //    _selectedParter = obj;
+                //    await _bimfaceCtrl?.ZoomAndSelectComponent(obj.Code);
+                //    ShowProperty();
+                //};
+                //dlg.HydroChangedEvent += (obj) =>
+                //{
+
+                //};
+                //dlg.ShowDialog();
             };
             //寮ご
             this.barBtnSetElbowsList.ItemClick += delegate
             {
-                if (_hydroInfo == null)
-                {
-                    return;
-                }
-                var dlg = new HydroElbowBulkSetListDlg();
-                dlg.SetBindingData(_hydroInfo);
-                dlg.ShowDialog();
+                //if (_hydroInfo == null)
+                //{
+                //    return;
+                //}
+                //var dlg = new SetHydroElbowListDlg();
+                //dlg.SetBindingData(_hydroInfo);
+                //dlg.HydroClickEvent += async (obj) =>
+                //{
+                //    if (obj == null)
+                //    {
+                //        return;
+                //    }
+                //    _selectedParter = obj;
+                //    await _bimfaceCtrl?.ZoomAndSelectComponent(obj.Code);
+                //    ShowProperty();
+                //};
+                //dlg.HydroChangedEvent += (obj) =>
+                //{
+
+                //};
+                //dlg.ShowDialog();
             };
             //涓夐��
             this.barBtnSetThreelinkList.ItemClick += delegate
@@ -645,7 +628,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroThreelinkBulkSetListDlg();
+                var dlg = new SetHydroThreelinkListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -656,7 +639,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroFourlinkBulkSetListDlg();
+                var dlg = new SetHydroFourlinkListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -667,7 +650,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroMeterBulkSetListDlg();
+                var dlg = new SetHydroMeterListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -678,7 +661,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroFlowmeterBulkSetListDlg();
+                var dlg = new SetHydroFlowmeterListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -689,7 +672,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroPressmeterBulkSetListDlg();
+                var dlg = new SetHydroPressmeterListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -700,7 +683,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroPipeBulkSetListDlg();
+                var dlg = new SetHydroPipeListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -711,7 +694,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroPumpBulkSetListDlg();
+                var dlg = new SetHydroPumpListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -722,7 +705,7 @@
                 {
                     return;
                 }
-                var dlg = new HydroValveBulkSetListDlg();
+                var dlg = new SetHydroValveListDlg();
                 dlg.SetBindingData(_hydroInfo);
                 dlg.ShowDialog();
             };
@@ -1022,7 +1005,7 @@
                         pump.SpeedRatio = Math.Round(x.CurrentHz / pump.RatedHz, 1);
                     }
                 });
-                ShowProperty();
+                ShowSelectedProperty();
                 return true;
             };
             dlg.ShowDialog();
@@ -1030,67 +1013,1288 @@
 
         #endregion
 
-        #region 姘村姏璁＄畻
+        #region 鏋勪欢鏌ヨ
 
+        //鏌ヨ缁勪欢
+        private HydroVisualSearchListCtrl _searchCtrl = null;
 
-        #region 鍓嶆彁鏉′欢
+        //鑾峰彇鏌ヨ缁勪欢
+        private HydroVisualSearchListCtrl GetSearchCtrl()
+        {
+            if (_searchCtrl == null)
+            {
+                _searchCtrl = new HydroVisualSearchListCtrl();
+                _searchCtrl.Dock = DockStyle.Fill;
+                var allVisualViewModelList = GetVisualViewModelList();
+                _searchCtrl.InitialData(allVisualViewModelList);
+                _searchCtrl.HydroClickInfoEvent += async (visual) =>
+                {
+                    ShowSelectedProperty(visual);
+                    await _bimfaceCtrl?.ZoomAndSelectComponent(visual?.Code);
+                };
+                _searchCtrl.HydroSearchInfoEvent += async (list) =>
+                {
+                    var elementIds = new List<string>();
+                    if (list != null && list.Count > 0)
+                    {
+                        _selectedVisual = list.First();
+                        list.ForEach(x => elementIds.Add(x.Code));
+                    }
+                    else
+                    {
+                        _selectedVisual = null;
+                    }
+                    ShowSelectedProperty();
+                    await _bimfaceCtrl?.ZoomAndSelectComponents(elementIds);
+                };
+            }
+            return _searchCtrl;
+        }
 
-        //鏄剧ず璁＄畻鍓嶆彁鏉′欢绐椾綋
-        private void ShowCalcuPrefixDlg()
+        //鏌ヨ鎺т欢鏄惁鍙
+        private bool IsSearchCtrlVisible
+        {
+            get
+            {
+                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
+                {
+                    if (this.controlContainerBottom.Controls.Count > 0)
+                    {
+                        if (this.controlContainerBottom.Controls[0] is HydroVisualSearchListCtrl)
+                        {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+
+        //鏄剧ず鏌ヨ鎺т欢
+        private void ShowSearchCtrl(string content)
+        {
+            if (IsSearchCtrlVisible)
+            {
+                return;
+            }
+            var searchCtrl = GetSearchCtrl();
+            searchCtrl.SetBindingData(content);
+            this.controlContainerBottom.Controls.Clear();
+            this.controlContainerBottom.Controls.Add(searchCtrl);
+            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
+            this.docPnlBottom.Text = "鏋勪欢鏌ヨ";
+            this.docPnlBottom.Height = 350;
+        }
+
+        //鏄剧ず鏌ヨ绐椾綋
+        private void ShowSearchDlg()
+        {
+            if (IsSearchCtrlVisible)
+            {
+                return;
+            }
+            var dlg = new InputHydroVisualSearchListDlg();
+            dlg.SearchEvent += (content) =>
+            {
+                if (string.IsNullOrEmpty(content))
+                {
+                    return;
+                }
+                ShowSearchCtrl(content);
+            };
+            dlg.SetBindingData();
+            dlg.ShowDialog();
+        }
+
+        //鏌ヨ
+        private void barBtnSearch_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            ShowSearchDlg();
+        }
+
+        #endregion
+
+        #region 妯″瀷鏍囨敞
+
+        #region 鏍囨敞璁剧疆
+
+        //鎵�鏈夋爣娉ㄨ缃垪琛�
+        private List<HydroMarkSetViewModel> _allMarkSetList = null;
+
+        //鑾峰彇鏍囨敞璁剧疆鍒楄〃
+        private List<HydroMarkSetViewModel> GetMarkSetList()
+        {
+            if (_hydroInfo == null)
+            {
+                return default;
+            }
+            if (_allMarkSetList == null)
+            {
+                _allMarkSetList = HydroMarkHelper.GetSetList(_hydroInfo);
+            }
+            return _allMarkSetList;
+        }
+
+        #endregion
+
+        #region 鏍囨敞缁撴灉
+
+        //鎵�鏈夋爣娉ㄧ粨鏋滃垪琛�
+        private List<HydroMarkResultViewModel> _allMarkResultList = null;
+
+        //鑾峰彇鏍囨敞缁撴灉鍒楄〃
+        //UseCache 鏄惁浣跨敤缂撳瓨
+        private List<HydroMarkResultViewModel> GetMarkResultList(bool useCache = true)
+        {
+            if (_hydroInfo == null)
+            {
+                return default;
+            }
+            if (!useCache)
+            {
+                var allSetList = GetMarkSetList();
+                _allMarkResultList = HydroMarkHelper.GetResultList(_hydroInfo, allSetList);
+            }
+            if (_allMarkResultList == null)
+            {
+                var allSetList = GetMarkSetList();
+                _allMarkResultList = HydroMarkHelper.GetResultList(_hydroInfo, allSetList);
+            }
+            return _allMarkResultList;
+        }
+
+        #endregion
+
+        #region 鏍囨敞鏄剧ず
+
+        //鏍囨敞鏄惁鏄剧ず
+        private bool _isMarkVisible = false;
+
+        //鏇存柊鏍囨敞
+        private async void UpdateMark(Yw.Model.HydroVisualInfo visual)
+        {
+            var allSetList = GetMarkSetList();
+            var result = HydroMarkHelper.GetResult(visual, allSetList);
+            if (result == null)
+            {
+                return;
+            }
+            var allResultList = GetMarkResultList(true);
+            allResultList.Remove(x => x.Code == visual.Code);
+            allResultList.Add(result);
+            if (_isMarkVisible)
+            {
+                var leadLabel = new LogicMarkLeadLabel() { Id = result.Code, Text = result.Text, Distance = null };
+                await _bimfaceCtrl?.UpdateLogicMarkLeadLabel(leadLabel);
+            }
+        }
+
+        //鏇存柊鏍囨敞鍒楄〃
+        private void UpdateMarkList(List<Yw.Model.HydroVisualInfo> visuals)
+        {
+            if (visuals == null || visuals.Count < 1)
+            {
+                visuals.ForEach(x => UpdateMark(x));
+            }
+        }
+
+        //搴旂敤鏍囨敞鍒楄〃
+        //UseCache 鏄惁浣跨敤缂撳瓨
+        private async void ApplyMarkList(bool useCache = true)
+        {
+            if (_isMarkVisible)
+            {
+                var allResultList = GetMarkResultList(useCache);
+                var leadLabels = allResultList?.Select(x => new LogicMarkLeadLabel(x.Code, x.Text, null)).ToList();
+                await _bimfaceCtrl?.SetLogicMarkLeadLabels(leadLabels);
+            }
+            else
+            {
+                await _bimfaceCtrl?.ClearLogicMarkLeadLabels();
+            }
+        }
+
+        //鏄剧ず鏍囨敞璁剧疆绐椾綋
+        private void ShowSetMarkDlg()
         {
             if (_hydroInfo == null)
             {
                 return;
             }
-            var dlg = new HStation.WinFrmUI.SetHydroCalcuPrefixDlg1();
-            dlg.SetBindingData(_hydroInfo);
-            dlg.HydroViewEvent += async (parter) =>
+            var allMarkSetList = GetMarkSetList();
+            var dlg = new SetHydroMarkDlg();
+            dlg.SetBindingData(allMarkSetList);
+            dlg.ReloadDataEvent += (list) =>
             {
-                _parter = parter;
-                if (_parter != null)
-                {
-                    await _bimfaceCtrl?.ZoomAndSelectComponents(new List<string>() { _parter.Code });
-                }
-                ShowProperty();
+                _allMarkSetList = list;
+                ApplyMarkList(false);
             };
-            dlg.HydroCalcuEvent += async () =>
+            dlg.ShowDialog();
+        }
+
+        //璁剧疆鏍囨敞
+        private void barBtnSetMark_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            ShowSetMarkDlg();
+        }
+
+        //鏄惁鏄剧ず
+        private void barCkMark_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            _isMarkVisible = this.barCkMark.Checked;
+            ApplyMarkList(true);
+        }
+
+        #endregion
+
+        #endregion
+
+        #region 棰滆壊鍒嗙骇
+
+        #region 棰滆壊閰嶇疆
+
+        //鎵�鏈夐鑹插垎绾ч厤缃垪琛�
+        private List<HydroGradingVmo> _allGradingList = null;
+
+        //鑾峰彇棰滆壊鍒嗙骇閰嶇疆鍒楄〃
+        private async Task<List<HydroGradingVmo>> GetGradingList()
+        {
+            if (_hydroInfo == null)
             {
-                if (_hydroInfo == null)
+                return default;
+            }
+            if (_allGradingList == null)
+            {
+                _allGradingList = await HydroGradingHelper.GetGradingList(_hydroInfo);
+            }
+            return _allGradingList;
+        }
+
+        //鏄剧ず棰滆壊鍒嗙骇绐椾綋
+        private async void ShowGradingDlg()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var allGradingList = await GetGradingList();
+            var dlg = new SetHydroGradingTreeDlg();
+            dlg.SetBindingData(_hydroInfo, allGradingList);
+            dlg.ReloadDataEvent += (list) =>
+            {
+                _allGradingList = list;
+                ApplyGradingResultList(false);
+            };
+            dlg.ApplyDataEvent += (catalog, propName) =>
+            {
+                UpdateGradingApplyList(catalog, propName);
+                ApplyGradingResultList(false);
+            };
+            dlg.ShowDialog();
+        }
+
+        //閰嶇疆棰滆壊鍒嗙骇
+        private void barBtnGradingSet_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            ShowGradingDlg();
+        }
+
+        #endregion
+
+        #region 搴旂敤鍒嗙骇
+
+        //棰滆壊鍒嗙骇搴旂敤鍒楄〃
+        private List<HydroGradingApplyViewModel> _allGradingApplyList = null;
+
+        //鑾峰彇棰滆壊鍒嗙骇搴旂敤鍒楄〃
+        private List<HydroGradingApplyViewModel> GetGradingApplyList()
+        {
+            if (_hydroInfo == null)
+            {
+                return default;
+            }
+            if (_allGradingApplyList == null)
+            {
+                _allGradingApplyList = HydroGradingHelper.GetApplyList(_hydroInfo);
+            }
+            return _allGradingApplyList;
+        }
+
+        //鏇存柊棰滆壊鍒嗙骇搴旂敤鍒楄〃
+        private void UpdateGradingApplyList(string catalog, string propName)
+        {
+            var allGradingApplyList = GetGradingApplyList();
+            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
+            {
+                return;
+            }
+            var apply = allGradingApplyList.Find(x => x.Catalog == catalog);
+            if (apply == null)
+            {
+                return;
+            }
+            apply.PropName = propName;
+        }
+
+        //鏄剧ず棰滆壊鍒嗙骇搴旂敤绐椾綋
+        private void ShowGradingApplyDlg()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var allGradingApplyList = GetGradingApplyList();
+            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
+            {
+                return;
+            }
+            var dlg = new ApplyHydroGradingDlg();
+            dlg.SetBindingData(allGradingApplyList);
+            dlg.ReloadDataEvent += (obj) =>
+            {
+                _allGradingApplyList = obj;
+                ApplyGradingResultList(false);
+            };
+            dlg.ShowDialog();
+        }
+
+        //搴旂敤棰滆壊鍒嗙骇
+        private void barBtnGradingApply_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            ShowGradingApplyDlg();
+        }
+
+        #endregion
+
+        #region 搴旂敤缁撴灉
+
+        //鎵�鏈夐鑹插垎绾х粨鏋滃垪琛�
+        private List<HydroGradingResultViewModel> _allGradingResultList = null;
+
+        //鑾峰彇棰滆壊鍒嗙骇缁撴灉鍒楄〃
+        //UseCache鏄惁浣跨敤缂撳瓨
+        private async Task<List<HydroGradingResultViewModel>> GetGradingResultList(bool useCache = true)
+        {
+            if (_hydroInfo == null)
+            {
+                return default;
+            }
+            var allGradingList = await GetGradingList();
+            var allGradingApplyList = GetGradingApplyList();
+            var allCalcuResultList = GetCalcuResultList();
+            if (!useCache)
+            {
+                _allGradingResultList = HydroGradingHelper.GetResultList(_hydroInfo, allGradingList, allGradingApplyList, allCalcuResultList);
+            }
+            if (_allGradingResultList == null)
+            {
+                _allGradingResultList = HydroGradingHelper.GetResultList(_hydroInfo, allGradingList, allGradingApplyList, allCalcuResultList);
+            }
+            return _allGradingResultList;
+        }
+
+        #endregion
+
+        #region 缁撴灉灞曠ず
+
+        //棰滆壊鍒嗙骇鏄惁鏄剧ず
+        private bool _isGradingVisible = false;
+
+        //搴旂敤棰滆壊鍒嗙骇缁撴灉鍒楄〃
+        //UseCache鏄惁浣跨敤缂撳瓨
+        private async void ApplyGradingResultList(bool useCache = true)
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var allGradingResultList = await GetGradingResultList(useCache);
+            if (allGradingResultList == null || allGradingResultList.Count < 1)
+            {
+                return;
+            }
+            if (_isGradingVisible)
+            {
+                var groupList = allGradingResultList.GroupBy(x => x.Color).ToList();
+                groupList.ForEach(async x => await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1));
+            }
+            else
+            {
+                var codes = allGradingResultList.Select(x => x.Code).Distinct().ToList();
+                await _bimfaceCtrl?.RestoreComponentsColor(codes);
+            }
+        }
+
+        //搴旂敤棰滆壊鍒嗙骇缁撴灉鍒楄〃
+        private async void ApplyGradingResultList(Yw.Model.HydroVisualInfo visual)
+        {
+            if (visual == null)
+            {
+                return;
+            }
+            var allGradingList = await GetGradingList();
+            var allGradingApplyList = GetGradingApplyList();
+            var allGradingResultList = await GetGradingResultList(true);
+            var allCalcuResultList = GetCalcuResultList(true);
+            var oldResult = allGradingResultList?.Find(x => x.Code == visual.Code);
+            if (oldResult != null)
+            {
+                allGradingResultList.Remove(oldResult);
+            }
+            var newResult = HydroGradingHelper.GetResult(visual, allGradingList, allGradingApplyList, allCalcuResultList);
+            if (newResult != null)
+            {
+                allGradingResultList.Add(newResult);
+            }
+            if (_isGradingVisible)
+            {
+                if (newResult == null)
                 {
-                    return;
-                }
-
-                //鏍￠獙
-                _checkResult = _hydroInfo.Check();
-                if (!_checkResult.Succeed)
-                {
-                    ShowCheckCtrl();
-                    TipFormHelper.ShowWarn("鏍￠獙澶辫触锛岃妫�鏌ュ悗閲嶈瘯");
-                    return;
-                }
-
-                WaitFormHelper.ShowWaitForm(this, "姝ｅ湪璁＄畻鍒嗘瀽涓紝璇风◢鍊�...");
-
-                await Task.Delay(5000);
-
-                var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
-                _calcuResult = netWork.Calcu();
-
-                WaitFormHelper.HideWaitForm();
-                if (_calcuResult.Succeed)
-                {
-                    GetCalcuResultList(false);
-                    await _bimfaceCtrl?.SetLogicCalcuCustomLabels(_calcuResult);
-                    TipFormHelper.ShowSucceed("璁＄畻鎴愬姛锛�");
+                    if (oldResult != null)
+                    {
+                        await _bimfaceCtrl?.RestoreComponentsColor(oldResult.Code);
+                    }
                 }
                 else
                 {
-                    ShowCalcuFailedCtrl();
-                    TipFormHelper.ShowError("璁＄畻澶辫触锛�");
+                    await _bimfaceCtrl?.OverrideComponentsColor(newResult.Code, newResult.Color, 1);
                 }
+            }
+        }
 
+        //搴旂敤棰滆壊鍒嗙骇缁撴灉鍒楄〃
+        private void ApplyGradingResultList(List<Yw.Model.HydroVisualInfo> visualList)
+        {
+            if (visualList == null || visualList.Count < 1)
+            {
+                return;
+            }
+            visualList.ForEach(x => ApplyGradingResultList(x));
+        }
+
+        //棰滆壊鍒嗙骇灞曠ず
+        private void barCkGrading_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            _isGradingVisible = this.barCkGrading.Checked;
+            ApplyGradingResultList(true);
+        }
+
+        #endregion
+
+        #endregion
+
+        #region 浜哄伐鍒锋柊
+
+        //鍒锋柊
+        private async void barBtnRefresh_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            if (XtraMessageBox.Show("鍒锋柊鍚庡皢涓㈠け褰撳墠姘村姏淇℃伅鏇存敼锛屾槸鍚︾户缁埛鏂帮紵", "璇㈤棶", MessageBoxButtons.YesNo) == DialogResult.Yes)
+            {
+                if (_project == null)
+                {
+                    return;
+                }
+                if (_projectSite == null)
+                {
+                    return;
+                }
+                var hydroRelation = await BLLFactory<Yw.BLL.HydroModelRelation>.Instance
+                    .GetDefaultByObjectTypeAndObjectIDOfPurpose(HStation.Xhs.DataType.XhsProjectSite, _projectSite.ID, HStation.Xhs.Purpose.Simulation);
+                Stopwatch sw = new Stopwatch();
+                sw.Start();
+                _hydroInfo = await BLLFactory<Yw.BLL.HydroModelInfo>.Instance.GetByID(hydroRelation.ModelID);
+                sw.Stop();
+                TimeSpan ts2 = sw.Elapsed;
+                Console.WriteLine("Stopwatch鎬诲叡鑺辫垂{0}ms.", ts2.TotalMilliseconds);
+                _selectedVisual = null;
+                await _bimfaceCtrl?.ZoomAndSelectComponents(null);
+                ShowSelectedProperty();
+                TipFormHelper.ShowSucceed("鏁版嵁宸插埛鏂�");
+            }
+        }
+
+        #endregion
+
+        #region 姘存祦鍔ㄧ敾
+
+        //姘存祦鍔ㄧ敾鏄惁鍙
+        private bool _isFlowEffectVisible = false;
+
+        //鎵�鏈夋按娴佸姩鐢诲垪琛�
+        private List<LogicFlowEffect> _allFlowEffectList = null;
+
+        //鑾峰彇娴佸悜鍒楄〃
+        private List<LogicFlowEffect> GetFlowEffectList()
+        {
+            if (_hydroInfo == null)
+            {
+                return default;
+            }
+            if (_allFlowEffectList == null)
+            {
+                _allFlowEffectList = new List<LogicFlowEffect>();
+                var allCalcuResultList = GetCalcuResultList();
+                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
+                {
+                    foreach (var parter in _hydroInfo.Pipes)
+                    {
+                        var flowEffect = new LogicFlowEffect();
+                        _allFlowEffectList.Add(flowEffect);
+                        flowEffect.Id = parter.Code;
+                        flowEffect.Rotation = 90;
+                        flowEffect.SpeedX = 0.1;
+                        if (parter.FlowDirectionX == Yw.Hydro.FlowDirection.None)
+                        {
+                            flowEffect.SpeedX = 0;
+                        }
+                        else if (parter.FlowDirectionX == Yw.Hydro.FlowDirection.Positive)
+                        {
+                            flowEffect.SpeedX = 0.1;
+                        }
+                        else
+                        {
+                            flowEffect.SpeedX = -0.1;
+                        }
+
+                        if (parter.FlowDirectionY == Yw.Hydro.FlowDirection.None)
+                        {
+                            flowEffect.SpeedY = 0;
+                        }
+                        else if (parter.FlowDirectionY == Yw.Hydro.FlowDirection.Positive)
+                        {
+                            flowEffect.SpeedY = 0.1;
+                        }
+                        else
+                        {
+                            flowEffect.SpeedY = -0.1;
+                        }
+
+                        var calcuResult = allCalcuResultList?.Find(x => x.Code == parter.Code) as HydroCalcuLinkResult;
+                        if (calcuResult != null)
+                        {
+                            if (calcuResult.CalcuVelocity < 0)
+                            {
+                                flowEffect.SpeedX = -flowEffect.SpeedX;
+                            }
+                        }
+                    }
+                }
+            }
+            return _allFlowEffectList;
+        }
+
+        //鍔犺浇姘存祦鍔ㄧ敾
+        private async void LoadFlowEffect()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var allFlowEffectList = GetFlowEffectList();
+            await _bimfaceCtrl?.LoadFlowEffect(allFlowEffectList);
+        }
+
+        //鍗歌浇姘存祦鍔ㄧ敾
+        private async void UnloadFlowEffect()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            await _bimfaceCtrl?.UnloadFlowEffect();
+        }
+
+        //璁剧疆姘村姏鍔ㄧ敾
+        private void SetFlowEffect()
+        {
+            if (_isFlowEffectVisible)
+            {
+                LoadFlowEffect();
+            }
+            else
+            {
+                UnloadFlowEffect();
+            }
+        }
+
+        //鏇存柊姘存祦鍔ㄧ敾
+        private async void UpdateFlowEffect(Yw.Model.HydroVisualInfo visual)
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var allFlowEffectList = GetFlowEffectList();
+            var flowEffect = _allFlowEffectList?.Find(x => x.Id == visual.Code);
+            if (flowEffect == null)
+            {
+                return;
+            }
+            if (visual.FlowDirectionX == Yw.Hydro.FlowDirection.None)
+            {
+                flowEffect.SpeedX = 0;
+            }
+            else if (visual.FlowDirectionX == Yw.Hydro.FlowDirection.Positive)
+            {
+                flowEffect.SpeedX = 0.1;
+            }
+            else
+            {
+                flowEffect.SpeedX = -0.1;
+            }
+
+            if (visual.FlowDirectionY == Yw.Hydro.FlowDirection.None)
+            {
+                flowEffect.SpeedY = 0;
+            }
+            else if (visual.FlowDirectionY == Yw.Hydro.FlowDirection.Positive)
+            {
+                flowEffect.SpeedY = 0.1;
+            }
+            else
+            {
+                flowEffect.SpeedY = -0.1;
+            }
+
+            var allCalcuResultList = GetCalcuResultList();
+            var calcuResult = allCalcuResultList?.Find(x => x.Code == visual.Code) as HydroCalcuLinkResult;
+            if (calcuResult != null)
+            {
+                if (calcuResult.CalcuVelocity < 0)
+                {
+                    flowEffect.SpeedX = -flowEffect.SpeedX;
+                }
+            }
+            if (_isFlowEffectVisible)
+            {
+                await _bimfaceCtrl?.UpdateFlowEffect(flowEffect);
+            }
+        }
+
+        //姘存祦鍔ㄧ敾鏄惁鍙
+        private void barCkFlowEffect_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            _isFlowEffectVisible = this.barCkFlowEffect.Checked;
+            SetFlowEffect();
+        }
+
+        #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 鏋勪欢鏄庣粏鎺т欢
+
+        //鏋勪欢鏄庣粏鎺т欢
+        private Yw.WinFrmUI.HydroVisualListCtrl _visualListCtrl = null;
+
+        //鑾峰彇鏋勪欢鏄庣粏鎺т欢
+        private Yw.WinFrmUI.HydroVisualListCtrl GetVisualListCtrl()
+        {
+            if (_visualListCtrl == null)
+            {
+                _visualListCtrl = new HydroVisualListCtrl();
+                _visualListCtrl.Dock = DockStyle.Fill;
+                _visualListCtrl.HydroClickInfoEvent += async (visual) =>
+                {
+                    ShowSelectedProperty(visual);
+                    await _bimfaceCtrl?.ZoomAndSelectComponent(_selectedVisual?.Code);
+                };
+                _visualListCtrl.HydroChangedInfoEvent += (visualList) =>
+                {
+                    UpdateMarkList(visualList);
+                    UpdateSelectedProperty();
+                    ApplyGradingResultList();
+                };
+            }
+            return _visualListCtrl;
+        }
+
+        //鏋勪欢鏄庣粏鎺т欢鏄惁鍙
+        private bool IsVisualListCtrlVisible
+        {
+            get
+            {
+                if (this.docPnlBottom.Visibility == DevExpress.XtraBars.Docking.DockVisibility.Visible)
+                {
+                    if (this.controlContainerBottom.Controls.Count > 0)
+                    {
+                        if (this.controlContainerBottom.Controls[0] is HydroVisualListCtrl)
+                        {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+
+        //鏄剧ず鏋勪欢鏄庣粏鎺т欢
+        private void ShowVisualListCtrl()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            if (IsVisualListCtrlVisible)
+            {
+                return;
+            }
+
+            var visualListCtrl = GetVisualListCtrl();
+            var allVisualViewModelList = GetVisualViewModelList();
+            visualListCtrl.SetBindingData(allVisualViewModelList);
+            var allCalcuResultList = GetCalcuResultList();
+            if (allCalcuResultList == null || allCalcuResultList.Count < 1)
+            {
+                visualListCtrl.SetNormalView();
+            }
+            else
+            {
+                visualListCtrl.SetCalcuView();
+            }
+            this.controlContainerBottom.Controls.Clear();
+            this.controlContainerBottom.Controls.Add(visualListCtrl);
+            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
+            this.docPnlBottom.Text = "鏋勪欢鏄庣粏";
+            this.docPnlBottom.Height = 350;
+        }
+
+        //鏇存柊鏋勪欢鏄庣粏鎺т欢
+        private void UpdateVisualListCtrl()
+        {
+            if (!IsVisualListCtrlVisible)
+            {
+                return;
+            }
+            _visualListCtrl?.UpdateBindingData();
+        }
+
+        //鏋勪欢鏄庣粏
+        private void barBtnHydroVisualList_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            ShowVisualListCtrl();
+        }
+
+        #endregion
+
+        #endregion
+
+        #region 鐩戞祴鍒楄〃
+
+        #region 娴嬬偣鍒楄〃
+
+        //鎵�鏈夌洃娴嬬偣鍒楄〃
+        private List<HydroMonitorVmo> _allMonitorList = null;
+
+        //鑾峰彇鐩戞祴鐐瑰垪琛�
+        private async Task<List<HydroMonitorVmo>> GetMonitorList()
+        {
+            if (_hydroInfo == null)
+            {
+                return default;
+            }
+            if (_allMonitorList == null)
+            {
+                _allMonitorList = await BLLFactory<Yw.BLL.HydroMonitor>.Instance.GetByModelID(_hydroInfo.ID);
+                if (_allMonitorList == null)
+                {
+                    _allMonitorList = new List<HydroMonitorVmo>();
+                }
+            }
+            return _allMonitorList;
+        }
+
+        //鏇存柊鐩戞祴鐐瑰垪琛�
+        private async void UpdateMonitorList(string code)
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            if (string.IsNullOrEmpty(code))
+            {
+                return;
+            }
+            var allMonitorList = await GetMonitorList();
+            allMonitorList.RemoveAll(x => x.Relation == code);
+            var monitorList = await BLLFactory<Yw.BLL.HydroMonitor>.Instance.GetByRelation(_hydroInfo.ID, code);
+            if (monitorList != null && monitorList.Count > 0)
+            {
+                allMonitorList.AddRange(monitorList);
+            }
+            UpdateMonitorValueList(code, monitorList);
+            SetLogicMonitorList();
+        }
+
+        //璁剧疆閫夋嫨鏋勪欢鐩戞祴鐐瑰垪琛�
+        private async void SetSelectVisualMonitorList()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            if (_selectedVisual == null)
+            {
+                return;
+            }
+            var allMonitorList = await GetMonitorList();
+            var dlg = new SetHydroVisualMonitorDlg();
+            dlg.SetBindingData(_hydroInfo, _selectedVisual, allMonitorList);
+            dlg.ReloadDataEvent += async (hydroInfo, visual, list) =>
+            {
+                if (hydroInfo == null)
+                {
+                    return;
+                }
+                if (visual == null)
+                {
+                    return;
+                }
+                var bol = await BLLFactory<Yw.BLL.HydroMonitor>.Instance.Save(hydroInfo.ID, visual.Code, list);
+                if (!bol)
+                {
+                    TipFormHelper.ShowError("璁剧疆澶辫触");
+                    return;
+                }
+                TipFormHelper.ShowSucceed("璁剧疆鎴愬姛");
+                UpdateMonitorList(visual.Code);
             };
             dlg.ShowDialog();
+        }
+
+        //璁剧疆鐩戞祴鐐�
+        private void barBtnSetMonitor_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            SetSelectVisualMonitorList();
+        }
+
+        #endregion
+
+        #region 鐩戞祴鍊煎垪琛�
+
+        //鎵�鏈夌洃娴嬪�煎垪琛�
+        private List<HydroVisualMonitorValueViewModel> _allMonitorValueList = null;
+
+        //鑾峰彇鐩戞祴鍊煎垪琛�
+        private async Task<List<HydroVisualMonitorValueViewModel>> GetMonitorValueList()
+        {
+            if (_allMonitorValueList == null)
+            {
+                _allMonitorValueList = new List<HydroVisualMonitorValueViewModel>();
+                var allMonitorList = await GetMonitorList();
+                var allVisualViewModelList = GetVisualViewModelList();
+                allMonitorList.ForEach(x =>
+                {
+                    var visual = allVisualViewModelList.Find(t => t.Code == x.Relation);
+                    if (visual != null)
+                    {
+                        var vm = new HydroVisualMonitorValueViewModel(visual.Vmo, x);
+                        _allMonitorValueList.Add(vm);
+                    }
+                });
+            }
+            return _allMonitorValueList;
+        }
+
+        //鏇存柊鐩戞祴鍊煎垪琛�
+        private async void UpdateMonitorValueList(string code, List<HydroMonitorVmo> monitorList)
+        {
+            if (string.IsNullOrEmpty(code))
+            {
+                return;
+            }
+            var visual = GetVisualViewModel(code)?.Vmo;
+            if (visual == null)
+            {
+                return;
+            }
+            var allMonitorValueList = await GetMonitorValueList();
+            var monitorValueList = allMonitorValueList.Where(x => x.Vmo.Relation == code).ToList();
+            monitorValueList?.ForEach(x =>
+            {
+                var result = monitorList?.Exists(t => t.Relation == x.Vmo.Relation && t.PropName == x.Vmo.PropName);
+                if (!(result.HasValue && result.Value))
+                {
+                    allMonitorValueList.Remove(x);
+                }
+            });
+            monitorList?.ForEach(x =>
+            {
+                var result = monitorValueList?.Exists(t => t.Vmo.Relation == x.Relation && t.Vmo.PropName == x.PropName);
+                if (!(result.HasValue && result.Value))
+                {
+                    var vm = new HydroVisualMonitorValueViewModel(visual, x);
+                    allMonitorValueList.Add(vm);
+                }
+            });
+        }
+
+        #endregion
+
+        #region 鐩戞祴鍊煎垪琛ㄦ帶浠�
+
+        //鐩戞祴鍊煎垪琛ㄦ帶浠�
+        private HydroVisualMonitorValueListCtrl _monitorValueListCtrl = null;
+
+        //鑾峰彇鐩戞祴鍊煎垪琛ㄦ帶浠�
+        private HydroVisualMonitorValueListCtrl GetMonitorValueListCtrl()
+        {
+            if (_monitorValueListCtrl == null)
+            {
+                _monitorValueListCtrl = new HydroVisualMonitorValueListCtrl();
+                _monitorValueListCtrl.Dock = DockStyle.Fill;
+                _monitorValueListCtrl.HydroViewEvent += (code) =>
+                {
+                    _bimfaceCtrl?.ZoomToComponent(code);
+                };
+            }
+            return _monitorValueListCtrl;
+        }
+
+        //鏄剧ず鐩戞祴鍊煎垪琛ㄦ帶浠�
+        private async void ShowMonitorValueListCtrl()
+        {
+            var monitorValueListCtrl = GetMonitorValueListCtrl();
+            var allMonitorValueList = await GetMonitorValueList();
+            monitorValueListCtrl.SetBindingData(allMonitorValueList);
+            this.controlContainerBottom.Controls.Clear();
+            this.controlContainerBottom.Controls.Add(monitorValueListCtrl);
+            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
+            this.docPnlBottom.Text = "鐩戞祴鍊�";
+            this.docPnlBottom.Height = 350;
+        }
+
+        //璁剧疆鐩戞祴鍊�
+        private void barBtnSetMonitorValue_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            ShowMonitorValueListCtrl();
+        }
+
+        #endregion
+
+        #region 鐩戞祴鍒楄〃鏄剧ず
+
+        //鐩戞祴鏄惁鏄剧ず
+        private bool _isMonitorVisible = false;
+
+        //鑾峰彇涓氬姟鐩戞祴鍒楄〃
+        private async Task<List<LogicMonitor>> GetLogicMonitorList()
+        {
+            var allMonitorList = await GetMonitorList();
+            var allLogicMonitorList = allMonitorList.Select(x =>
+            {
+                var logicMonitor = new LogicMonitor();
+                logicMonitor.Id = x.Relation;
+                logicMonitor.PropName = x.PropName;
+                logicMonitor.Description = x.Description;
+                return logicMonitor;
+            }).ToList();
+            return allLogicMonitorList;
+        }
+
+        //璁剧疆涓氬姟鐩戞祴鍒楄〃
+        private async void SetLogicMonitorList()
+        {
+            if (_isMonitorVisible)
+            {
+                var allLogicMonitorList = await GetLogicMonitorList();
+                await _bimfaceCtrl?.SetLogicMonitors(allLogicMonitorList);
+            }
+            else
+            {
+                await _bimfaceCtrl?.ClearLogicMonitors();
+            }
+        }
+
+        //鏄剧ず鐘舵�佹敼鍙�
+        private void barCkMonitor_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            _isMonitorVisible = this.barCkMonitor.Checked;
+            SetLogicMonitorList();
+        }
+
+
+        #endregion
+
+        #endregion
+
+        #region 姘村姏妫�鏌�
+
+        #region 妫�鏌ョ粨鏋�
+
+        //妫�鏌ョ粨鏋滅紦瀛�
+        private HydroCheckResult _checkResult = null;
+
+        //鑾峰彇妫�鏌ョ粨鏋�
+        //needCheckAgain 鐢ㄤ簬纭畾鏄惁闇�瑕侀噸鏂版鏌�
+        private HydroCheckResult GetCheckResult(bool needCheckAgain = false)
+        {
+            if (_hydroInfo == null)
+            {
+                return default;
+            }
+            if (needCheckAgain)
+            {
+                _checkResult = _hydroInfo.Check();
+            }
+            if (_checkResult == null)
+            {
+                _checkResult = _hydroInfo.Check();
+            }
+            return _checkResult;
+        }
+
+        #endregion
+
+        #region 妫�鏌ユ帶浠�
+
+        //妫�鏌ユ帶浠�
+        private HydroCheckResultCtrl _checkCtrl = null;
+
+        //鑾峰彇妫�鏌ユ帶浠�
+        private HydroCheckResultCtrl GetCheckCtrl()
+        {
+            if (_checkCtrl == null)
+            {
+                _checkCtrl = new HydroCheckResultCtrl();
+                _checkCtrl.Dock = DockStyle.Fill;
+                _checkCtrl.HydroClickEvent += async (code) =>
+                {
+                    if (_hydroInfo == null)
+                    {
+                        return;
+                    }
+                    var elementIds = new List<string>();
+                    if (string.IsNullOrEmpty(code))
+                    {
+                        this.SelectedVisual = null;
+                    }
+                    else
+                    {
+                        var allVisualViewModelList = GetVisualViewModelList();
+                        this.SelectedVisual = allVisualViewModelList?.Find(x => x.Code == code)?.Vmo;
+                        if (this.SelectedVisual != null)
+                        {
+                            elementIds.Add(this.SelectedVisual.Code);
+                        }
+                    }
+                    await _bimfaceCtrl?.ZoomAndSelectComponents(elementIds);
+                    ShowSelectedProperty();
+                };
+            }
+            return _checkCtrl;
+        }
+
+        //鏄剧ず妫�鏌ユ帶浠�
+        //needCheckAgain 鐢ㄤ簬纭畾鏄惁闇�瑕侀噸鏂版鏌�
+        private void ShowCheckCtrl(bool needCheckAgain = false)
+        {
+            var checkResult = GetCheckResult(needCheckAgain);
+            if (checkResult == null)
+            {
+                return;
+            }
+            var checkCtrl = GetCheckCtrl();
+            checkCtrl.SetBindingData(checkResult);
+            this.controlContainerBottom.Controls.Clear();
+            this.controlContainerBottom.Controls.Add(checkCtrl);
+            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
+            this.docPnlBottom.Text = "妫�鏌ョ粨鏋�";
+            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
@@ -1112,22 +2316,22 @@
         }
 
         //鏄剧ず璁＄畻澶辫触鎺т欢
-        private void ShowCalcuFailedCtrl()
+        private void ShowCalcuFailedCtrl(Yw.EPAnet.CalcuResult calcuResult)
         {
             if (_hydroInfo == null)
             {
                 return;
             }
-            if (_calcuResult == null)
+            if (calcuResult == null)
             {
                 return;
             }
-            if (_calcuResult.Succeed)
+            if (calcuResult.Succeed)
             {
                 return;
             }
             var calcuFailedCtrl = GetCalcuFailedCtrl();
-            calcuFailedCtrl.SetBindingData(_calcuResult.FailedList);
+            calcuFailedCtrl.SetBindingData(calcuResult.FailedList);
             this.controlContainerBottom.Controls.Clear();
             this.controlContainerBottom.Controls.Add(calcuFailedCtrl);
             this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
@@ -1135,26 +2339,281 @@
             this.docPnlBottom.Height = 350;
         }
 
+        //鏄剧ず璁＄畻澶辫触鎺т欢
+        private void ShowCalcuFailedCtrl()
+        {
+            ShowCalcuFailedCtrl(_epaCalcuResult);
+        }
+
+
         #endregion
+
+        #region 绠＄綉淇
+
+        //淇绠＄綉
+        private void Repair()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var checkResult = GetCheckResult(true);
+            if (checkResult == null)
+            {
+                return;
+            }
+            if (!checkResult.Succeed)
+            {
+                ShowCheckCtrl(false);
+                TipFormHelper.ShowWarn("妫�鏌ュけ璐ュ鑷存棤娉曡繘琛岃瘯绠楋紝鍋滄淇锛�");
+                return;
+            }
+            var calcuResult = GetEpaCalcuResult(Yw.EPAnet.CalcuMode.Simple, true);
+            if (calcuResult == null || !calcuResult.Succeed)
+            {
+                ShowCalcuFailedCtrl(calcuResult);
+                TipFormHelper.ShowWarn("璇曠畻澶辫触锛屽仠姝慨澶嶏紒");
+                return;
+            }
+
+            var allLinks = _hydroInfo.GetAllLinks();
+            if (allLinks != null && allLinks.Count < 1)
+            {
+                TipFormHelper.ShowError("妯″瀷涓湭鍖呭惈绠℃淇℃伅锛屽仠姝慨澶嶏紒");
+                return;
+            }
+            int count = 0;
+            foreach (var link in allLinks)
+            {
+                var calcuLink = calcuResult.LinkList?.Find(x => x.Id == link.Code);
+                if (calcuLink == null)
+                {
+                    continue;
+                }
+                if (calcuLink.Flow < 0)
+                {
+                    var tempCode = link.StartCode;
+                    link.StartCode = link.EndCode;
+                    link.EndCode = tempCode;
+                    count++;
+                }
+            }
+            UpdateVisualViewModelProperty();
+            UpdateVisualListCtrl();
+            UpdateSelectedProperty();
+            TipFormHelper.ShowSucceed($"淇瀹屾垚锛屽叡淇绠℃({count})涓紒");
+        }
+
+        //绠＄綉淇
+        private void barBtnRepair_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            Repair();
+        }
+
+        #endregion
+
+        #region 瀵煎嚭INP鏂囦欢
+
+        //瀵煎嚭INP鏂囦欢
+        private void barBtnExportInp_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var fileName = FileDialogHelper.SaveInp("瀵煎嚭Inp鏂囦欢");
+            if (string.IsNullOrEmpty(fileName))
+            {
+                return;
+            }
+            var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
+            var result = netWork.ToInpString();
+            File.WriteAllText(fileName, result);
+            TipFormHelper.ShowSucceed("瀵煎嚭鎴愬姛");
+        }
+
+        #endregion
+
+        #region 骞惰仈鍒嗘瀽
+
+        //骞惰仈鍒嗘瀽
+        private void ParallelAnalysis()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var pumps = _hydroInfo.Pumps;
+            if (pumps == null || pumps.Count < 1)
+            {
+                XtraMessageBox.Show("鏃犳按娉典俊鎭�");
+                return;
+            }
+            var vmList = new List<XhsSinglePumpViewModel>();
+            foreach (var pump in 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, 1);
+                vm.CurveQH = qhPtList;
+                vm.CurveQE = qePtList;
+                vm.CurveQP = qpPtList;
+
+            }
+
+            var dlg = new PumpParallelAnalyDlg();
+            dlg.SetBindingData(vmList);
+            dlg.ReloadDataEvent += (list) =>
+            {
+                list?.ForEach(x =>
+                {
+                    var pump = pumps.Find(t => t.Code == x.Code);
+                    if (pump != null)
+                    {
+                        pump.LinkStatus = x.RunStatus ? Yw.Hydro.PumpStatus.Open : Yw.Hydro.PumpStatus.Closed;
+                        pump.SpeedRatio = x.CurrentHz / pump.RatedHz;
+                    }
+                });
+                var codes = list?.Select(x => x.Code).ToList();
+                UpdateVisualViewModelProperty(codes);
+                ShowSelectedProperty();
+                UpdateVisualListCtrl();
+                return true;
+            };
+            dlg.ShowDialog();
+        }
+
+        //骞惰仈鍒嗘瀽
+        private void barBtnParallel_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            ParallelAnalysis();
+        }
+
+        #endregion
+
+        #region 宸ュ喌璁＄畻
+
+        //鎵�鏈夊伐鍐靛厓缁勫垪琛�
+        private Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult> _allWorkingTupleList = null;
+
+
+
+
+
+
+
+        #region 宸ュ喌
+
+
+        //鏄剧ず宸ュ喌璁＄畻绐椾綋
+        private void ShowWorkingCalcuDlg()
+        {
+            var dlg = new SetHydroWorkingDlg();
+            dlg.HydroViewEvent += async (parter) =>
+            {
+                _selectedVisual = parter as Yw.Model.HydroVisualInfo;
+                if (_selectedVisual != null)
+                {
+                    await _bimfaceCtrl?.ZoomAndSelectComponents(new List<string>() { _selectedVisual.Code });
+                }
+                ShowSelectedProperty();
+            };
+            dlg.HydroCalcuEvent += async (hydroInfo, workingInfo) =>
+            {
+                if (_hydroInfo == null)
+                {
+                    return;
+                }
+                _hydroInfo.UpdateWorkingInfo(workingInfo);
+                //鏍￠獙
+                _checkResult = _hydroInfo.Check();
+                if (!_checkResult.Succeed)
+                {
+                    ShowCheckCtrl();
+                    TipFormHelper.ShowWarn("鏍￠獙澶辫触锛岃妫�鏌ュ悗閲嶈瘯");
+                    return;
+                }
+
+                WaitFormHelper.ShowWaitForm(this, "姝ｅ湪璁＄畻鍒嗘瀽涓紝璇风◢鍊�...");
+
+
+                //await Task.Delay(5000);
+
+                var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
+                _epaCalcuResult = netWork.CalcuMinorLoss();
+
+                WaitFormHelper.HideWaitForm();
+                if (_epaCalcuResult.Succeed)
+                {
+                    GetCalcuResultList(false);
+                    UpdateVisualViewModelProperty();
+                    UpdateVisualViewModelCalcuProperty();
+                    UpdateVisualListCtrl();
+                    UpdateSelectedProperty();
+                    await _bimfaceCtrl?.SetLogicCalcuCustomLabels(_epaCalcuResult);
+                    TipFormHelper.ShowSucceed("璁＄畻鎴愬姛锛�");
+                    var codes = _hydroInfo.Pumps.Select(x => x.Code).ToList();
+                    await _bimfaceCtrl?.ZoomAndSelectComponents(codes);
+                }
+                else
+                {
+                    ShowCalcuFailedCtrl();
+                    TipFormHelper.ShowError("璁＄畻澶辫触锛�");
+                }
+                ApplyGradingResultList(false);
+                UpdateVisualListCtrl();
+                ShowSelectedProperty();
+            };
+            dlg.SetBindingData(_hydroInfo);
+            dlg.ShowDialog();
+        }
+
+        #endregion
+
+
 
         #region 璁＄畻缁撴灉
 
         //鎵�鏈夎绠楃粨鏋滃垪琛�
-        private List<HydroCalcuResult> _allCalcuResultList = null;
+        private List<HydroCalcuVisualResult> _allCalcuResultList = null;
 
         //鑾峰彇璁＄畻缁撴灉
         //true 浣跨敤缂撳瓨锛宖alse 涓嶄娇鐢ㄧ紦瀛�
-        private List<HydroCalcuResult> GetCalcuResultList(bool isCache = true)
+        private List<HydroCalcuVisualResult> GetCalcuResultList(bool isCache = true)
         {
             if (_hydroInfo == null)
             {
                 return default;
             }
-            if (_calcuResult == null)
+            if (_epaCalcuResult == null)
             {
                 return default;
             }
-            if (!_calcuResult.Succeed)
+            if (!_epaCalcuResult.Succeed)
             {
                 return default;
             }
@@ -1163,7 +2622,7 @@
                 return _allCalcuResultList;
             }
 
-            _allCalcuResultList = new List<HydroCalcuResult>();
+            _allCalcuResultList = new List<HydroCalcuVisualResult>();
 
             //鑺傜偣
             var allNodeList = _hydroInfo.GetAllNodes();
@@ -1171,7 +2630,7 @@
             {
                 foreach (var node in allNodeList)
                 {
-                    var calcuNode = _calcuResult.NodeList?.Find(x => x.Id == node.Code);
+                    var calcuNode = _epaCalcuResult.NodeList?.Find(x => x.Id == node.Code);
                     if (calcuNode != null)
                     {
                         var calcuResult = new HydroCalcuNodeResult()
@@ -1192,7 +2651,7 @@
             {
                 foreach (var link in allLinkList)
                 {
-                    var calcuLink = _calcuResult.LinkList?.Find(x => x.Id == link.Code);
+                    var calcuLink = _epaCalcuResult.LinkList?.Find(x => x.Id == link.Code);
                     if (calcuLink != null)
                     {
                         var calcuResult = new HydroCalcuLinkResult()
@@ -1312,705 +2771,19 @@
         //姘村姏璁＄畻
         private void barBtnHydroCalcu_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
         {
-            ShowCalcuPrefixDlg();
+            ShowWorkingCalcuDlg();
         }
 
         #endregion
 
-        #region 鏋勪欢鏌ヨ
 
-        //鏌ヨ缁勪欢
-        private XhsProjectSimulationSearchCtrl _searchCtrl = null;
 
-        //鑾峰彇鏌ヨ缁勪欢
-        private XhsProjectSimulationSearchCtrl GetSearchCtrl()
-        {
-            if (_searchCtrl == null)
-            {
-                _searchCtrl = new XhsProjectSimulationSearchCtrl();
-                _searchCtrl.Dock = DockStyle.Fill;
-                _searchCtrl.InitialData(() => _hydroInfo);
-                _searchCtrl.ApplySearchEvent += async (list) =>
-                {
-                    if (_hydroInfo == null)
-                    {
-                        return;
-                    }
-                    var elementIds = new List<string>();
-                    if (list != null && list.Count > 0)
-                    {
-                        var first = list.First();
-                        var allParterList = _hydroInfo.GetAllParters();
-                        _parter = allParterList?.Find(x => x.Code == first.Code);
-                        list.ForEach(x => elementIds.Add(x.Code));
-                    }
-                    else
-                    {
-                        _parter = null;
-                    }
-                    await _bimfaceCtrl?.ZoomAndSelectComponents(elementIds);
-                    ShowProperty();
-                };
-            }
-            return _searchCtrl;
-        }
 
-        //鏄剧ず鏌ヨ鎺т欢
-        private void ShowSearchCtrl()
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            var searchCtrl = GetSearchCtrl();
-            this.controlContainerBottom.Controls.Clear();
-            this.controlContainerBottom.Controls.Add(searchCtrl);
-            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
-            this.docPnlBottom.Text = "鏋勪欢鏌ヨ";
-            this.docPnlBottom.Height = 350;
-        }
 
-        //鏌ヨ
-        private void barBtnSearch_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            ShowSearchCtrl();
-        }
 
-        #endregion
 
-        #region 妯″瀷鏍囨敞
 
-        //鎵�鏈夋爣娉ㄥ垪琛�
-        private List<HydroMarkSetViewModel> _allMarkList = null;
 
-        //鏄剧ず鏍囨敞绐椾綋
-        private void ShowMarkDlg()
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            if (_allMarkList == null)
-            {
-                _allMarkList = new List<HydroMarkSetViewModel>();
-                if (_hydroInfo.Waterboxs != null && _hydroInfo.Waterboxs.Count > 0)
-                {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Waterbox,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Waterbox),
-                        MarkType = (int)eWaterboxMarkType.None
-                    });
-                }
-                if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
-                {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Pump,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pump),
-                        MarkType = (int)eWaterboxMarkType.None
-                    });
-                }
-                if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
-                {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Valve,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Valve),
-                        MarkType = (int)eWaterboxMarkType.None
-                    });
-                }
-                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
-                {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Pipe,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pipe),
-                        MarkType = (int)eWaterboxMarkType.None
-                    });
-                }
-                if (_hydroInfo.Nozzles != null && _hydroInfo.Nozzles.Count > 0)
-                {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Nozzle,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Nozzle),
-                        MarkType = (int)eWaterboxMarkType.None
-                    });
-                }
-            }
-            var dlg = new SetHydroMarkDlg();
-            dlg.SetBindingData(_hydroInfo, _allMarkList);
-            dlg.ReloadDataEvent += async (allResultList) =>
-            {
-                var leadLabels = allResultList?.Select(x => new LogicMarkLeadLabel(x.Code, x.Text, 100000)).ToList();
-                await _bimfaceCtrl?.SetLogicMarkLeadLabels(leadLabels);
-            };
-            dlg.ShowDialog();
-        }
 
-        //璁剧疆鏍囨敞
-        private void barBtnSetMark_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            ShowMarkDlg();
-        }
-
-        #endregion
-
-        #region 棰滆壊鍒嗙骇
-
-        #region 棰滆壊閰嶇疆
-
-        //鎵�鏈夊垎绾у垪琛�
-        private List<HydroGradingVmo> _allGradingList = null;
-
-        //鑾峰彇鍒嗙骇鍒楄〃
-        private async Task<List<HydroGradingVmo>> GetGradingList()
-        {
-            if (_hydroInfo == null)
-            {
-                return default;
-            }
-            if (_allGradingList == null)
-            {
-                _allGradingList = await BLLFactory<Yw.BLL.HydroGrading>.Instance.GetByModelID(_hydroInfo.ID);
-                if (_allGradingList == null || _allGradingList.Count < 1)
-                {
-                    var config = Yw.Settings.HydroParasHelper.Hydro.Grading;
-                    if (config != null && config.Items != null && config.Items.Count > 0)
-                    {
-                        _allGradingList = new List<HydroGradingVmo>();
-                        config.Items.ForEach(x =>
-                        {
-                            var vmo = new HydroGradingVmo()
-                            {
-                                ModelID = _hydroInfo.ID,
-                                Catalog = x.Catalog,
-                                PropName = x.PropName,
-                                SetValue = x.SetValue,
-                                MinValue = x.MinValue,
-                                MaxValue = x.MaxValue,
-                                Color = x.Color,
-                                SortCode = config.Items.IndexOf(x)
-                            };
-                            _allGradingList.Add(vmo);
-                        });
-                    }
-                }
-            }
-            return _allGradingList;
-        }
-
-        //鏄剧ず閰嶇疆棰滆壊鍒嗙骇绐椾綋
-        private async void ShowSetGradingDlg()
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            var allGradingList = await GetGradingList();
-            var dlg = new SetHydroGradingTreeDlg();
-            dlg.SetBindingData(_hydroInfo, allGradingList);
-            dlg.ReloadDataEvent += (list) =>
-            {
-                _allGradingList = list;
-            };
-            dlg.ApplyDataEvent += () =>
-            {
-                ShowApplyGradingDlg();
-            };
-            dlg.ShowDialog();
-        }
-
-        //閰嶇疆棰滆壊鍒嗙骇
-        private void barBtnGradingSet_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            ShowSetGradingDlg();
-        }
-
-        #endregion
-
-        #region 搴旂敤鍒嗙骇
-
-        //棰滆壊鍒嗙骇搴旂敤鍒楄〃
-        private List<HydroGradingApplyViewModel> _allGradingApplyList = null;
-
-        //鑾峰彇棰滆壊鍒嗙骇搴旂敤鍒楄〃
-        private List<HydroGradingApplyViewModel> GetGradingApplyList()
-        {
-            if (_allGradingApplyList == null)
-            {
-                _allGradingApplyList = new List<HydroGradingApplyViewModel>();
-
-                if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
-                {
-                    _allGradingApplyList.Add(new HydroGradingApplyViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Pump,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pump),
-                        PropName = Yw.Hydro.ParterProp.LinkStatus
-                    });
-                }
-                if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
-                {
-                    _allGradingApplyList.Add(new HydroGradingApplyViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Valve,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Valve),
-                        PropName = Yw.Hydro.ParterProp.LinkStatus
-                    });
-                }
-                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
-                {
-                    _allGradingApplyList.Add(new HydroGradingApplyViewModel()
-                    {
-                        Code = Yw.Hydro.ParterCatalog.Pipe,
-                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pipe),
-                        PropName = Yw.Hydro.ParterProp.CalcuFlow
-                    });
-                }
-            }
-            return _allGradingApplyList;
-        }
-
-        //棰滆壊鍒嗙骇搴旂敤缁撴灉鍒楄〃
-        private List<HydroGradingApplyResultViewModel> _allGradingApplyResultList = null;
-
-        //鑾峰彇棰滆壊鍒嗙骇搴旂敤缁撴灉鍒楄〃
-        private async Task<List<HydroGradingApplyResultViewModel>> GetGradingApplyResultList()
-        {
-            if (_hydroInfo == null)
-            {
-                return default;
-            }
-
-            //鎵�鏈夊垎绾у垪琛�
-            var allGradingList = await GetGradingList();
-            if (allGradingList == null || allGradingList.Count < 1)
-            {
-                return default;
-            }
-
-            //鎵�鏈夊垎绾у簲鐢ㄥ垪琛�
-            var allGradingApplyList = GetGradingApplyList();
-            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
-            {
-                return default;
-            }
-
-            var allCalcuResultList = GetCalcuResultList();
-
-            _allGradingApplyResultList = new List<HydroGradingApplyResultViewModel>();
-            allGradingApplyList.ForEach(x =>
-            {
-                var allCatalogGradingList = allGradingList.Where(t => t.Catalog == x.Code).ToList();
-                if (allCatalogGradingList != null || allCatalogGradingList.Count > 0)
-                {
-                    switch (x.Code)
-                    {
-                        case Yw.Hydro.ParterCatalog.Pump:
-                            {
-                                if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
-                                {
-                                    foreach (var pump in _hydroInfo.Pumps)
-                                    {
-                                        switch (x.PropName)
-                                        {
-                                            case Yw.Hydro.ParterProp.LinkStatus:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var grading = gradingList.Meet(pump.LinkStatus);
-                                                        if (grading != null)
-                                                        {
-                                                            var result = new HydroGradingApplyResultViewModel()
-                                                            {
-                                                                Code = pump.Code,
-                                                                Color = grading.Color
-                                                            };
-                                                            _allGradingApplyResultList.Add(result);
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuFlow:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuFlow.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = pump.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuVelocity:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = pump.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuHeadLoss:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = pump.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            default: break;
-                                        }
-                                    }
-                                }
-                            }
-                            break;
-                        case Yw.Hydro.ParterCatalog.Valve:
-                            {
-                                if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
-                                {
-                                    foreach (var valve in _hydroInfo.Valves)
-                                    {
-                                        switch (x.PropName)
-                                        {
-                                            case Yw.Hydro.ParterProp.LinkStatus:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var grading = gradingList.Meet(valve.LinkStatus);
-                                                        if (grading != null)
-                                                        {
-                                                            var result = new HydroGradingApplyResultViewModel()
-                                                            {
-                                                                Code = valve.Code,
-                                                                Color = grading.Color
-                                                            };
-                                                            _allGradingApplyResultList.Add(result);
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuFlow:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuFlow.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = valve.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuVelocity:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = valve.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuHeadLoss:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = valve.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            default: break;
-                                        }
-                                    }
-                                }
-                            }
-                            break;
-                        case Yw.Hydro.ParterCatalog.Pipe:
-                            {
-                                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
-                                {
-                                    foreach (var pipe in _hydroInfo.Pipes)
-                                    {
-                                        switch (x.PropName)
-                                        {
-                                            case Yw.Hydro.ParterProp.CalcuFlow:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuFlow.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = pipe.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuVelocity:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = pipe.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            case Yw.Hydro.ParterProp.CalcuHeadLoss:
-                                                {
-                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
-                                                    if (gradingList != null && gradingList.Count > 0)
-                                                    {
-                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
-                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
-                                                        {
-                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
-                                                            {
-                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
-                                                                if (grading != null)
-                                                                {
-                                                                    var result = new HydroGradingApplyResultViewModel()
-                                                                    {
-                                                                        Code = pipe.Code,
-                                                                        Color = grading.Color
-                                                                    };
-                                                                    _allGradingApplyResultList.Add(result);
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                                break;
-                                            default: break;
-                                        }
-                                    }
-                                }
-                            }
-                            break;
-                        default: break;
-                    }
-                }
-            });
-
-            return _allGradingApplyResultList;
-        }
-
-        //棰滆壊鍒嗙骇缂栫爜鍒楄〃
-        private List<string> _allGradingCodeList = null;
-
-        //搴旂敤棰滆壊鍒嗙骇
-        private async void ApplyGrading()
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            var allGradingApplyResultList = await GetGradingApplyResultList();
-            _allGradingCodeList = allGradingApplyResultList?.Select(x => x.Code).Distinct().ToList();
-            var objGroupList = allGradingApplyResultList?.GroupBy(x => x.Color).ToList();
-            objGroupList?.ForEach(async x =>
-            {
-                await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1);
-            });
-        }
-
-        //鏄剧ず搴旂敤棰滆壊鍒嗙骇绐椾綋
-        private void ShowApplyGradingDlg()
-        {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
-            var allGradingApplyList = GetGradingApplyList();
-            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
-            {
-                return;
-            }
-            var dlg = new ApplyHydroGradingDlg();
-            dlg.SetBindingData(allGradingApplyList);
-            dlg.ReloadDataEvent += async (obj) =>
-            {
-                _allGradingApplyList = obj;
-                ApplyGrading();
-            };
-            dlg.ShowDialog();
-        }
-
-        //搴旂敤棰滆壊鍒嗙骇
-        private void barBtnGradingApply_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            ShowApplyGradingDlg();
-        }
-
-        #endregion
-
-        #endregion
-
-        #region 浜哄伐鍒锋柊
-
-        //鍒锋柊
-        private async void barBtnRefresh_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            if (XtraMessageBox.Show("鍒锋柊鍚庡皢涓㈠け褰撳墠姘村姏淇℃伅鏇存敼锛屾槸鍚︾户缁埛鏂帮紵", "璇㈤棶", MessageBoxButtons.YesNo) == DialogResult.Yes)
-            {
-                if (_project == null)
-                {
-                    return;
-                }
-                if (_projectSite == null)
-                {
-                    return;
-                }
-                var hydroRelation = await BLLFactory<Yw.BLL.HydroModelRelation>.Instance
-                    .GetDefaultByObjectTypeAndObjectIDOfPurpose(HStation.Xhs.DataType.XhsProjectSite, _projectSite.ID, HStation.Xhs.Purpose.Simulation);
-                _hydroInfo = await BLLFactory<Yw.BLL.HydroModelInfo>.Instance.GetByID(hydroRelation.ModelID);
-                _parter = null;
-                await _bimfaceCtrl?.ZoomAndSelectComponents(null);
-                ShowProperty();
-                TipFormHelper.ShowSucceed("鏁版嵁宸插埛鏂�");
-            }
-        }
-
-        #endregion
-
-        private void barButtonItem1_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
-        {
-            var pipes = _hydroInfo.GetAllPipes();
-            var list = pipes.Select(x =>
-            {
-                return new Yw.WinFrmUI.Bimface.LogicFlowEffect()
-                {
-                    Id = x.Code,
-                    Rotation = 90,
-                    Direction = true,
-                    Speed = 0.1d
-                };
-            }).ToList();
-            _bimfaceCtrl?.LoadAllFlowMaterialList(list);
-        }
     }
 }
\ No newline at end of file

--
Gitblit v1.9.3