using System.Text.RegularExpressions;
|
|
namespace HydroUI
|
{
|
|
|
[Serializable]
|
public class NetWork
|
{
|
public NetWork() { }
|
public virtual void AddJunction(JunctionModel junction)
|
{
|
CheckNodesExist(junction);
|
Nodes.Add(junction);
|
}
|
|
public virtual void AddJunctions(List<JunctionModel> junctions)
|
{
|
junctions.ForEach(junction => { AddJunction(junction); });
|
}
|
|
public virtual void AddTank(TankModel tank)
|
{
|
CheckNodesExist(tank);
|
Nodes.Add(tank);
|
}
|
|
public virtual void AddTanks(List<TankModel> tanks)
|
{
|
tanks.ForEach(tank => { AddTank(tank); });
|
}
|
|
public virtual void AddPipe(PipeModel pipe)
|
{
|
CheckLinksExist(pipe);
|
Links.Add(pipe);
|
}
|
|
public virtual void AddPipes(List<PipeModel> pipes)
|
{
|
pipes.ForEach(pipe => { AddPipe(pipe); });
|
}
|
public virtual void AddPump(PumpModel pump)
|
{
|
CheckLinksExist(pump);
|
Links.Add(pump);
|
}
|
|
public virtual void AddPumps(List<PumpModel> pumps)
|
{
|
pumps.ForEach(pump => { AddPump(pump); });
|
}
|
public virtual void AddValve(ValveModel valve)
|
{
|
CheckLinksExist(valve);
|
Links.Add(valve);
|
}
|
|
public virtual void AddValves(List<ValveModel> valves)
|
{
|
valves.ForEach(valve => { AddValve(valve); });
|
}
|
public virtual void AddReservos(ReservoisModel reservois)
|
{
|
CheckNodesExist(reservois);
|
Nodes.Add(reservois);
|
}
|
public virtual void AddReservoss(List<ReservoisModel> reservoiss)
|
{
|
reservoiss.ForEach(reservois => { AddReservos(reservois); });
|
}
|
public virtual void AddMeter(MeterModel meter)
|
{
|
CheckNodesExist(meter);
|
Nodes.Add(meter);
|
}
|
public virtual void AddMeters(List<MeterModel> meters)
|
{
|
meters.ForEach(meter => { AddMeter(meter); });
|
}
|
public virtual void AddNozzle(NozzleModel nozzle)
|
{
|
CheckNodesExist(nozzle);
|
Nodes.Add(nozzle);
|
}
|
public virtual void AddNozzles(List<NozzleModel> nozzles)
|
{
|
nozzles.ForEach(nozzle => { AddNozzle(nozzle); });
|
}
|
|
private void CheckNodesExist(NodeCalcModel node)
|
{
|
if (Nodes.Any(d => d.ID == node.ID))
|
throw new Exception("已存在重复的对象");
|
}
|
|
private void CheckLinksExist(LinkCalcModel link)
|
{
|
if (Links.Any(d => d.ID == link.ID))
|
throw new Exception("已存在重复的对象");
|
}
|
|
public List<NodeCalcModel> Nodes { get; set; } = new List<NodeCalcModel>();
|
public List<LinkCalcModel> Links { get; set; } = new List<LinkCalcModel>();
|
|
|
/// 根据INP文件生成
|
public virtual bool BuildFromInp(string InpPath)
|
{
|
if (InpPath == null || !File.Exists(InpPath)) return false;
|
List<Coor> points = new List<Coor>();
|
StreamReader sr = new StreamReader(InpPath);
|
|
{
|
string line;
|
string section = "";
|
while ((line = sr.ReadLine()) != null)
|
{
|
if (line.Trim().StartsWith("["))
|
{
|
section = line.TrimStart('[').TrimEnd(']');
|
}
|
else
|
{
|
string s = line.Trim('\t').Trim(' ');
|
if (s.Length == 0 || s[0] == ';') continue;
|
line = line.Replace("\t\t", "\t_\t").Replace("\t \t", "\t_\t");
|
Parts parts = new Parts(line.Split(new char[] { '\t', ' ', ';' }, StringSplitOptions.RemoveEmptyEntries));
|
switch (section)
|
{
|
case "JUNCTIONS":
|
{
|
var ID = parts[0];
|
float elev;
|
float.TryParse(parts[1], out elev);
|
var Elev = elev;
|
float demand;
|
float.TryParse(parts[2], out demand);
|
var Demand = demand;
|
var PatternID = parts[3];
|
int level;
|
int.TryParse(parts[6], out level);
|
var Level = level;
|
|
if (parts[5] == "Meter")
|
{
|
AddMeter(new MeterModel()
|
{
|
ID = ID,
|
Elev = Elev,
|
Demand = Demand,
|
PatternID = PatternID,
|
});
|
}
|
else if (parts[5] == "Nozzle")
|
{
|
AddNozzle(new NozzleModel()
|
{
|
ID = ID,
|
Elev = Elev,
|
Demand = Demand,
|
PatternID = PatternID,
|
});
|
}
|
else
|
{
|
AddJunction(new JunctionModel()
|
{
|
ID = ID,
|
Elev = Elev,
|
Demand = Demand,
|
PatternID = PatternID,
|
});
|
}
|
|
}
|
break;
|
case "RESERVOIRS":
|
{
|
ReservoisModel r = new ReservoisModel();
|
r.ID = parts[0];
|
float head;
|
if (float.TryParse(parts[1], out head))
|
r.Head = head;
|
r.PatternID = parts.Length > 2 ? parts[2] : "";
|
int level;
|
|
AddReservos(r);
|
}
|
break;
|
case "TANKS":
|
{
|
float initLevel = 0;
|
float.TryParse(parts[2], out initLevel);
|
|
float minLevel = 0;
|
float.TryParse(parts[3], out minLevel);
|
|
float maxLevel = 0;
|
float.TryParse(parts[4], out maxLevel);
|
|
float diamter = 0;
|
float.TryParse(parts[5], out diamter);
|
|
float minVol = 0;
|
float.TryParse(parts[6], out minVol);
|
var tank = new TankModel()
|
{
|
ID = parts[0],
|
Elev = float.Parse(parts[1]),
|
InitLevel = initLevel,
|
MinLevel = minLevel,
|
MaxLevel = maxLevel,
|
Diameter = diamter,
|
MinVol = minVol,
|
VolCurve = "",
|
IsOverFlow = true
|
};
|
AddTank(tank);
|
}
|
break;
|
case "PIPES":
|
{
|
PipeModel p = new PipeModel();
|
p.ID = parts[0];
|
p.Node1 = parts[1];
|
p.Node2 = parts[2];
|
float length;
|
if (float.TryParse(parts[3], out length))
|
p.Length = length;
|
float diameter;
|
if (float.TryParse(parts[4], out diameter))
|
p.Diameter = diameter;
|
float roughness;
|
if (float.TryParse(parts[5], out roughness))
|
p.Roughness = roughness;
|
float minorLoss;
|
if (float.TryParse(parts[6], out minorLoss))
|
p.MinorLoss = minorLoss;
|
p.Status = parts.Length > 7 ? StatusType.CLOSED : StatusType.DEFAULT;
|
AddPipe(p);
|
}
|
break;
|
case "VALVES":
|
{
|
ValveModel valve = new ValveModel();
|
valve.ID = parts[0];
|
|
valve.Node1 = parts[1];
|
valve.Node2 = parts[2];
|
|
float diameter;
|
if (float.TryParse(parts[3], out diameter))
|
valve.Diameter = diameter;
|
valve.Type = parts[4];
|
valve.CurvSetting = parts[5];
|
float minorLoss;
|
if (float.TryParse(parts[6], out minorLoss))
|
valve.MinorLoss = minorLoss;
|
AddValve(valve);
|
}
|
break;
|
case "REPEATERS":
|
{
|
|
}
|
break;
|
case "COORDINATES":
|
{
|
string id = parts[0];
|
float x;
|
float y;
|
if (float.TryParse(parts[1], out x) && float.TryParse(parts[2], out y))
|
{
|
points.Add(new Coor(id, new PointF(x, y)));
|
}
|
}
|
break;
|
}
|
}
|
}
|
sr.Close();
|
|
#region 坐标匹配方法
|
#endregion
|
|
|
|
#region 优化方案
|
int k1 = 0;
|
int k2 = 0;
|
|
|
Nodes.Sort((a, b) => string.Compare(a.ID, b.ID));
|
points.Sort((a, b) => string.Compare(a.ID, b.ID));
|
k1 = 0;
|
k2 = 0;
|
while (k1 < Nodes.Count)
|
{
|
var J = Nodes[k1];
|
var coor = points[k2];
|
|
while (J.ID != coor.ID && k2 < points.Count)
|
{
|
k2++;
|
if (k2 < points.Count) coor = points[k2];
|
|
}
|
if (k2 == points.Count)
|
{
|
throw new Exception($"未找到Node[{J.ID}]的坐标");
|
}
|
J.X = coor.Position.X;
|
J.Y = coor.Position.Y;
|
|
k1++;
|
}
|
#endregion
|
|
|
|
|
|
Links.Sort((a, b) => string.Compare(a.Node1, b.Node1));
|
k1 = 0;
|
k2 = 0;
|
while (k2 < Links.Count)
|
{
|
var p = Links[k2];
|
var J = Nodes[k1];
|
while (J.ID != p.Node1 && k1 < Nodes.Count)
|
{
|
k1++;
|
if (k1 < Nodes.Count) J = Nodes[k1];
|
|
}
|
if (k1 == Nodes.Count)
|
{
|
throw new Exception($"未找到Link[{p.ID}]的起始节点[{p.Node1}]");
|
}
|
k2++;
|
}
|
|
|
|
Links.Sort((a, b) => string.Compare(a.Node2, b.Node2));
|
k1 = 0;
|
k2 = 0;
|
while (k2 < Links.Count)
|
{
|
var p = Links[k2];
|
var J = Nodes[k1];
|
while (J.ID != p.Node2 && k1 < Nodes.Count)
|
{
|
k1++;
|
if (k1 < Nodes.Count) J = Nodes[k1];
|
}
|
if (k1 == Nodes.Count)
|
{
|
throw new Exception($"未找到Link[{p.ID}]的终止节点[{p.Node2}]");
|
}
|
k2++;
|
}
|
return true;
|
}
|
}
|
|
|
public static string ReplaceCoordinatesSection(string text, string content, string str)
|
{
|
string pattern = $@"(\[{content}\]).*?(\[|$)";
|
|
string replacedText = Regex.Replace(text, pattern, match =>
|
{
|
string section = match.Groups[2].Value.Trim();
|
|
if (!string.IsNullOrEmpty(section))
|
{
|
return $"{match.Groups[1].Value}\n{str}\n[";
|
}
|
else
|
{
|
return $"{match.Groups[1].Value}\n{str}\n[";
|
}
|
}, RegexOptions.Singleline);
|
|
return replacedText;
|
}
|
|
}
|
}
|
