private static double GetNodeValue(NodeVariableType type, FieldsMap fmap, AwareStep step, Node node, int index)
{
switch (type)
{
case NodeVariableType.BASEDEMAND: {
double dsum = node.Demands.Sum(demand => demand.Base);
return(fmap.RevertUnit((FieldType)type, dsum));
}
case NodeVariableType.ELEVATION:
return(fmap.RevertUnit((FieldType)type, node.Elevation));
case NodeVariableType.DEMAND:
return(step != null?step.GetNodeDemand(index, node, fmap) : 0);
case NodeVariableType.HEAD:
return(step != null?step.GetNodeHead(index, node, fmap) : 0);
case NodeVariableType.INITQUALITY:
return(fmap.RevertUnit((FieldType)type, node.C0));
case NodeVariableType.PRESSURE:
return(step != null?step.GetNodePressure(index, node, fmap) : 0);
case NodeVariableType.QUALITY:
return(step != null?step.GetNodeQuality(index) : 0);
default:
return(0.0);
}
}
private void ComposeValves()
{
var valves = _net.Valves.ToArray();
if (valves.Length == 0)
{
return;
}
FieldsMap fMap = _net.FieldsMap;
_writer.WriteStartElement(SectType.VALVES.ToString().ToLower());
foreach (Valve valve in valves)
{
double d = valve.Diameter;
double kc = double.IsNaN(valve.Kc) ? 0.0 : valve.Kc;
switch (valve.Type)
{
case LinkType.FCV:
kc = fMap.RevertUnit(FieldType.FLOW, kc);
break;
case LinkType.PRV:
case LinkType.PSV:
case LinkType.PBV:
kc = fMap.RevertUnit(FieldType.PRESSURE, kc);
break;
}
double km = valve.Km * Math.Pow(d, 4) / 0.02517;
_writer.WriteStartElement("link");
_writer.WriteAttributeString("name", valve.Name);
_writer.WriteAttributeString("node1", valve.FirstNode.Name);
_writer.WriteAttributeString("node2", valve.SecondNode.Name);
_writer.WriteAttributeString("diameter", XmlConvert.ToString(fMap.RevertUnit(FieldType.DIAM, d)));
_writer.WriteAttributeString("type", valve.Type.ParseStr());
if (valve.Type == LinkType.GPV && valve.Curve != null)
{
_writer.WriteAttributeString("setting", valve.Curve.Name);
}
else
{
_writer.WriteAttributeString("setting", XmlConvert.ToString(kc));
}
_writer.WriteAttributeString("minorloss", XmlConvert.ToString(km));
ComposeElement(valve);
ComposeVertices(valve);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
private void ComposePipes()
{
var pipes = _net.Links.Where(x => x.Type == LinkType.PIPE || x.Type == LinkType.CV).ToArray();
if (pipes.Length == 0)
{
return;
}
FieldsMap fMap = _net.FieldsMap;
_writer.WriteStartElement(SectType.PIPES.ToString().ToLower());
foreach (Link link in pipes)
{
double d = link.Diameter;
double kc = link.Kc;
if (_net.FormFlag == FormType.DW)
{
kc = fMap.RevertUnit(FieldType.ELEV, kc * 1000.0);
}
double km = link.Km * Math.Pow(d, 4.0) / 0.02517;
_writer.WriteStartElement("link");
_writer.WriteAttributeString("name", link.Name);
_writer.WriteAttributeString("node1", link.FirstNode.Name);
_writer.WriteAttributeString("node2", link.SecondNode.Name);
_writer.WriteAttributeString("length", XmlConvert.ToString(fMap.RevertUnit(FieldType.LENGTH, link.Lenght)));
_writer.WriteAttributeString("diameter", XmlConvert.ToString(fMap.RevertUnit(FieldType.DIAM, d)));
_writer.WriteAttributeString("roughness", XmlConvert.ToString(kc));
_writer.WriteAttributeString("minorloss", XmlConvert.ToString(km));
if (link.Type == LinkType.CV)
{
_writer.WriteAttributeString("status", LinkType.CV.ToString());
}
else if (link.Status == StatType.CLOSED)
{
_writer.WriteAttributeString("status", StatType.CLOSED.ToString());
}
else if (link.Status == StatType.OPEN)
{
_writer.WriteAttributeString("status", StatType.OPEN.ToString());
}
ComposeVertices(link);
ComposeElement(link);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
public float ENgetnodevalue(int index, int code)
{
double v;
FieldsMap fMap = _net.FieldsMap;
if (index <= 0 || index > _nodes.Count)
{
return(203);
}
Tank tank;
switch (code)
{
case EN_INITVOLUME:
v = 0.0;
tank = _nodes[index - 1] as Tank;
if (tank != null)
{
v = fMap.RevertUnit(FieldType.VOLUME, tank.V0);
}
break;
case EN_MIXMODEL:
v = (double)Enums.MixType.MIX1;
tank = _nodes[index - 1] as Tank;
if (tank != null)
{
v = (double)tank.MixModel;
}
break;
case EN_MIXZONEVOL:
v = 0.0;
tank = _nodes[index - 1] as Tank;
if (tank != null)
{
v = fMap.RevertUnit(FieldType.VOLUME, tank.V1Max);
}
break;
default:
throw new ENException(ErrorCode.Err251);
}
return((float)v);
}
private void ComposeReservoirs(Network net)
{
FieldsMap fMap = net.FieldsMap;
if (!net.Reservoirs.Any())
{
return;
}
buffer.WriteLine(SectType.RESERVOIRS.ParseStr());
buffer.WriteLine(RESERVOIRS_SUBTITLE);
foreach (Tank tank in net.Reservoirs)
{
buffer.Write(" {0}\t{1}", tank.Name, fMap.RevertUnit(FieldType.ELEV, tank.Elevation));
if (tank.Pattern != null)
{
buffer.Write("\t{0}", tank.Pattern.Name);
}
if (!string.IsNullOrEmpty(tank.Comment))
{
buffer.Write("\t;" + tank.Comment);
}
buffer.WriteLine();
}
buffer.WriteLine();
}
private void ComposeQuality()
{
FieldsMap fmap = _net.FieldsMap;
if (_net.Nodes.Count == 0)
{
return;
}
_writer.WriteStartElement(SectType.QUALITY.ToString().ToLower());
foreach (Node node in _net.Nodes)
{
if (node.C0 == 0.0)
{
continue;
}
_writer.WriteStartElement("node");
_writer.WriteAttributeString("name", node.Name);
_writer.WriteAttributeString("value", XmlConvert.ToString(fmap.RevertUnit(FieldType.QUALITY, node.C0)));
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
public double GetLinkHeadLoss(int id, Link link, FieldsMap fMap)
{
try {
if (GetLinkFlow(id, link, null) == 0)
{
return(0.0);
}
else
{
double hh = _dh[id];
if (!(link is Pump))
{
hh = Math.Abs(hh);
}
if (link.Type <= LinkType.PIPE)
{
return(1000 * hh / link.Lenght);
}
else
{
return(fMap != null?fMap.RevertUnit(FieldType.HEADLOSS, hh) : hh);
}
}
}
catch (ENException) {
return(0);
}
}
public double GetLinkFlow(int id, Link link, FieldsMap fMap)
{
try {
return(fMap != null?fMap.RevertUnit(FieldType.FLOW, _q[id]) : _q[id]);
}
catch (ENException) {
return(0);
}
}
public double GetNodeHead(int id, Node node, FieldsMap fMap)
{
try {
return(fMap != null?fMap.RevertUnit(FieldType.HEAD, _h[id]) : _h[id]);
}
catch (ENException) {
return(0);
}
}
public double GetNodeDemand(int id, Node node, FieldsMap fMap)
{
try {
return(fMap != null?fMap.RevertUnit(FieldType.DEMAND, _d[id]) : _d[id]);
}
catch (ENException) {
return(0);
}
}
public float ENgetlinkvalue(int index, int code)
{
FieldsMap fMap = _net.FieldsMap;
double v;
if (index <= 0 || index > _links.Count)
{
throw new ENException(ErrorCode.Err204);
}
var link = _links[index - 1];
switch (code)
{
case EN_DIAMETER:
v = link is Pump
? 0.0
: fMap.RevertUnit(FieldType.DIAM, link.Diameter);
break;
case EN_LENGTH:
v = fMap.RevertUnit(FieldType.ELEV, link.Lenght);
break;
case EN_ROUGHNESS:
if (link.Type <= LinkType.PIPE)
{
v = _net.FormFlag == FormType.DW
? fMap.RevertUnit(FieldType.ELEV, link.Kc * 1000.00)
: link.Kc;
}
else
{
v = 0.0;
}
break;
default:
throw new ENException(ErrorCode.Err251);
}
return((float)v);
}
private void ComposeJunctions(Network net)
{
FieldsMap fMap = net.FieldsMap;
if (!net.Junctions.Any())
{
return;
}
buffer.WriteLine(SectType.JUNCTIONS.ParseStr());
buffer.WriteLine(JUNCS_SUBTITLE);
foreach (Node node in net.Junctions)
{
buffer.Write(" {0}\t{1}", node.Name, fMap.RevertUnit(FieldType.ELEV, node.Elevation));
//if(node.getDemand()!=null && node.getDemand().size()>0 && !node.getDemand()[0].getPattern().getId().equals(""))
// buffer.write("\t"+node.getDemand()[0].getPattern().getId());
if (node.Demands.Count > 0)
{
Demand demand = node.Demands[0];
buffer.Write("\t{0}", fMap.RevertUnit(FieldType.DEMAND, demand.Base));
if (!string.IsNullOrEmpty(demand.pattern.Name) &&
!net.DefPatId.Equals(demand.pattern.Name, StringComparison.OrdinalIgnoreCase))
{
buffer.Write("\t" + demand.pattern.Name);
}
}
if (!string.IsNullOrEmpty(node.Comment))
{
buffer.Write("\t;" + node.Comment);
}
buffer.WriteLine();
}
buffer.WriteLine();
}
public double GetNodePressure(int id, Node node, FieldsMap fMap)
{
try {
double p = (GetNodeHead(id, node, null) - node.Elevation);
return(fMap != null?fMap.RevertUnit(FieldType.PRESSURE, p) : p);
}
catch (ENException) {
return(0);
}
}
private static double GetLinkValue(
LinkVariableType type,
FormType formType,
FieldsMap fmap,
AwareStep step,
Link link,
int index)
{
switch (type)
{
case LinkVariableType.LENGHT:
return(fmap.RevertUnit((FieldType)type, link.Lenght));
case LinkVariableType.DIAMETER:
return(fmap.RevertUnit((FieldType)type, link.Diameter));
case LinkVariableType.ROUGHNESS:
return(link.Type == LinkType.PIPE && formType == FormType.DW
? fmap.RevertUnit(FieldType.DIAM, link.Kc)
: link.Kc);
case LinkVariableType.FLOW:
return(step != null?Math.Abs(step.GetLinkFlow(index, link, fmap)) : 0);
case LinkVariableType.VELOCITY:
return(step != null?Math.Abs(step.GetLinkVelocity(index, link, fmap)) : 0);
case LinkVariableType.UNITHEADLOSS:
return(step != null?step.GetLinkHeadLoss(index, link, fmap) : 0);
case LinkVariableType.FRICTIONFACTOR:
return(step != null?step.GetLinkFriction(index, link, fmap) : 0);
case LinkVariableType.QUALITY:
return(step != null?fmap.RevertUnit((FieldType)type, step.GetLinkAvrQuality(index)) : 0);
default:
return(0.0);
}
}
public double GetLinkVelocity(int id, Link link, FieldsMap fMap)
{
try {
double v;
double flow = GetLinkFlow(id, link, null);
if (link is Pump)
{
v = 0;
}
else
{
v = (Math.Abs(flow) / (Math.PI * Math.Pow(link.Diameter, 2) / 4.0));
}
return(fMap != null?fMap.RevertUnit(FieldType.VELOCITY, v) : v);
}
catch (ENException) {
return(0);
}
}
private void ComposeQuality(Network net)
{
FieldsMap fmap = net.FieldsMap;
if (net.Nodes.Count == 0)
{
return;
}
buffer.WriteLine(SectType.QUALITY.ParseStr());
buffer.WriteLine(QUALITY_SUBTITLE);
foreach (Node node in net.Nodes)
{
if (node.C0 == 0.0)
{
continue;
}
buffer.WriteLine(" {0}\t{1}", node.Name, fmap.RevertUnit(FieldType.QUALITY, node.C0));
}
buffer.WriteLine();
}
public double GetLinkFriction(int id, Link link, FieldsMap fMap)
{
try {
double f;
double flow = GetLinkFlow(id, link, null);
if (link.Type <= LinkType.PIPE && Math.Abs(flow) > Constants.TINY)
{
double hh = Math.Abs(_dh[id]);
f = 39.725 * hh * Math.Pow(link.Diameter, 5) / link.Lenght /
(flow * flow);
}
else
{
f = 0;
}
return(fMap != null?fMap.RevertUnit(FieldType.FRICTION, f) : f);
}
catch (ENException) {
return(0);
}
}
private void ComposeTanks(Network net)
{
FieldsMap fMap = net.FieldsMap;
if (!net.Tanks.Any())
{
return;
}
buffer.WriteLine(SectType.TANKS.ParseStr());
buffer.WriteLine(TANK_SUBTITLE);
foreach (Tank tank in net.Tanks)
{
double vmin = tank.Vmin;
if (Math.Round(vmin / tank.Area) == Math.Round(tank.Hmin - tank.Elevation))
{
vmin = 0;
}
buffer.Write(
" {0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}",
tank.Name,
fMap.RevertUnit(FieldType.ELEV, tank.Elevation),
fMap.RevertUnit(FieldType.ELEV, tank.H0 - tank.Elevation),
fMap.RevertUnit(FieldType.ELEV, tank.Hmin - tank.Elevation),
fMap.RevertUnit(FieldType.ELEV, tank.Hmax - tank.Elevation),
fMap.RevertUnit(FieldType.ELEV, 2 * Math.Sqrt(tank.Area / Math.PI)),
fMap.RevertUnit(FieldType.VOLUME, vmin));
if (tank.Vcurve != null)
{
buffer.Write(" " + tank.Vcurve.Name);
}
if (!string.IsNullOrEmpty(tank.Comment))
{
buffer.Write("\t;" + tank.Comment);
}
buffer.WriteLine();
}
buffer.WriteLine();
}
private void ComposeReservoirs()
{
if (!_net.Reservoirs.Any())
{
return;
}
FieldsMap fMap = _net.FieldsMap;
_writer.WriteStartElement(SectType.RESERVOIRS.ToString().ToLower());
foreach (Tank r in _net.Reservoirs)
{
_writer.WriteStartElement("node");
_writer.WriteAttributeString("name", r.Name);
_writer.WriteAttributeString("head", XmlConvert.ToString(fMap.RevertUnit(FieldType.ELEV, r.Elevation)));
if (r.Pattern != null)
{
_writer.WriteAttributeString("pattern", r.Pattern.Name);
}
if (!r.Position.IsInvalid)
{
_writer.WriteAttributeString("x", XmlConvert.ToString(r.Position.X));
_writer.WriteAttributeString("y", XmlConvert.ToString(r.Position.Y));
}
ComposeElement(r);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
private void ComposeOptions()
{
FieldsMap fMap = _net.FieldsMap;
_writer.WriteStartElement(SectType.OPTIONS.ToString().ToLower());
WriteOption("units", _net.FlowFlag.ParseStr());
WriteOption("pressure", _net.PressFlag.ParseStr());
WriteOption("headloss", _net.FormFlag.ParseStr());
if (!string.IsNullOrEmpty(_net.DefPatId))
{
WriteOption("pattern", _net.DefPatId);
}
switch (_net.HydFlag)
{
case HydType.USE:
WriteOption("hydraulics use", _net.HydFname);
break;
case HydType.SAVE:
WriteOption("hydraulics save", _net.HydFname);
break;
}
if (_net.ExtraIter == -1)
{
WriteOption("unbalanced stop", "");
}
else if (_net.ExtraIter >= 0)
{
WriteOption("unbalanced continue", _net.ExtraIter.ToString());
}
switch (_net.QualFlag)
{
case QualType.CHEM:
_writer.WriteStartElement("option");
_writer.WriteAttributeString("name", "quality");
_writer.WriteAttributeString("value", "chem");
_writer.WriteAttributeString("chemname", _net.ChemName);
_writer.WriteAttributeString("chemunits", _net.ChemUnits);
_writer.WriteEndElement();
break;
case QualType.TRACE:
_writer.WriteStartElement("option");
_writer.WriteAttributeString("name", "quality");
_writer.WriteAttributeString("value", "trace");
_writer.WriteAttributeString("node", _net.TraceNode);
_writer.WriteEndElement();
break;
case QualType.AGE:
WriteOption("quality", "age");
break;
case QualType.NONE:
WriteOption("quality", "none");
break;
}
WriteOption("demand_multiplier", XmlConvert.ToString(_net.DMult));
WriteOption("emitter_exponent", XmlConvert.ToString(1.0 / _net.QExp));
WriteOption("viscosity", XmlConvert.ToString(_net.Viscos / Constants.VISCOS));
WriteOption("diffusivity", XmlConvert.ToString(_net.Diffus / Constants.DIFFUS));
WriteOption("specific_gravity", XmlConvert.ToString(_net.SpGrav));
WriteOption("trials", _net.MaxIter.ToString());
WriteOption("accuracy", _net.HAcc.ToString(CultureInfo.InvariantCulture));
WriteOption("tolerance", fMap.RevertUnit(FieldType.QUALITY, _net.Ctol).ToString(CultureInfo.InvariantCulture));
WriteOption("checkfreq", _net.CheckFreq.ToString());
WriteOption("maxcheck", _net.MaxCheck.ToString());
WriteOption("damplimit", _net.DampLimit.ToString(CultureInfo.InvariantCulture));
ComposeExtraOptions();
_writer.WriteEndElement();
}
/// <summary>Get link quality values in user units.</summary>
/// <param name="id">Link sequential identification number.</param>
/// <returns>Species concentration, trace or age value in user units.</returns>
public float GetLinkQuality(int id)
{
return((float)fld.RevertUnit(FieldType.QUALITY, linkQ[id]));
}
private void ComposeControls()
{
var controls = _net.Controls;
FieldsMap fmap = _net.FieldsMap;
if (controls.Count == 0)
{
return;
}
_writer.WriteStartElement(SectType.CONTROLS.ToString().ToLower());
foreach (Control control in controls)
{
// Check that controlled link exists
if (control.Link == null)
{
continue;
}
_writer.WriteStartElement("control");
// Get text of control's link status/setting
if (double.IsNaN(control.Setting))
{
_writer.WriteAttributeString("link", control.Link.Name);
_writer.WriteAttributeString("status", control.Status.ToString());
}
else
{
double kc = control.Setting;
switch (control.Link.Type)
{
case LinkType.PRV:
case LinkType.PSV:
case LinkType.PBV:
kc = fmap.RevertUnit(FieldType.PRESSURE, kc);
break;
case LinkType.FCV:
kc = fmap.RevertUnit(FieldType.FLOW, kc);
break;
}
_writer.WriteAttributeString("link", control.Link.Name);
_writer.WriteAttributeString("status", XmlConvert.ToString(kc));
}
switch (control.Type)
{
// Print level control
case ControlType.LOWLEVEL:
case ControlType.HILEVEL:
double kc = control.Grade - control.Node.Elevation;
kc = fmap.RevertUnit(control.Node.Type == NodeType.JUNC ? FieldType.PRESSURE : FieldType.HEAD, kc);
_writer.WriteAttributeString("type", control.Type.ParseStr());
_writer.WriteAttributeString("node", control.Node.Name);
_writer.WriteAttributeString("value", XmlConvert.ToString(kc));
break;
case ControlType.TIMER:
case ControlType.TIMEOFDAY:
// Print timer control
// Print time-of-day control
_writer.WriteAttributeString("type", control.Type.ParseStr());
_writer.WriteAttributeString("value", XmlConvert.ToString(control.Time));
break;
}
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
/// <summary>Write simulation summary to one worksheet.</summary>
/// <param name="inpFile">Hydraulic network file name.</param>
/// <param name="net">Hydraulic network.</param>
/// <param name="msxFile">MSX file.</param>
/// <param name="msx">MSX solver.</param>
public void WriteSummary(string inpFile, EpanetNetwork net, string msxFile, EpanetMSX msx)
{
var sh = _sheet.NewSpreadsheet("Summary");
try {
FieldsMap fMap = net.FieldsMap;
if (net.Title != null)
{
for (int i = 0; i < net.Title.Count && i < 3; i++)
{
if (!string.IsNullOrEmpty(net.Title[i]))
{
sh.AddData(
net.Title[i].Length > 70
? net.Title[i].Substring(0, 70)
: net.Title[i]);
}
}
}
sh.AddData("\n");
sh.AddData(Text.FMT19, inpFile);
sh.AddData(Text.FMT20, net.Junctions.Count());
int nReservoirs = net.Reservoirs.Count();
int nTanks = net.Tanks.Count();
int nValves = net.Valves.Count();
int nPumps = net.Pumps.Count();
int nPipes = net.Links.Count - nPumps - nValves;
sh.AddData(Text.FMT21a, nReservoirs);
sh.AddData(Text.FMT21b, nTanks);
sh.AddData(Text.FMT22, nPipes);
sh.AddData(Text.FMT23, nPumps);
sh.AddData(Text.FMT24, nValves);
sh.AddData(Text.FMT25, net.FormFlag.ParseStr());
sh.AddData(Text.FMT26, net.HStep.GetClockTime());
sh.AddData(Text.FMT27, net.HAcc);
sh.AddData(Text.FMT27a, net.CheckFreq);
sh.AddData(Text.FMT27b, net.MaxCheck);
sh.AddData(Text.FMT27c, net.DampLimit);
sh.AddData(Text.FMT28, net.MaxIter);
switch (net.Duration == 0 ? QualType.NONE : net.QualFlag)
{
case QualType.NONE:
sh.AddData(Text.FMT29, "None");
break;
case QualType.CHEM:
sh.AddData(Text.FMT30, net.ChemName);
break;
case QualType.TRACE:
sh.AddData(Text.FMT31, "Trace From Node", net.GetNode(net.TraceNode).Name);
break;
case QualType.AGE:
sh.AddData(Text.FMT32, "Age");
break;
}
if (net.QualFlag != QualType.NONE && net.Duration > 0)
{
sh.AddData(Text.FMT33, "Time Step", net.QStep.GetClockTime());
sh.AddData(
Text.FMT34,
"Tolerance",
fMap.RevertUnit(FieldType.QUALITY, net.Ctol),
fMap.GetField(FieldType.QUALITY).Units);
}
sh.AddData(Text.FMT36, net.SpGrav);
sh.AddData(Text.FMT37a, net.Viscos / Constants.VISCOS);
sh.AddData(Text.FMT37b, net.Diffus / Constants.DIFFUS);
sh.AddData(Text.FMT38, net.DMult);
sh.AddData(
Text.FMT39,
fMap.RevertUnit(FieldType.TIME, net.Duration),
fMap.GetField(FieldType.TIME).Units);
if (msxFile != null && msx != null)
{
sh.AddData("");
sh.AddData("MSX data file", msxFile);
sh.AddData("Species");
Species[] spe = msx.Network.Species;
for (int i = 1; i < msx.Network.Species.Length; i++)
{
sh.AddData(spe[i].Id, spe[i].Units);
}
}
}
catch (IOException) {}
catch (ENException e) {
Debug.Print(e.ToString());
}
}
private void ComposePumps()
{
var pumps = _net.Pumps.ToArray();
if (pumps.Length == 0)
{
return;
}
FieldsMap fMap = _net.FieldsMap;
_writer.WriteStartElement(SectType.PUMPS.ToString().ToLower());
foreach (Pump pump in pumps)
{
_writer.WriteStartElement("link");
_writer.WriteAttributeString("name", pump.Name);
_writer.WriteAttributeString("node1", pump.FirstNode.Name);
_writer.WriteAttributeString("node2", pump.SecondNode.Name);
bool oldFormat = false;
if (pump.Ptype == PumpType.CONST_HP)
{
// Pump has constant power
_writer.WriteAttributeString("power", XmlConvert.ToString(pump.Km));
}
else if (pump.HCurve != null)
{
// Pump has a head curve
_writer.WriteAttributeString("head", pump.HCurve.Name);
}
else
{
// Old format used for pump curve
_writer.WriteAttributeString("h0", XmlConvert.ToString(fMap.RevertUnit(FieldType.HEAD, -pump.H0)));
_writer.WriteAttributeString("h1", XmlConvert.ToString(fMap.RevertUnit(FieldType.HEAD, -pump.H0 - pump.FlowCoefficient * Math.Pow(pump.Q0, pump.N))));
_writer.WriteAttributeString("q1", XmlConvert.ToString(fMap.RevertUnit(FieldType.FLOW, pump.Q0)));
_writer.WriteAttributeString("h2", XmlConvert.ToString(0.0));
_writer.WriteAttributeString("q2", XmlConvert.ToString(fMap.RevertUnit(FieldType.FLOW, pump.Qmax)));
oldFormat = true;
}
if (!oldFormat)
{
if (pump.UPat != null)
{
_writer.WriteAttributeString("pattern", pump.UPat.Name);
}
if (pump.Kc != 1.0)
{
_writer.WriteAttributeString("speed", XmlConvert.ToString(pump.Kc));
}
}
ComposeElement(pump);
ComposeVertices(pump);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
private void ComposePipes(Network net)
{
FieldsMap fMap = net.FieldsMap;
if (net.Links.Count == 0)
{
return;
}
List <Link> pipes = new List <Link>();
foreach (Link link in net.Links)
{
if (link.Type == LinkType.PIPE || link.Type == LinkType.CV)
{
pipes.Add(link);
}
}
buffer.WriteLine(SectType.PIPES.ParseStr());
buffer.WriteLine(PIPES_SUBTITLE);
foreach (Link link in pipes)
{
double d = link.Diameter;
double kc = link.Kc;
if (net.FormFlag == FormType.DW)
{
kc = fMap.RevertUnit(FieldType.ELEV, kc * 1000.0);
}
double km = link.Km * Math.Pow(d, 4.0) / 0.02517;
buffer.Write(
" {0}\t{1}\t{2}\t{3}\t{4}",
link.Name,
link.FirstNode.Name,
link.SecondNode.Name,
fMap.RevertUnit(FieldType.LENGTH, link.Lenght),
fMap.RevertUnit(FieldType.DIAM, d));
// if (net.FormFlag == FormType.DW)
buffer.Write(" {0}\t{1}", kc, km);
if (link.Type == LinkType.CV)
{
buffer.Write(" CV");
}
else if (link.Status == StatType.CLOSED)
{
buffer.Write(" CLOSED");
}
else if (link.Status == StatType.OPEN)
{
buffer.Write(" OPEN");
}
if (!string.IsNullOrEmpty(link.Comment))
{
buffer.Write("\t;" + link.Comment);
}
buffer.WriteLine();
}
buffer.WriteLine();
}
private void ComposeTanks()
{
if (!_net.Tanks.Any())
{
return;
}
FieldsMap fMap = _net.FieldsMap;
_writer.WriteStartElement(SectType.TANKS.ToString().ToLower());
foreach (Tank tank in _net.Tanks)
{
double vmin = tank.Vmin;
if (Math.Round(vmin / tank.Area) == Math.Round(tank.Hmin - tank.Elevation))
{
vmin = 0;
}
double elev = fMap.RevertUnit(FieldType.ELEV, tank.Elevation);
double initlvl = fMap.RevertUnit(FieldType.ELEV, tank.H0 - tank.Elevation);
double minlvl = fMap.RevertUnit(FieldType.ELEV, tank.Hmin - tank.Elevation);
double maxlvl = fMap.RevertUnit(FieldType.ELEV, tank.Hmax - tank.Elevation);
double diam = fMap.RevertUnit(FieldType.ELEV, 2 * Math.Sqrt(tank.Area / Math.PI));
double minvol = fMap.RevertUnit(FieldType.VOLUME, vmin);
_writer.WriteStartElement("node");
_writer.WriteAttributeString("name", tank.Name);
_writer.WriteAttributeString("elevation", XmlConvert.ToString(elev));
_writer.WriteAttributeString("InitLevel", XmlConvert.ToString(initlvl));
_writer.WriteAttributeString("MinLevel", XmlConvert.ToString(minlvl));
_writer.WriteAttributeString("MaxLevel", XmlConvert.ToString(maxlvl));
_writer.WriteAttributeString("diameter", XmlConvert.ToString(diam));
_writer.WriteAttributeString("MinVolume", XmlConvert.ToString(minvol));
if (tank.Vcurve != null)
{
_writer.WriteAttributeString("volcurve", tank.Vcurve.Name);
}
if (!tank.Position.IsInvalid)
{
_writer.WriteAttributeString("x", XmlConvert.ToString(tank.Position.X));
_writer.WriteAttributeString("y", XmlConvert.ToString(tank.Position.Y));
}
if (tank.MixModel != MixType.MIX1)
{
_writer.WriteStartElement(SectType.MIXING.ToString().ToLower());
_writer.WriteAttributeString("model", tank.MixModel.ParseStr());
if (tank.MixModel == MixType.MIX2)
{
_writer.WriteAttributeString("compartment", XmlConvert.ToString(tank.V1Max / tank.Vmax));
}
_writer.WriteEndElement();
}
ComposeElement(tank);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
private void ComposeOptions(Network net)
{
FieldsMap fMap = net.FieldsMap;
buffer.WriteLine(SectType.OPTIONS.ParseStr());
buffer.WriteLine("UNITS " + net.FlowFlag);
buffer.WriteLine("PRESSURE " + net.PressFlag);
buffer.WriteLine("HEADLOSS " + net.FormFlag);
if (!string.IsNullOrEmpty(net.DefPatId))
{
buffer.WriteLine("PATTERN " + net.DefPatId);
}
if (net.HydFlag == HydType.USE)
{
buffer.WriteLine("HYDRAULICS USE " + net.HydFname);
}
if (net.HydFlag == HydType.SAVE)
{
buffer.WriteLine("HYDRAULICS SAVE " + net.HydFname);
}
if (net.ExtraIter == -1)
{
buffer.WriteLine("UNBALANCED STOP");
}
if (net.ExtraIter >= 0)
{
buffer.WriteLine("UNBALANCED CONTINUE " + net.ExtraIter);
}
switch (net.QualFlag)
{
case QualType.CHEM:
buffer.WriteLine("QUALITY {0} {1}", net.ChemName, net.ChemUnits);
break;
case QualType.TRACE:
buffer.WriteLine("QUALITY TRACE " + net.TraceNode);
break;
case QualType.AGE:
buffer.WriteLine("QUALITY AGE");
break;
case QualType.NONE:
buffer.WriteLine("QUALITY NONE");
break;
}
buffer.WriteLine("DEMAND MULTIPLIER {0}", net.DMult);
buffer.WriteLine("EMITTER EXPONENT {0}", 1.0 / net.QExp);
buffer.WriteLine("VISCOSITY {0}", net.Viscos / Constants.VISCOS);
buffer.WriteLine("DIFFUSIVITY {0}", net.Diffus / Constants.DIFFUS);
buffer.WriteLine("SPECIFIC GRAVITY {0}", net.SpGrav);
buffer.WriteLine("TRIALS {0}", net.MaxIter);
buffer.WriteLine("ACCURACY {0}", net.HAcc);
buffer.WriteLine("TOLERANCE {0}", fMap.RevertUnit(FieldType.QUALITY, net.Ctol));
buffer.WriteLine("CHECKFREQ {0}", net.CheckFreq);
buffer.WriteLine("MAXCHECK {0}", net.MaxCheck);
buffer.WriteLine("DAMPLIMIT {0}", net.DampLimit);
buffer.WriteLine();
}
private void ComposePumps(Network net)
{
FieldsMap fMap = net.FieldsMap;
if (!net.Pumps.Any())
{
return;
}
buffer.WriteLine(SectType.PUMPS.ParseStr());
buffer.WriteLine(PUMPS_SUBTITLE);
foreach (Pump pump in net.Pumps)
{
buffer.Write(
" {0}\t{1}\t{2}",
pump.Name,
pump.FirstNode.Name,
pump.SecondNode.Name);
// Pump has constant power
if (pump.Ptype == PumpType.CONST_HP)
{
buffer.Write(" POWER " + pump.Km);
}
// Pump has a head curve
else if (pump.HCurve != null)
{
buffer.Write(" HEAD " + pump.HCurve.Name);
}
// Old format used for pump curve
else
{
buffer.Write(
" {0}\t{1}\t{2}\t0.0\t{3}",
fMap.RevertUnit(FieldType.HEAD, -pump.H0),
fMap.RevertUnit(
FieldType.HEAD,
-pump.H0 - pump.FlowCoefficient * Math.Pow(pump.Q0, pump.N)),
fMap.RevertUnit(FieldType.FLOW, pump.Q0),
fMap.RevertUnit(FieldType.FLOW, pump.Qmax));
continue;
}
if (pump.UPat != null)
{
buffer.Write(" PATTERN " + pump.UPat.Name);
}
if (pump.Kc != 1.0)
{
buffer.Write(" SPEED {0}", pump.Kc);
}
if (!string.IsNullOrEmpty(pump.Comment))
{
buffer.Write("\t;" + pump.Comment);
}
buffer.WriteLine();
}
buffer.WriteLine();
}
private void ComposeControls(Network net)
{
var controls = net.Controls;
FieldsMap fmap = net.FieldsMap;
if (controls.Count == 0)
{
return;
}
buffer.WriteLine(SectType.CONTROLS.ParseStr());
foreach (Control control in controls)
{
// Check that controlled link exists
if (control.Link == null)
{
continue;
}
// Get text of control's link status/setting
if (double.IsNaN(control.Setting))
{
buffer.Write(" LINK {0} {1} ", control.Link.Name, control.Status);
}
else
{
double kc = control.Setting;
switch (control.Link.Type)
{
case LinkType.PRV:
case LinkType.PSV:
case LinkType.PBV:
kc = fmap.RevertUnit(FieldType.PRESSURE, kc);
break;
case LinkType.FCV:
kc = fmap.RevertUnit(FieldType.FLOW, kc);
break;
}
buffer.Write(" LINK {0} {1} ", control.Link.Name, kc);
}
switch (control.Type)
{
// Print level control
case ControlType.LOWLEVEL:
case ControlType.HILEVEL:
double kc = control.Grade - control.Node.Elevation;
kc = fmap.RevertUnit(
control.Node.Type == NodeType.JUNC
? FieldType.PRESSURE
: FieldType.HEAD,
kc);
buffer.Write(
" IF NODE {0} {1} {2}",
control.Node.Name,
control.Type.ParseStr(),
kc);
break;
// Print timer control
case ControlType.TIMER:
buffer.Write(
" AT {0} {1} HOURS",
ControlType.TIMER.ParseStr(),
control.Time / 3600.0f);
break;
// Print time-of-day control
case ControlType.TIMEOFDAY:
buffer.Write(
" AT {0} {1}",
ControlType.TIMEOFDAY.ParseStr(),
control.Time.GetClockTime());
break;
}
buffer.WriteLine();
}
buffer.WriteLine();
}
private void ComposeValves(Network net)
{
FieldsMap fMap = net.FieldsMap;
if (!net.Valves.Any())
{
return;
}
buffer.WriteLine(SectType.VALVES.ParseStr());
buffer.WriteLine(VALVES_SUBTITLE);
foreach (Valve valve in net.Valves)
{
double d = valve.Diameter;
double kc = valve.Kc;
if (double.IsNaN(kc))
{
kc = 0.0;
}
switch (valve.Type)
{
case LinkType.FCV:
kc = fMap.RevertUnit(FieldType.FLOW, kc);
break;
case LinkType.PRV:
case LinkType.PSV:
case LinkType.PBV:
kc = fMap.RevertUnit(FieldType.PRESSURE, kc);
break;
}
double km = valve.Km * Math.Pow(d, 4) / 0.02517;
buffer.Write(
" {0}\t{1}\t{2}\t{3}\t{4}",
valve.Name,
valve.FirstNode.Name,
valve.SecondNode.Name,
fMap.RevertUnit(FieldType.DIAM, d),
valve.Type.ParseStr());
if (valve.Type == LinkType.GPV && valve.Curve != null)
{
buffer.Write(" {0}\t{1}", valve.Curve.Name, km);
}
else
{
buffer.Write(" {0}\t{1}", kc, km);
}
if (!string.IsNullOrEmpty(valve.Comment))
{
buffer.Write("\t;" + valve.Comment);
}
buffer.WriteLine();
}
buffer.WriteLine();
}