核心界面修改

lixiaojun

2024-11-20 74dba39c95f8120bb31a64739c872cb43790935c

 WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs

@@ -1,4 +1,5 @@
global using Yw.EPAnet;
using DevExpress.CodeParser;
using DevExpress.Mvvm.Native;
using DevExpress.Office.Utils;
using DevExpress.Utils.Extensions;
@@ -7,10 +8,12 @@
using DevExpress.XtraRichEdit.Layout;
using DevExpress.XtraSpreadsheet.Commands;
using HStation.WinFrmUI.PhartRelation;
using NPOI.SS.Formula.Functions;
using System.Diagnostics;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using Yw.Hydro;
using Yw.Model;
using Yw.Pump;
using Yw.Vmo;
using Yw.WinFrmUI.Bimface;
@@ -167,6 +170,314 @@

        #endregion

        #region 可见列表

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

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

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

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

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

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

        #endregion

        #region 计算结果

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

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

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

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

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

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

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

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

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

        #endregion

        #region 可见视图列表

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

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

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

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

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

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

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

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

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

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

        #endregion

        #region 选择构件

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

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

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


        #endregion

        #region 属性控件

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

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

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

            }
@@ -339,6 +644,27 @@
            _propertyCtrl?.UpdateRows();
        }

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

            }
        }

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

        #endregion

        #region 工况列表



        #endregion

        #region 自动匹配
@@ -390,7 +716,7 @@
            }
            this.controlContainerBottom.Controls.Clear();
            var matchingListCtrl = GetMatchingListCtrl();
            var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetCalcuResultList());
            var input = AssetsMatchingParasHelper.Create(_hydroInfo, GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false));
            matchingListCtrl.SetBindingData(input);
            this.controlContainerBottom.Controls.Add(matchingListCtrl);
            this.docPnlBottom.Visibility = DevExpress.XtraBars.Docking.DockVisibility.Visible;
