using Microsoft.VisualBasic;
|
using System.Security.Permissions;
|
using Yw.EPAnet;
|
|
namespace Yw.Hydro
|
{
|
/// <summary>
|
/// 解析辅助类
|
/// </summary>
|
public static class ParseHelper
|
{
|
/// <summary>
|
///
|
/// </summary>
|
public static Network ToNetwork(this Yw.Model.HydroModelInfo model)
|
{
|
if (model == null)
|
{
|
return default;
|
}
|
var netWork = new Network();
|
|
#region 节点
|
|
//水库
|
if (model.Reservoirs != null && model.Reservoirs.Count > 0)
|
{
|
foreach (var reservoir in model.Reservoirs)
|
{
|
var reservoirModel = new Reservoir();
|
reservoirModel.Id = reservoir.Code;
|
reservoirModel.Catalog = Yw.EPAnet.Catalog.Reservoir;
|
reservoirModel.Name = reservoir.Name;
|
reservoirModel.Quality = 0;
|
reservoirModel.Position = new Position2d(reservoir.Position2d.X, reservoir.Position2d.Y);
|
reservoirModel.PoolElev = reservoir.PoolElev ?? 0;
|
reservoirModel.Head = reservoir.Head;
|
reservoirModel.HeadPattern = reservoir.HeadPattern;
|
netWork.Reservoirs.Add(reservoirModel);
|
}
|
}
|
|
//水池
|
if (model.Tanks != null && model.Tanks.Count > 0)
|
{
|
foreach (var tank in model.Tanks)
|
{
|
var tankModel = new Tank();
|
tankModel.Id = tank.Code;
|
tankModel.Catalog = Yw.EPAnet.Catalog.Tank;
|
tankModel.Name = tank.Name;
|
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.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 = junction.Demand;
|
junctionModel.DemandPattern = junction.DemandPattern;
|
|
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 = nozzle.Demand;
|
nozzleModel.DemandPattern = nozzle.DemandPattern;
|
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 = cooling.Demand;
|
coolingModel.DemandPattern = cooling.DemandPattern;
|
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 = hydrant.Demand;
|
hydrantModel.DemandPattern = hydrant.DemandPattern;
|
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 = blunthead.Demand;
|
bluntheadModel.DemandPattern = blunthead.DemandPattern;
|
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 = elbow.Demand;
|
elbowModel.DemandPattern = elbow.DemandPattern;
|
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 = threelink.Demand;
|
threelinkModel.DemandPattern = threelink.DemandPattern;
|
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 Pipe();
|
pipeModel.Id = pipe.Code;
|
pipeModel.Catalog = Yw.EPAnet.Catalog.Pipe;
|
pipeModel.Name = pipe.Name;
|
pipeModel.StartNode = allNodes.Find(x => x.Id == pipe.StartCode);
|
pipeModel.EndNode = allNodes.Find(x => x.Id == pipe.EndCode);
|
pipeModel.LinkStatus = pipe.LinkStatus;
|
pipeModel.Length = pipe.Length;
|
pipeModel.Diameter = pipe.Diameter;
|
pipeModel.Roughness = pipe.Roughness;
|
pipeModel.MinorLossCoeff = pipe.MinorLoss;
|
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 = translation.LinkStatus;
|
translationModel.Length = translation.Length;
|
translationModel.Diameter = translation.Diameter;
|
translationModel.Roughness = translation.Roughness;
|
translationModel.MinorLossCoeff = translation.MinorLoss;
|
netWork.Translations.Add(translationModel);
|
}
|
}
|
|
//水泵
|
if (model.Pumps != null && model.Pumps.Count > 0)
|
{
|
foreach (var pump in model.Pumps)
|
{
|
var pumpModel = new Pump();
|
pumpModel.Id = pump.Code;
|
pumpModel.Catalog = Yw.EPAnet.Catalog.Pump;
|
pumpModel.Name = pump.Name;
|
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;
|
}
|
|
|
|
|
}
|
}
|
