From 7507591ef45cfa8f1080f6dbf68b411edcc7f086 Mon Sep 17 00:00:00 2001
From: lixiaojun <1287241240@qq.com>
Date: 星期日, 03 十一月 2024 15:42:56 +0800
Subject: [PATCH] 水力存储优化

---
 WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs | 1085 ++++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 files changed, 1,004 insertions(+), 81 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 217d09e..832ba33 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,13 @@
 锘縢lobal using Yw.EPAnet;
 using DevExpress.Mvvm.Native;
+using DevExpress.Xpo.Helpers;
 using DevExpress.XtraRichEdit.Layout;
 using DevExpress.XtraSpreadsheet.Commands;
 using HStation.WinFrmUI.PhartRelation;
+using System.Diagnostics;
+using System.Windows.Media.Media3D;
 using Yw.Pump;
+using Yw.Vmo;
 using Yw.WinFrmUI.Bimface;
 using Yw.WinFrmUI.Hydro;
 
@@ -166,7 +170,7 @@
             {
                 _propertyCtrl = new XhsProjectSimulationPropertyCtrl();
                 _propertyCtrl.Dock = DockStyle.Fill;
-                _propertyCtrl.InitialData(() => _hydroInfo, () => GetAllCalcuResultList());
+                _propertyCtrl.InitialData(() => _hydroInfo, () => GetCalcuResultList());
                 _propertyCtrl.BlinkLinkParterEvent += async (code, linkCode) =>
                 { //寮鸿皟杩炴帴缁勪欢
                     if (string.IsNullOrEmpty(code))
@@ -254,7 +258,7 @@
             }
             _propertyCtrl?.SelectParter(_parter.Code);
 
-            var allCalcuResultList = GetAllCalcuResultList();
+            var allCalcuResultList = GetCalcuResultList();
             if (allCalcuResultList != null && allCalcuResultList.Count > 0)
             {
                 var calcuResult = allCalcuResultList.Find(x => x.Code == _parter.Code);
@@ -316,7 +320,7 @@
             }
             this.controlContainerBottom.Controls.Clear();
             var matchingListCtrl = GetMatchingListCtrl();
-            var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetAllCalcuResultList());
+            var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetCalcuResultList());
             matchingListCtrl.SetBindingData(input);
             this.controlContainerBottom.Controls.Add(matchingListCtrl);
             this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
@@ -457,7 +461,7 @@
             return _checkCtrl;
         }
 
-        //鏄剧ず鏍¢獙鎺т欢
+        //鏄剧ず妫�鏌ユ帶浠�
         private void ShowCheckCtrl()
         {
             if (_checkResult == null)
@@ -469,12 +473,12 @@
             this.controlContainerBottom.Controls.Clear();
             this.controlContainerBottom.Controls.Add(checkCtrl);
             this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
-            this.docPnlBottom.Text = "鏍¢獙缁撴灉";
+            this.docPnlBottom.Text = "妫�鏌ョ粨鏋�";
             this.docPnlBottom.Height = 350;
 
         }
 
-        //姘村姏楠岃瘉
+        //姘村姏妫�鏌�
         private void barBtnHydroCheck_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
         {
             if (_hydroInfo == null)
@@ -496,7 +500,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("淇濆瓨澶辫触锛�");
@@ -543,7 +557,7 @@
                 return;
             }
             var parterListCtrl = GetParterListCtrl();
-            parterListCtrl.SetBindingData(_hydroInfo, GetAllCalcuResultList());
+            parterListCtrl.SetBindingData(_hydroInfo, GetCalcuResultList());
             this.controlContainerBottom.Controls.Clear();
             this.controlContainerBottom.Controls.Add(parterListCtrl);
             this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
@@ -948,7 +962,7 @@
             {
                 return;
             }
-            var allCalcuResultList = GetAllCalcuResultList();
+            var allCalcuResultList = GetCalcuResultList();
             var vmList = new List<XhsSinglePumpViewModel>();
             foreach (var pump in _hydroInfo.Pumps)
             {
@@ -1007,7 +1021,7 @@
 
             }
 