@@ -933,7 +1259,7 @@
            {
                return;
            }
            var allCalcuResultList = GetCalcuResultList();
            var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
            var vmList = new List<XhsSinglePumpViewModel>();
            foreach (var pump in _hydroInfo.Pumps)
            {
@@ -1381,7 +1707,7 @@
            }
            var allGradingList = await GetGradingList();
            var allGradingApplyList = GetGradingApplyList();
            var allCalcuResultList = GetCalcuResultList();
            var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
            if (!useCache)
            {
                _allGradingResultList = HydroGradingHelper.GetResultList(_hydroInfo, allGradingList, allGradingApplyList, allCalcuResultList);
@@ -1435,7 +1761,7 @@
            var allGradingList = await GetGradingList();
            var allGradingApplyList = GetGradingApplyList();
            var allGradingResultList = await GetGradingResultList(true);
            var allCalcuResultList = GetCalcuResultList(true);
            var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
            var oldResult = allGradingResultList?.Find(x => x.Code == visual.Code);
            if (oldResult != null)
            {
@@ -1533,7 +1859,7 @@
            if (_allFlowEffectList == null)
            {
                _allFlowEffectList = new List<LogicFlowEffect>();
                var allCalcuResultList = GetCalcuResultList();
                var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
                {
                    foreach (var parter in _hydroInfo.Pipes)
@@ -1656,7 +1982,7 @@
                flowEffect.SpeedY = -0.1;
            }

            var allCalcuResultList = GetCalcuResultList();
            var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
            var calcuResult = allCalcuResultList?.Find(x => x.Code == visual.Code) as HydroCalcuLinkResult;
            if (calcuResult != null)
            {
@@ -1676,165 +2002,6 @@
        {
            _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
@@ -1900,7 +2067,7 @@
            var visualListCtrl = GetVisualListCtrl();
            var allVisualViewModelList = GetVisualViewModelList();
            visualListCtrl.SetBindingData(allVisualViewModelList);
            var allCalcuResultList = GetCalcuResultList();
            var allCalcuResultList = GetCalcuVisualResultList(Yw.EPAnet.CalcuMode.MinorLoss, false);
            if (allCalcuResultList == null || allCalcuResultList.Count < 1)
            {
                visualListCtrl.SetNormalView();
@@ -1931,8 +2098,6 @@
        {
            ShowVisualListCtrl();
        }

        #endregion

        #endregion

@@ -2175,8 +2340,6 @@

        #endregion

        #region 水力检查

        #region 检查结果

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

        #endregion

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

        #endregion

        #region EPA计算结果

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

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

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

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

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


        #endregion

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

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

        #region 工况计算

        //所有工况列表
        private List<HydroWorkingVmo> _allWorkingList = null;

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







        #region 工况

        private List<Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>> _allWorkingTupleList = new List<Tuple<HydroWorkingVmo, HydroCheckResult, HydroCalcuResult>>();

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

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


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

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

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

        #endregion



        #region 计算结果

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

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

            _allCalcuResultList = new List<HydroCalcuVisualResult>();

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

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

            //流量计
            var allFlowmeterList = _hydroInfo.Flowmeters;
            if (allFlowmeterList != null && allFlowmeterList.Count > 0)
            {
                foreach (var flowmeter in allFlowmeterList)
                {
                    var calcuFlowmeterResult = _allCalcuResultList.Find(x => x.Code == flowmeter.Code) as HydroCalcuNodeResult;
                    if (calcuFlowmeterResult != null)
                    {
                        var calcuFlowmeterNewResult = new HydroCalcuFlowmeterResult(calcuFlowmeterResult);
                        var calcuFlowmeterLinkResultList = new List<HydroCalcuLinkResult>();
                        var flowmeterLinkList = allLinkList?.Where(x => x.StartCode == flowmeter.Code || x.EndCode == flowmeter.Code).ToList();
                        if (flowmeterLinkList != null && flowmeterLinkList.Count > 0)
                        {
                            foreach (var flowmeterLink in flowmeterLinkList)
                            {
                                var calcuFlowmeterLinkResult = _allCalcuResultList.Find(x => x.Code == flowmeterLink.Code) as HydroCalcuLinkResult;
                                if (calcuFlowmeterLinkResult != null)
                                {
                                    calcuFlowmeterLinkResultList.Add(calcuFlowmeterLinkResult);
                                }
                            }
                        }
                        if (calcuFlowmeterLinkResultList.Exists(x => x.CalcuFlow.HasValue))
                        {
                            calcuFlowmeterNewResult.CalcuQ = calcuFlowmeterLinkResultList.Where(x => x.CalcuFlow.HasValue).Average(x => x.CalcuFlow.Value);
                        }
                        _allCalcuResultList.Remove(calcuFlowmeterResult);
                        _allCalcuResultList.Add(calcuFlowmeterNewResult);
                    }
                }
            }

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

            //水泵
            var allPumpList = _hydroInfo.Pumps;
            if (allPumpList != null && allPumpList.Count > 0)
            {
                foreach (var pump in allPumpList)
                {
                    var calcuPumpResult = _allCalcuResultList.Find(x => x.Code == pump.Code) as HydroCalcuLinkResult;
                    if (calcuPumpResult != null)
                    {
                        var calcuPumpNewResult = new HydroCalcuPumpResult(calcuPumpResult);
                        calcuPumpNewResult.CalcuQ = calcuPumpResult.CalcuFlow;
                        if (calcuPumpNewResult.CalcuQ.HasValue)
                        {
                            var calcuNodeStartResult = _allCalcuResultList.Find(x => x.Code == pump.StartCode) as HydroCalcuNodeResult;
                            var calcuNodeEndResult = _allCalcuResultList.Find(x => x.Code == pump.EndCode) as HydroCalcuNodeResult;
                            if (calcuNodeStartResult != null && calcuNodeEndResult != null)
                            {
                                if (calcuNodeStartResult.CalcuPress.HasValue && calcuNodeEndResult.CalcuPress.HasValue)
                                {
                                    calcuPumpNewResult.CalcuH = Math.Abs(calcuNodeStartResult.CalcuPress.Value - calcuNodeEndResult.CalcuPress.Value);
                                }
                                if (pump.LinkStatus == Yw.Hydro.PumpStatus.Open && pump.RatedN.HasValue)
                                {
                                    var curveqp = _hydroInfo.Curves?.Find(x => x.Code == pump.CurveQP);
                                    if (curveqp != null)
                                    {
                                        if (curveqp.CurveData != null && curveqp.CurveData.Count > 3)
                                        {
                                            var point2dList = curveqp.CurveData.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
                                            var point2dSimularList = point2dList.GetQPPointListByN(pump.RatedN.Value, pump.RatedN.Value * pump.SpeedRatio);
                                            var pumpCurveQp = new Yw.Pump.CurveQP(eFeatType.Cubic, point2dSimularList);
                                            calcuPumpNewResult.CalcuP = pumpCurveQp.FeatCurve.GetPointY(calcuPumpNewResult.CalcuQ.Value);
                                        }
                                    }
                                }
                                if (calcuPumpNewResult.CalcuH.HasValue && calcuPumpNewResult.CalcuP.HasValue)
                                {
                                    calcuPumpNewResult.CalcuE = Yw.Pump.CalculationHelper.CalcuE(calcuPumpNewResult.CalcuQ.Value, calcuPumpNewResult.CalcuH.Value, calcuPumpNewResult.CalcuP.Value);
                                }
                            }
                        }
                        _allCalcuResultList.Remove(calcuPumpResult);
                        _allCalcuResultList.Add(calcuPumpNewResult);
                    }
                }
            }

            return _allCalcuResultList;
        }

        #endregion

        //水力计算
        private void barBtnHydroCalcu_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
@@ -2779,8 +2745,65 @@

        #endregion

        #region 当前工况

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

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

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

        //设置当前工况
        private void SetCurrentWorking(HydroWorkingVmo working)
        {
            _currentWorking = working;
        }

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


        #endregion

        #region 工况列表

        //所有工况列表
        private List<HydroWorkingVmo> _allWorkingList = null;

        //初始化工况列表
        private async void InitialWorkingList()
        {
            _allWorkingList = await BLLFactory<Yw.BLL.HydroWorking>.Instance.GetByModelID(_hydroInfo.ID);
            if (_allWorkingList == null)
            {
                _allWorkingList = new List<HydroWorkingVmo>();
            }
        }

        #endregion