HStation/XHS.V1.0.git

			@@ -1,52 +1,39 @@

			using Microsoft.Extensions.Logging.Abstractions;

			namespace Yw.Hydro
			{
			/// <summary>
			/// 解析辅助类
			/// </summary>
			public class ParseHelper
			public static class ParseHelper
			{
			/// <summary>
			///
			/// </summary>
			public static NetWork ToNetWork(Yw.Model.HydroModelInfo model)
			public static Network ToNetwork(this Yw.Model.HydroModelInfo model)
			{
			if (model == null)
			{
			return default;
			}
			var netWork = new NetWork();
			var netWork = new Network();

			//连接节点
			if (model.Junctions != null && model.Junctions.Count > 0)
			{
			foreach (var junction in model.Junctions)
			{
			var junctionModel = new JunctionModel();
			junctionModel.ID = junction.Code;
			junctionModel.Name = junction.Name;
			junctionModel.Elev = (float)junction.Elev;
			junctionModel.Demand = junction.Demand.HasValue ? (float)junction.Demand.Value : 0;
			junctionModel.PatternID = junction.DemandPattern;
			junctionModel.X = (float)junction.Position2d.X;
			junctionModel.Y = (float)junction.Position2d.Y;
			netWork.Nodes.Add(junctionModel);
			}
			}
			#region 节点

			//水库
			if (model.Reservoirs != null && model.Reservoirs.Count > 0)
			{
			foreach (var reservoir in model.Reservoirs)
			{
			var reservoirModel = new ReservoisModel();
			reservoirModel.ID = reservoir.Code;
			var reservoirModel = new Reservoir();
			reservoirModel.Id = reservoir.Code;
			reservoirModel.Catalog = Yw.EPAnet.Catalog.Reservoir;
			reservoirModel.Name = reservoir.Name;
			reservoirModel.Head = (float)reservoir.Head;
			reservoirModel.PatternID = reservoir.HeadPattern;
			reservoirModel.X = (float)reservoir.Position2d.X;
			reservoirModel.Y = (float)reservoir.Position2d.Y;
			netWork.Nodes.Add(reservoirModel);
			reservoirModel.Quality = 0;
			reservoirModel.Position = new Position2d(reservoir.Position2d.X, reservoir.Position2d.Y);
			reservoirModel.Head = reservoir.Head;
			reservoirModel.HeadPattern = string.Empty;
			netWork.Reservoirs.Add(reservoirModel);
			}
			}

			@@ -55,37 +42,307 @@
			{
			foreach (var tank in model.Tanks)
			{
			var tankModel = new TankModel();
			tankModel.ID = tank.Code;
			var tankModel = new Tank();
			tankModel.Id = tank.Code;
			tankModel.Catalog = Yw.EPAnet.Catalog.Tank;
			tankModel.Name = tank.Name;
			tankModel.Elev = (float)tank.PoolElev;
			tankModel.InitLevel = (float)tank.InitLevel;
			tankModel.MaxLevel = (float)tank.MaxLevel;
			tankModel.MinLevel = (float)tank.MinLevel;
			tankModel.MinVol = (float)tank.MinVol;
			tankModel.Quality = 0;
			tankModel.Position = new Position2d(tank.Position2d.X, tank.Position2d.Y);
			tankModel.PoolElev = tank.PoolElev;
			tankModel.InitLevel = tank.InitLevel;
			tankModel.MaxLevel = tank.MaxLevel;
			tankModel.MinLevel = tank.MinLevel;
			tankModel.Diameter = tank.DN;
			tankModel.MinVol = tank.MinVol;
			tankModel.VolCurve = tank.VolCurve;
			tankModel.Diameter = (float)tank.Diameter;
			tankModel.X = (float)tank.Position2d.X;
			tankModel.Y = (float)tank.Position2d.Y;
			netWork.Nodes.Add(tankModel);
			tankModel.Overflow = tank.OverFlow;
			netWork.Tanks.Add(tankModel);
			}
			}

			//水箱
			if (model.Waterboxs != null && model.Waterboxs.Count > 0)
			{
			foreach (var waterbox in model.Waterboxs)
			{
			var waterboxModel = new Waterbox();
			waterboxModel.Id = waterbox.Code;
			waterboxModel.Catalog = Yw.EPAnet.Catalog.Waterbox;
			waterboxModel.Name = waterbox.Name;
			waterboxModel.Quality = 0;
			waterboxModel.Position = new Position2d(waterbox.Position2d.X, waterbox.Position2d.Y);
			waterboxModel.PoolElev = waterbox.PoolElev;
			waterboxModel.InitLevel = waterbox.InitLevel;
			waterboxModel.MaxLevel = waterbox.MaxLevel;
			waterboxModel.MinLevel = waterbox.MinLevel;
			waterboxModel.Diameter = waterbox.DN;
			waterboxModel.MinVol = waterbox.MinVol;
			waterboxModel.VolCurve = waterbox.VolCurve;
			waterboxModel.Overflow = waterbox.OverFlow;
			netWork.Waterboxs.Add(waterboxModel);
			}
			}

			//连接节点
			if (model.Junctions != null && model.Junctions.Count > 0)
			{
			foreach (var junction in model.Junctions)
			{
			var junctionModel = new Junction();
			junctionModel.Id = junction.Code;
			junctionModel.Catalog = Yw.EPAnet.Catalog.Junction;
			junctionModel.Name = junction.Name;
			junctionModel.Quality = 0;
			junctionModel.Position = new Position2d(junction.Position2d.X, junction.Position2d.Y);
			junctionModel.Elev = junction.Elev;
			junctionModel.MinorLoss = junction.MinorLoss;
			junctionModel.Demand = 0;
			junctionModel.DemandPattern = null;

			netWork.Junctions.Add(junctionModel);
			}
			}

			//喷嘴
			if (model.Nozzles != null && model.Nozzles.Count > 0)
			{
			foreach (var nozzle in model.Nozzles)
			{
			var nozzleModel = new Nozzle();
			nozzleModel.Id = nozzle.Code;
			nozzleModel.Catalog = Yw.EPAnet.Catalog.Nozzle;
			nozzleModel.Name = nozzle.Name;
			nozzleModel.Quality = 0;
			nozzleModel.Position = new Position2d(nozzle.Position2d.X, nozzle.Position2d.Y);
			nozzleModel.Elev = nozzle.Elev;
			nozzleModel.MinorLoss = nozzle.MinorLoss;
			nozzleModel.Demand = 0;
			nozzleModel.DemandPattern = null;
			nozzleModel.Coefficient = nozzle.Coefficient;
			netWork.Nozzles.Add(nozzleModel);
			}
			}

			//冷却塔
			if (model.Coolings != null && model.Coolings.Count > 0)
			{
			foreach (var cooling in model.Coolings)
			{
			var coolingModel = new Nozzle();
			coolingModel.Id = cooling.Code;
			coolingModel.Catalog = Yw.EPAnet.Catalog.Nozzle;
			coolingModel.Name = cooling.Name;
			coolingModel.Quality = 0;
			coolingModel.Position = new Position2d(cooling.Position2d.X, cooling.Position2d.Y);
			coolingModel.Elev = cooling.Elev;
			coolingModel.MinorLoss = cooling.MinorLoss;
			coolingModel.Demand = 0;
			coolingModel.DemandPattern = null;
			coolingModel.Coefficient = cooling.Coefficient;
			netWork.Nozzles.Add(coolingModel);
			}
			}

			//消火栓
			if (model.Hydrants != null && model.Hydrants.Count > 0)
			{
			foreach (var hydrant in model.Hydrants)
			{
			var hydrantModel = new Hydrant();
			hydrantModel.Id = hydrant.Code;
			hydrantModel.Catalog = Yw.EPAnet.Catalog.Hydrant;
			hydrantModel.Name = hydrant.Name;
			hydrantModel.Quality = 0;
			hydrantModel.Position = new Position2d(hydrant.Position2d.X, hydrant.Position2d.Y);
			hydrantModel.Elev = hydrant.Elev;
			hydrantModel.MinorLoss = hydrant.MinorLoss;
			hydrantModel.Demand = 0;
			hydrantModel.DemandPattern = null;
			hydrantModel.Coefficient = hydrant.Coefficient;
			netWork.Hydrants.Add(hydrantModel);
			}
			}

			//闷头
			if (model.Bluntheads != null && model.Bluntheads.Count > 0)
			{
			foreach (var blunthead in model.Bluntheads)
			{
			var bluntheadModel = new Blunthead();
			bluntheadModel.Id = blunthead.Code;
			bluntheadModel.Catalog = Yw.EPAnet.Catalog.Blunthead;
			bluntheadModel.Name = blunthead.Name;
			bluntheadModel.Quality = 0;
			bluntheadModel.Position = new Position2d(blunthead.Position2d.X, blunthead.Position2d.Y);
			bluntheadModel.Elev = blunthead.Elev;
			bluntheadModel.MinorLoss = blunthead.MinorLoss;
			bluntheadModel.Demand = 0;
			bluntheadModel.DemandPattern = null;
			netWork.Bluntheads.Add(bluntheadModel);
			}
			}

			//弯头
			if (model.Elbows != null && model.Elbows.Count > 0)
			{
			foreach (var elbow in model.Elbows)
			{
			var elbowModel = new Elbow();
			elbowModel.Id = elbow.Code;
			elbowModel.Catalog = Yw.EPAnet.Catalog.Elbow;
			elbowModel.Name = elbow.Name;
			elbowModel.Quality = 0;
			elbowModel.Position = new Position2d(elbow.Position2d.X, elbow.Position2d.Y);
			elbowModel.Elev = elbow.Elev;
			elbowModel.MinorLoss = elbow.MinorLoss;
			elbowModel.Demand = 0;
			elbowModel.DemandPattern = null;
			elbowModel.ElbowType = elbow.ElbowType;
			elbowModel.BendingAngle = elbow.BendingAngle;
			netWork.Elbows.Add(elbowModel);
			}
			}

			//三通
			if (model.Threelinks != null && model.Threelinks.Count > 0)
			{
			foreach (var threelink in model.Threelinks)
			{
			var threelinkModel = new Threelink();
			threelinkModel.Id = threelink.Code;
			threelinkModel.Catalog = Yw.EPAnet.Catalog.Threelink;
			threelinkModel.Name = threelink.Name;
			threelinkModel.Quality = 0;
			threelinkModel.Position = new Position2d(threelink.Position2d.X, threelink.Position2d.Y);
			threelinkModel.Elev = threelink.Elev;
			threelinkModel.MinorLoss = threelink.MinorLoss;
			threelinkModel.Demand = 0;
			threelinkModel.DemandPattern = null;
			threelinkModel.RunningThroughLoss = threelink.RunningThroughLoss;
			threelinkModel.BranchThroughLoss = threelink.BranchThroughLoss;
			netWork.Threelinks.Add(threelinkModel);
			}
			}

			//四通
			if (model.Fourlinks != null && model.Fourlinks.Count > 0)
			{
			foreach (var fourlink in model.Fourlinks)
			{
			var fourlinkModel = new Fourlink();
			fourlinkModel.Id = fourlink.Code;
			fourlinkModel.Catalog = Yw.EPAnet.Catalog.Fourlink;
			fourlinkModel.Name = fourlink.Name;
			fourlinkModel.Quality = 0;
			fourlinkModel.Position = new Position2d(fourlink.Position2d.X, fourlink.Position2d.Y);
			fourlinkModel.Elev = fourlink.Elev;
			fourlinkModel.MinorLoss = fourlink.MinorLoss;
			fourlinkModel.Demand = fourlink.Demand;
			fourlinkModel.DemandPattern = fourlink.DemandPattern;
			netWork.Fourlinks.Add(fourlinkModel);
			}
			}

			//水表
			if (model.Meters != null && model.Meters.Count > 0)
			{
			foreach (var meter in model.Meters)
			{
			var meterModel = new Meter();
			meterModel.Id = meter.Code;
			meterModel.Catalog = Yw.EPAnet.Catalog.Meter;
			meterModel.Name = meter.Name;
			meterModel.Quality = 0;
			meterModel.Position = new Position2d(meter.Position2d.X, meter.Position2d.Y);
			meterModel.Elev = meter.Elev;
			meterModel.MinorLoss = meter.MinorLoss;
			meterModel.Demand = meter.Demand;
			meterModel.DemandPattern = meter.DemandPattern;
			netWork.Meters.Add(meterModel);
			}
			}

			//流量计
			if (model.Flowmeters != null && model.Flowmeters.Count > 0)
			{
			foreach (var flowmeter in model.Flowmeters)
			{
			var flowmeterModel = new Flowmeter();
			flowmeterModel.Id = flowmeter.Code;
			flowmeterModel.Catalog = Yw.EPAnet.Catalog.Flowmeter;
			flowmeterModel.Name = flowmeter.Name;
			flowmeterModel.Quality = 0;
			flowmeterModel.Position = new Position2d(flowmeter.Position2d.X, flowmeter.Position2d.Y);
			flowmeterModel.Elev = flowmeter.Elev;
			flowmeterModel.MinorLoss = flowmeter.MinorLoss;
			flowmeterModel.Demand = flowmeter.Demand;
			flowmeterModel.DemandPattern = flowmeter.DemandPattern;
			netWork.Flowmeters.Add(flowmeterModel);
			}
			}

			//压力表
			if (model.Pressmeters != null && model.Pressmeters.Count > 0)
			{
			foreach (var pressmeter in model.Pressmeters)
			{
			var pressmeterModel = new Pressmeter();
			pressmeterModel.Id = pressmeter.Code;
			pressmeterModel.Catalog = Yw.EPAnet.Catalog.Pressmeter;
			pressmeterModel.Name = pressmeter.Name;
			pressmeterModel.Quality = 0;
			pressmeterModel.Position = new Position2d(pressmeter.Position2d.X, pressmeter.Position2d.Y);
			pressmeterModel.Elev = pressmeter.Elev;
			pressmeterModel.MinorLoss = pressmeter.MinorLoss;
			pressmeterModel.Demand = pressmeter.Demand;
			pressmeterModel.DemandPattern = pressmeter.DemandPattern;
			netWork.Pressmeters.Add(pressmeterModel);
			}
			}

			#endregion

			#region 管段

			var allNodes = netWork.GetAllNodes();

			//管道
			if (model.Pipes != null && model.Pipes.Count > 0)
			{
			foreach (var pipe in model.Pipes)
			{
			var pipeModel = new PipeModel();
			pipeModel.ID = pipe.Code;
			var pipeModel = new Pipe();
			pipeModel.Id = pipe.Code;
			pipeModel.Catalog = Yw.EPAnet.Catalog.Pipe;
			pipeModel.Name = pipe.Name;
			pipeModel.Node1 = pipe.StartCode;
			pipeModel.Node2 = pipe.EndCode;
			pipeModel.Length = (float)pipe.Length;
			pipeModel.Diameter = (float)pipe.Diameter;
			pipeModel.Roughness = (float)pipe.Roughness;
			pipeModel.MinorLoss = (float)pipe.MinorLoss;
			netWork.Links.Add(pipeModel);
			pipeModel.StartNode = allNodes.Find(x => x.Id == pipe.StartCode);
			pipeModel.EndNode = allNodes.Find(x => x.Id == pipe.EndCode);
			pipeModel.LinkStatus = Yw.Hydro.PipeStatus.Open;
			pipeModel.Length = pipe.Length;
			pipeModel.Diameter = pipe.Diameter;
			pipeModel.Roughness = pipe.Roughness;
			pipeModel.MinorLossCoeff = 0;
			netWork.Pipes.Add(pipeModel);
			}
			}

			//过渡件
			if (model.Translations != null && model.Translations.Count > 0)
			{
			foreach (var translation in model.Translations)
			{
			var translationModel = new Translation();
			translationModel.Id = translation.Code;
			translationModel.Catalog = Yw.EPAnet.Catalog.Translation;
			translationModel.Name = translation.Name;
			translationModel.StartNode = allNodes.Find(x => x.Id == translation.StartCode);
			translationModel.EndNode = allNodes.Find(x => x.Id == translation.EndCode);
			translationModel.LinkStatus = Yw.Hydro.LinkStatus.Open;
			translationModel.Length = translation.Length;
			translationModel.Diameter = (translation.StartDiameter + translation.EndDiameter) / 2f;
			translationModel.Roughness = translation.Roughness;
			translationModel.MinorLossCoeff = translation.MinorLoss;
			netWork.Translations.Add(translationModel);
			}
			}

			@@ -94,18 +351,181 @@
			{
			foreach (var pump in model.Pumps)
			{
			var pumpModel = new PumpModel();
			pumpModel.ID = pump.Code;
			var pumpModel = new Pump();
			pumpModel.Id = pump.Code;
			pumpModel.Catalog = Yw.EPAnet.Catalog.Pump;
			pumpModel.Name = pump.Name;
			pumpModel.Node1 = pump.StartCode;
			pumpModel.Node2 = pump.EndCode;
			pumpModel.RatedPower = pump.RatedPower;
			pumpModel.FlowCurveID = pump.CurveQH;
			// pumpModel.Status = HyCore.ObjectEnum.StatusType.OPEN;
			netWork.Links.Add(pumpModel);
			pumpModel.StartNode = allNodes.Find(x => x.Id == pump.StartCode);
			pumpModel.EndNode = allNodes.Find(x => x.Id == pump.EndCode);
			pumpModel.LinkStatus = pump.LinkStatus;
			pumpModel.RatedP = pump.RatedP;
			pumpModel.CurveQH = pump.CurveQH;
			if (string.IsNullOrEmpty(pumpModel.CurveQH))
			{
			pumpModel.CurveQH = "PumpDefault";//使用network默认泵曲线
			}
			pumpModel.SpeedRatio = pump.SpeedRatio;
			pumpModel.SpeedRatioPattern = pump.SpeedRatioPattern;
			netWork.Pumps.Add(pumpModel);
			}
			}

			//阀门
			if (model.Valves != null && model.Valves.Count > 0)
			{
			foreach (var valve in model.Valves)
			{
			//止回阀被当成管道处理
			if (valve.ValveType == Yw.Hydro.ValveType.CV)
			{
			var pipeModel = new Pipe();
			pipeModel.Id = valve.Code;
			pipeModel.Catalog = Yw.EPAnet.Catalog.Pipe;
			pipeModel.Name = valve.Name;
			pipeModel.StartNode = allNodes.Find(x => x.Id == valve.StartCode);
			pipeModel.EndNode = allNodes.Find(x => x.Id == valve.EndCode);
			pipeModel.LinkStatus = valve.LinkStatus;
			pipeModel.Length = 0.01;
			pipeModel.Diameter = valve.Diameter;
			pipeModel.Roughness = 110;
			pipeModel.MinorLossCoeff = valve.MinorLoss;
			netWork.Pipes.Add(pipeModel);
			}
			else
			{
			var valveModel = new Yw.EPAnet.Valve();
			valveModel.Id = valve.Code;
			valveModel.Catalog = Yw.EPAnet.Catalog.Valve;
			valveModel.Name = valve.Name;
			valveModel.StartNode = allNodes.Find(x => x.Id == valve.StartCode);
			valveModel.EndNode = allNodes.Find(x => x.Id == valve.EndCode);
			valveModel.LinkStatus = valve.LinkStatus;
			valveModel.Diameter = valve.Diameter;
			valveModel.MinorLoss = valve.MinorLoss;
			valveModel.ValveType = valve.ValveType;
			//valveModel.ValveSetting = valve.ValveSetting;
			switch (valve.ValveType)
			{
			case Yw.Hydro.ValveType.PRV://减压阀
			{

			}
			break;
			case Yw.Hydro.ValveType.PSV://稳压阀
			{

			}
			break;
			case Yw.Hydro.ValveType.PBV://压力制动阀
			{

			}
			break;
			case Yw.Hydro.ValveType.FCV://流量控制阀
			{

			}
			break;
			case Yw.Hydro.ValveType.TCV://节流控制阀
			{
			valveModel.ValveSetting = "0";
			// var curveol = model.Curves?.Find(x => x.Code == valve.ValveSetting);
			//if (curveol != null)
			//{
			// var point2dList = curveol.CurveData.Select(x => new Yw.Geometry.Point2d(x.X, x.Y)).ToList();
			// var ptCurveOL = new Yw.Geometry.CubicSpline2d(point2dList);
			// valveModel.ValveSetting = ptCurveOL.GetPointY(valve.OpeningDegree).ToString();
			// if (valve.LinkStatus == Yw.Hydro.LinkStatus.Open)
			// {
			// if (valve.OpeningDegree > 0)
			// {
			// valveModel.LinkStatus = Yw.EPAnet.ValveStatus.None;
			// }
			// }
			//}

			}
			break;
			case Yw.Hydro.ValveType.GPV://常规阀门
			{

			}
			break;
			default: break;
			}
			netWork.Valves.Add(valveModel);
			}
			}
			}

			//换热器
			if (model.Exchangers != null && model.Exchangers.Count > 0)
			{
			foreach (var exchanger in model.Exchangers)
			{
			var exchangerModel = new Exchanger();
			exchangerModel.Id = exchanger.Code;
			exchangerModel.Catalog = Yw.EPAnet.Catalog.Exchanger;
			exchangerModel.Name = exchanger.Name;
			exchangerModel.StartNode = allNodes.Find(x => x.Id == exchanger.StartCode);
			exchangerModel.EndNode = allNodes.Find(x => x.Id == exchanger.EndCode);
			exchangerModel.LinkStatus = exchanger.LinkStatus;
			exchangerModel.Diameter = exchanger.Diameter;
			exchangerModel.MinorLoss = exchanger.MinorLoss;
			exchangerModel.CurveQL = exchanger.CurveQL;
			netWork.Exchangers.Add(exchangerModel);
			}
			}

			//压缩机
			if (model.Compressors != null && model.Compressors.Count > 0)
			{
			foreach (var compressor in model.Compressors)
			{
			var compressModel = new Compressor();
			compressModel.Id = compressor.Code;
			compressModel.Catalog = Yw.EPAnet.Catalog.Compressor;
			compressModel.Name = compressor.Name;
			compressModel.StartNode = allNodes.Find(x => x.Id == compressor.StartCode);
			compressModel.EndNode = allNodes.Find(x => x.Id == compressor.EndCode);
			compressModel.LinkStatus = compressor.LinkStatus;
			compressModel.Diameter = compressor.Diameter;
			compressModel.MinorLoss = compressor.MinorLoss;
			compressModel.CurveQL = compressor.CurveQL;
			netWork.Compressors.Add(compressModel);
			}
			}

			//曲线
			if (model.Curves != null && model.Curves.Count > 0)
			{
			foreach (var curve in model.Curves)
			{
			var curveModel = new Yw.EPAnet.Curve();
			curveModel.Id = curve.Code;
			curveModel.Catalog = Yw.EPAnet.Catalog.Curve;
			curveModel.Name = curve.Name;
			curveModel.CurveType = curve.CurveType;
			curveModel.CurveData = curve.CurveData?.Select(x => new CurvePoint(x.X, x.Y)).ToList();
			netWork.Curves.Add(curveModel);
			}
			}



			#endregion

			#region 节点连接

			var allLinks = netWork.GetAllLinks();
			foreach (var node in allNodes)
			{
			var links = allLinks.Where(x => x.StartNode.Id == node.Id \|\| x.EndNode.Id == node.Id).ToList();
			node.Links = links;
			}

			#endregion

			return netWork;
			}