epyt-flow 0.14.2__py3-none-any.whl → 0.15.0b1__py3-none-any.whl

epyt_flow/EPANET/EPANET/SRC_engines/input3.c

@@ -1,2170 +0,0 @@
-/*
-******************************************************************************
-Project:      OWA EPANET
-Version:      2.2
-Module:       input3.c
-Description:  parses network data from a line of an EPANET input file
-Authors:      see AUTHORS
-Copyright:    see AUTHORS
-License:      see LICENSE
-Last Updated: 11/29/2019
-******************************************************************************
-*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-
-#include "types.h"
-#include "funcs.h"
-#include "hash.h"
-#include "text.h"
-
-// Defined in ENUMSTXT.H
-extern char *MixTxt[];
-extern char *Fldname[];
-extern char *DemandModelTxt[];
-
-// Exported functions
-int powercurve(double, double, double, double, double, double *, double *,
-               double *);
-
-// Imported Functions
-extern int addnodeID(Network *, int, char *);
-extern int addlinkID(Network *, int, char *);
-
-// Local functions
-static int  optionchoice(Project *, int);
-static int  optionvalue(Project *, int);
-static int  getpumpcurve(Project *, int);
-static void changestatus(Network *, int, StatusType, double);
-static int  setError(Parser *, int, int);
-
-
-int setError(Parser *parser, int tokindex, int errcode)
-/*
-**--------------------------------------------------------------
-**  Input:   tokindex = index of input line token
-**           errcode = an error code
-**  Output:  returns error code
-**  Purpose: records index of token from line of input associated
-**           with an error
-**--------------------------------------------------------------
-*/
-{
-    parser->ErrTok = tokindex;
-    return errcode;
-}
-
-int juncdata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes junction data
-**  Format:
-**    [JUNCTIONS]
-**      id  elev.  (demand)  (demand pattern)
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-    Hydraul *hyd = &pr->hydraul;
-
-    int p = 0;                  // time pattern index
-    int n;                      // number of tokens
-    int njuncs;                 // number of network junction nodes
-    double el,                  // elevation
-           y = 0.0;             // base demand
-    Snode *node;
-    int err = 0;
-
-    // Add new junction to data base
-    n = parser->Ntokens;
-    if (net->Nnodes == parser->MaxNodes) return 200;
-    net->Njuncs++;
-    net->Nnodes++;
-    njuncs = net->Njuncs;
-    err = addnodeID(net, net->Njuncs, parser->Tok[0]);
-    if (err) return setError(parser, 0, err);
-
-    // Check for valid data
-    if (n < 2) return 201;
-    if (!getfloat(parser->Tok[1], &el)) return setError(parser, 1, 202);
-    if (n >= 3 && !getfloat(parser->Tok[2], &y)) return setError(parser, 2, 202);
-    if (n >= 4)
-    {
-        p = findpattern(net, parser->Tok[3]);
-        if (p < 0) return setError(parser, 3, 205);
-    }
-
-    // Save junction data
-    node = &net->Node[njuncs];
-    node->X = MISSING;
-    node->Y = MISSING;
-    node->El = el;
-    node->C0 = 0.0;
-    node->S = NULL;
-    node->Ke = 0.0;
-    node->Rpt = 0;
-    node->ResultIndex = 0;
-    node->Type = JUNCTION;
-    node->Comment = xstrcpy(&node->Comment, parser->Comment, MAXMSG);
-
-    // Create a demand for the junction and use NodeDemand as an indicator
-    // to be used when processing demands from the [DEMANDS] section
-    if (!adddemand(node, y, p, NULL)) return 101;
-    hyd->NodeDemand[njuncs] = y;
-    return 0;
-}
-
-int tankdata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes tank & reservoir data
-**  Format:
-**   [RESERVOIRS]
-**     id elev (pattern)
-**   [TANKS]
-**     id elev (pattern)
-**     id elev initlevel minlevel maxlevel diam (minvol vcurve)
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int    i,               // Node index
-           n,               // # data items
-           pattern = 0,     // Time pattern index
-           curve = 0,       // Curve index
-           overflow = FALSE;// Overflow indicator
-
-    double el = 0.0,        // Elevation
-           initlevel = 0.0, // Initial level
-           minlevel = 0.0,  // Minimum level
-           maxlevel = 0.0,  // Maximum level
-           minvol = 0.0,    // Minimum volume
-           diam = 0.0,      // Diameter
-           area;            // X-sect. area
-    Snode *node;
-    Stank *tank;
-
-    int err = 0;
-
-    // Add new tank to data base
-    n = parser->Ntokens;
-    if (net->Ntanks == parser->MaxTanks ||
-        net->Nnodes == parser->MaxNodes) return 200;
-    net->Ntanks++;
-    net->Nnodes++;
-
-    i = parser->MaxJuncs + net->Ntanks;
-    err = addnodeID(net, i, parser->Tok[0]);
-    if (err) return setError(parser, 0, err);
-
-    // Check for valid data
-    if (n < 2) return 201;
-    if (!getfloat(parser->Tok[1], &el)) return setError(parser, 1, 202);
-
-    // Tank is reservoir
-    if (n <= 3)
-    {
-        // Head pattern supplied
-        if (n == 3)
-        {
-            pattern = findpattern(net, parser->Tok[2]);
-            if (pattern < 0) return setError(parser, 2, 205);
-        }
-    }
-    else if (n < 6) return 201;
-
-    // Tank is a storage tank
-    else
-    {
-        if (!getfloat(parser->Tok[2], &initlevel)) return setError(parser, 2, 202);
-        if (!getfloat(parser->Tok[3], &minlevel))  return setError(parser, 3, 202);
-        if (!getfloat(parser->Tok[4], &maxlevel))  return setError(parser, 4, 202);
-        if (!getfloat(parser->Tok[5], &diam))      return setError(parser, 5, 202);
-        if (n >= 7 && !getfloat(parser->Tok[6], &minvol)) return setError(parser, 6, 202);
-
-        // If volume curve supplied check it exists
-        if (n >= 8)
-        {
-            if (strlen(parser->Tok[7]) > 0 && *(parser->Tok[7]) != '*')
-            {
-                curve = findcurve(net, parser->Tok[7]);
-                if (curve == 0) return setError(parser, 7, 206);
-                net->Curve[curve].Type = VOLUME_CURVE;
-            }
-        }
-
-        // Parse overflow indicator if present
-        if (n >= 9)
-        {
-            if (match(parser->Tok[8], w_YES)) overflow = TRUE;
-            else if (match(parser->Tok[8], w_NO)) overflow = FALSE;
-            else return setError(parser, 8, 213);
-        }
-
-        if (initlevel < 0.0) return setError(parser, 2, 209);
-        if (minlevel  < 0.0) return setError(parser, 3, 209);
-        if (maxlevel  < 0.0) return setError(parser, 4, 209);
-        if (diam      < 0.0) return setError(parser, 5, 209);
-        if (minvol    < 0.0) return setError(parser, 6, 209);
-    }
-    node = &net->Node[i];
-    tank = &net->Tank[net->Ntanks];
-
-    node->X = MISSING;
-    node->Y = MISSING;
-    node->Rpt = 0;
-    node->ResultIndex = 0;
-    node->El = el;
-    node->C0 = 0.0;
-    node->S = NULL;
-    node->Ke = 0.0;
-    node->Type = (diam == 0) ? RESERVOIR : TANK;
-    node->Comment = xstrcpy(&node->Comment, parser->Comment, MAXMSG);
-    tank->Node = i;
-    tank->H0 = initlevel;
-    tank->Hmin = minlevel;
-    tank->Hmax = maxlevel;
-    tank->A = diam;
-    tank->Pat = pattern;
-    tank->Kb = MISSING;
-    tank->CanOverflow = overflow;
-
-    //*******************************************************************
-    // NOTE: The min, max, & initial volumes set here are based on a
-    //    nominal tank diameter. They will be modified in INPUT1.C if
-    //    a volume curve is supplied for this tank.
-    //*******************************************************************
-    area = PI * SQR(diam) / 4.0;
-    tank->Vmin = area * minlevel;
-    if (minvol > 0.0) tank->Vmin = minvol;
-    tank->V0 = tank->Vmin + area * (initlevel - minlevel);
-    tank->Vmax = tank->Vmin + area * (maxlevel - minlevel);
-
-    tank->Vcurve = curve;
-    tank->MixModel = MIX1; // Completely mixed
-    tank->V1max = 1.0;     // Mixing compartment size fraction
-    return 0;
-}
-
-int pipedata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes pipe data
-**  Format:
-**    [PIPE]
-**    id  node1  node2  length  diam  rcoeff (lcoeff) (status)
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int      j1,               // Start-node index
-             j2,               // End-node index
-             n;                // # data items
-    double   length,           // Pipe length
-             diam,             // Pipe diameter
-             rcoeff,           // Roughness coeff.
-             lcoeff = 0.0;     // Minor loss coeff
-    LinkType type = PIPE;      // Link type
-    StatusType status = OPEN;  // Link status
-    Slink *link;
-    int err = 0;
-
-    // Add new pipe to data base
-    n = parser->Ntokens;
-    if (net->Nlinks == parser->MaxLinks) return 200;
-    net->Npipes++;
-    net->Nlinks++;
-    err = addlinkID(net, net->Nlinks, parser->Tok[0]);
-    if (err) return setError(parser, 0, err);
-
-    // Check for valid data
-    if (n < 6) return 201;
-    if ((j1 = findnode(net, parser->Tok[1])) == 0) return setError(parser, 1, 203);
-    if ((j2 = findnode(net, parser->Tok[2])) == 0) return setError(parser, 2, 203);
-    if (j1 == j2) return setError(parser, 0, 222);
-
-    if (!getfloat(parser->Tok[3], &length)) return setError(parser, 3, 202);
-    if (length <= 0.0) return setError(parser, 3, 211);
-    if (!getfloat(parser->Tok[4], &diam)) return  setError(parser, 4, 202);
-    if (diam <= 0.0) return setError(parser, 4, 211);
-    if (!getfloat(parser->Tok[5], &rcoeff)) return setError(parser, 5, 202);
-    if (rcoeff <= 0.0) setError(parser, 5, 211);
-
-    // Either a loss coeff. or a status is supplied
-    if (n == 7)
-    {
-        if (match(parser->Tok[6], w_CV)) type = CVPIPE;
-        else if (match(parser->Tok[6], w_CLOSED)) status = CLOSED;
-        else if (match(parser->Tok[6], w_OPEN))   status = OPEN;
-        else if (!getfloat(parser->Tok[6], &lcoeff)) return setError(parser, 6, 202);
-    }
-
-    // Both a loss coeff. and a status is supplied
-    if (n == 8)
-    {
-        if (!getfloat(parser->Tok[6], &lcoeff)) return setError(parser, 6, 202);
-        if (match(parser->Tok[7], w_CV))  type = CVPIPE;
-        else if (match(parser->Tok[7], w_CLOSED)) status = CLOSED;
-        else if (match(parser->Tok[7], w_OPEN))   status = OPEN;
-        else return setError(parser, 7, 213);
-    }
-    if (lcoeff < 0.0) return setError(parser, 6, 211);
-
-    // Save pipe data
-    link = &net->Link[net->Nlinks];
-    link->N1 = j1;
-    link->N2 = j2;
-    link->Len = length;
-    link->Diam = diam;
-    link->Kc = rcoeff;
-    link->Km = lcoeff;
-    link->Kb = MISSING;
-    link->Kw = MISSING;
-    link->Type = type;
-    link->Status = status;
-    link->Rpt = 0;
-    link->ResultIndex = 0;
-    link->Comment = xstrcpy(&link->Comment, parser->Comment, MAXMSG);
-    return 0;
-}
-
-int pumpdata(Project *pr)
-/*
-**--------------------------------------------------------------
-** Input:   none
-** Output:  returns error code
-** Purpose: processes pump data
-** Formats:
-**  [PUMP]
-**   (Version 1.x Format):
-**   id  node1  node2  power
-**   id  node1  node2  h1    q1
-**   id  node1  node2  h0    h1   q1   h2   q2
-**   (Version 2 Format):
-**   id  node1  node2  KEYWORD value {KEYWORD value ...}
-**   where KEYWORD = [POWER,HEAD,PATTERN,SPEED]
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int    j, m,  // Token array indexes
-           j1,    // Start-node index
-           j2,    // End-node index
-           n,     // # data items
-           c, p;  // Curve & Pattern indexes
-    double y;
-    Slink *link;
-    Spump *pump;
-    int err = 0;
-
-    /* Add new pump to data base */
-    n = parser->Ntokens;
-    if (net->Nlinks == parser->MaxLinks ||
-        net->Npumps == parser->MaxPumps) return 200;
-    net->Nlinks++;
-    net->Npumps++;
-    err = addlinkID(net, net->Nlinks, parser->Tok[0]);
-    if (err) return setError(parser, 0, err);
-
-    // Check for valid data
-    if (n < 3) return 201;
-    if ((j1 = findnode(net, parser->Tok[1])) == 0) return setError(parser, 1, 203);
-    if ((j2 = findnode(net, parser->Tok[2])) == 0) return setError(parser, 2, 203);
-    if (j1 == j2) return setError(parser, 0, 222);
-
-    // Save pump data
-    link = &net->Link[net->Nlinks];
-    pump = &net->Pump[net->Npumps];
-
-    link->N1 = j1;
-    link->N2 = j2;
-    link->Diam = 0;
-    link->Len = 0.0;
-    link->Kc = 1.0;
-    link->Km = 0.0;
-    link->Kb = 0.0;
-    link->Kw = 0.0;
-    link->Type = PUMP;
-    link->Status = OPEN;
-    link->Rpt = 0;
-    link->ResultIndex = 0;
-    link->Comment = xstrcpy(&link->Comment, parser->Comment, MAXMSG);
-    pump->Link = net->Nlinks;
-    pump->Ptype = NOCURVE; // NOCURVE is a placeholder
-    pump->Hcurve = 0;
-    pump->Ecurve = 0;
-    pump->Upat = 0;
-    pump->Ecost = 0.0;
-    pump->Epat = 0;
-    if (n < 4) return 0;
-
-    // If 4-th token is a number then input follows Version 1.x format
-    // so retrieve pump curve parameters
-    if (getfloat(parser->Tok[3], &parser->X[0]))
-    {
-        m = 1;
-        for (j = 4; j < n; j++)
-        {
-            if (!getfloat(parser->Tok[j], &parser->X[m])) return setError(parser, j, 202);
-            m++;
-        }
-        return (getpumpcurve(pr, m));
-    }
-
-    // Otherwise input follows Version 2 format
-    // so retrieve keyword/value pairs
-    m = 4;
-    while (m < n)
-    {
-        if (match(parser->Tok[m - 1], w_POWER)) // Const. HP curve
-        {
-            y = atof(parser->Tok[m]);
-            if (y <= 0.0) return setError(parser, m, 202);
-            pump->Ptype = CONST_HP;
-            link->Km = y;
-        }
-        else if (match(parser->Tok[m - 1], w_HEAD))  // Custom pump curve
-        {
-            c = findcurve(net, parser->Tok[m]);
-            if (c == 0) return setError(parser, m, 206);
-            pump->Hcurve = c;
-        }
-        else if (match(parser->Tok[m - 1], w_PATTERN))  // Speed/status pattern
-        {
-            p = findpattern(net, parser->Tok[m]);
-            if (p < 0) return setError(parser, m, 205);
-            pump->Upat = p;
-        }
-        else if (match(parser->Tok[m - 1], w_SPEED))   // Speed setting
-        {
-            if (!getfloat(parser->Tok[m], &y)) return setError(parser, m, 202);
-            if (y < 0.0) return setError(parser, m, 211);
-            link->Kc = y;
-        }
-        else return 201;
-        m = m + 2;  // Move to next keyword token
-    }
-    return 0;
-}
-
-int valvedata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes valve data
-**  Format:
-**     [VALVE]
-**        id  node1  node2  diam  type  setting (lcoeff)
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int c,                     // Curve index
-        j1,                    // Start-node index
-        j2,                    // End-node index
-        n;                     // # data items
-    char  status = ACTIVE,     // Valve status
-          type;                // Valve type
-    double diam = 0.0,         // Valve diameter
-           setting,            // Valve setting
-           lcoeff = 0.0;       // Minor loss coeff.
-    Slink *link;
-    int err = 0;
-
-    // Add new valve to data base
-    n = parser->Ntokens;
-    if (net->Nlinks == parser->MaxLinks ||
-        net->Nvalves == parser->MaxValves) return 200;
-    net->Nvalves++;
-    net->Nlinks++;
-    err = addlinkID(net, net->Nlinks, parser->Tok[0]);
-    if (err) return setError(parser, 0, err);
-
-    // Check for valid data
-    if (n < 6)
-      return 201;
-    if ((j1 = findnode(net, parser->Tok[1])) == 0)
-      return setError(parser, 1, 203);
-    if ((j2 = findnode(net, parser->Tok[2])) == 0)
-      return setError(parser, 2, 203);
-    if (j1 == j2)
-      return setError(parser, 0, 222);
-
-    if (match(parser->Tok[4], w_PRV))
-      type = PRV;
-    else if (match(parser->Tok[4], w_PSV))
-      type = PSV;
-    else if (match(parser->Tok[4], w_PBV))
-      type = PBV;
-    else if (match(parser->Tok[4], w_FCV))
-      type = FCV;
-    else if (match(parser->Tok[4], w_TCV))
-      type = TCV;
-    else if (match(parser->Tok[4], w_GPV))
-      type = GPV;
-    else
-      return setError(parser, 4, 213);
-
-    if (!getfloat(parser->Tok[3], &diam)) return setError(parser, 3, 202);
-    if (diam <= 0.0) return setError(parser, 3, 211);
-
-    // Find headloss curve for GPV
-    if (type == GPV)
-    {
-        c = findcurve(net, parser->Tok[5]);
-        if (c == 0) return setError(parser, 5, 206);
-        setting = c;
-        net->Curve[c].Type = HLOSS_CURVE;
-        status = OPEN;
-    }
-    else if (!getfloat(parser->Tok[5], &setting)) return setError(parser, 5, 202);
-    if (n >= 7 && !getfloat(parser->Tok[6], &lcoeff)) return setError(parser, 6, 202);
-
-    // Check for illegal connections
-    if (valvecheck(pr, net->Nlinks, type, j1, j2))
-    {
-        if      (j1 > net->Njuncs) return setError(parser, 1, 219);
-        else if (j2 > net->Njuncs) return setError(parser, 2, 219);
-        else                       return setError(parser, -1, 220);
-    }
-
-    // Save valve data
-    link = &net->Link[net->Nlinks];
-    link->N1 = j1;
-    link->N2 = j2;
-    link->Diam = diam;
-    link->Len = 0.0;
-    link->Kc = setting;
-    link->Km = lcoeff;
-    link->Kb = 0.0;
-    link->Kw = 0.0;
-    link->Type = type;
-    link->Status = status;
-    link->Rpt = 0;
-    link->ResultIndex = 0;
-    link->Comment = xstrcpy(&link->Comment, parser->Comment, MAXMSG);
-    net->Valve[net->Nvalves].Link = net->Nlinks;
-    return 0;
-}
-
-int patterndata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes time pattern data
-**  Format:
-**     [PATTERNS]
-**        id  mult1  mult2 .....
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int i, j, n, n1;
-    double x;
-    Spattern *pattern;
-
-    // "n" is the number of pattern factors contained in the line
-    n = parser->Ntokens - 1;
-    if (n < 1) return 201;
-
-    // Check if previous input line was for the same pattern
-    if (parser->PrevPat && strcmp(parser->Tok[0], parser->PrevPat->ID) == 0)
-    {
-        pattern = parser->PrevPat;
-    }
-
-    // Otherwise retrieve pattern from the network's Pattern array
-    else
-    {
-        i = findpattern(net, parser->Tok[0]);
-        if (i <= 0) return setError(parser, 0, 205);
-        pattern = &(net->Pattern[i]);
-        if (pattern->Comment == NULL && parser->Comment[0])
-        {
-            pattern->Comment = xstrcpy(&pattern->Comment, parser->Comment, MAXMSG);
-        }
-    }
-
-    // Expand size of the pattern's factors array
-    n1 = pattern->Length;
-    pattern->Length += n;
-    pattern->F = realloc(pattern->F, pattern->Length * sizeof(double));
-
-    // Add parsed multipliers to the pattern
-    for (j = 1; j <= n; j++)
-    {
-        if (!getfloat(parser->Tok[j], &x)) return setError(parser, j, 202);
-        pattern->F[n1 + j - 1] = x;
-    }
-
-    // Save a reference to this pattern for processing additional pattern data
-    parser->PrevPat = pattern;
-    return 0;
-}
-
-int curvedata(Project *pr)
-/*
-**------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes curve data
-**  Format:
-**     [CURVES]
-**      CurveID   x-value  y-value
-**------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int i;
-    double x, y;
-    Scurve *curve;
-
-    // Check for valid data
-    if (parser->Ntokens < 3) return 201;
-    if (!getfloat(parser->Tok[1], &x)) return setError(parser, 1, 202);
-    if (!getfloat(parser->Tok[2], &y)) return setError(parser, 2, 202);
-
-    // Check if previous input line was for the same curve
-    if (parser->PrevCurve && strcmp(parser->Tok[0], parser->PrevCurve->ID) == 0)
-    {
-        curve = parser->PrevCurve;
-    }
-
-    // Otherwise retrieve curve from the network's Curve array
-    else
-    {
-        i = findcurve(net, parser->Tok[0]);
-        if (i == 0) return setError(parser, 0, 206);
-        curve = &(net->Curve[i]);
-        if (curve->Comment == NULL && parser->Comment[0])
-        {
-            curve->Comment = xstrcpy(&curve->Comment, parser->Comment, MAXMSG);
-        }
-    }
-
-    // Expand size of data arrays if need be
-    if (curve->Capacity == curve->Npts)
-    {
-        if (resizecurve(curve, curve->Capacity + 10) > 0) return 101;
-    }
-
-    // Add new data point to curve
-    curve->X[curve->Npts] = x;
-    curve->Y[curve->Npts] = y;
-    curve->Npts++;
-
-    // Save a reference to this curve for processing additional curve data
-    parser->PrevCurve = curve;
-    return 0;
-}
-
-int coordata(Project *pr)
-/*
- **--------------------------------------------------------------
- **  Input:   none
- **  Output:  returns error code
- **  Purpose: processes coordinate data
- **  Format:
- **    [COORD]
- **      id  x  y
- **--------------------------------------------------------------
- */
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int j;
-    double x, y;
-    Snode *node;
-
-    // Check for valid node ID
-    if (parser->Ntokens < 3) return 201;
-    if ((j = findnode(net, parser->Tok[0])) == 0) return setError(parser, 0, 203);
-
-    // Check for valid data
-    if (!getfloat(parser->Tok[1], &x)) return setError(parser, 1, 202);
-    if (!getfloat(parser->Tok[2], &y)) return setError(parser, 2, 202);
-
-    // Save coord data
-    node = &net->Node[j];
-    node->X = x;
-    node->Y = y;
-    return 0;
-}
-
-int vertexdata(Project *pr)
-/*
- **--------------------------------------------------------------
- **  Input:   none
- **  Output:  returns error code
- **  Purpose: processes link vertex data
- **  Format:
- **    [VERTICES]
- **      id  x  y
- **--------------------------------------------------------------
- */
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int j;
-    double x, y;
-    
-    // Check for valid link ID
-    if (parser->Ntokens < 3) return 201;
-    if ((j = findlink(net, parser->Tok[0])) == 0) return setError(parser, 0, 204);
-
-    // Check for valid coordinate data
-    if (!getfloat(parser->Tok[1], &x)) return setError(parser, 1, 202);
-    if (!getfloat(parser->Tok[2], &y)) return setError(parser, 2, 202);
-
-    // Add to link's list of vertex points
-    return addlinkvertex(&net->Link[j], x, y);
-}
-
-
-int demanddata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes node demand data
-**  Format:
-**     [DEMANDS]
-**        MULTIPLY  factor
-**        node  base_demand  (pattern)
-**
-**  NOTE: Demands entered in this section replace those
-**        entered in the [JUNCTIONS] section
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Hydraul *hyd = &pr->hydraul;
-    Parser  *parser = &pr->parser;
-
-    int j, n, p = 0;
-    double y;
-
-    Pdemand demand;
-
-    // Extract data from tokens
-    n = parser->Ntokens;
-    if (n < 2) return 201;
-    if (!getfloat(parser->Tok[1], &y)) return setError(parser, 1, 202);
-
-    // If MULTIPLY command, save multiplier
-    if (match(parser->Tok[0], w_MULTIPLY))
-    {
-        if (y <= 0.0) return setError(parser, 1, 213);
-        else hyd->Dmult = y;
-        return 0;
-    }
-
-    // Otherwise find node (and pattern) being referenced
-    if ((j = findnode(net, parser->Tok[0])) == 0) return setError(parser, 0, 203);
-    if (j > net->Njuncs) return 0;
-    if (n >= 3)
-    {
-        p = findpattern(net, parser->Tok[2]);
-        if (p < 0) return setError(parser, 2, 205);
-    }
-
-    // Replace any demand entered in [JUNCTIONS] section
-    demand = net->Node[j].D;
-    if (demand && hyd->NodeDemand[j] != MISSING)
-    {
-        // First category encountered will overwrite demand category
-        // created when junction was read from [JUNCTIONS] section
-        demand->Base = y;
-        demand->Pat = p;
-        if (parser->Comment[0])
-        {
-            demand->Name = xstrcpy(&demand->Name, parser->Comment, MAXID);
-        }
-        hyd->NodeDemand[j] = MISSING; // marker - next iteration will append a new category.
-    }
-
-    // Otherwise add new demand to junction
-    else if (!adddemand(&net->Node[j], y, p, parser->Comment) > 0) return 101;
-    return 0;
-}
-
-int controldata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes simple controls
-**  Formats:
-**  [CONTROLS]
-**  LINK  linkID  setting IF NODE      nodeID {BELOW/ABOVE}  level
-**  LINK  linkID  setting AT TIME      value  (units)
-**  LINK  linkID  setting AT CLOCKTIME value  (units)
-**   (0)   (1)      (2)   (3) (4)       (5)     (6)          (7)
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int          i = 0,                // Node index
-                 k,                    // Link index
-                 n;                    // # data items
-    double       setting = MISSING,    // Link setting
-                 time = 0.0,           // Simulation time
-                 level = 0.0;          // Pressure or tank level
-    StatusType   status = ACTIVE;      // Link status
-    ControlType  ctltype;              // Control type
-    LinkType     linktype;             // Link type
-    Scontrol     *control;
-
-    // Check for sufficient number of input tokens
-    n = parser->Ntokens;
-    if (n < 6) return 201;
-
-    // Check that controlled link exists
-    k = findlink(net, parser->Tok[1]);
-    if (k == 0) return setError(parser, 1, 204);
-
-    // Cannot control a check valve
-    linktype = net->Link[k].Type;
-    if (linktype == CVPIPE)  return setError(parser, 1, 207);
-
-    // Parse control setting into a status level or numerical setting
-    if (match(parser->Tok[2], w_OPEN))
-    {
-        status = OPEN;
-        if (linktype == PUMP) setting = 1.0;
-        if (linktype == GPV)  setting = net->Link[k].Kc;
-    }
-    else if (match(parser->Tok[2], w_CLOSED))
-    {
-        status = CLOSED;
-        if (linktype == PUMP) setting = 0.0;
-        if (linktype == GPV)  setting = net->Link[k].Kc;
-    }
-    else if (linktype == GPV) return setError(parser, 1, 207);
-    else if (!getfloat(parser->Tok[2], &setting)) return setError(parser, 2, 202);
-
-    // Set status for pump in case speed setting was supplied
-    // or for pipe if numerical setting was supplied
-    if (linktype == PUMP || linktype == PIPE)
-    {
-        if (setting != MISSING)
-        {
-            if (setting < 0.0)       return setError(parser, 2, 211);
-            else if (setting == 0.0) status = CLOSED;
-            else                     status = OPEN;
-        }
-    }
-
-    // Determine type of control
-    if (match(parser->Tok[4], w_TIME))           ctltype = TIMER;
-    else if (match(parser->Tok[4], w_CLOCKTIME)) ctltype = TIMEOFDAY;
-    else
-    {
-        if (n < 8) return 201;
-        if ((i = findnode(net, parser->Tok[5])) == 0) return setError(parser, 5, 203);
-        if (match(parser->Tok[6], w_BELOW))      ctltype = LOWLEVEL;
-        else if (match(parser->Tok[6], w_ABOVE)) ctltype = HILEVEL;
-        else return setError(parser, 6, 213);
-  }
-
-    // Parse control level or time
-    switch (ctltype)
-    {
-        case TIMER:
-        case TIMEOFDAY:
-          if (n == 6) time = hour(parser->Tok[5], "");
-          if (n == 7) time = hour(parser->Tok[5], parser->Tok[6]);
-          if (time < 0.0) return setError(parser, 5, 213);
-          break;
-        case LOWLEVEL:
-        case HILEVEL:
-          if (!getfloat(parser->Tok[7], &level)) return setError(parser, 7, 202);
-          break;
-    }
-
-    // Fill in fields of control data structure
-    net->Ncontrols++;
-    if (net->Ncontrols > parser->MaxControls) return 200;
-    control = &net->Control[net->Ncontrols];
-    control->Link = k;
-    control->Node = i;
-    control->Type = ctltype;
-    control->Status = status;
-    control->Setting = setting;
-    control->Time = (long)(3600.0 * time);
-    if (ctltype == TIMEOFDAY) control->Time %= SECperDAY;
-    control->Grade = level;
-    return 0;
-}
-
-int sourcedata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes water quality source data
-**  Formats:
-**     [SOURCE]
-**        node  sourcetype  quality  (pattern)
-**
-**  NOTE: units of mass-based source are mass/min
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int i,              // Token with quality value
-        j,              // Node index
-        n,              // # data items
-        p = 0;          // Time pattern index
-    char type = CONCEN; // Source type
-    double c0 = 0;      // Initial quality
-    Psource source;
-
-    // Check for enough tokens & that source node exists
-    n = parser->Ntokens;
-    if (n < 2) return 201;
-    if ((j = findnode(net, parser->Tok[0])) == 0) return setError(parser, 0, 203);
-
-    // Parse source type
-    // NOTE: Under old 1.1 format, SourceType not supplied so
-    //       let i = index of token that contains quality value
-    i = 2;
-    if (match(parser->Tok[1], w_CONCEN))         type = CONCEN;
-    else if (match(parser->Tok[1], w_MASS))      type = MASS;
-    else if (match(parser->Tok[1], w_SETPOINT))  type = SETPOINT;
-    else if (match(parser->Tok[1], w_FLOWPACED)) type = FLOWPACED;
-    else i = 1;
-
-    // Parse source quality
-    if (!getfloat(parser->Tok[i], &c0))
-    {
-        if (i == 1) return setError(parser, i, 213);
-        else        return setError(parser, i, 202);
-    }
-
-    // Parse optional source time pattern
-    if (n > i + 1 && strlen(parser->Tok[i + 1]) > 0 &&
-        strcmp(parser->Tok[i + 1], "*") != 0)
-    {
-        p = findpattern(net, parser->Tok[i + 1]);
-        if (p < 0) return setError(parser, i + 1, 205);
-    }
-
-    // Destroy any existing source assigned to node
-    if (net->Node[j].S != NULL) free(net->Node[j].S);
-
-    // Create a new source & assign it to the node
-    source = (struct Ssource *)malloc(sizeof(struct Ssource));
-    if (source == NULL) return 101;
-    source->C0 = c0;
-    source->Pat = p;
-    source->Type = type;
-    net->Node[j].S = source;
-    return 0;
-}
-
-int emitterdata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes junction emitter data
-**  Format:
-**     [EMITTER]
-**        node   Ke
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int j,       // Node index
-        n;       // # data items
-    double k;    // Flow coeff.
-
-    // Check that node exists & is a junction
-    n = parser->Ntokens;
-    if (n < 2) return 201;
-    if ((j = findnode(net, parser->Tok[0])) == 0) return setError(parser, 0, 203);
-    if (j > net->Njuncs) return 0;
-
-    // Parse emitter flow coeff.
-    if (!getfloat(parser->Tok[1], &k)) return setError(parser, 1, 202);
-    if (k < 0.0) return setError(parser, 1, 209);
-    net->Node[j].Ke = k;
-    return 0;
-}
-
-int qualdata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes initial water quality data
-**  Formats:
-**     [QUALITY]
-**        node   initqual
-**        node1  node2    initqual
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int j, n;
-    long i, i1, i2;
-    double c0;
-    Snode *Node = net->Node;
-
-    if (net->Nnodes == 0) return setError(parser, 0, 203);  // No nodes defined yet
-    n = parser->Ntokens;
-    if (n < 2) return 0;
-
-    // Single node name supplied
-    if (n == 2)
-    {
-        if ((j = findnode(net,parser->Tok[0])) == 0) return setError(parser, 0, 203);
-        if (!getfloat(parser->Tok[1], &c0)) return setError(parser, 1, 202);
-        if (c0 < 0.0) return setError(parser, 1, 209);
-        Node[j].C0 = c0;
-    }
-
-    // Range of node names supplied
-    else
-    {
-        // Parse quality value
-        if (!getfloat(parser->Tok[2], &c0)) return setError(parser, 2, 202);
-        if (c0 < 0.0) return setError(parser, 2, 209);
-
-        // If numerical node names supplied, then use numerical comparison
-        // to find which nodes are assigned the quality value
-        if ((i1 = atol(parser->Tok[0])) > 0 &&
-            (i2 = atol(parser->Tok[1])) > 0)
-        {
-            for (j = 1; j <= net->Nnodes; j++)
-            {
-                i = atol(Node[j].ID);
-                if (i >= i1 && i <= i2) Node[j].C0 = c0;
-            }
-        }
-
-        // Otherwise use lexicographic comparison
-        else
-        {
-            for (j = 1; j <= net->Nnodes; j++)
-            {
-                if ((strcmp(parser->Tok[0], Node[j].ID) <= 0) &&
-                    (strcmp(parser->Tok[1], Node[j].ID) >= 0)
-                   ) Node[j].C0 = c0;
-            }
-        }
-    }
-    return 0;
-}
-
-int reactdata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes reaction coeff. data
-**  Formats:
-**     [REACTIONS]
-**        ORDER     {BULK/WALL/TANK} value
-**        GLOBAL    BULK             coeff
-**        GLOBAL    WALL             coeff
-**        BULK      link1  (link2)   coeff
-**        WALL      link1  (link2)   coeff
-**        TANK      node1  (node2)   coeff
-**        LIMITING  POTENTIAL        value
-**        ROUGHNESS CORRELATION      value
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Quality *qual = &pr->quality;
-    Parser  *parser = &pr->parser;
-
-    int item, j, n;
-    long i, i1, i2;
-    double y;
-
-    // Skip line if insufficient data
-    n = parser->Ntokens;
-    if (n < 3) return 0;
-
-    // Keyword is ORDER
-    if (match(parser->Tok[0], w_ORDER))
-    {
-        if (!getfloat(parser->Tok[n - 1], &y))  return setError(parser, n-1, 202);
-        if (match(parser->Tok[1], w_BULK))      qual->BulkOrder = y;
-        else if (match(parser->Tok[1], w_TANK)) qual->TankOrder = y;
-        else if (match(parser->Tok[1], w_WALL))
-        {
-            if (y == 0.0)      qual->WallOrder = 0.0;
-            else if (y == 1.0) qual->WallOrder = 1.0;
-            else return setError(parser, n-1, 213);
-        }
-        else return setError(parser, 1, 213);
-        return 0;
-    }
-
-    // Keyword is ROUGHNESS
-    if (match(parser->Tok[0], w_ROUGHNESS))
-    {
-        if (!getfloat(parser->Tok[n - 1], &y)) return setError(parser, n-1, 202);
-        qual->Rfactor = y;
-        return 0;
-    }
-
-    // Keyword is LIMITING
-    if (match(parser->Tok[0], w_LIMITING))
-    {
-        if (!getfloat(parser->Tok[n - 1], &y)) return setError(parser, n-1, 202);
-        qual->Climit = y;
-        return 0;
-    }
-
-    // Keyword is GLOBAL
-    if (match(parser->Tok[0], w_GLOBAL))
-    {
-        if (!getfloat(parser->Tok[n - 1], &y)) return setError(parser, n-1, 202);
-        if (match(parser->Tok[1], w_BULK))      qual->Kbulk = y;
-        else if (match(parser->Tok[1], w_WALL)) qual->Kwall = y;
-        else return setError(parser, 1, 213);
-        return 0;
-    }
-
-    // Keyword is BULK, WALL or TANK
-    if (match(parser->Tok[0], w_BULK))      item = 1;
-    else if (match(parser->Tok[0], w_WALL)) item = 2;
-    else if (match(parser->Tok[0], w_TANK)) item = 3;
-    else return setError(parser, 0, 213);
-
-    // Case where tank rate coeffs. are being set
-    if (item == 3)
-    {
-        // Get the rate coeff. value
-        if (!getfloat(parser->Tok[n - 1], &y)) return setError(parser, n-1, 202);
-
-        // Case where just a single tank is specified
-        if (n == 3)
-        {
-            if ((j = findnode(net,parser->Tok[1])) <= net->Njuncs) return 0;
-            net->Tank[j - net->Njuncs].Kb = y;
-        }
-
-        // Case where a numerical range of tank IDs is specified
-        else if ((i1 = atol(parser->Tok[1])) > 0 &&
-                 (i2 = atol(parser->Tok[2])) > 0)
-        {
-            for (j = net->Njuncs + 1; j <= net->Nnodes; j++)
-            {
-                i = atol(net->Node[j].ID);
-                if (i >= i1 && i <= i2) net->Tank[j - net->Njuncs].Kb = y;
-            }
-        }
-
-        // Case where a general range of tank IDs is specified
-        else for (j = net->Njuncs + 1; j <= net->Nnodes; j++)
-        {
-            if ((strcmp(parser->Tok[1], net->Node[j].ID) <= 0) &&
-                (strcmp(parser->Tok[2], net->Node[j].ID) >= 0)
-                ) net->Tank[j - net->Njuncs].Kb = y;
-        }
-    }
-
-    // Case where pipe rate coeffs. are being set
-    else
-    {
-        // Get the rate coeff. value
-        if (!getfloat(parser->Tok[n - 1], &y)) return setError(parser, n-1, 202);
-        if (net->Nlinks == 0) return 0;
-
-        // Case where just a single link is specified
-        if (n == 3)
-        {
-            if ((j = findlink(net, parser->Tok[1])) == 0) return 0;
-            if (item == 1) net->Link[j].Kb = y;
-            else           net->Link[j].Kw = y;
-        }
-
-        // Case where a numerical range of link IDs is specified
-        else if ((i1 = atol(parser->Tok[1])) > 0 &&
-                 (i2 = atol(parser->Tok[2])) > 0)
-        {
-            for (j = 1; j <= net->Nlinks; j++)
-            {
-                i = atol(net->Link[j].ID);
-                if (i >= i1 && i <= i2)
-                {
-                    if (item == 1)  net->Link[j].Kb = y;
-                    else            net->Link[j].Kw = y;
-                }
-            }
-        }
-
-        // Case where a general range of link IDs is specified
-        else for (j = 1; j <= net->Nlinks; j++)
-        {
-            if ((strcmp(parser->Tok[1], net->Link[j].ID) <= 0) &&
-                (strcmp(parser->Tok[2], net->Link[j].ID) >= 0))
-            {
-                if (item == 1) net->Link[j].Kb = y;
-                else           net->Link[j].Kw = y;
-            }
-        }
-    }
-    return 0;
-}
-
-int mixingdata(Project *pr)
-/*
-**-------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes tank mixing data
-**  Format:
-**    [MIXING]
-**     TankID  MixModel  FractVolume
-**-------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int    i,     // Tank index
-           j,     // Node index
-           m,     // Type of mixing model
-           n;     // Number of data items
-    double v;     // Mixing zone volume fraction
-
-    // Check for valid data
-    if (net->Nnodes == 0) return setError(parser, 0, 203);
-    n = parser->Ntokens;
-    if (n < 2) return 0;
-    j = findnode(net, parser->Tok[0]);
-    if (j == 0) return setError(parser, 0, 203);
-    if (j <= net->Njuncs) return 0;
-    if ((m = findmatch(parser->Tok[1], MixTxt)) < 0) return setError(parser, 1, 213);
-
-    // Find mixing zone volume fraction (which can't be 0)
-    v = 1.0;
-    if ((m == MIX2) && (n == 3) &&
-        (!getfloat(parser->Tok[2], &v))) return setError(parser, 2, 202);
-    if (v == 0.0) v = 1.0;
-
-    // Assign mixing data to tank (return if tank is a reservoir)
-    i = j - net->Njuncs;
-    if (net->Tank[i].A == 0.0) return 0;
-    net->Tank[i].MixModel = (char)m;
-    net->Tank[i].V1max = v;
-    return 0;
-}
-
-int statusdata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes link initial status data
-**  Formats:
-**    [STATUS]
-**       link   value
-**       link1  (link2)  value
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    int j, n;
-    long i, i1, i2;
-    double y = 0.0;
-    char status = ACTIVE;
-
-    if (net->Nlinks == 0) return setError(parser, 0, 204);
-    n = parser->Ntokens - 1;
-    if (n < 1) return 201;
-
-    // Check for legal status setting
-    if (match(parser->Tok[n], w_OPEN))  status = OPEN;
-    else if (match(parser->Tok[n], w_CLOSED)) status = CLOSED;
-    else
-    {
-        if (!getfloat(parser->Tok[n], &y)) return setError(parser, n, 202);
-        if (y < 0.0) return setError(parser, n, 211);
-    }
-
-    // A single link ID was supplied
-    if (n == 1)
-    {
-        if ((j = findlink(net, parser->Tok[0])) == 0) return setError(parser, 0, 204);
-
-        // Cannot change status of a Check Valve
-        if (net->Link[j].Type == CVPIPE) return setError(parser, 0, 207);
-
-        // Cannot change setting for a GPV
-        if (net->Link[j].Type == GPV && status == ACTIVE) return setError(parser, 0, 207);
-        changestatus(net, j, status, y);
-    }
-
-    // A range of numerical link ID's was supplied
-    else if ((i1 = atol(parser->Tok[0])) > 0 &&
-             (i2 = atol(parser->Tok[1])) > 0)
-    {
-        for (j = 1; j <= net->Nlinks; j++)
-        {
-            i = atol(net->Link[j].ID);
-            if (i >= i1 && i <= i2) changestatus(net, j, status, y);
-        }
-    }
-
-    // A range of general link ID's was supplied
-    else for (j = 1; j <= net->Nlinks; j++)
-    {
-        if ((strcmp(parser->Tok[0], net->Link[j].ID) <= 0) &&
-            (strcmp(parser->Tok[1], net->Link[j].ID) >= 0)
-           ) changestatus(net, j, status, y);
-    }
-    return 0;
-}
-
-int energydata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes pump energy data
-**  Formats:
-**    [ENERGY]
-**       GLOBAL         {PRICE/PATTERN/EFFIC}  value
-**       PUMP   id      {PRICE/PATTERN/EFFIC}  value
-**       DEMAND CHARGE  value
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Hydraul *hyd = &pr->hydraul;
-    Parser  *parser = &pr->parser;
-
-    int j, k, n, p, c;
-    double y;
-
-    Slink *Link = net->Link;
-    Spump *Pump = net->Pump;
-
-    // Check for sufficient data
-    n = parser->Ntokens;
-    if (n < 3) return 201;
-
-    // First keyword is DEMAND
-    if (match(parser->Tok[0], w_DMNDCHARGE))
-    {
-        if (!getfloat(parser->Tok[2], &y)) return setError(parser, 2, 202);
-        if (y < 0.0) return setError(parser, 2, 213);
-        hyd->Dcost = y;
-        return 0;
-    }
-
-    // First keyword is GLOBAL (remaining data refer to global options)
-    if (match(parser->Tok[0], w_GLOBAL))
-    {
-        j = 0;
-    }
-
-    // First keyword is PUMP (remaining data refer to a specific pump)
-    else if (match(parser->Tok[0], w_PUMP))
-    {
-        if (n < 4) return 201;
-        k = findlink(net,parser->Tok[1]);
-        if (k == 0) return setError(parser, 1, 216);
-        if (Link[k].Type != PUMP) return setError(parser, 1, 216);
-        j = findpump(net, k);
-    }
-    else return setError(parser, 0, 213);
-
-    // PRICE parameter being set
-    if (match(parser->Tok[n - 2], w_PRICE))
-    {
-        if (!getfloat(parser->Tok[n - 1], &y)) return setError(parser, n-1, 202);
-        if (y < 0.0) return setError(parser, n-1, 217);
-        if (j == 0) hyd->Ecost = y;
-        else        Pump[j].Ecost = y;
-        return 0;
-    }
-
-    // Price PATTERN being set
-    else if (match(parser->Tok[n - 2], w_PATTERN))
-    {
-        p = findpattern(net, parser->Tok[n - 1]);
-        if (p < 0) return setError(parser, n - 1, 205);
-        if (j == 0) hyd->Epat = p;
-        else        Pump[j].Epat = p;
-        return 0;
-    }
-
-    // Pump EFFIC being set
-    else if (match(parser->Tok[n - 2], w_EFFIC))
-    {
-        if (j == 0)
-        {
-            if (!getfloat(parser->Tok[n - 1], &y)) return setError(parser, n - 1, 202);
-            if (y <= 0.0) return setError(parser, n - 1, 217);
-            hyd->Epump = y;
-        }
-        else
-        {
-            c = findcurve(net, parser->Tok[n - 1]);
-            if (c == 0) return setError(parser, n - 1, 206);
-            Pump[j].Ecurve = c;
-            net->Curve[c].Type = EFFIC_CURVE;
-        }
-        return 0;
-    }
-    return 201;
-}
-
-int reportdata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes report options data
-**  Formats:
-**    PAGE     linesperpage
-**    STATUS   {NONE/YES/FULL}
-**    SUMMARY  {YES/NO}
-**    MESSAGES {YES/NO}
-**    ENERGY   {NO/YES}
-**    NODES    {NONE/ALL}
-**    NODES    node1  node2 ...
-**    LINKS    {NONE/ALL}
-**    LINKS    link1  link2 ...
-**    FILE     filename
-**    variable {YES/NO}
-**    variable {BELOW/ABOVE/PRECISION}  value
-**--------------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Report  *rpt = &pr->report;
-    Parser  *parser = &pr->parser;
-
-    int i, j, n;
-    double y;
-
-    n = parser->Ntokens - 1;
-    if (n < 1) return 201;
-
-    // Value for page size
-    if (match(parser->Tok[0], w_PAGE))
-    {
-        if (!getfloat(parser->Tok[n], &y)) return setError(parser, n, 202);
-        if (y < 0.0 || y > 255.0) return setError(parser, n, 213);
-        rpt->PageSize = (int)y;
-        return 0;
-    }
-
-    // Request that status reports be written
-    if (match(parser->Tok[0], w_STATUS))
-    {
-        if (match(parser->Tok[n], w_NO))   rpt->Statflag = FALSE;
-        if (match(parser->Tok[n], w_YES))  rpt->Statflag = TRUE;
-        if (match(parser->Tok[n], w_FULL)) rpt->Statflag = FULL;
-        return 0;
-    }
-
-    // Request summary report
-    if (match(parser->Tok[0], w_SUMMARY))
-    {
-        if (match(parser->Tok[n], w_NO)) rpt->Summaryflag = FALSE;
-        if (match(parser->Tok[n], w_YES))   rpt->Summaryflag = TRUE;
-        return 0;
-    }
-
-    // Request error/warning message reporting
-    if (match(parser->Tok[0], w_MESSAGES))
-    {
-        if (match(parser->Tok[n], w_NO))  rpt->Messageflag = FALSE;
-        if (match(parser->Tok[n], w_YES)) rpt->Messageflag = TRUE;
-        return 0;
-    }
-
-    // Request an energy usage report
-    if (match(parser->Tok[0], w_ENERGY))
-    {
-        if (match(parser->Tok[n], w_NO))  rpt->Energyflag = FALSE;
-        if (match(parser->Tok[n], w_YES)) rpt->Energyflag = TRUE;
-        return 0;
-    }
-
-    // Particular reporting nodes specified
-    if (match(parser->Tok[0], w_NODE))
-    {
-        if (match(parser->Tok[n], w_NONE))     rpt->Nodeflag = 0; // No nodes
-        else if (match(parser->Tok[n], w_ALL)) rpt->Nodeflag = 1; // All nodes
-        else
-        {
-            if (net->Nnodes == 0) return setError(parser, 1, 203);
-            for (i = 1; i <= n; i++)
-            {
-                if ((j = findnode(net, parser->Tok[i])) == 0) return setError(parser, i, 203);
-                net->Node[j].Rpt = 1;
-            }
-            rpt->Nodeflag = 2;
-        }
-        return 0;
-    }
-
-    // Particular reporting links specified
-    if (match(parser->Tok[0], w_LINK))
-    {
-        if (match(parser->Tok[n], w_NONE))     rpt->Linkflag = 0;
-        else if (match(parser->Tok[n], w_ALL)) rpt->Linkflag = 1;
-        else
-        {
-            if (net->Nlinks == 0) return setError(parser, 1, 204);
-            for (i = 1; i <= n; i++)
-            {
-                if ((j = findlink(net, parser->Tok[i])) == 0) return setError(parser, i, 204);
-                net->Link[j].Rpt = 1;
-            }
-            rpt->Linkflag = 2;
-        }
-        return 0;
-    }
-
-    // Report fields specified
-    // Special case needed to distinguish "HEAD" from "HEADLOSS"
-    if (strcomp(parser->Tok[0], t_HEADLOSS)) i = HEADLOSS;
-    else i = findmatch(parser->Tok[0], Fldname);
-    if (i >= 0)
-    {
-        if (i > FRICTION) return setError(parser, 0, 213);
-        if (parser->Ntokens == 1 || match(parser->Tok[1], w_YES))
-        {
-            rpt->Field[i].Enabled = TRUE;
-            return 0;
-        }
-
-        if (match(parser->Tok[1], w_NO))
-        {
-            rpt->Field[i].Enabled = FALSE;
-            return 0;
-        }
-
-        // Get field qualifier type
-        if (parser->Ntokens < 3) return 201;
-        if      (match(parser->Tok[1], w_BELOW))     j = LOW;
-        else if (match(parser->Tok[1], w_ABOVE))     j = HI;
-        else if (match(parser->Tok[1], w_PRECISION)) j = PREC;
-        else return setError(parser, 1, 213);
-
-        // Get field qualifier value
-        if (!getfloat(parser->Tok[2], &y)) return setError(parser, 2, 202);
-        if (j == PREC)
-        {
-            rpt->Field[i].Enabled = TRUE;
-            rpt->Field[i].Precision = ROUND(y);
-        }
-        else rpt->Field[i].RptLim[j] = y;
-        return (0);
-    }
-
-    // Name of external report file
-    if (match(parser->Tok[0], w_FILE))
-    {
-        strncpy(rpt->Rpt2Fname, parser->Tok[1], MAXFNAME);
-        return 0;
-    }
-
-    // If get to here then return error condition
-    return 201;
-}
-
-int timedata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes time options data
-**  Formats:
-**    STATISTIC                  {NONE/AVERAGE/MIN/MAX/RANGE}
-**    DURATION                   value   (units)
-**    HYDRAULIC TIMESTEP         value   (units)
-**    QUALITY TIMESTEP           value   (units)
-**    MINIMUM TRAVELTIME         value   (units)
-**    RULE TIMESTEP              value   (units)
-**    PATTERN TIMESTEP           value   (units)
-**    PATTERN START              value   (units)
-**    REPORT TIMESTEP            value   (units)
-**    REPORT START               value   (units)
-**    START CLOCKTIME            value   (AM PM)
-**-------------------------------------------------------------
-*/
-{
-    Report *rpt = &pr->report;
-    Parser *parser = &pr->parser;
-    Times  *time = &pr->times;
-
-    int n;
-    long t;
-    double y;
-
-    n = parser->Ntokens - 1;
-    if (n < 1) return 201;
-
-    // Check if setting report time statistic flag
-    if (match(parser->Tok[0], w_STATISTIC))
-    {
-        if      (match(parser->Tok[n], w_NONE))  rpt->Tstatflag = SERIES;
-        else if (match(parser->Tok[n], w_NO))    rpt->Tstatflag = SERIES;
-        else if (match(parser->Tok[n], w_AVG))   rpt->Tstatflag = AVG;
-        else if (match(parser->Tok[n], w_MIN))   rpt->Tstatflag = MIN;
-        else if (match(parser->Tok[n], w_MAX))   rpt->Tstatflag = MAX;
-        else if (match(parser->Tok[n], w_RANGE)) rpt->Tstatflag = RANGE;
-        else return setError(parser, n, 213);
-        return 0;
-    }
-
-    // Convert text time value to numerical value in seconds
-    // Examples:
-    //    5           = 5 * 3600 sec
-    //    5 MINUTES   = 5 * 60   sec
-    //    13:50       = 13*3600 + 50*60 sec
-    //    1:50 pm     = (12+1)*3600 + 50*60 sec
-
-    if (!getfloat(parser->Tok[n], &y))
-    {
-        if ((y = hour(parser->Tok[n], "")) < 0.0)
-        {
-            if ((y = hour(parser->Tok[n - 1], parser->Tok[n])) < 0.0)
-            {
-                return setError(parser, n-1, 213);
-            }
-        }
-    }
-    t = (long)(3600.0 * y + 0.5);
-
-    /// Process the value assigned to the matched parameter
-    if      (match(parser->Tok[0], w_DURATION))  time->Dur = t;
-    else if (match(parser->Tok[0], w_HYDRAULIC)) time->Hstep = t;
-    else if (match(parser->Tok[0], w_QUALITY) )  time->Qstep = t;
-    else if (match(parser->Tok[0], w_RULE))      time->Rulestep = t;
-    else if (match(parser->Tok[0], w_MINIMUM))   return 0; // Not used anymore
-    else if (match(parser->Tok[0], w_PATTERN))
-    {
-        if      (match(parser->Tok[1], w_TIME))  time->Pstep = t;
-        else if (match(parser->Tok[1], w_START)) time->Pstart = t;
-        else return setError(parser, 1, 213);
-    }
-    else if (match(parser->Tok[0], w_REPORT))
-    {
-        if      (match(parser->Tok[1], w_TIME))  time->Rstep = t;
-        else if (match(parser->Tok[1], w_START)) time->Rstart = t;
-        else return setError(parser, 1, 213);
-    }
-    else if (match(parser->Tok[0], w_START)) time->Tstart = t % SECperDAY;
-    else return setError(parser, 0, 213);
-    return 0;
-}
-
-int optiondata(Project *pr)
-/*
-**--------------------------------------------------------------
-**  Input:   none
-**  Output:  returns error code
-**  Purpose: processes [OPTIONS] data
-**--------------------------------------------------------------
-*/
-{
-    int i, n;
-    Parser *parser = &pr->parser;
-
-    // Option is a named choice
-    n = parser->Ntokens - 1;
-    i = optionchoice(pr, n);
-    if (i >= 0) return i;
-
-    // Option is a numerical value
-    return (optionvalue(pr, n));
-}
-
-int optionchoice(Project *pr, int n)
-/*
-**--------------------------------------------------------------
-**  Input:   n = index of last input token
-**  Output:  returns error code or 0 if option belongs to
-**           those listed below, or -1 otherwise
-**  Purpose: processes fixed choice [OPTIONS] data
-**  Formats:
-**    UNITS               CFS/GPM/MGD/IMGD/AFD/LPS/LPM/MLD/CMH/CMD/SI
-**    PRESSURE            PSI/KPA/M
-**    HEADLOSS            H-W/D-W/C-M
-**    HYDRAULICS          USE/SAVE  filename
-**    QUALITY             NONE/AGE/TRACE/CHEMICAL  (TraceNode)
-**    MAP                 filename
-**    VERIFY              filename
-**    UNBALANCED          STOP/CONTINUE {Niter}
-**    PATTERN             id
-**    DEMAND MODEL        DDA/PDA
-**--------------------------------------------------------------
-*/
-{
-    Network *net    = &pr->network;
-    Hydraul *hyd    = &pr->hydraul;
-    Quality *qual   = &pr->quality;
-    Parser  *parser = &pr->parser;
-    Outfile *out    = &pr->outfile;
-
-    int choice;
-
-    // Check if 1st token matches a parameter name and
-    // process the input for the matched parameter
-    if (n < 0) return 201;
-
-    // Flow UNITS
-    if (match(parser->Tok[0], w_UNITS))
-    {
-        if (n < 1) return 0;
-        else if (match(parser->Tok[1], w_CFS))  parser->Flowflag = CFS;
-        else if (match(parser->Tok[1], w_GPM))  parser->Flowflag = GPM;
-        else if (match(parser->Tok[1], w_AFD))  parser->Flowflag = AFD;
-        else if (match(parser->Tok[1], w_MGD))  parser->Flowflag = MGD;
-        else if (match(parser->Tok[1], w_IMGD)) parser->Flowflag = IMGD;
-        else if (match(parser->Tok[1], w_LPS))  parser->Flowflag = LPS;
-        else if (match(parser->Tok[1], w_LPM))  parser->Flowflag = LPM;
-        else if (match(parser->Tok[1], w_CMH))  parser->Flowflag = CMH;
-        else if (match(parser->Tok[1], w_CMD))  parser->Flowflag = CMD;
-        else if (match(parser->Tok[1], w_MLD))  parser->Flowflag = MLD;
-        else if (match(parser->Tok[1], w_SI))   parser->Flowflag = LPS;
-        else return setError(parser, 1, 213);
-    }
-
-    // PRESSURE units
-    else if (match(parser->Tok[0], w_PRESSURE))
-    {
-        if (n < 1) return 0;
-        else if (match(parser->Tok[1], w_EXPONENT)) return -1;
-        else if (match(parser->Tok[1], w_PSI))    parser->Pressflag = PSI;
-        else if (match(parser->Tok[1], w_KPA))    parser->Pressflag = KPA;
-        else if (match(parser->Tok[1], w_METERS)) parser->Pressflag = METERS;
-        else return setError(parser, 1, 213);
-    }
-
-    // HEADLOSS formula
-    else if (match(parser->Tok[0], w_HEADLOSS))
-    {
-        if (n < 1)  return 0;
-        else if (match(parser->Tok[1], w_HW))   hyd->Formflag = HW;
-        else if (match(parser->Tok[1], w_DW))   hyd->Formflag = DW;
-        else if (match(parser->Tok[1], w_CM))   hyd->Formflag = CM;
-        else return setError(parser, 1, 213);
-    }
-
-    // HYDRUALICS USE/SAVE file option
-    else if (match(parser->Tok[0], w_HYDRAULIC))
-    {
-        if (n < 2) return 0;
-        else if (match(parser->Tok[1], w_USE))  out->Hydflag = USE;
-        else if (match(parser->Tok[1], w_SAVE)) out->Hydflag = SAVE;
-        else return setError(parser, 1, 213);
-        strncpy(out->HydFname, parser->Tok[2], MAXFNAME);
-    }
-
-    // Water QUALITY option
-    else if (match(parser->Tok[0], w_QUALITY))
-    {
-        if (n < 1) return 0;
-        else if (match(parser->Tok[1], w_NONE))  qual->Qualflag = NONE;
-        else if (match(parser->Tok[1], w_CHEM))  qual->Qualflag = CHEM;
-        else if (match(parser->Tok[1], w_AGE))   qual->Qualflag = AGE;
-        else if (match(parser->Tok[1], w_TRACE)) qual->Qualflag = TRACE;
-        else
-        {
-            qual->Qualflag = CHEM;
-            strncpy(qual->ChemName, parser->Tok[1], MAXID);
-            if (n >= 2) strncpy(qual->ChemUnits, parser->Tok[2], MAXID);
-        }
-        if (qual->Qualflag == TRACE)
-        {
-            // Copy Trace Node ID to parser->Tok[0] for error reporting
-            strcpy(parser->Tok[0], "");
-            if (n < 2) return 201;
-            strcpy(parser->Tok[0], parser->Tok[2]);
-            qual->TraceNode = findnode(net, parser->Tok[2]);
-            if (qual->TraceNode == 0) return setError(parser, 2, 212);
-            strncpy(qual->ChemName, u_PERCENT, MAXID);
-            strncpy(qual->ChemUnits, parser->Tok[2], MAXID);
-        }
-        if (qual->Qualflag == AGE)
-        {
-            strncpy(qual->ChemName, w_AGE, MAXID);
-            strncpy(qual->ChemUnits, u_HOURS, MAXID);
-        }
-    }
-
-    // MAP file name
-    else if (match(parser->Tok[0], w_MAP))
-    {
-        if (n < 1) return 0;
-        strncpy(pr->MapFname, parser->Tok[1], MAXFNAME);
-    }
-
-    else if (match(parser->Tok[0], w_VERIFY))
-    {
-        // Deprecated
-    }
-
-    // Hydraulics UNBALANCED option
-    else if (match(parser->Tok[0], w_UNBALANCED))
-    {
-        if (n < 1) return 0;
-        if (match(parser->Tok[1], w_STOP)) hyd->ExtraIter = -1;
-        else if (match(parser->Tok[1], w_CONTINUE))
-        {
-            if (n >= 2)  hyd->ExtraIter = atoi(parser->Tok[2]);
-            else         hyd->ExtraIter = 0;
-        }
-        else return setError(parser, 1, 213);
-    }
-
-    // Default demand PATTERN
-    else if (match(parser->Tok[0], w_PATTERN))
-    {
-        if (n < 1) return 0;
-        strncpy(parser->DefPatID, parser->Tok[1], MAXID);
-    }
-
-    // DEMAND model
-    else if (match(parser->Tok[0], w_DEMAND))
-    {
-        if (n < 2) return 0;
-        if (!match(parser->Tok[1], w_MODEL)) return -1;
-        choice = findmatch(parser->Tok[2], DemandModelTxt);
-        if (choice < 0) return setError(parser, 2, 213);
-        hyd->DemandModel = choice;
-    }
-
-    // Return -1 if keyword did not match any option
-    else return -1;
-    return 0;
-}
-
-int optionvalue(Project *pr, int n)
-/*
-**-------------------------------------------------------------
-**  Input:   *line = line read from input file
-**  Output:  returns error code
-**  Purpose: processes numerical value [OPTIONS] data
-**  Formats:
-**    DEMAND MULTIPLIER   value
-**    EMITTER EXPONENT    value
-**    VISCOSITY           value
-**    DIFFUSIVITY         value
-**    SPECIFIC GRAVITY    value
-**    TRIALS              value
-**    ACCURACY            value
-
-**    HEADERROR           value
-**    FLOWCHANGE          value
-**    MINIMUM PRESSURE    value
-**    REQUIRED PRESSURE   value
-**    PRESSURE EXPONENT   value
-
-**    TOLERANCE           value
-**    SEGMENTS            value  (not used)
-**  ------ Undocumented Options -----
-**    HTOL                value
-**    QTOL                value
-**    RQTOL               value
-**    CHECKFREQ           value
-**    MAXCHECK            value
-**    DAMPLIMIT           value
-**--------------------------------------------------------------
-*/
-{
-    Hydraul *hyd = &pr->hydraul;
-    Quality *qual = &pr->quality;
-    Parser  *parser = &pr->parser;
-
-    int    nvalue = 1;   // Index of token with numerical value
-    double y;
-    char* tok0 = parser->Tok[0];
-
-    // Check for deprecated SEGMENTS keyword
-    if (match(tok0, w_SEGMENTS)) return 0;
-
-    // Check for missing value (which is permissible)
-    if (match(tok0, w_SPECGRAV) || match(tok0, w_EMITTER) ||
-        match(tok0, w_DEMAND)   || match(tok0, w_MINIMUM) ||
-        match(tok0, w_REQUIRED) || match(tok0, w_PRESSURE) ||
-        match(tok0, w_PRECISION)
-       ) nvalue = 2;
-    if (n < nvalue) return 0;
-
-    // Check for valid numerical input
-    if (!getfloat(parser->Tok[nvalue], &y)) return setError(parser, nvalue, 202);
-
-    // Quality tolerance option (which can be 0)
-    if (match(tok0, w_TOLERANCE))
-    {
-        if (y < 0.0) return setError(parser, nvalue, 213);
-        qual->Ctol = y;
-        return 0;
-    }
-
-    // Diffusivity
-    if (match(tok0, w_DIFFUSIVITY))
-    {
-        if (y < 0.0) return setError(parser, nvalue, 213);
-        qual->Diffus = y;
-        return 0;
-    }
-
-    // Hydraulic damping limit option */
-    if (match(tok0, w_DAMPLIMIT))
-    {
-        hyd->DampLimit = y;
-        return 0;
-    }
-
-    // Flow change limit
-    else if (match(tok0, w_FLOWCHANGE))
-    {
-          if (y < 0.0) return setError(parser, nvalue, 213);
-          hyd->FlowChangeLimit = y;
-          return 0;
-    }
-
-    // Head loss error limit
-    else if (match(tok0, w_HEADERROR))
-    {
-        if (y < 0.0) return setError(parser, nvalue, 213);
-        hyd->HeadErrorLimit = y;
-        return 0;
-    }
-
-    // Pressure dependent demand parameters
-    else if (match(tok0, w_MINIMUM))
-    {
-        if (y < 0.0) return setError(parser, nvalue, 213);
-        // Required pressure still at default value
-        if (hyd->Preq == MINPDIFF)
-            hyd->Preq = y + MINPDIFF;
-        // Required pressure already entered
-        else if (hyd->Preq - y < MINPDIFF)
-            return setError(parser, nvalue, 208);
-        hyd->Pmin = y;
-        return 0;
-    }
-    else if (match(tok0, w_REQUIRED))
-    {
-        if (y < 0.0) return setError(parser, nvalue, 213);
-        if (y - hyd->Pmin < MINPDIFF)
-            return setError(parser, nvalue, 208);
-        hyd->Preq = y;
-        return 0;
-    }
-    else if (match(tok0, w_PRESSURE))
-    {
-        if (y < 0.0) return setError(parser, nvalue, 213);
-        hyd->Pexp = y;
-        return 0;
-    }
-
-    // All other options must be > 0
-    if (y <= 0.0) return setError(parser, nvalue, 213);
-
-    // Assign value to all other options
-    if (match(tok0, w_VISCOSITY))     hyd->Viscos = y;
-    else if (match(tok0, w_SPECGRAV)) hyd->SpGrav = y;
-    else if (match(tok0, w_TRIALS))   hyd->MaxIter = (int)y;
-    else if (match(tok0, w_ACCURACY))
-    {
-        y = MAX(y, 1.e-5);
-        y = MIN(y, 1.e-1);
-        hyd->Hacc = y;
-    }
-    else if (match(tok0, w_HTOL))  hyd->Htol = y;
-    else if (match(tok0, w_QTOL))  hyd->Qtol = y;
-    else if (match(tok0, w_RQTOL))
-    {
-        if (y >= 1.0) return 213;
-        hyd->RQtol = y;
-    }
-    else if (match(tok0, w_CHECKFREQ)) hyd->CheckFreq = (int)y;
-    else if (match(tok0, w_MAXCHECK))  hyd->MaxCheck = (int)y;
-    else if (match(tok0, w_EMITTER))   hyd->Qexp = 1.0 / y;
-    else if (match(tok0, w_DEMAND))    hyd->Dmult = y;
-    else return 201;
-    return 0;
-}
-
-int getpumpcurve(Project *pr, int n)
-/*
-**--------------------------------------------------------
-**  Input:   n = number of parameters for pump curve
-**  Output:  returns error code
-**  Purpose: processes pump curve data for Version 1.1-
-**           style input data
-**  Notes:
-**    1. Called by pumpdata() in INPUT3.C
-**    2. Current link index & pump index of pump being
-**       processed is found in network variables Nlinks
-**       and Npumps, respectively
-**    3. Curve data read from input line is found in
-**       parser's array X[0],...X[n-1]
-**---------------------------------------------------------
-*/
-{
-    Network *net = &pr->network;
-    Parser  *parser = &pr->parser;
-
-    double a, b, c, h0, h1, h2, q1, q2;
-    Spump *pump = &net->Pump[net->Npumps];
-
-    // Constant HP curve
-    if (n == 1)
-    {
-        if (parser->X[0] <= 0.0) return 202;
-        pump->Ptype = CONST_HP;
-        net->Link[net->Nlinks].Km = parser->X[0];
-    }
-
-    // Power function curve
-    else
-    {
-        // Single point power curve
-        if (n == 2)
-        {
-            q1 = parser->X[1];
-            h1 = parser->X[0];
-            h0 = 1.33334 * h1;
-            q2 = 2.0 * q1;
-            h2 = 0.0;
-        }
-
-        // 3-point power curve
-        else if (n >= 5)
-        {
-            h0 = parser->X[0];
-            h1 = parser->X[1];
-            q1 = parser->X[2];
-            h2 = parser->X[3];
-            q2 = parser->X[4];
-        }
-        else return 202;
-        pump->Ptype = POWER_FUNC;
-        if (!powercurve(h0, h1, h2, q1, q2, &a, &b, &c)) return 206;
-        pump->H0 = -a;
-        pump->R = -b;
-        pump->N = c;
-        pump->Q0 = q1;
-        pump->Qmax = pow((-a / b), (1.0 / c));
-        pump->Hmax = h0;
-    }
-    return 0;
-}
-
-int powercurve(double h0, double h1, double h2, double q1, double q2,
-               double *a, double *b, double *c)
-/*
-**---------------------------------------------------------
-**  Input:   h0 = shutoff head
-**           h1 = design head
-**           h2 = head at max. flow
-**           q1 = design flow
-**           q2 = max. flow
-**  Output:  *a, *b, *c = pump curve coeffs. (H = a-bQ^c),
-**           Returns 1 if sucessful, 0 otherwise.
-**  Purpose: computes coeffs. for pump curve
-**----------------------------------------------------------
-*/
-{
-    double h4, h5;
-
-    if (h0 < TINY || h0 - h1 < TINY || h1 - h2 < TINY ||
-        q1 < TINY || q2 - q1 < TINY
-       ) return 0;
-    *a = h0;
-    h4 = h0 - h1;
-    h5 = h0 - h2;
-    *c = log(h5 / h4) / log(q2 / q1);
-    if (*c <= 0.0 || *c > 20.0) return 0;
-    *b = -h4 / pow(q1, *c);
-    if (*b >= 0.0) return 0;
-    return 1;
-}
-
-void changestatus(Network *net, int j, StatusType status, double y)
-/*
-**--------------------------------------------------------------
-**  Input:   j      = link index
-**           status = status setting (OPEN, CLOSED)
-**           y      = numerical setting (pump speed, valve
-**                    setting)
-**  Output:  none
-**  Purpose: changes status or setting of a link
-**
-**  NOTE: If status = ACTIVE, then a numerical setting (y) was
-**        supplied. If status = OPEN/CLOSED, then numerical
-**        setting is 0.
-**--------------------------------------------------------------
-*/
-{
-    Slink *link = &net->Link[j];
-
-    if (link->Type == PIPE || link->Type == GPV)
-    {
-        if (status != ACTIVE) link->Status = status;
-    }
-    else if (link->Type == PUMP)
-    {
-        if (status == ACTIVE)
-        {
-            link->Kc = y;
-            status = OPEN;
-            if (y == 0.0) status = CLOSED;
-        }
-        else if (status == OPEN) link->Kc = 1.0;
-        link->Status = status;
-    }
-    else if (link->Type >= PRV)
-    {
-        link->Kc = y;
-        link->Status = status;
-        if (status != ACTIVE) link->Kc = MISSING;
-    }
-}