-            var dlg = new PumpParallelChartDlg();
+            var dlg = new PumpParallelAnalyDlg();
             dlg.SetBindingData(vmList);
             dlg.ReloadDataEvent += (list) =>
             {
@@ -1034,13 +1048,13 @@
         #region 鍓嶆彁鏉′欢
 
         //鏄剧ず璁$畻鍓嶆彁鏉′欢绐椾綋
-        private async void ShowCalcuPrefixDlg()
+        private void ShowCalcuPrefixDlg()
         {
             if (_hydroInfo == null)
             {
                 return;
             }
-            var dlg = new SetHydroCalcuPrefixDlg();
+            var dlg = new HStation.WinFrmUI.SetHydroCalcuPrefixDlg1();
             dlg.SetBindingData(_hydroInfo);
             dlg.HydroViewEvent += async (parter) =>
             {
@@ -1067,11 +1081,17 @@
                     return;
                 }
 
+                WaitFormHelper.ShowWaitForm(this, "姝e湪璁$畻鍒嗘瀽涓紝璇风◢鍊�...");
+
+                await Task.Delay(5000);
+
                 var netWork = Yw.Hydro.ParseHelper.ToNetwork(_hydroInfo);
                 _calcuResult = netWork.Calcu();
+
+                WaitFormHelper.HideWaitForm();
                 if (_calcuResult.Succeed)
                 {
-                    GetAllCalcuResultList(false);
+                    GetCalcuResultList(false);
                     await _bimfaceCtrl?.SetLogicCalcuCustomLabels(_calcuResult);
                     TipFormHelper.ShowSucceed("璁$畻鎴愬姛锛�");
                 }
@@ -1082,10 +1102,7 @@
                 }
 
             };
-            if (dlg.ShowDialog() == DialogResult.Cancel)
-            {
-                await _bimfaceCtrl?.ClearLogicCalcuCustomLabels();
-            }
+            dlg.ShowDialog();
         }
 
         #endregion
@@ -1139,7 +1156,7 @@
 
         //鑾峰彇璁$畻缁撴灉
         //true 浣跨敤缂撳瓨锛宖alse 涓嶄娇鐢ㄧ紦瀛�
