Yw/Hydro.V1.2.git

using Hydro.CommonBase;
using Hydro.HydraulicModel;
using MetroFramework;
using System;
using System.Collections.Generic;
using System.Drawing;
 
namespace Hydro.ConfigModel
{
    public class GlobalModel
    {
 
 
        //创建查询缓存，将查询过的内容记录到缓存
        public static Dictionary<string, dynamic> dict_StringToType
        {
            get;
            set;
        } = new Dictionary<string, dynamic>();
        public static Dictionary<string, int> dict_StringToObjType
        {
            get;
            set;
        } = new Dictionary<string, int>();
        public static Dictionary<string, bool> dict_StringToisNode
        {
            get;
            set;
        } = new Dictionary<string, bool>();
        public static Dictionary<string, int> dict_StringToFuncType
        {
            get;
            set;
        } = new Dictionary<string, int>();
 
        //public static List<string> Type_LogicalOfPoint = new List<string>() { "初始条件", "约束条件", "试算参数", "目标函数", "变量" };
        //public static List<MetroColorStyle_Inner> Color_Logical = new List<MetroColorStyle_Inner>() { MetroColorStyle_Inner.Blue, MetroColorStyle_Inner.Pink, MetroColorStyle_Inner.Orange, MetroColorStyle_Inner.Red, MetroColorStyle_Inner.Yellow };
        ///// <summary>
        ///// 跟EpaModelInput对应
        ///// </summary>
        //public static List<string> Type_Indicator = new List<string>() { "压力", "用水量", "水位", "水泵转速比", "阻力系数", "水泵状态" };
 
