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);
}
}
///<summary>Finds length of next time step & updates tank levels and rule-based contol actions.</summary>
protected virtual long NextHyd()
{
long hydstep = 0;
if (_simulationOutput != null)
{
AwareStep.Write(_simulationOutput, this, Htime);
}
if (Htime < net.Duration)
{
hydstep = TimeStep();
}
if (net.Duration == 0)
{
SimulationPump.StepEnergy(net, _epat, _pumps, Htime, 0);
}
else if (Htime < net.Duration)
{
SimulationPump.StepEnergy(net, _epat, _pumps, Htime, hydstep);
}
if (Htime < net.Duration)
{
Htime += hydstep;
if (Htime >= Rtime)
{
Rtime += net.RStep;
}
}
return(hydstep);
}
///<summary>Retrieves hydraulic solution and hydraulic time step for next hydraulic event.</summary>
private void GetHyd(BinaryWriter outStream, HydraulicReader hydSeek)
{
AwareStep step = hydSeek.GetStep(_htime);
LoadHydValues(step);
_htime += step.Step;
if (_htime >= _rtime)
{
SaveOutput(outStream);
_nperiods++;
_rtime += _net.RStep;
}
if (_qualflag != QualType.NONE && _qtime < _net.Duration)
{
if (_reactflag && _qualflag != QualType.AGE)
{
Ratecoeffs();
}
if (_qtime == 0)
{
Initsegs();
}
else
{
Reorientsegs();
}
}
}
public void Simulate(BinaryWriter @out)
{
bool halted = false;
if (_running)
{
throw new InvalidOperationException("Already running");
}
_runningThread = Thread.CurrentThread;
_running = true;
_simulationOutput = @out;
if (_simulationOutput != null)
{
AwareStep.WriteHeader(@out, this, net.RStart, net.RStep, net.Duration);
}
// writeHeader(simulationOutput);
try {
long tstep;
do
{
if (!RunHyd())
{
break;
}
tstep = NextHyd();
if (!_running && tstep > 0)
{
halted = true;
}
}while (_running && tstep > 0);
}
catch (IOException e) {
Debug.Print(e.ToString());
throw new ENException(ErrorCode.Err1000);
}
finally {
_running = false;
_runningThread = null;
}
if (halted)
{
throw new ENException(ErrorCode.Err1000);
}
}
///<summary>Load hydraulic simulation data to the water quality structures.</summary>
private void LoadHydValues(AwareStep step)
{
int count = 0;
foreach (QualityNode qN in _nodes)
{
qN.Demand = step.GetNodeDemand(count++, qN.Node, null);
}
count = 0;
foreach (QualityLink qL in _links)
{
qL.Flow = step.GetLinkFlow(count++, qL.Link, null);
}
}
/// <summary>
/// Retrieves hydraulic solution and time step for next hydraulic event from a hydraulics file.
/// </summary>
private ErrorCodeType GetHydVars()
{
AwareStep step = _tk2.GetStep((int)_msx.Htime);
int n = _msx.Nobjects[(int)ObjectTypes.NODE];
for (int i = 0; i < n; i++)
{
_msx.D[i + 1] = (float)step.GetNodeDemand(i, null, null);
}
for (int i = 0; i < n; i++)
{
_msx.H[i + 1] = (float)step.GetNodeHead(i, null, null);
}
n = _msx.Nobjects[(int)ObjectTypes.LINK];
for (int i = 0; i < n; i++)
{
_msx.Q[i + 1] = (float)step.GetLinkFlow(i, null, null);
}
// update elapsed time until next hydraulic event
_msx.Htime = step.Time + step.Step;
// Initialize pipe segments (at time 0) or else re-orient segments to accommodate any flow reversals
if (_msx.Qtime < _msx.Dur)
{
if (_msx.Qtime == 0)
{
InitSegs();
}
else
{
ReorientSegs();
}
}
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 static void main(string[] args)
{
int i;
var net = new EpanetNetwork();
//Tank
Tank tank = new Tank("0")
{
Elevation = 210
};
net.Nodes.Add(tank);
//Nodes
Node[] node = new Node[7];
for (i = 1; i < 7; i++)
{
node[i] = new Node(i.ToString());
}
node[1].Elevation = 150;
node[1].Demands.Add(new Demand(100, null));
node[2].Elevation = 160;
node[2].Demands.Add(new Demand(100, null));
node[3].Elevation = 155;
node[3].Demands.Add(new Demand(120, null));
node[4].Elevation = 150;
node[4].Demands.Add(new Demand(270, null));
node[5].Elevation = 165;
node[5].Demands.Add(new Demand(330, null));
node[6].Elevation = 160;
node[6].Demands.Add(new Demand(200, null));
//Links
Link[] pipe = new Link[8];
for (i = 0; i < 8; i++)
{
pipe[i] = new Link(i.ToString())
{
Lenght = 1000
};
}
pipe[0].FirstNode = tank;
pipe[0].SecondNode = node[1];
pipe[1].FirstNode = node[1];
pipe[1].SecondNode = node[2];
pipe[2].FirstNode = node[1];
pipe[2].SecondNode = node[3];
pipe[3].FirstNode = node[3];
pipe[3].SecondNode = node[4];
pipe[4].FirstNode = node[3];
pipe[4].SecondNode = node[5];
pipe[5].FirstNode = node[5];
pipe[5].SecondNode = node[6];
pipe[6].FirstNode = node[2];
pipe[6].SecondNode = node[4];
pipe[7].FirstNode = node[4];
pipe[7].SecondNode = node[6];
for (i = 1; i < 7; i++)
{
net.Nodes.Add(node[i]);
}
for (i = 0; i < 8; i++)
{
net.Links.Add(pipe[i]);
}
//Prepare Network
TraceSource log = new TraceSource(typeof(SampleOOPNetwork2).FullName, SourceLevels.All);
NullParser nP = (NullParser)InputParser.Create(FileType.NULL_FILE);
Debug.Assert(nP != null);
nP.Parse(new EpanetNetwork(), null);
//// Simulate hydraulics
string hydFile = Path.GetTempFileName(); // ("hydSim", "bin");
HydraulicSim hydSim = new HydraulicSim(net, log);
hydSim.Simulate(hydFile);
// Read hydraulic results
HydraulicReader hydReader = new HydraulicReader(hydFile);
for (long time = net.RStart; time <= net.Duration; time += net.RStep)
{
AwareStep step = hydReader.GetStep((int)time);
Console.WriteLine("Time : " + step.Time.GetClockTime() + ", nodes heads : ");
i = 0;
foreach (Node inode in net.Nodes)
{
Console.Write("{0:F2}\t", step.GetNodeHead(i++, inode, null));
}
Console.WriteLine();
}
hydReader.Close();
}
public static void main(string[] args)
{
TraceSource log = new TraceSource(typeof(EPATool).FullName, SourceLevels.All);
string hydFile = null;
string qualFile = null;
var net = new EpanetNetwork();
List <NodeVariableType> nodesVariables = new List <NodeVariableType>();
List <LinkVariableType> linksVariables = new List <LinkVariableType>();
string inFile = "";
List <long> targetTimes = new List <long>();
List <string> targetNodes = new List <string>();
List <string> targetLinks = new List <string>();
int parseMode = 0;
foreach (string arg in args)
{
if (arg.EndsWith(".inp", StringComparison.OrdinalIgnoreCase))
{
parseMode = 0;
inFile = arg;
if (!File.Exists(inFile))
{
ConsoleLog("END_RUN_ERR");
Console.Error.WriteLine("File not found !");
return;
}
continue;
}
switch (arg)
{
case "-T":
case "-t":
parseMode = 1;
continue;
case "-N":
case "-n":
parseMode = 2;
continue;
case "-L":
case "-l":
parseMode = 3;
continue;
}
switch (parseMode)
{
case 1:
targetTimes.Add((long)(Utilities.GetHour(arg) * 3600));
break;
case 2:
targetNodes.Add(arg);
break;
case 3:
targetLinks.Add(arg);
break;
}
}
try {
InputParser parserInp = InputParser.Create(FileType.INP_FILE);
net = parserInp.Parse(new EpanetNetwork(), inFile);
if (targetTimes.Count > 0)
{
foreach (long time in targetTimes)
{
string epanetTime = time.GetClockTime();
if (time < net.RStart)
{
throw new Exception("Target time \"" + epanetTime + "\" smaller than simulation start time");
}
if (time > net.Duration)
{
throw new Exception("Target time \"" + epanetTime + "\" bigger than simulation duration");
}
if ((time - net.RStart) % net.RStep != 0)
{
throw new Exception("Target time \"" + epanetTime + "\" not found");
}
}
}
foreach (string nodeName in targetNodes)
{
if (net.GetNode(nodeName) == null)
{
throw new Exception("Node \"" + nodeName + "\" not found");
}
}
foreach (string linkName in targetLinks)
{
if (net.GetLink(linkName) == null)
{
throw new Exception("Link \"" + linkName + "\" not found");
}
}
nodesVariables.Add(NodeVariableType.ELEVATION);
nodesVariables.Add(NodeVariableType.BASEDEMAND);
if (net.QualFlag != QualType.NONE)
{
nodesVariables.Add(NodeVariableType.INITQUALITY);
}
nodesVariables.Add(NodeVariableType.PRESSURE);
nodesVariables.Add(NodeVariableType.HEAD);
nodesVariables.Add(NodeVariableType.DEMAND);
if (net.QualFlag != (QualType.NONE))
{
nodesVariables.Add(NodeVariableType.QUALITY);
}
linksVariables.Add(LinkVariableType.LENGHT);
linksVariables.Add(LinkVariableType.DIAMETER);
linksVariables.Add(LinkVariableType.ROUGHNESS);
linksVariables.Add(LinkVariableType.FLOW);
linksVariables.Add(LinkVariableType.VELOCITY);
linksVariables.Add(LinkVariableType.UNITHEADLOSS);
linksVariables.Add(LinkVariableType.FRICTIONFACTOR);
if (net.QualFlag != QualType.NONE)
{
linksVariables.Add(LinkVariableType.QUALITY);
}
hydFile = Path.GetTempFileName(); // "hydSim.bin"
ConsoleLog("START_RUNNING");
HydraulicSim hydSim = new HydraulicSim(net, log);
hydSim.Simulate(hydFile);
if (net.QualFlag != QualType.NONE)
{
qualFile = Path.GetTempFileName(); // "qualSim.bin"
QualitySim q = new QualitySim(net, log);
q.Simulate(hydFile, qualFile);
}
HydraulicReader hydReader = new HydraulicReader(new BinaryReader(File.OpenRead(hydFile)));
StreamWriter nodesTextWriter = null;
StreamWriter linksTextWriter = null;
string nodesOutputFile = null;
if (targetNodes.Count == 0 && targetLinks.Count == 0 || targetNodes.Count > 0)
{
nodesOutputFile = Path.GetFullPath(inFile) + ".nodes.out";
nodesTextWriter = new StreamWriter(nodesOutputFile, false, Encoding.UTF8);
nodesTextWriter.Write('\t');
foreach (NodeVariableType nodeVar in nodesVariables)
{
nodesTextWriter.Write('\t');
nodesTextWriter.Write(nodeVar.ToString());
}
nodesTextWriter.Write("\n\t");
foreach (NodeVariableType nodeVar in nodesVariables)
{
nodesTextWriter.Write('\t');
nodesTextWriter.Write(net.FieldsMap.GetField(ToFieldType(nodeVar)).Units);
}
nodesTextWriter.Write('\n');
}
if (targetNodes.Count == 0 && targetLinks.Count == 0 || targetLinks.Count > 0)
{
string linksOutputFile = Path.GetFullPath(inFile) + ".links.out";
linksTextWriter = new StreamWriter(linksOutputFile, false, Encoding.UTF8);
linksTextWriter.Write('\t');
foreach (LinkVariableType linkVar in linksVariables)
{
linksTextWriter.Write('\t');
linksTextWriter.Write(linkVar.ToString());
}
linksTextWriter.Write("\n\t");
foreach (LinkVariableType linkVar in linksVariables)
{
linksTextWriter.Write('\t');
if (linkVar < 0)
{
continue;
}
linksTextWriter.Write(net.FieldsMap.GetField((FieldType)linkVar).Units);
}
linksTextWriter.Write('\n');
}
for (long time = net.RStart; time <= net.Duration; time += net.RStep)
{
AwareStep step = hydReader.GetStep((int)time);
int i = 0;
if (targetTimes.Count > 0 && !targetTimes.Contains(time))
{
continue;
}
if (nodesTextWriter != null)
{
foreach (Node node in net.Nodes)
{
if (targetNodes.Count > 0 && !targetNodes.Contains(node.Name))
{
continue;
}
nodesTextWriter.Write(node.Name);
nodesTextWriter.Write('\t');
nodesTextWriter.Write(time.GetClockTime());
foreach (NodeVariableType nodeVar in nodesVariables)
{
nodesTextWriter.Write('\t');
double val = GetNodeValue(nodeVar, net.FieldsMap, step, node, i);
nodesTextWriter.Write(ConvertToScientifcNotation(val, 1000, 0.01, 2));
}
nodesTextWriter.Write('\n');
i++;
}
}
i = 0;
if (linksTextWriter != null)
{
foreach (Link link in net.Links)
{
if (targetLinks.Count > 0 && !targetLinks.Contains(link.Name))
{
continue;
}
linksTextWriter.Write(link.Name);
linksTextWriter.Write('\t');
linksTextWriter.Write(time.GetClockTime());
foreach (LinkVariableType linkVar in linksVariables)
{
linksTextWriter.Write('\t');
double val = GetLinkValue(
linkVar,
net.FormFlag,
net.FieldsMap,
step,
link,
i);
linksTextWriter.Write(ConvertToScientifcNotation(val, 1000, 0.01, 2));
}
linksTextWriter.Write('\n');
i++;
}
}
}
if (nodesTextWriter != null)
{
nodesTextWriter.Close();
ConsoleLog("NODES FILE \"" + nodesOutputFile + "\"");
}
if (linksTextWriter != null)
{
linksTextWriter.Close();
ConsoleLog("LINKS FILES \"" + nodesOutputFile + "\"");
}
ConsoleLog("END_RUN_OK");
}
catch (ENException e) {
ConsoleLog("END_RUN_ERR");
Debug.Print(e.ToString());
}
catch (IOException e) {
ConsoleLog("END_RUN_ERR");
Debug.Print(e.ToString());
}
catch (Exception e) {
ConsoleLog("END_RUN_ERR");
Debug.Print(e.ToString());
}
if (!string.IsNullOrEmpty(hydFile))
{
File.Delete(hydFile);
}
if (!string.IsNullOrEmpty(qualFile))
{
File.Delete(qualFile);
}
}