-        private List<HydroCalcuResult> GetAllCalcuResultList(bool isCache = true)
+        private List<HydroCalcuResult> GetCalcuResultList(bool isCache = true)
         {
             if (_hydroInfo == null)
             {
@@ -1273,7 +1290,7 @@
                                 {
                                     calcuPumpNewResult.CalcuH = Math.Abs(calcuNodeStartResult.CalcuPress.Value - calcuNodeEndResult.CalcuPress.Value);
                                 }
-                                if (pump.RatedN.HasValue)
+                                if (pump.LinkStatus == Yw.Hydro.PumpStatus.Open && pump.RatedN.HasValue)
                                 {
                                     var curveqp = _hydroInfo.Curves?.Find(x => x.Code == pump.CurveQP);
                                     if (curveqp != null)
@@ -1375,22 +1392,18 @@
 
         #region 妯″瀷鏍囨敞
 
-        //鎵�鏈夋爣娉ㄥ垪琛�
-        private List<HydroMarkSetViewModel> _allMarkList = null;
+        //鎵�鏈夋爣娉ㄨ缃垪琛�
+        private List<HydroMarkSetViewModel> _allMarkSetList = null;
 
-        //鏄剧ず鏍囨敞绐椾綋
-        private async void ShowMarkDlg()
+        //鑾峰彇鏍囨敞璁剧疆鍒楄〃
+        private List<HydroMarkSetViewModel> GetMarkSetList()
         {
-            if (_hydroInfo == null)
+            if (_allMarkSetList == null)
             {
-                return;
-            }
-            if (_allMarkList == null)
-            {
-                _allMarkList = new List<HydroMarkSetViewModel>();
+                _allMarkSetList = new List<HydroMarkSetViewModel>();
                 if (_hydroInfo.Waterboxs != null && _hydroInfo.Waterboxs.Count > 0)
                 {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
+                    _allMarkSetList.Add(new HydroMarkSetViewModel()
                     {
                         Code = Yw.Hydro.ParterCatalog.Waterbox,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Waterbox),
@@ -1399,7 +1412,7 @@
                 }
                 if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
                 {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
+                    _allMarkSetList.Add(new HydroMarkSetViewModel()
                     {
                         Code = Yw.Hydro.ParterCatalog.Pump,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pump),
@@ -1408,7 +1421,7 @@
                 }
                 if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
                 {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
+                    _allMarkSetList.Add(new HydroMarkSetViewModel()
                     {
                         Code = Yw.Hydro.ParterCatalog.Valve,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Valve),
@@ -1417,7 +1430,7 @@
                 }
                 if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
                 {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
+                    _allMarkSetList.Add(new HydroMarkSetViewModel()
                     {
                         Code = Yw.Hydro.ParterCatalog.Pipe,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pipe),
@@ -1426,7 +1439,7 @@
                 }
                 if (_hydroInfo.Nozzles != null && _hydroInfo.Nozzles.Count > 0)
                 {
-                    _allMarkList.Add(new HydroMarkSetViewModel()
+                    _allMarkSetList.Add(new HydroMarkSetViewModel()
                     {
                         Code = Yw.Hydro.ParterCatalog.Nozzle,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Nozzle),
@@ -1434,54 +1447,561 @@
                     });
                 }
             }
-            var dlg = new SetHydroMarkDlg();
-            dlg.InitialData(() => _hydroInfo);
-            dlg.SetBindingData(_allMarkList);
-            dlg.ReloadDataEvent += async (allResultList) =>
+            return _allMarkSetList;
+        }
+
+        //鎵�鏈夋爣娉ㄧ粨鏋滃垪琛�
+        private List<HydroMarkResultViewModel> _allMarkResultList = null;
+
+        //鑾峰彇鏍囨敞缁撴灉鍒楄〃
+        private List<HydroMarkResultViewModel> GetMarkResultList()
+        {
+            if (_hydroInfo == null)
             {
-                var leadLabels = allResultList?.Select(x => new LogicMarkLeadLabel(x.Code, x.Text)).ToList();
-                await _bimfaceCtrl?.SetLogicMarkLeadLabels(leadLabels);
-            };
-            if (dlg.ShowDialog() != DialogResult.OK)
-            {
-                await _bimfaceCtrl?.ClearLogicMarkLeadLabels();
+                return default;
             }
+            _allMarkResultList = new List<HydroMarkResultViewModel>();
+            var allMarkSetList = GetMarkSetList();
+            foreach (var markSet in allMarkSetList)
+            {
+                switch (markSet.Code)
+                {
+                    case Yw.Hydro.ParterCatalog.Waterbox:
+                        {
+                            if (_hydroInfo.Waterboxs != null && _hydroInfo.Waterboxs.Count > 0)
+                            {
+                                switch ((eWaterboxMarkType)markSet.MarkType)
+                                {
+                                    case eWaterboxMarkType.None:
+                                        {
+
+                                        }
+                                        break;
+                                    case eWaterboxMarkType.PoolElev:
+                                        {
+                                            _hydroInfo.Waterboxs.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"姹犲簳鏍囬珮:{Math.Round(t.PoolElev, 4)}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eWaterboxMarkType.InitLevel:
+                                        {
+                                            _hydroInfo.Waterboxs.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鍒濆姘翠綅:{Math.Round(t.InitLevel, 4)}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eWaterboxMarkType.MinLevel:
+                                        {
+                                            _hydroInfo.Waterboxs.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鏈�灏忔按浣�:{Math.Round(t.MinLevel, 4)}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eWaterboxMarkType.MaxLevel:
+                                        {
+                                            _hydroInfo.Waterboxs.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鏈�楂樻按浣�:{Math.Round(t.MaxLevel, 4)}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eWaterboxMarkType.DN:
+                                        {
+                                            _hydroInfo.Waterboxs.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鐩村緞:{Math.Round(t.DN, 4)}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eWaterboxMarkType.MinVol:
+                                        {
+                                            _hydroInfo.Waterboxs.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鏈�灏忓绉�:{Math.Round(t.MinVol, 1)}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    default: break;
+                                }
+                            }
+                        }
+                        break;
+                    case Yw.Hydro.ParterCatalog.Pump:
+                        {
+                            if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
+                            {
+                                switch ((ePumpMarkType)markSet.MarkType)
+                                {
+                                    case ePumpMarkType.None:
+                                        {
+
+                                        }
+                                        break;
+                                    case ePumpMarkType.PumpStatus:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"寮�鏈虹姸鎬�:{Yw.WinFrmUI.HydroLinkStatusHelper.GetStatusName(t.LinkStatus)}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePumpMarkType.RatedP:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"棰濆畾鍔熺巼:{t.RatedP}kW"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePumpMarkType.RatedQ:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"棰濆畾娴侀噺:{t.RatedQ}m鲁/h"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePumpMarkType.RatedH:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"棰濆畾鎵▼:{t.RatedH}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePumpMarkType.RatedN:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"棰濆畾杞��:{t.RatedN}r/min"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePumpMarkType.RatedHz:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"棰濆畾棰戠巼:{t.RatedHz}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePumpMarkType.CurrentN:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                if (t.RatedN.HasValue)
+                                                {
+                                                    _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                    {
+                                                        Code = t.Code,
+                                                        Text = $"璁惧畾杞��:{Math.Round(t.RatedN.Value * t.SpeedRatio, 1)}r/min"
+                                                    });
+                                                }
+                                            });
+                                        }
+                                        break;
+                                    case ePumpMarkType.CurrentHz:
+                                        {
+                                            _hydroInfo.Pumps.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"璁惧畾棰戠巼:{Math.Round(t.RatedHz * t.SpeedRatio, 1)}hz"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    default: break;
+                                }
+                            }
+                        }
+                        break;
+                    case Yw.Hydro.ParterCatalog.Valve:
+                        {
+                            if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
+                            {
+                                switch ((eValveMarkType)markSet.MarkType)
+                                {
+                                    case eValveMarkType.None:
+                                        {
+
+                                        }
+                                        break;
+                                    case eValveMarkType.ValveStatus:
+                                        {
+                                            _hydroInfo.Valves.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"闃�闂ㄧ姸鎬�:{HydroLinkStatusHelper.GetStatusName(t.LinkStatus)}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eValveMarkType.ValveType:
+                                        {
+                                            _hydroInfo.Valves.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"闃�闂ㄧ被鍨�:{HydroValveTypeHelper.GetTypeName(t.ValveType)}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eValveMarkType.Diameter:
+                                        {
+                                            _hydroInfo.Valves.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鐩村緞:{t.Diameter}mm"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eValveMarkType.MinorLoss:
+                                        {
+                                            _hydroInfo.Valves.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"灞�闃荤郴鏁�:{t.MinorLoss}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    default: break;
+                                }
+                            }
+                        }
+                        break;
+                    case Yw.Hydro.ParterCatalog.Pipe:
+                        {
+                            if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
+                            {
+                                switch ((ePipeMarkType)markSet.MarkType)
+                                {
+                                    case ePipeMarkType.None:
+                                        {
+
+                                        }
+                                        break;
+                                    case ePipeMarkType.PipeStatus:
+                                        {
+                                            _hydroInfo.Pipes.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鐘舵��:{Yw.WinFrmUI.HydroLinkStatusHelper.GetStatusName(t.LinkStatus)}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePipeMarkType.Diameter:
+                                        {
+                                            _hydroInfo.Pipes.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鐩村緞:{t.Diameter}mm"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePipeMarkType.Length:
+                                        {
+                                            _hydroInfo.Pipes.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"闀垮害:{t.Length}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePipeMarkType.Roughness:
+                                        {
+                                            _hydroInfo.Pipes.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"绮楃硻绯绘暟:{t.Roughness}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case ePipeMarkType.MinorLoss:
+                                        {
+                                            _hydroInfo.Pipes.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"灞�闃荤郴鏁�:{t.MinorLoss}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    default: break;
+                                }
+                            }
+                        }
+                        break;
+                    case Yw.Hydro.ParterCatalog.Nozzle:
+                        {
+                            if (_hydroInfo.Nozzles != null && _hydroInfo.Nozzles.Count > 0)
+                            {
+                                switch ((eNozzleMarkType)markSet.MarkType)
+                                {
+                                    case eNozzleMarkType.None:
+                                        {
+
+                                        }
+                                        break;
+                                    case eNozzleMarkType.Elev:
+                                        {
+                                            _hydroInfo.Nozzles.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鏍囬珮:{Math.Round(t.Elev, 4)}m"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eNozzleMarkType.Demand:
+                                        {
+                                            _hydroInfo.Nozzles.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"闇�姘撮噺:{t.Demand}m鲁/h"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    case eNozzleMarkType.Coefficient:
+                                        {
+                                            _hydroInfo.Nozzles.ForEach(t =>
+                                            {
+                                                _allMarkResultList.Add(new HydroMarkResultViewModel()
+                                                {
+                                                    Code = t.Code,
+                                                    Text = $"鍠峰皠绯绘暟:{t.Coefficient}"
+                                                });
+                                            });
+                                        }
+                                        break;
+                                    default: break;
+                                }
+                            }
+                        }
+                        break;
+                    default: break;
+                }
+            }
+            return _allMarkResultList;
+        }
+
+        //搴旂敤鏍囨敞缁撴灉鍒楄〃
+        private async Task ApplyMarkResultList()
+        {
+            var allMarkResultList = GetMarkResultList();
+            var leadLabels = allMarkResultList?.Select(x => new LogicMarkLeadLabel(x.Code, x.Text, 100000)).ToList();
+            await _bimfaceCtrl?.SetLogicMarkLeadLabels(leadLabels);
+            TipFormHelper.ShowSucceed("鏍囨敞淇℃伅宸茶缃�");
+        }
+
+        //娓呴櫎鏍囨敞缁撴灉鍒楄〃
+        private async Task ClearMarkResultList()
+        {
+            if (_allMarkResultList == null || _allMarkResultList.Count < 1)
+            {
+                TipFormHelper.ShowWarn("灏氭湭璁剧疆鏍囨敞淇℃伅");
+                return;
+            }
+            _allMarkResultList = null;
+            await _bimfaceCtrl?.ClearLogicMarkLeadLabels();
+            TipFormHelper.ShowSucceed("鏍囨敞淇℃伅宸叉竻闄�");
+        }
+
+        //鏄剧ず鏍囨敞璁剧疆绐椾綋
+        private void ShowMarkSetDlg()
+        {
+            if (_hydroInfo == null)
+            {
+                return;
+            }
+            var allMarkSetList = GetMarkSetList();
+            var dlg = new SetHydroMarkDlg();
+            dlg.SetBindingData(allMarkSetList);
+            dlg.ReloadDataEvent += async (list) =>
+            {
+                _allMarkSetList = list;
+                await ApplyMarkResultList();
+            };
+            dlg.ShowDialog();
         }
 
         //璁剧疆鏍囨敞
         private void barBtnSetMark_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
         {
-            ShowMarkDlg();
+            ShowMarkSetDlg();
+        }
+
+        //娓呴櫎鏍囨敞
+        private async void barBtnClearMark_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            await ClearMarkResultList();
         }
 
         #endregion
 
         #region 棰滆壊鍒嗙骇
 
-        //棰滆壊鍒嗙骇搴旂敤鍒楄〃
-        private List<HydroGradingApplyViewModel> _allGradingApplyList = null;
-        //棰滆壊鍒嗙骇缂栫爜鍒楄〃
-        private List<string> _allGradingCodeList = null;
+        #region 棰滆壊閰嶇疆
 
-        //璁剧疆棰滆壊鍒嗙骇
-        private void SetGrading()
+        //鎵�鏈夊垎绾у垪琛�
+        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 dlg = new SetHydroGradingModelDlg();
-            dlg.SetBindingData(_hydroInfo.ID);
+            var allGradingList = await GetGradingList();
+            var dlg = new SetHydroGradingTreeDlg();
+            dlg.SetBindingData(_hydroInfo, allGradingList);
+            dlg.ReloadDataEvent += (list) =>
+            {
+                _allGradingList = list;
+            };
+            dlg.ApplyDataEvent += () =>
+            {
+                ShowApplyGradingDlg();
+            };
             dlg.ShowDialog();
         }
 
-        //搴旂敤棰滆壊鍒嗙骇
-        private async void ApplyGrading()
+        //閰嶇疆棰滆壊鍒嗙骇
+        private void barBtnGradingSet_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
         {
-            if (_hydroInfo == null)
-            {
-                return;
-            }
+            ShowSetGradingDlg();
+        }
+
+        #endregion
+
+        #region 搴旂敤鍒嗙骇
+
+        //棰滆壊鍒嗙骇搴旂敤鍒楄〃
+        private List<HydroGradingApplyViewModel> _allGradingApplyList = null;
+
+        //鑾峰彇棰滆壊鍒嗙骇搴旂敤鍒楄〃
+        private List<HydroGradingApplyViewModel> GetGradingApplyList()
+        {
             if (_allGradingApplyList == null)
             {
                 _allGradingApplyList = new List<HydroGradingApplyViewModel>();
@@ -1492,7 +2012,7 @@
                     {
                         Code = Yw.Hydro.ParterCatalog.Pump,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pump),
-                        PropName = string.Empty
+                        PropName = Yw.Hydro.ParterProp.LinkStatus
                     });
                 }
                 if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
@@ -1501,7 +2021,7 @@
                     {
                         Code = Yw.Hydro.ParterCatalog.Valve,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Valve),
-                        PropName = string.Empty
+                        PropName = Yw.Hydro.ParterProp.LinkStatus
                     });
                 }
                 if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
@@ -1510,38 +2030,407 @@
                     {
                         Code = Yw.Hydro.ParterCatalog.Pipe,
                         Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetCatalogName(Yw.Hydro.ParterCatalog.Pipe),
-                        PropName = string.Empty
+                        PropName = Yw.Hydro.ParterProp.CalcuFlow
                     });
                 }
             }
-            var dlg = new ApplyHydroGradingDlg();
-            dlg.SetBindingData(() => _hydroInfo, _allGradingApplyList, GetAllCalcuResultList());
-            dlg.ReloadDataEvent += (obj) =>
-            {
-                _allGradingCodeList = obj?.Select(x => x.Code).Distinct().ToList();
-                var objGroupList = obj?.GroupBy(x => x.Color).ToList();
-                objGroupList?.ForEach(async x =>
-                {
-                    await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1);
-                });
-            };
-            if (dlg.ShowDialog() == DialogResult.Cancel)
-            {
-                await _bimfaceCtrl?.RestoreComponentsColor(_allGradingCodeList);
-            }
+            return _allGradingApplyList;
         }
 
-        //璁剧疆
-        private void barBtnGradingSet_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        //棰滆壊鍒嗙骇搴旂敤缁撴灉鍒楄〃
+        private List<HydroGradingApplyResultViewModel> _allGradingApplyResultList = null;
+
+        //鑾峰彇棰滆壊鍒嗙骇搴旂敤缁撴灉鍒楄〃
+        private async Task<List<HydroGradingApplyResultViewModel>> GetGradingApplyResultList()
         {
-            SetGrading();
+            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)
         {
-            ApplyGrading();
+            ShowApplyGradingDlg();
         }
+
+        #endregion
 
         #endregion
 
@@ -1562,7 +2451,12 @@
                 }
                 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);
                 _parter = null;
                 await _bimfaceCtrl?.ZoomAndSelectComponents(null);
                 ShowProperty();
@@ -1571,5 +2465,34 @@
         }
 
         #endregion
+
+        #region 姘存祦鍔ㄧ敾
+
+        //鍔犺浇娴佸悜
+        private async void barBtnLoadFlowDirection_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            var pipes = _hydroInfo.Pipes;
+            var list = pipes.Select(x =>
+            {
+                return new Yw.WinFrmUI.Bimface.LogicFlowEffect()
+                {
+                    Id = x.Code,
+                    Rotation = 90,
+                    Speed = 0.1d
+                };
+            }).ToList();
+            await _bimfaceCtrl?.LoadFlowEffect(list);
+        }
+
+        //鍗歌浇娴佸悜
+        private async void barBtnUnloadFlowDirection_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
+        {
+            await _bimfaceCtrl?.UnloadFlowEffect();
+        }
+
+        #endregion
+
+
+
     }
 }
\ No newline at end of file

--
Gitblit v1.9.3