        //public static List<bool> Type_Indicator_isNode = new List<bool>() { true, true, true, false, false, false };
        private static HashSet<string> _NameList = null;
        public static HashSet<string> NameList
        {
            get
            {
                //if (_NameList!=null) _NameList.Sort();
                return _NameList;
            }
            set
            {
                _NameList = value;
            }
        }
        private static HashSet<string> _TagList = null;
        public static HashSet<string> TagList
        {
            get
            {
                //if (_TagList != null) _TagList.Sort();
                return _TagList;
            }
            set
            {
                _TagList = value;
            }
        }
 
 
        public static List<TypeFacilities> DEFINE_FACI = new List<TypeFacilities>() 
        {
             new TypeFacilities()
             {
                 Name="取水泵站",
                 Icon="🚆",
                 Color=Color.Green,
             },
             new TypeFacilities()
             {
                 Name="水厂",
                 Icon="🏢",
                 Color=Color.Blue,
             },
             new TypeFacilities()
             {
                 Name="加压泵站",
                 Icon="🏡",
                 Color=Color.Yellow,
             },
             new TypeFacilities()
             {
                 Name="管网",
                 Icon="🔧",
                 Color=Color.Gray,
             },
             new TypeFacilities()
             {
                 Name="变量集",
                 Icon="📂",
                 Color=Color.Brown,
             },
             new TypeFacilities()
             {
                 Name="说明",
                 Icon="📄",
                 Color=Color.Pink,
             },
 
        };
        public static List<TypeIndicator> DEFINE_INDICATOR = new List<TypeIndicator>()
        {
            new TypeIndicator
            {
                Name="已知压力",
                isNode=true,
                Type=HydraulicInputType.press,
                
                ObjectNames=new List<string>(){"已知压力点"},
            },
            new TypeIndicator
            {
                Name="节点用水量",
                isNode=true,
                Type=HydraulicInputType.demand,
                
                ObjectNames=new List<string>(){"节点","水表","消火栓"},
            },
            new TypeIndicator
            {
                Name="节点用水模式",
                isNode=true,
                Type=HydraulicInputType.pattern,
                
                ObjectNames=new List<string>(){"节点","水表","消火栓"},
            },
            new TypeIndicator
            {
                Name="水池水位",
                isNode=true,
                Type=HydraulicInputType.level,
                
                ObjectNames=new List<string>(){"水池","水库"},
            },
            new TypeIndicator
            {
                Name="水泵转速比",
                isNode=false,
                Type=HydraulicInputType.initPumpRS,
                
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="管线阻力系数",
                isNode=false,
                Type=HydraulicInputType.initSettings,
                
                ObjectNames=new List<string>(){"管线"},
            },
            new TypeIndicator
            {
                Name="阀门开度",
                isNode=false,
                Type=HydraulicInputType.initSettings,
                
                ObjectNames=new List<string>(){"阀门"},
            },
            new TypeIndicator
            {
                Name="水泵开关",
                isNode=false,
                Type=HydraulicInputType.initStatus,
                
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="阀门开关",
                isNode=false,
                Type=HydraulicInputType.initStatus,
                
                ObjectNames=new List<string>(){"阀门"},
            },
            new TypeIndicator
            {
                Name="管线开关",
                isNode=false,
                Type=HydraulicInputType.initStatus,
                
                ObjectNames=new List<string>(){"管线"},
            },
            new TypeIndicator
            {
                Name="管线直径",
                isNode=false,
                Type=HydraulicInputType.diameter,
                
                ObjectNames=new List<string>(){"管线"},
            },
            new TypeIndicator
            {
                Name="管线长度",
                isNode=false,
                Type=HydraulicInputType.length,
                
                ObjectNames=new List<string>(){"管线"},
            },
            new TypeIndicator
            {
                Name="总水量",
                isNode=true,
                Type=HydraulicInputType.totalDemand,               
                ObjectNames=new List<string>(){"节点","水表","消火栓"},
            },
            //new TypeIndicator
            //{
            //    Name="总分配水量",
            //    isNode=true,
            //    Type=HydraulicInputType.Distribution_TotalDemand,
                
            //    ObjectNames=new List<string>(){"节点","水表","消火栓"},
            //},
            new TypeIndicator
            {
                Name="节点压力",
                isNode=true,
                Type=HydraulicOutputType.Head,
        
                
                ObjectNames=new List<string>(){"节点","水表","消火栓","水池","水库"},
            },
            new TypeIndicator
            {
                Name="节点自由压力",
                isNode=true,
                Type=HydraulicOutputType.Pressure,
 
                
                ObjectNames=new List<string>(){"节点","水表","消火栓","水池","水库"},
            },
            new TypeIndicator
            {
                Name="节点需水量",
                isNode=true,
                Type=HydraulicOutputType.Demand,
 
                
                ObjectNames=new List<string>(){"节点","水表","消火栓","水池","水库"},
            },
            new TypeIndicator
            {
                Name="节点标高",
                isNode=true,
                Type=HydraulicOutputType.Diameter,
 
                
                ObjectNames=new List<string>(){"节点","水表","消火栓","水池","水库"},
            },
            new TypeIndicator
            {
                Name="节点水龄",
                isNode=true,
                Type=HydraulicOutputType.Quality,
 
                
                ObjectNames=new List<string>(){"节点","水表","消火栓","水池","水库"},
            },
            new TypeIndicator
            {
                Name="节点水质",
                isNode=true,
                Type=HydraulicOutputType.Quality,
                
                ObjectNames=new List<string>(){"节点","水表","消火栓","水池","水库"},
            },
            new TypeIndicator
            {
                Name="管线流量",
                isNode=false,
                Type=HydraulicOutputType.Flow,
                
                ObjectNames=new List<string>(){"管线","阀门","水泵"},
            },
            new TypeIndicator
            {
                Name="管线流速",
                isNode=false,
                Type=HydraulicOutputType.Velocity,
                
                ObjectNames=new List<string>(){"管线","阀门","水泵"},
            },
            new TypeIndicator
            {
                Name="水头损失",
                isNode=false,
                Type=HydraulicOutputType.HeadLoss,
                
                ObjectNames=new List<string>(){"管线","阀门","水泵"},
            },
            new TypeIndicator
            {
                Name="当前状态",
                isNode=false,
                Type=HydraulicOutputType.Status,
                
                ObjectNames=new List<string>(){"管线","阀门","水泵"},
            },
            new TypeIndicator
            {
                Name="水泵能耗",
                isNode=false,
                Type=HydraulicOutputType.Energy,
                
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="水泵开关",
                isNode=false,
                Type=HydraulicOutputType.InitStatus,
                
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="水泵转速比",
                isNode=false,
                Type=HydraulicOutputType.Settings,
                
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="初始及运行传参",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="初始传参",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="运行传参",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="种群生成器",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="方案筛选器",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="计算前处理",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="结果处理",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"水泵"},
            },
            new TypeIndicator
            {
                Name="当量分配",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"节点","水表","消火栓"},
            },
            new TypeIndicator
            {
                Name="随机分配",
                isNode=true,
                Type=HydraulicInputType.None,
                ObjectNames=new List<string>(){"节点","水表","消火栓"},
            }
 
 
 
        };
        public static List<TypeObject> DEFINE_OBJECT = new List<TypeObject>()
        {
            new TypeObject
            {
                Name="已知压力点",
                Type=HydraulicObjectType.EN_RESERVOIR,
                isNode=true,
            },
            new TypeObject
            {
                Name="节点",
                Type=HydraulicObjectType.EN_JUNCTION,
                isNode=true,
            },
            new TypeObject
            {
                Name="水表",
                Type=HydraulicObjectType.EN_JUNCTION,
                isNode=true,
            },
            new TypeObject
            {
                Name="消火栓",
                Type=HydraulicObjectType.EN_JUNCTION,
                isNode=true,
            },
            new TypeObject
            {
                Name="水池",
                Type=HydraulicObjectType.EN_TANK,
                isNode=true,
            },
            new TypeObject
            {
                Name="水库",
                Type=HydraulicObjectType.EN_RESERVOIR,
                isNode=true,
            },
            new TypeObject
            {
                Name="水泵",
                Type=HydraulicObjectType.EN_PUMP,
                isNode=false,
            },
            new TypeObject
            {
                Name="管线",
                Type=HydraulicObjectType.EN_PIPE,
                isNode=false,
            },
            new TypeObject
            {
                Name="阀门",
                Type=HydraulicObjectType.EN_GPV,
                isNode=false,
            },
          
        };
 
 
        public static List<AggregateFunction> DEFIND_AGGFUNC = new List<AggregateFunction>()
        {
            //生成一系列AggregateFunction，名称分别为："累计值","平均值","最大值","最小值","计数","绝对累计值"
            new AggregateFunction("累计值",(arr)=>
            {
                double sum = 0;
                foreach (var item in arr)
                {
                    sum += item;
                }
                return sum;
            }), 
            new AggregateFunction("平均值",(arr)=>
            {
                double sum = 0;
                foreach (var item in arr)
                {
                    sum += item;
                }
                return sum/arr.Length;
            }),
            new AggregateFunction("最大值",(arr)=>
            {
                double max = arr[0];
                foreach (var item in arr)
                {
                    if (item > max) max = item;
                }
                return max;
            }),
            new AggregateFunction("最小值",(arr)=>
            {
                double min = arr[0];
                foreach (var item in arr)
                {
                    if (item < min) min = item;
                }
                return min;
            }),
            new AggregateFunction("计数",(arr)=>
            {
                return arr.Length;
            }),
            new AggregateFunction("绝对累计值",(arr)=>
            {
                double sum = 0;
                foreach (var item in arr)
                {
                    sum += Math.Abs(item);
                }
                return sum;
            }),
 
 
 
        };
        public static Dictionary<string, LogicalPointType> dict_LogicPoint = null;
        /// <summary>
        /// 
        /// </summary>
        public static List<LogicalPointType> DEFINE_LOGICPOINT = new List<LogicalPointType>()
        {
 
            new LogicalPointType()
            {
                Name = "初始条件",
                titleStyle = MetroColorStyle_Inner.Blue,
                IndicatorNames = new List<string>(){ "已知压力","节点用水量", "节点用水模式", "水池水位", "总水量", "水泵转速比","管线阻力系数","阀门开度","水泵开关","阀门开关","管线开关","管线直径","管线长度" },
                Type_expression= new List<string>() { "基准值(界面)",  "基准值(接口)", "模式系数(界面)", "模式系数(接口)"},
            },
            new LogicalPointType()
            {
                Name = "下阶段条件",
                titleStyle = MetroColorStyle_Inner.Blue,
                IndicatorNames = new List<string>(){ "已知压力","节点用水量", "节点用水模式", "水池水位","水泵转速比","管线阻力系数","阀门开度","水泵开关","阀门开关","管线开关","管线直径","管线长度","总水量" },
                Type_expression= new List<string>() { "基准值(界面)",  "基准值(接口)", "模式系数(界面)", "模式系数(接口)"},
            },
            new LogicalPointType()
            {
                Name = "试算参数",
                titleStyle = MetroColorStyle_Inner.Pink,
                IndicatorNames = new List<string>(){ "已知压力","节点用水量","水池水位","水泵转速比","管线阻力系数","阀门开度","水泵开关","阀门开关","管线开关","管线直径","管线长度","总水量" },
                Type_expression= new List<string>() { "∈","变化值∈" },
            },
            new LogicalPointType()
            {
                Name = "水量分配",
                titleStyle = MetroColorStyle_Inner.DarkGreen,
                IndicatorNames = new List<string>(){ "当量分配" ,"随机分配","总水量"},//,"总分配水量"
                Type_expression= new List<string>() { "基准值(界面)", "基准值(接口)", "模式系数(界面)", "模式系数(接口)" },
            },
            new LogicalPointType()
            {
                Name = "约束条件",
                titleStyle = MetroColorStyle_Inner.Yellow_Content,
                IndicatorNames = new List<string>(){ "节点压力", "节点自由压力", "节点需水量", "节点标高", "管线流量", "管线流速", "水头损失", "水泵能耗","水泵开关","水泵转速比" },
                Type_expression= new List<string>() { "∈" },
            },
            new LogicalPointType()
            {
                Name = "目标函数",
                titleStyle = MetroColorStyle_Inner.DarkRed,
                IndicatorNames = new List<string>(){ "节点压力", "节点自由压力", "节点需水量", "节点标高", "管线流量", "管线流速", "水头损失", "水泵能耗","水泵开关","水泵转速比" },
                Type_expression= new List<string>() { "最小","最大"  },//"接近",
            },
            new LogicalPointType()
            {
                Name = "表达式",
                titleStyle = MetroColorStyle_Inner.SkyBlue_Content,
                IndicatorNames = new List<string>(){ "节点压力", "节点自由压力", "节点需水量", "节点标高", "管线流量", "管线流速", "水头损失", "水泵能耗","水泵开关","水泵转速比" },
                Type_expression= new List<string>() { "表达式计算"  },//"接近",
            },
            new LogicalPointType()
            {
                Name = "变量",
                titleStyle = MetroColorStyle_Inner.Green_Content,
                IndicatorNames = new List<string>(){ "节点压力","节点自由压力", "节点需水量","节点标高","节点水质", "管线流量", "管线流速","水头损失","管线状态", "水泵能耗" ,"水泵开关","水泵转速比"},
                Type_expression= new List<string>() { "计算值","变化值","初始计算值","基准值(界面)","基准值(接口)", "模式系数(界面)", "模式系数(接口)", "子方案值"},
            },
            new LogicalPointType()
            {
                Name = "预处理插件",
                titleStyle = MetroColorStyle_Inner.Yellow_Content,
                IndicatorNames = new List<string>(){"初始及运行传参", "初始传参", "运行传参", "种群生成器", "方案筛选器", "计算前处理", "结果处理" },
                Type_expression= new List<string>() { },
            },
            new LogicalPointType()
            {
                Name = "集合",
                titleStyle = MetroColorStyle_Inner.Yellow_Content,
                //IndicatorNames = new List<string>(){ "已知压力","节点用水量", "水池水位","水泵转速比","管线阻力系数","阀门开度","水泵开关","阀门开关","管线开关","管线直径","管线长度","[-----输出-----]","节点压力", "节点自由压力", "节点需水量", "管线流量", "管线流速", "水泵能耗","水泵开关","水泵转速比" },
                IndicatorNames = new List<string>(){  "节点压力","节点自由压力", "节点需水量", "节点标高", "节点水质", "管线流量", "管线流速","水头损失","管线状态", "水泵能耗" ,"水泵开关","水泵转速比" },
                //Type_expression= new List<string>() { "最大值","最小值","平均值","累计值","计数"},
                Type_expression= new List<string>(){ "集合计算"},
            },            
        };
    }
    
 
    public class AggregateFunction
    {
        //生成构造函数
        public AggregateFunction(string Name, Func<double[], double> CalcFunc)
        {
            this.Name = Name;
            this.CalcFunc = CalcFunc;
        }
        public string Name;
        public string Description;
        public Func<double[],double> CalcFunc;
    }
    public class LogicalPointType
    {
        public string Name;
        public MetroColorStyle_Inner titleStyle;
        public List<string> IndicatorNames;
        public List<string> Type_expression;
 
    }
    public class TypeIndicator
    {
        public string Name;
        /// <summary>
        /// true:节点;false:管线
        /// </summary>
        public bool isNode;
        private HydraulicInputType _inType= HydraulicInputType.None;
        private HydraulicOutputType _outType = HydraulicOutputType.None;
        public dynamic Type 
        { 
            get
            {
                if(_outType==HydraulicOutputType.None)
                    return _inType;
                else
                    return _outType;
                //if (isInput) return _inType;
                //else return _outType;
            }
            set
            {
                if (value is HydraulicInputType) _inType = value;
                else _outType = value;  
            }
        }
 
        public dynamic EpaResultType;
        public List<string> ObjectNames;
        /// <summary>
        /// true:输入;false:输出
        /// </summary>
        public bool isInput;
        
    }
    public class TypeObject
    {
        public string Name;
        public bool isNode;
        public HydraulicObjectType Type=HydraulicObjectType.EN_CVPIPE;
 
    }
    public class TypeFacilities
    {
        public string Name;
        public string Icon;
        public Color Color;
    }
 
}