epyt-flow 0.1.0__py3-none-any.whl

epyt_flow/EPANET/EPANET/SRC_engines/project.c

@@ -0,0 +1,1359 @@
+/*
+ ******************************************************************************
+ Project:      OWA EPANET
+ Version:      2.2
+ Module:       project.c
+ Description:  project data management routines
+ Authors:      see AUTHORS
+ Copyright:    see AUTHORS
+ License:      see LICENSE
+ Last Updated: 11/15/2019
+ ******************************************************************************
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h> 
+
+//*** For the Windows SDK _tempnam function ***//
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include "types.h"
+#include "funcs.h"
+
+
+int openfiles(Project *pr, const char *f1, const char *f2, const char *f3)
+/*----------------------------------------------------------------
+**  Input:   f1 = pointer to name of input file
+**           f2 = pointer to name of report file
+**           f3 = pointer to name of binary output file
+**  Output:  none
+**  Returns: error code
+**  Purpose: opens input & report files
+**----------------------------------------------------------------
+*/
+{
+    // Initialize file pointers to NULL
+    pr->parser.InFile = NULL;
+    pr->report.RptFile = NULL;
+    pr->outfile.OutFile = NULL;
+    pr->outfile.HydFile = NULL;
+    pr->outfile.TmpOutFile = NULL;
+
+    // Save file names
+    strncpy(pr->parser.InpFname, f1, MAXFNAME);
+    strncpy(pr->report.Rpt1Fname, f2, MAXFNAME);
+    strncpy(pr->outfile.OutFname, f3, MAXFNAME);
+    if (strlen(f3) > 0) pr->outfile.Outflag = SAVE;
+    else
+    {
+        pr->outfile.Outflag = SCRATCH;
+        strcpy(pr->outfile.OutFname, pr->TmpOutFname);
+    }
+
+    // Check that file names are not identical
+    if (strlen(f1) > 0 && (strcomp(f1, f2) || strcomp(f1, f3))) return 301;
+    if (strlen(f3) > 0 && strcomp(f2, f3)) return 301;
+
+    // Attempt to open input and report files
+    if (strlen(f1) > 0)
+    {
+        if ((pr->parser.InFile = fopen(f1, "rt")) == NULL) return 302;
+    }
+    if (strlen(f2) == 0) pr->report.RptFile = stdout;
+    else
+    {
+        pr->report.RptFile = fopen(f2, "wt");
+        if (pr->report.RptFile == NULL) return 303;
+    }
+    writelogo(pr);
+    return 0;
+}
+
+int openhydfile(Project *pr)
+/*----------------------------------------------------------------
+** Input:   none
+** Output:  none
+** Returns: error code
+** Purpose: opens file that saves hydraulics solution
+**----------------------------------------------------------------
+*/
+{
+    const int Nnodes = pr->network.Nnodes;
+    const int Ntanks = pr->network.Ntanks;
+    const int Nlinks = pr->network.Nlinks;
+    const int Nvalves = pr->network.Nvalves;
+    const int Npumps = pr->network.Npumps;
+
+    INT4 nsize[6]; // Temporary array
+    INT4 magic;
+    INT4 version;
+    int errcode = 0;
+
+    // If HydFile currently open, then close it if its not a scratch file
+    if (pr->outfile.HydFile != NULL)
+    {
+        if (pr->outfile.Hydflag == SCRATCH) return 0;
+        fclose(pr->outfile.HydFile);
+        pr->outfile.HydFile = NULL;
+    }
+
+    // Use Hydflag to determine the type of hydraulics file to use.
+    // Write error message if the file cannot be opened.
+    pr->outfile.HydFile = NULL;
+    switch (pr->outfile.Hydflag)
+    {
+      case SCRATCH:
+        strcpy(pr->outfile.HydFname, pr->TmpHydFname);
+        pr->outfile.HydFile = fopen(pr->outfile.HydFname, "w+b");
+        break;
+      case SAVE:
+        pr->outfile.HydFile = fopen(pr->outfile.HydFname, "w+b");
+        break;
+      case USE:
+        pr->outfile.HydFile = fopen(pr->outfile.HydFname, "rb");
+        break;
+    }
+    if (pr->outfile.HydFile == NULL) return 305;
+
+    // If a previous hydraulics solution is not being used, then
+    // save the current network size parameters to the file.
+    if (pr->outfile.Hydflag != USE)
+    {
+        magic = MAGICNUMBER;
+        version = ENGINE_VERSION;
+        nsize[0] = Nnodes;
+        nsize[1] = Nlinks;
+        nsize[2] = Ntanks;
+        nsize[3] = Npumps;
+        nsize[4] = Nvalves;
+        nsize[5] = (int)pr->times.Dur;
+        fwrite(&magic, sizeof(INT4), 1, pr->outfile.HydFile);
+        fwrite(&version, sizeof(INT4), 1, pr->outfile.HydFile);
+        fwrite(nsize, sizeof(INT4), 6, pr->outfile.HydFile);
+    }
+
+    // If a previous hydraulics solution is being used, then
+    // make sure its network size parameters match those of
+    // the current network
+    if (pr->outfile.Hydflag == USE)
+    {
+        fread(&magic, sizeof(INT4), 1, pr->outfile.HydFile);
+        if (magic != MAGICNUMBER) return 306;
+        fread(&version, sizeof(INT4), 1, pr->outfile.HydFile);
+        if (version != ENGINE_VERSION) return 306;
+        if (fread(nsize, sizeof(INT4), 6, pr->outfile.HydFile) < 6) return 306;
+        if (nsize[0] != Nnodes || nsize[1] != Nlinks || nsize[2] != Ntanks ||
+            nsize[3] != Npumps || nsize[4] != Nvalves ||
+            nsize[5] != pr->times.Dur
+           ) return 306;
+        pr->outfile.SaveHflag = TRUE;
+    }
+
+    // Save current position in hydraulics file
+    // where storage of hydraulic results begins
+    pr->outfile.HydOffset = ftell(pr->outfile.HydFile);
+    return errcode;
+}
+
+int openoutfile(Project *pr)
+/*----------------------------------------------------------------
+**  Input:   none
+**  Output:  none
+**  Returns: error code
+**  Purpose: opens binary output file.
+**----------------------------------------------------------------
+*/
+{
+    int errcode = 0;
+
+    // Close output file if already opened
+    closeoutfile(pr);
+
+    // Try to open binary output file
+    pr->outfile.OutFile = fopen(pr->outfile.OutFname, "w+b");
+    if (pr->outfile.OutFile == NULL) return 304;
+
+    // Save basic network data & energy usage results
+    ERRCODE(savenetdata(pr));
+    pr->outfile.OutOffset1 = ftell(pr->outfile.OutFile);
+    ERRCODE(saveenergy(pr));
+    pr->outfile.OutOffset2 = ftell(pr->outfile.OutFile);
+
+    // Open temporary file if computing time series statistic
+    if (!errcode)
+    {
+        if (pr->report.Tstatflag != SERIES)
+        {
+            pr->outfile.TmpOutFile = fopen(pr->TmpStatFname, "w+b");
+            if (pr->outfile.TmpOutFile == NULL) errcode = 304;
+        }
+        else pr->outfile.TmpOutFile = pr->outfile.OutFile;
+    }
+    return errcode;
+}
+
+void closeoutfile(Project *pr)
+/*----------------------------------------------------------------
+**  Input:   none
+**  Output:  none
+**  Purpose: closes binary output file.
+**----------------------------------------------------------------
+*/
+{
+    if (pr->outfile.TmpOutFile != pr->outfile.OutFile)
+    {
+        if (pr->outfile.TmpOutFile != NULL)
+        {
+            fclose(pr->outfile.TmpOutFile);
+            pr->outfile.TmpOutFile = NULL;
+        }
+    }
+    if (pr->outfile.OutFile != NULL)
+    {
+        if (pr->outfile.OutFile == pr->outfile.TmpOutFile)
+        {
+            pr->outfile.TmpOutFile = NULL;
+        }
+        fclose(pr->outfile.OutFile);
+        pr->outfile.OutFile = NULL;
+    }
+}
+
+void initpointers(Project *pr)
+/*----------------------------------------------------------------
+**  Input:   none
+**  Output:  none
+**  Purpose: initializes data array pointers to NULL
+**----------------------------------------------------------------
+*/
+{
+    Network* nw = &pr->network;
+    nw->Nnodes = 0;
+    nw->Ntanks = 0;
+    nw->Njuncs = 0;
+    nw->Nlinks = 0;
+    nw->Npipes = 0;
+    nw->Npumps = 0;
+    nw->Nvalves = 0;
+    nw->Ncontrols = 0;
+    nw->Nrules = 0;
+    nw->Npats = 0;
+    nw->Ncurves = 0;
+
+    pr->hydraul.NodeDemand = NULL;
+    pr->hydraul.NodeHead = NULL;
+    pr->hydraul.LinkFlow = NULL;
+    pr->hydraul.LinkStatus = NULL;
+    pr->hydraul.LinkSetting = NULL;
+    pr->hydraul.OldStatus = NULL;
+    pr->hydraul.P = NULL;
+    pr->hydraul.Y = NULL;
+    pr->hydraul.Xflow = NULL;
+
+    pr->quality.NodeQual = NULL;
+    pr->quality.PipeRateCoeff = NULL;
+
+    pr->network.Node = NULL;
+    pr->network.Link = NULL;
+    pr->network.Tank = NULL;
+    pr->network.Pump = NULL;
+    pr->network.Valve = NULL;
+    pr->network.Pattern = NULL;
+    pr->network.Curve = NULL;
+    pr->network.Control = NULL;
+    pr->network.Adjlist = NULL;
+    pr->network.NodeHashTable = NULL;
+    pr->network.LinkHashTable = NULL;
+
+    pr->hydraul.smatrix.Aii = NULL;
+    pr->hydraul.smatrix.Aij = NULL;
+    pr->hydraul.smatrix.F = NULL;
+    pr->hydraul.smatrix.Order = NULL;
+    pr->hydraul.smatrix.Row = NULL;
+    pr->hydraul.smatrix.Ndx = NULL;
+    pr->hydraul.smatrix.XLNZ = NULL;
+    pr->hydraul.smatrix.NZSUB = NULL;
+    pr->hydraul.smatrix.LNZ = NULL;
+
+    initrules(pr);
+}
+
+int allocdata(Project *pr)
+/*----------------------------------------------------------------
+**  Input:   none
+**  Output:  none
+**  Returns: error code
+**  Purpose: allocates memory for network data structures
+**----------------------------------------------------------------
+*/
+{
+    int n;
+    int errcode = 0;
+
+    // Allocate node & link ID hash tables
+    pr->network.NodeHashTable = hashtable_create();
+    pr->network.LinkHashTable = hashtable_create();
+    ERRCODE(MEMCHECK(pr->network.NodeHashTable));
+    ERRCODE(MEMCHECK(pr->network.LinkHashTable));
+
+    // Allocate memory for network nodes
+    //*************************************************************
+    // NOTE: Because network components of a given type are indexed
+    // starting from 1, their arrays must be sized 1
+    // element larger than the number of components.
+    //*************************************************************
+    if (!errcode)
+    {
+        n = pr->parser.MaxNodes + 1;
+        pr->network.Node       = (Snode *)calloc(n, sizeof(Snode));
+        pr->hydraul.NodeDemand = (double *)calloc(n, sizeof(double));
+        pr->hydraul.NodeHead   = (double *)calloc(n, sizeof(double));
+        pr->quality.NodeQual   = (double *)calloc(n, sizeof(double));
+        ERRCODE(MEMCHECK(pr->network.Node));
+        ERRCODE(MEMCHECK(pr->hydraul.NodeDemand));
+        ERRCODE(MEMCHECK(pr->hydraul.NodeHead));
+        ERRCODE(MEMCHECK(pr->quality.NodeQual));
+    }
+
+    // Allocate memory for network links
+    if (!errcode)
+    {
+        n = pr->parser.MaxLinks + 1;
+        pr->network.Link        = (Slink *)calloc(n, sizeof(Slink));
+        pr->hydraul.LinkFlow    = (double *)calloc(n, sizeof(double));
+        pr->hydraul.LinkSetting = (double *)calloc(n, sizeof(double));
+        pr->hydraul.LinkStatus  = (StatusType *)calloc(n, sizeof(StatusType));
+        ERRCODE(MEMCHECK(pr->network.Link));
+        ERRCODE(MEMCHECK(pr->hydraul.LinkFlow));
+        ERRCODE(MEMCHECK(pr->hydraul.LinkSetting));
+        ERRCODE(MEMCHECK(pr->hydraul.LinkStatus));
+    }
+
+    // Allocate memory for tanks, sources, pumps, valves, and controls
+    // (memory for Patterns and Curves arrays expanded as each is added)
+    if (!errcode)
+    {
+        pr->network.Tank =
+            (Stank *)calloc(pr->parser.MaxTanks + 1, sizeof(Stank));
+        pr->network.Pump =
+            (Spump *)calloc(pr->parser.MaxPumps + 1, sizeof(Spump));
+        pr->network.Valve =
+            (Svalve *)calloc(pr->parser.MaxValves + 1, sizeof(Svalve));
+        pr->network.Control =
+            (Scontrol *)calloc(pr->parser.MaxControls + 1, sizeof(Scontrol));
+        ERRCODE(MEMCHECK(pr->network.Tank));
+        ERRCODE(MEMCHECK(pr->network.Pump));
+        ERRCODE(MEMCHECK(pr->network.Valve));
+        ERRCODE(MEMCHECK(pr->network.Control));
+    }
+
+    // Initialize pointers used in nodes and links
+    if (!errcode)
+    {
+        for (n = 0; n <= pr->parser.MaxNodes; n++)
+        {
+            pr->network.Node[n].D = NULL;    // node demand
+            pr->network.Node[n].S = NULL;    // node source
+            pr->network.Node[n].Comment = NULL;
+        }
+        for (n = 0; n <= pr->parser.MaxLinks; n++)
+        {
+            pr->network.Link[n].Vertices = NULL;
+            pr->network.Link[n].Comment = NULL;
+        }
+    }
+
+    // Allocate memory for rule base (see RULES.C)
+    if (!errcode) errcode = allocrules(pr);
+    return errcode;
+}
+
+void freedata(Project *pr)
+/*----------------------------------------------------------------
+**  Input:   none
+**  Output:  none
+**  Purpose: frees memory allocated for network data structures.
+**----------------------------------------------------------------
+*/
+{
+    int j;
+
+    // Free memory for computed results
+    free(pr->hydraul.NodeDemand);
+    free(pr->hydraul.NodeHead);
+    free(pr->hydraul.LinkFlow);
+    free(pr->hydraul.LinkSetting);
+    free(pr->hydraul.LinkStatus);
+    free(pr->quality.NodeQual);
+
+    // Free memory used for nodal adjacency lists
+    freeadjlists(&pr->network);
+
+    // Free memory for node data
+    if (pr->network.Node != NULL)
+    {
+        for (j = 1; j <= pr->network.Nnodes; j++)
+        {
+            // Free memory used for demands and WQ source data
+            freedemands(&(pr->network.Node[j]));
+            free(pr->network.Node[j].S);
+            free(pr->network.Node[j].Comment);
+        }
+        free(pr->network.Node);
+    }
+
+    // Free memory for link data
+    if (pr->network.Link != NULL)
+    {
+        for (j = 1; j <= pr->network.Nlinks; j++)
+        {
+            freelinkvertices(&pr->network.Link[j]);
+            free(pr->network.Link[j].Comment);
+        }
+    }
+    free(pr->network.Link);
+
+    // Free memory for other network objects
+    free(pr->network.Tank);
+    free(pr->network.Pump);
+    free(pr->network.Valve);
+    free(pr->network.Control);
+
+    // Free memory for time patterns
+    if (pr->network.Pattern != NULL)
+    {
+        for (j = 0; j <= pr->network.Npats; j++)
+        {
+            free(pr->network.Pattern[j].F);
+            free(pr->network.Pattern[j].Comment);
+        }
+        free(pr->network.Pattern);
+    }
+
+    // Free memory for curves
+    if (pr->network.Curve != NULL)
+    {
+        // There is no Curve[0]
+        for (j = 1; j <= pr->network.Ncurves; j++)
+        {
+            free(pr->network.Curve[j].X);
+            free(pr->network.Curve[j].Y);
+            free(pr->network.Curve[j].Comment);
+        }
+        free(pr->network.Curve);
+    }
+
+    // Free memory for rule base (see RULES.C)
+    freerules(pr);
+
+    // Free hash table memory
+    if (pr->network.NodeHashTable != NULL)
+    {
+        hashtable_free(pr->network.NodeHashTable);
+    }
+    if (pr->network.LinkHashTable != NULL)
+    {
+        hashtable_free(pr->network.LinkHashTable);
+    }
+}
+
+Pdemand finddemand(Pdemand d, int index)
+/*----------------------------------------------------------------
+**  Input:   d = pointer to start of a list of demands
+**           index = the position of the demand to retrieve
+**  Output:  none
+**  Returns: the demand at the requested position
+**  Purpose: finds the demand at a given position in a demand list
+**----------------------------------------------------------------
+*/
+{
+    int n = 1;
+    if (index <= 0)return NULL;
+    while (d)
+    {
+        if (n == index) break;
+        n++;
+        d = d->next;
+    }
+    return d;
+}
+
+int adddemand(Snode *node, double dbase, int dpat, char *dname)
+/*----------------------------------------------------------------
+**  Input:   node = a network junction node
+**           dbase = base demand value
+**           dpat = demand pattern index
+**           dname = name of demand category
+**  Output:  returns TRUE if successful, FALSE if not
+**  Purpose: adds a new demand category to a node.
+**----------------------------------------------------------------
+*/
+{
+    Pdemand demand, lastdemand;
+
+    // Create a new demand struct
+    demand = (struct Sdemand *)malloc(sizeof(struct Sdemand));
+    if (demand == NULL) return FALSE;
+
+    // Assign it the designated properties
+    demand->Base = dbase;
+    demand->Pat = dpat;
+    demand->Name = NULL;
+    if (dname && strlen(dname) > 0) xstrcpy(&demand->Name, dname, MAXID);
+    demand->next = NULL;
+
+    // If node has no demands make this its first demand category
+    if (node->D == NULL) node->D = demand;
+
+    // Otherwise append this demand to the end of the node's demands list
+    else
+    {
+        lastdemand = node->D;
+        while (lastdemand->next) lastdemand = lastdemand->next;
+        lastdemand->next = demand;
+    }
+    return TRUE;
+}
+
+void freedemands(Snode *node)
+/*----------------------------------------------------------------
+**  Input:   node = a network junction node
+**  Output:  node
+**  Purpose: frees the memory used for a node's list of demands.
+**----------------------------------------------------------------
+*/
+{
+    Pdemand nextdemand;
+    Pdemand demand = node->D;
+    while (demand != NULL)
+    {
+        nextdemand = demand->next;
+        free(demand->Name);
+        free(demand);
+        demand = nextdemand;
+    }
+    node->D = NULL;
+}
+
+int  addlinkvertex(Slink *link, double x, double y)
+/*----------------------------------------------------------------
+**  Input:   link = pointer to a network link
+**           x = x-coordinate of a new vertex
+**           y = y-coordiante of a new vertex
+**  Returns: an error code
+**  Purpose: adds to a link's collection of vertex points.
+**----------------------------------------------------------------
+*/
+{
+    static int CHUNKSIZE = 5;
+    int n;
+    Pvertices vertices;
+    if (link->Vertices == NULL)
+    {
+        vertices = (struct Svertices *) malloc(sizeof(struct Svertices));
+        if (vertices == NULL) return 101;
+        vertices->Npts = 0;
+        vertices->Capacity = CHUNKSIZE;
+        vertices->X = (double *) calloc(vertices->Capacity, sizeof(double));
+        vertices->Y = (double *) calloc(vertices->Capacity, sizeof(double));
+        link->Vertices = vertices;
+    }
+    vertices = link->Vertices;
+    if (vertices->Npts >= vertices->Capacity)
+    {
+        vertices->Capacity += CHUNKSIZE;
+        vertices->X = realloc(vertices->X, vertices->Capacity * sizeof(double));
+        vertices->Y = realloc(vertices->Y, vertices->Capacity * sizeof(double));
+    }
+    if (vertices->X == NULL || vertices->Y == NULL) return 101;
+    n = vertices->Npts;
+    vertices->X[n] = x;
+    vertices->Y[n] = y;
+    vertices->Npts++;
+    return 0;    
+}
+
+void freelinkvertices(Slink *link)
+/*----------------------------------------------------------------
+**  Input:   vertices = list of link vertex points
+**  Output:  none
+**  Purpose: frees the memory used for a link's list of vertices.
+**----------------------------------------------------------------
+*/
+{
+    if (link->Vertices)
+    {
+        free(link->Vertices->X);
+        free(link->Vertices->Y);
+        free(link->Vertices);
+        link->Vertices = NULL;
+    }
+}
+
+int  buildadjlists(Network *net)
+/*
+**--------------------------------------------------------------
+** Input:   none
+** Output:  returns error code
+** Purpose: builds linked list of links adjacent to each node
+**--------------------------------------------------------------
+*/
+{
+    int       i, j, k;
+    int       errcode = 0;
+    Padjlist  alink;
+
+    // Create an array of adjacency lists
+    freeadjlists(net);
+    net->Adjlist = (Padjlist *)calloc(net->Nnodes + 1, sizeof(Padjlist));
+    if (net->Adjlist == NULL) return 101;
+    for (i = 0; i <= net->Nnodes; i++) net->Adjlist[i] = NULL;
+
+    // For each link, update adjacency lists of its end nodes
+    for (k = 1; k <= net->Nlinks; k++)
+    {
+        i = net->Link[k].N1;
+        j = net->Link[k].N2;
+
+        // Include link in start node i's list
+        alink = (struct Sadjlist *) malloc(sizeof(struct Sadjlist));
+        if (alink == NULL)
+        {
+            errcode = 101;
+            break;
+        }
+        alink->node = j;
+        alink->link = k;
+        alink->next = net->Adjlist[i];
+        net->Adjlist[i] = alink;
+
+        // Include link in end node j's list
+        alink = (struct Sadjlist *) malloc(sizeof(struct Sadjlist));
+        if (alink == NULL)
+        {
+            errcode = 101;
+            break;
+        }
+        alink->node = i;
+        alink->link = k;
+        alink->next = net->Adjlist[j];
+        net->Adjlist[j] = alink;
+    }
+    if (errcode) freeadjlists(net);
+    return errcode;
+}
+
+
+void  freeadjlists(Network *net)
+/*
+**--------------------------------------------------------------
+** Input:   none
+** Output:  none
+** Purpose: frees memory used for nodal adjacency lists
+**--------------------------------------------------------------
+*/
+{
+    int   i;
+    Padjlist alink;
+
+    if (net->Adjlist == NULL) return;
+    for (i = 0; i <= net->Nnodes; i++)
+    {
+        for (alink = net->Adjlist[i]; alink != NULL; alink = net->Adjlist[i])
+        {
+            net->Adjlist[i] = alink->next;
+            free(alink);
+        }
+    }
+    FREE(net->Adjlist);
+}
+
+int incontrols(Project *pr, int objType, int index)
+/*----------------------------------------------------------------
+**  Input:   objType = type of object (either NODE or LINK)
+**           index  = the object's index
+**  Output:  none
+**  Returns: 1 if any controls contain the object; 0 if not
+**  Purpose: determines if any simple or rule-based controls
+**           contain a particular node or link.
+**----------------------------------------------------------------
+*/
+{
+    Network *net = &pr->network;
+
+    int i, ruleObject;
+    Spremise *premise;
+    Saction *action;
+
+    // Check simple controls
+    for (i = 1; i <= net->Ncontrols; i++)
+    {
+        if (objType == NODE && net->Control[i].Node == index) return 1;
+        if (objType == LINK && net->Control[i].Link == index) return 1;
+    }
+
+    // Check rule-based controls
+    for (i = 1; i <= net->Nrules; i++)
+    {
+        // Convert objType to a rule object type
+        if (objType == NODE) ruleObject = 6;
+        else                 ruleObject = 7;
+
+        // Check rule's premises
+        premise = net->Rule[i].Premises;
+        while (premise != NULL)
+        {
+            if (ruleObject == premise->object && premise->index == index) return 1;
+            premise = premise->next;
+        }
+
+        // Rule actions only need to be checked for link objects
+        if (objType == LINK)
+        {
+            // Check rule's THEN actions
+            action = net->Rule[i].ThenActions;
+            while (action != NULL)
+            {
+                if (action->link == index) return 1;
+                action = action->next;
+            }
+
+            // Check rule's ELSE actions
+            action = net->Rule[i].ElseActions;
+            while (action != NULL)
+            {
+                if (action->link == index) return 1;
+                action = action->next;
+            }
+        }
+    }
+    return 0;
+}
+
+int valvecheck(Project *pr, int index, int type, int j1, int j2)
+/*
+**--------------------------------------------------------------
+**  Input:   index = link index
+**           type = valve type
+**           j1   = index of upstream node
+**           j2   = index of downstream node
+**  Output:  returns an error code
+**  Purpose: checks for illegal connections between valves
+**--------------------------------------------------------------
+*/
+{
+    Network *net = &pr->network;
+
+    int k, vj1, vj2;
+    LinkType vtype;
+    Slink *link;
+    Svalve *valve;
+
+    if (type == PRV || type == PSV || type == FCV)
+    {
+        // Can't be connected to a fixed grade node
+        if (j1 > net->Njuncs || j2 > net->Njuncs) return 219;
+
+        // Examine each existing valve
+        for (k = 1; k <= net->Nvalves; k++)
+        {
+            valve = &net->Valve[k];
+            if (valve->Link == index) continue;
+            link = &net->Link[valve->Link];
+            vj1 = link->N1;
+            vj2 = link->N2;
+            vtype = link->Type;
+
+            // Cannot have two PRVs sharing downstream nodes or in series
+            if (vtype == PRV && type == PRV)
+            {
+                if (vj2 == j2 || vj2 == j1 || vj1 == j2) return 220;
+            }
+
+            // Cannot have two PSVs sharing upstream nodes or in series
+            if (vtype == PSV && type == PSV)
+            {
+                if (vj1 == j1 || vj1 == j2 || vj2 == j1) return 220;
+            }
+
+            // Cannot have PSV connected to downstream node of PRV
+            if (vtype == PSV && type == PRV && vj1 == j2) return 220;
+            if (vtype == PRV && type == PSV && vj2 == j1) return 220;
+
+            // Cannot have PSV connected to downstream node of FCV
+            // nor have PRV connected to upstream node of FCV
+            if (vtype == FCV && type == PSV && vj2 == j1) return 220;
+            if (vtype == FCV && type == PRV && vj1 == j2) return 220;
+            if (vtype == PSV && type == FCV && vj1 == j2) return 220;
+            if (vtype == PRV && type == FCV && vj2 == j1) return 220;
+        }
+    }
+    return 0;
+}
+
+int findnode(Network *network, char *id)
+/*----------------------------------------------------------------
+**  Input:   id = node ID
+**  Output:  none
+**  Returns: index of node with given ID, or 0 if ID not found
+**  Purpose: uses hash table to find index of node with given ID
+**----------------------------------------------------------------
+*/
+{
+    return (hashtable_find(network->NodeHashTable, id));
+}
+
+int findlink(Network *network, char *id)
+/*----------------------------------------------------------------
+**  Input:   id = link ID
+**  Output:  none
+**  Returns: index of link with given ID, or 0 if ID not found
+**  Purpose: uses hash table to find index of link with given ID
+**----------------------------------------------------------------
+*/
+{
+    return (hashtable_find(network->LinkHashTable, id));
+}
+
+int findtank(Network *network, int index)
+/*----------------------------------------------------------------
+**  Input:   index = node index
+**  Output:  none
+**  Returns: index of tank with given node id, or NOTFOUND if tank not found
+**  Purpose: for use in the deletenode function
+**----------------------------------------------------------------
+*/
+{
+    int i;
+    for (i = 1; i <= network->Ntanks; i++)
+    {
+        if (network->Tank[i].Node == index) return i;
+    }
+    return NOTFOUND;
+}
+
+int findpump(Network *network, int index)
+/*----------------------------------------------------------------
+**  Input:   index = link ID
+**  Output:  none
+**  Returns: index of pump with given link id, or NOTFOUND if pump not found
+**  Purpose: for use in the deletelink function
+**----------------------------------------------------------------
+*/
+{
+    int i;
+    for (i = 1; i <= network->Npumps; i++)
+    {
+        if (network->Pump[i].Link == index) return i;
+    }
+    return NOTFOUND;
+}
+
+int findvalve(Network *network, int index)
+/*----------------------------------------------------------------
+**  Input:   index = link ID
+**  Output:  none
+**  Returns: index of valve with given link id, or NOTFOUND if valve not found
+**  Purpose: for use in the deletelink function
+**----------------------------------------------------------------
+*/
+{
+    int i;
+    for (i = 1; i <= network->Nvalves; i++)
+    {
+        if (network->Valve[i].Link == index) return i;
+    }
+    return NOTFOUND;
+}
+
+int findpattern(Network *network, char *id)
+/*----------------------------------------------------------------
+**  Input:   id = time pattern ID
+**  Output:  none
+**  Returns: time pattern index, or -1 if pattern not found
+**  Purpose: finds index of time pattern given its ID
+**----------------------------------------------------------------
+*/
+{
+    int i;
+
+    // Don't forget to include the "dummy" pattern 0 in the search
+    for (i = 0; i <= network->Npats; i++)
+    {
+        if (strcmp(id, network->Pattern[i].ID) == 0) return i;
+    }
+    return -1;
+}
+
+int findcurve(Network *network, char *id)
+/*----------------------------------------------------------------
+**  Input:   id = data curve ID
+**  Output:  none
+**  Returns: data curve index, or 0 if curve not found
+**  Purpose: finds index of data curve given its ID
+**----------------------------------------------------------------
+*/
+{
+    int i;
+    for (i = 1; i <= network->Ncurves; i++)
+    {
+        if (strcmp(id, network->Curve[i].ID) == 0) return i;
+    }
+    return 0;
+}
+
+void adjustpattern(int *pat, int index)
+/*----------------------------------------------------------------
+** Local function that modifies a reference to a deleted time pattern
+**----------------------------------------------------------------
+*/
+{
+	if (*pat == index) *pat = 0;
+	else if (*pat > index) (*pat)--;
+}
+
+void adjustpatterns(Network *network, int index)
+/*----------------------------------------------------------------
+**  Input:   index = index of time pattern being deleted
+**  Output:  none
+**  Purpose: modifies references made to a deleted time pattern
+**----------------------------------------------------------------
+*/
+{
+    int j;
+    Pdemand demand;
+    Psource source;
+
+    // Adjust patterns used by junctions
+    for (j = 1; j <= network->Nnodes; j++)
+    {
+        // Adjust demand patterns
+        for (demand = network->Node[j].D; demand != NULL; demand = demand->next)
+        {
+            adjustpattern(&demand->Pat, index);
+        }
+        // Adjust WQ source patterns
+        source = network->Node[j].S;
+        if (source) adjustpattern(&source->Pat, index);
+    }
+
+    // Adjust patterns used by reservoir tanks
+    for (j = 1; j <= network->Ntanks; j++)
+    {
+        adjustpattern(&network->Tank[j].Pat, index);
+    }
+
+    // Adjust patterns used by pumps
+    for (j = 1; j <= network->Npumps; j++)
+    {
+        adjustpattern(&network->Pump[j].Upat, index);
+        adjustpattern(&network->Pump[j].Epat, index);
+    }
+}
+
+void adjustcurve(int *curve, int index)
+/*----------------------------------------------------------------
+** Local function that modifies a reference to a deleted data curve
+**----------------------------------------------------------------
+*/
+{
+    if (*curve == index) *curve = 0;
+    else if (*curve > index) (*curve)--;
+}
+
+void adjustcurves(Network *network, int index)
+/*----------------------------------------------------------------
+**  Input:   index = index of data curve being deleted
+**  Output:  none
+**  Purpose: modifies references made to a deleted data curve
+**----------------------------------------------------------------
+*/
+{
+    int j, k, setting;
+
+    // Adjust tank volume curves
+    for (j = 1; j <= network->Ntanks; j++)
+    {
+        adjustcurve(&network->Tank[j].Vcurve, index);
+    }
+
+    // Adjust pump curves
+    for (j = 1; j <= network->Npumps; j++)
+    {
+        adjustcurve(&network->Pump[j].Hcurve, index);
+        adjustcurve(&network->Pump[j].Ecurve, index);
+    }
+
+    // Adjust GPV curves
+    for (j = 1; j <= network->Nvalves; j++)
+    {
+        k = network->Valve[j].Link;
+        if (network->Link[k].Type == GPV)
+        {
+            setting = INT(network->Link[k].Kc);
+            adjustcurve(&setting, index);
+            network->Link[k].Kc = setting;
+        }
+    }
+}
+
+int adjustpumpparams(Project *pr, int curveIndex)
+/*----------------------------------------------------------------
+**  Input:   curveIndex = index of a data curve
+**  Output:  returns an error code
+**  Purpose: updates head curve parameters for pumps using a 
+**           curve whose data have been modified.
+**----------------------------------------------------------------
+*/
+{
+    Network *network = &pr->network;
+
+    double *Ucf = pr->Ucf;
+    int j, err = 0;
+    Spump *pump;
+    
+    // Check each pump
+    for (j = 1; j <= network->Npumps; j++)
+    {
+        // Pump uses curve as head curve
+        pump = &network->Pump[j];
+        if ( curveIndex == pump->Hcurve)
+        {
+            // Update its head curve parameters
+            pump->Ptype = NOCURVE;
+            err = updatepumpparams(pr, curveIndex);
+            if (err > 0) break;
+            
+            // Convert parameters to internal units
+            if (pump->Ptype == POWER_FUNC)
+            {
+                pump->H0 /= Ucf[HEAD];
+                pump->R *= (pow(Ucf[FLOW], pump->N) / Ucf[HEAD]);
+            }
+            pump->Q0 /= Ucf[FLOW];
+            pump->Qmax /= Ucf[FLOW];
+            pump->Hmax /= Ucf[HEAD];
+        }
+    }
+    return err;
+}
+        
+
+int resizecurve(Scurve *curve, int size)
+/*----------------------------------------------------------------
+**  Input:   curve = a data curve object
+**           size = desired number of curve data points
+**  Output:  error code
+**  Purpose: resizes a data curve to a desired size
+**----------------------------------------------------------------
+*/
+{
+    double *x;
+    double *y;
+
+    if (curve->Capacity < size)
+    {
+        x = (double *)realloc(curve->X, size * sizeof(double));
+        if (x == NULL) return 101;
+        y = (double *)realloc(curve->Y, size * sizeof(double));
+        if (y == NULL)
+        {
+            free(x);
+            return 101;
+        }
+        curve->X = x;
+        curve->Y = y;
+        curve->Capacity = size;
+    }
+    return 0;
+}
+
+int  getcomment(Network *network, int object, int index, char *comment)
+//----------------------------------------------------------------
+//  Input:   object = a type of network object
+//           index = index of the specified object
+//           comment = the object's comment string
+//  Output:  error code
+//  Purpose: gets the comment string assigned to an object.
+//----------------------------------------------------------------
+{
+    char *currentcomment;
+
+    // Get pointer to specified object's comment
+    switch (object)
+    {
+    case NODE:
+        if (index < 1 || index > network->Nnodes) return 251;
+        currentcomment = network->Node[index].Comment;
+        break;
+    case LINK:
+        if (index < 1 || index > network->Nlinks) return 251;
+        currentcomment = network->Link[index].Comment;
+        break;
+    case TIMEPAT:
+        if (index < 1 || index > network->Npats) return 251;
+        currentcomment = network->Pattern[index].Comment;
+        break;
+    case CURVE:
+        if (index < 1 || index > network->Ncurves) return 251;
+        currentcomment = network->Curve[index].Comment;
+        break;
+    default:
+        strcpy(comment, "");
+        return 251;
+    }
+
+    // Copy the object's comment to the returned string
+    if (currentcomment) strcpy(comment, currentcomment);
+    else comment[0] = '\0';
+    return 0;
+}
+
+int setcomment(Network *network, int object, int index, const char *newcomment)
+//----------------------------------------------------------------
+//  Input:   object = a type of network object
+//           index = index of the specified object
+//           newcomment = new comment string
+//  Output:  error code
+//  Purpose: sets the comment string of an object.
+//----------------------------------------------------------------
+{
+    char *comment;
+
+    switch (object)
+    {
+    case NODE:
+        if (index < 1 || index > network->Nnodes) return 251;
+        comment = network->Node[index].Comment;
+        network->Node[index].Comment = xstrcpy(&comment, newcomment, MAXMSG);
+        return 0;
+
+    case LINK:
+        if (index < 1 || index > network->Nlinks) return 251;
+        comment = network->Link[index].Comment;
+        network->Link[index].Comment = xstrcpy(&comment, newcomment, MAXMSG);
+        return 0;
+
+    case TIMEPAT:
+        if (index < 1 || index > network->Npats) return 251;
+        comment = network->Pattern[index].Comment;
+        network->Pattern[index].Comment = xstrcpy(&comment, newcomment, MAXMSG);
+        return 0;
+
+    case CURVE:
+        if (index < 1 || index > network->Ncurves) return 251;
+        comment = network->Curve[index].Comment;
+        network->Curve[index].Comment = xstrcpy(&comment, newcomment, MAXMSG);
+        return 0;
+
+    default: return 251;
+    }
+}
+
+int namevalid(const char *name)
+//----------------------------------------------------------------
+//  Input:   name = name used to ID an object
+//  Output:  returns TRUE if name is valid, FALSE if not
+//  Purpose: checks that an object's ID name is valid.
+//----------------------------------------------------------------
+{
+    size_t n = strlen(name);
+    if (n < 1 || n > MAXID || strpbrk(name, " ;") || name[0] == '"') return FALSE;
+    return TRUE;
+}
+
+void getTmpName(char *fname)
+//----------------------------------------------------------------
+//  Input:   fname = file name string
+//  Output:  an unused file name
+//  Purpose: creates a temporary file name with an "en" prefix
+//           or a blank name if an error occurs.
+//----------------------------------------------------------------
+{
+#ifdef _WIN32
+
+    char* name = NULL;
+
+    // --- use Windows _tempnam function to get a pointer to an
+    //     unused file name that begins with "en"
+    strcpy(fname, "");
+    name = _tempnam(NULL, "en");
+    if (name)
+    {
+        // --- copy the file name to fname
+        if (strlen(name) < MAXFNAME) strncpy(fname, name, MAXFNAME);
+
+        // --- free the pointer returned by _tempnam
+        free(name);
+    }
+    // --- for non-Windows systems:
+#else
+    // --- use system function mkstemp() to create a temporary file name
+/*    
+    int f = -1;
+    strcpy(fname, "enXXXXXX");
+    f = mkstemp(fname);
+    close(f);
+    remove(fname);
+*/
+    strcpy(fname, "enXXXXXX");
+    FILE *f = fdopen(mkstemp(fname), "r");
+    if (f == NULL) strcpy(fname, "");
+    else fclose(f);
+    remove(fname);
+#endif
+}
+
+char *xstrcpy(char **s1, const char *s2, const size_t n)
+//----------------------------------------------------------------
+//  Input:   s1 = destination string
+//           s2 = source string
+//           n = maximum size of strings
+//  Output:  none
+//  Purpose: like strcpy except for dynamic strings.
+//  Note:    The calling program is responsible for ensuring that
+//           s1 points to a valid memory location or is NULL. E.g.,
+//           the following code will likely cause a segment fault:
+//             char *s;
+//             s = xstrcpy(s, "Some text");
+//           while this would work correctly:
+//             char *s = NULL;
+//             s = xstrcpy(s, "Some text");
+//----------------------------------------------------------------
+{
+    size_t n1 = 0, n2 = 0;
+
+    // Find size of source string
+    if (s2) n2 = strlen(s2);
+    if (n2 > n) n2 = n;
+
+    // Source string is empty -- free destination string
+    if (n2 == 0)
+    {
+        free(*s1);
+        *s1 = NULL;
+        return NULL;
+    }
+
+    // See if size of destination string needs to grow
+    if (*s1) n1 = strlen(*s1);
+    if (n2 > n1) *s1 = realloc(*s1, (n2 + 1) * sizeof(char));
+
+    // Copy the source string into the destination string
+    strncpy(*s1, s2, n2+1);
+    return *s1;
+}
+
+int strcomp(const char *s1, const char *s2)
+/*---------------------------------------------------------------
+**  Input:   s1 = character string
+**           s2 = character string
+**  Output:  none
+**  Returns: 1 if s1 is same as s2, 0 otherwise
+**  Purpose: case insensitive comparison of strings s1 & s2
+**---------------------------------------------------------------
+*/
+{
+    int i;
+    for (i = 0; UCHAR(s1[i]) == UCHAR(s2[i]); i++)
+    {
+        if (!s1[i + 1] && !s2[i + 1]) return 1;
+    }
+    return 0;
+}
+
+double interp(int n, double x[], double y[], double xx)
+/*----------------------------------------------------------------
+**  Input:   n  = number of data pairs defining a curve
+**           x  = x-data values of curve
+**           y  = y-data values of curve
+**           xx = specified x-value
+**  Output:  none
+**  Returns: y-value on curve at x = xx
+**  Purpose: uses linear interpolation to find y-value on a
+**           data curve corresponding to specified x-value.
+**  NOTE:    does not extrapolate beyond endpoints of curve.
+**----------------------------------------------------------------
+*/
+{
+    int k, m;
+    double dx, dy;
+
+    m = n - 1;                        // Highest data index
+    if (xx <= x[0]) return (y[0]);    // xx off low end of curve
+    for (k = 1; k <= m; k++)          // Bracket xx on curve
+    {
+        if (x[k] >= xx)               // Interp. over interval
+        {
+            dx = x[k] - x[k - 1];
+            dy = y[k] - y[k - 1];
+            if (ABS(dx) < TINY) return (y[k]);
+            else return (y[k] - (x[k] - xx) * dy / dx);
+        }
+    }
+    return (y[m]); // xx off high end of curve
+}
+
+char *geterrmsg(int errcode, char *msg)
+/*----------------------------------------------------------------
+**  Input:   errcode = error code
+**  Output:  none
+**  Returns: pointer to string with error message
+**  Purpose: retrieves text of error message
+**----------------------------------------------------------------
+*/
+{
+    switch (errcode)
+    {
+
+//#define DAT(code,string) case code: sprintf(msg, "%s", string); break;
+#define DAT(code,string) case code: strcpy(msg, string); break;
+#include "errors.dat"
+#undef DAT
+
+    default:
+        strcpy(msg, "");
+    }
+    return (msg);
+}
+
+void errmsg(Project *pr, int errcode)
+/*----------------------------------------------------------------
+**  Input:   errcode = error code
+**  Output:  none
+**  Purpose: writes error message to report file
+**----------------------------------------------------------------
+*/
+{
+    char errmsg[MAXMSG + 1] = "";
+    if (errcode == 309) /* Report file write error -  */
+    {                   /* Do not write msg to file.  */
+
+    }
+    else if (pr->report.RptFile != NULL && pr->report.Messageflag && errcode > 100)
+    {
+        sprintf(pr->Msg, "Error %d: %s", errcode, geterrmsg(errcode, errmsg));
+        writeline(pr, pr->Msg);
+    }
+}
+
+void writewin(void(*vp)(char *), char *s)
+/*----------------------------------------------------------------
+**  Input:   text string
+**  Output:  none
+**  Purpose: passes character string to viewprog() in
+**           application which calls the EPANET DLL
+**----------------------------------------------------------------
+*/
+{
+    char progmsg[MAXMSG + 1];
+    if (vp != NULL)
+    {
+        strncpy(progmsg, s, MAXMSG);
+        vp(progmsg);
+    }
+}