epyt-flow 0.14.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

epyt_flow/EPANET/EPANET/SRC_engines/epanet.c

@@ -1,13 +1,13 @@
 /*
  ******************************************************************************
  Project:      OWA EPANET
- Version:      2.2
+ Version:      2.3
  Module:       epanet.c
  Description:  implementation of EPANET's API functions
  Authors:      see AUTHORS
  Copyright:    see AUTHORS
  License:      see LICENSE
- Last Updated: 11/15/2019
+ Last Updated: 04/23/2025
  ******************************************************************************
 */
 
@@ -143,7 +143,7 @@ int DLLEXPORT EN_init(EN_Project p, const char *rptFile, const char *outFile,
     p->report.Rptflag = 1;
 
     // Check for valid arguments
-    if (unitsType < 0 || unitsType > CMD) return 251;
+    if (unitsType < 0 || unitsType > CMS) return 251;
     if (headLossType < 0 || headLossType > CM) return 251;
 
     // Open files
@@ -179,61 +179,29 @@ int DLLEXPORT EN_open(EN_Project p, const char *inpFile, const char *rptFile,
  **           outFile = name of binary output file
  **  Output:  none
  **  Returns: error code
- **  Purpose: opens an EPANET input file & reads in network data
+ **  Purpose: reads an EPANET input file with no errors allowed.
  **----------------------------------------------------------------
  */
-{
-  int errcode = 0;
-
-  // Set system flags
-  p->Openflag = FALSE;
-  p->hydraul.OpenHflag = FALSE;
-  p->quality.OpenQflag = FALSE;
-  p->outfile.SaveHflag = FALSE;
-  p->outfile.SaveQflag = FALSE;
-  p->Warnflag = FALSE;
-  p->report.Messageflag = TRUE;
-  p->report.Rptflag = 1;
-
-  // Initialize data arrays to NULL
-  initpointers(p);
-
-  // Open input & report files
-  ERRCODE(openfiles(p, inpFile, rptFile, outFile));
-  if (errcode > 0)
-  {
-    errmsg(p, errcode);
-    return errcode;
-  }
-
-  // Allocate memory for project's data arrays
-  writewin(p->viewprog, FMT100);
-  ERRCODE(netsize(p));
-  ERRCODE(allocdata(p));
-
-  // Read input data
-  ERRCODE(getdata(p));
-
-  // Close input file
-  if (p->parser.InFile != NULL)
-  {
-      fclose(p->parser.InFile);
-      p->parser.InFile = NULL;
-  }
-
-  // If using previously saved hydraulics file then open it
-  if (p->outfile.Hydflag == USE) ERRCODE(openhydfile(p));
+ {
+   writewin(p->viewprog, FMT100);
+   return openproject(p, inpFile, rptFile, outFile, FALSE);
+ }     
 
-  // Write input summary to report file
-  if (!errcode)
-  {
-    if (p->report.Summaryflag) writesummary(p);
-    writetime(p, FMT104);
-    p->Openflag = TRUE;
-  }
-  else errmsg(p, errcode);
-  return errcode;
-}
+int DLLEXPORT EN_openX(EN_Project p, const char *inpFile,
+    const char *rptFile, const char *outFile)
+/*----------------------------------------------------------------
+ **  Input:   inpFile = name of input file
+ **           rptFile = name of report file
+ **           outFile = name of binary output file
+ **  Output:  none
+ **  Returns: error code
+ **  Purpose: reads an EPANET input file with errors allowed.
+ **----------------------------------------------------------------
+ */
+{
+    writewin(p->viewprog, FMT100);
+    return openproject(p, inpFile, rptFile, outFile, TRUE);
+}    
 
 int DLLEXPORT EN_gettitle(EN_Project p, char *line1, char *line2, char *line3)
 /*----------------------------------------------------------------
@@ -251,7 +219,8 @@ int DLLEXPORT EN_gettitle(EN_Project p, char *line1, char *line2, char *line3)
     return 0;
 }
 
-int DLLEXPORT EN_settitle(EN_Project p, char *line1, char *line2, char *line3)
+int DLLEXPORT EN_settitle(EN_Project p, const char *line1, 
+    const char *line2, const char *line3)
 /*----------------------------------------------------------------
 **  Input:  line1, line2, line3 = project's title lines
 **  Returns: error code
@@ -279,7 +248,8 @@ int DLLEXPORT EN_getcomment(EN_Project p, int object, int index, char *comment)
     return getcomment(&p->network, object, index, comment);
 }
 
-int  DLLEXPORT EN_setcomment(EN_Project p, int object, int index, char *comment)
+int  DLLEXPORT EN_setcomment(EN_Project p, int object, int index,
+    const char *comment)
 /*----------------------------------------------------------------
 **  Input:   object = a type of object (see EN_ObjectType)
 **           index = the object's index
@@ -292,6 +262,32 @@ int  DLLEXPORT EN_setcomment(EN_Project p, int object, int index, char *comment)
     return setcomment(&p->network, object, index, comment);
 }
 
+int DLLEXPORT EN_gettag(EN_Project p, int object, int index, char *tag)
+/*----------------------------------------------------------------
+**  Input:   object = either EN_NODE or EN_LINK
+**           index = the object's index
+**  Output:  tag = the tag string assigned to the object
+**  Returns: error code
+**  Purpose: Retrieves an object's tag string
+**----------------------------------------------------------------
+*/
+{
+    return gettag(&p->network, object, index, tag);
+}
+
+int  DLLEXPORT EN_settag(EN_Project p, int object, int index,
+    const char *tag)
+/*----------------------------------------------------------------
+**  Input:   object = either EN_NODE or EN_LINK
+**           index = the object's index
+**           tag =  a descriptive comment to assign
+**  Returns: error code
+**  Purpose: Assigns a tag string to an object
+**----------------------------------------------------------------
+*/
+{
+    return settag(&p->network, object, index, tag);
+}
 int DLLEXPORT EN_getcount(EN_Project p, int object, int *count)
 /*----------------------------------------------------------------
 **  Input:   object = type of object to count (see EN_CountType)
@@ -357,7 +353,6 @@ int DLLEXPORT EN_close(EN_Project p)
  */
 {
     // Free all project data
-    if (p->Openflag) writetime(p, FMT105);
     freedata(p);
 
     // Close output file
@@ -493,7 +488,11 @@ int DLLEXPORT EN_openH(EN_Project p)
 
     // Open hydraulics solver
     ERRCODE(openhyd(p));
-    if (!errcode) p->hydraul.OpenHflag = TRUE;
+    if (!errcode)
+    {
+        p->hydraul.OpenHflag = TRUE;
+        writetime(p, FMT104);
+    }    
     else errmsg(p, errcode);
     return errcode;
 }
@@ -536,6 +535,10 @@ int DLLEXPORT EN_initH(EN_Project p, int initFlag)
             return errcode;
         }
     }
+    
+    // Open pipe leakage modeling system
+    errcode = openleakage(p);
+    if (errcode) return errcode;
 
     // Initialize hydraulics solver
     inithyd(p, fflag);
@@ -590,7 +593,11 @@ int DLLEXPORT EN_closeH(EN_Project p)
 */
 {
   if (!p->Openflag) return 102;
-  if (p->hydraul.OpenHflag) closehyd(p);
+  if (p->hydraul.OpenHflag)
+  {
+      closeleakage(p);
+      closehyd(p);
+  }
   p->hydraul.OpenHflag = FALSE;
   return 0;
 }
@@ -832,6 +839,7 @@ int DLLEXPORT EN_closeQ(EN_Project p)
     closequal(p);
     p->quality.OpenQflag = FALSE;
     closeoutfile(p);
+    writetime(p, FMT105);
     return 0;
 }
 
@@ -841,7 +849,35 @@ int DLLEXPORT EN_closeQ(EN_Project p)
 
  ********************************************************************/
 
-int DLLEXPORT EN_writeline(EN_Project p, char *line)
+
+ int  DLLEXPORT EN_setreportcallback(EN_Project p, void (*callback)(void*,void*,const char*))
+ /*----------------------------------------------------------------
+**  Input:   callback = a pointer to a reporting function
+**  Output:  none
+**  Returns: error code
+**  Purpose: replaces EPANET's normal use of a designated report file
+**----------------------------------------------------------------
+*/
+{
+   p->report.reportCallback = callback;
+   return 0;
+ }
+
+ int DLLEXPORT EN_setreportcallbackuserdata(EN_Project p, void *userData)
+/*----------------------------------------------------------------
+**  Input:   userData = a pointer to a client-side data object
+**  Output:  none
+**  Returns: error code
+**  Purpose: sets the client-side data object used in conjunction with
+**           the callback function in EN_setreportcallback
+**----------------------------------------------------------------
+*/
+{
+   p->report.reportCallbackUserData = userData;
+   return 0;
+ }
+
+int DLLEXPORT EN_writeline(EN_Project p, const char *line)
 /*----------------------------------------------------------------
 **  Input:   line = line of text
 **  Output:  none
@@ -877,7 +913,7 @@ int DLLEXPORT EN_report(EN_Project p)
     return errcode;
 }
 
-int  DLLEXPORT EN_copyreport(EN_Project p, char *filename)
+int  DLLEXPORT EN_copyreport(EN_Project p, const char *filename)
 /*----------------------------------------------------------------
 **  Input:   filename = name of file to receive copy of report
 **  Output:  none
@@ -926,7 +962,7 @@ int DLLEXPORT EN_resetreport(EN_Project p)
     return 0;
 }
 
-int DLLEXPORT EN_setreport(EN_Project p, char *format)
+int DLLEXPORT EN_setreport(EN_Project p, const char *format)
 /*----------------------------------------------------------------
 **  Input:   format = a report formatting command
 **  Output:  none
@@ -983,7 +1019,7 @@ int DLLEXPORT EN_getversion(int *version)
 
 int DLLEXPORT EN_geterror(int errcode, char *errmsg, int maxLen)
 /*----------------------------------------------------------------
-**  Input:   errcode = an error or warnng code
+**  Input:   errcode = an error or warning code
 **           maxLen = maximum characters that errmsg can hold
 **  Output:  errmsg = text of error/warning message
 **  Returns: error code
@@ -1056,6 +1092,9 @@ int DLLEXPORT EN_getstatistic(EN_Project p, int type, double *value)
     case EN_DEMANDREDUCTION:
         *value = p->hydraul.DemandReduction;
         break;
+    case EN_LEAKAGELOSS:    
+        *value = p->hydraul.LeakageLoss;
+        break;
     case EN_MASSBALANCE:
         *value = p->quality.MassBalance.ratio;
         break;
@@ -1187,7 +1226,18 @@ int DLLEXPORT EN_getoption(EN_Project p, int option, double *value)
     case EN_CONCENLIMIT:
         v = qual->Climit * p->Ucf[QUALITY];
         break;
-
+    case EN_DEMANDPATTERN:
+        v = hyd->DefPat;
+        break;
+    case EN_EMITBACKFLOW:
+        v = hyd->EmitBackFlag;
+        break;
+    case EN_PRESS_UNITS:
+        v = (double)p->parser.Pressflag;
+        break;
+    case EN_STATUS_REPORT:
+        v = (double)( p->report.Statflag);
+        break;        
     default:
         return 251;
     }
@@ -1211,9 +1261,12 @@ int DLLEXPORT EN_setoption(EN_Project p, int option, double value)
 
     int Njuncs = net->Njuncs;
     double *Ucf = p->Ucf;
-    int i, j, pat;
+    int i, j, pat, unit;
     double Ke, n, ucf;
 
+    double qfactor, hfactor, pfactor, dfactor;
+    double dcf, pcf, hcf, qcf;
+
     if (!p->Openflag) return 102;
 
     // The EN_UNBALANCED option can be < 0 indicating that the simulation
@@ -1230,7 +1283,7 @@ int DLLEXPORT EN_setoption(EN_Project p, int option, double value)
     // All other option values must be non-negative
     if (value < 0.0) return 213;
 
-    // Process the speficied option
+    // Process the specified option
     switch (option)
     {
     case EN_TRIALS:
@@ -1302,7 +1355,12 @@ int DLLEXPORT EN_setoption(EN_Project p, int option, double value)
 
     case EN_SP_GRAVITY:
         if (value <= 0.0) return 213;
-        Ucf[PRESSURE] *= (value / hyd->SpGrav);
+        if (p->parser.Pressflag == PSI || 
+            p->parser.Pressflag == KPA || 
+            p->parser.Pressflag == BAR)
+        {
+            Ucf[PRESSURE] *= (value / hyd->SpGrav);
+        }
         hyd->SpGrav = value;
         break;
 
@@ -1344,6 +1402,42 @@ int DLLEXPORT EN_setoption(EN_Project p, int option, double value)
         qual->Climit = value / p->Ucf[QUALITY];
         break;
 
+    case EN_DEMANDPATTERN:
+        pat = ROUND(value);
+        if (pat < 0 || pat > net->Npats) return 205;
+        hyd->DefPat = pat;
+        break;
+
+    case EN_EMITBACKFLOW:
+        if (value == 0.0 || value == 1.0) hyd->EmitBackFlag = (int)value;
+        else return 213;
+        break;
+
+    case EN_PRESS_UNITS:
+        unit = ROUND(value);
+        if (unit < 0 || unit > FEET) return 205;
+        p->parser.Pressflag = unit;
+
+        dfactor = Ucf[DEMAND];
+        pfactor = Ucf[PRESSURE];
+        hfactor = Ucf[HEAD];
+        qfactor = Ucf[FLOW];
+        initunits(p);
+
+        // Update units in rules
+        dcf =  Ucf[DEMAND] / dfactor;
+        pcf =  Ucf[PRESSURE] / pfactor;
+        hcf =  Ucf[HEAD] / hfactor;
+        qcf =  Ucf[FLOW] / qfactor;
+        updateruleunits(p, dcf, pcf, hcf, qcf);
+        break;
+        
+    case EN_STATUS_REPORT:
+        i = ROUND(value);
+        if (i < EN_NO_REPORT || i > EN_FULL_REPORT) return 213;
+        p->report.Statflag = i;
+        break;
+
     default:
         return 251;
     }
@@ -1376,8 +1470,9 @@ int DLLEXPORT EN_setflowunits(EN_Project p, int units)
 {
     Network *net = &p->network;
 
-    int i, j;
-    double qfactor, vfactor, hfactor, efactor, xfactor, yfactor;
+    int i, j, oldUnitFlag;
+    double qfactor, vfactor, hfactor, efactor, pfactor, dfactor, xfactor, yfactor;
+    double dcf, pcf, hcf, qcf;
     double *Ucf = p->Ucf;
 
     if (!p->Openflag) return 102;
@@ -1387,7 +1482,10 @@ int DLLEXPORT EN_setflowunits(EN_Project p, int units)
     vfactor = Ucf[VOLUME];
     hfactor = Ucf[HEAD];
     efactor = Ucf[ELEV];
+    pfactor = Ucf[PRESSURE];
+    dfactor = Ucf[DEMAND];
 
+    oldUnitFlag = p->parser.Unitsflag;
     p->parser.Flowflag = units;
     switch (units)
     {
@@ -1396,6 +1494,7 @@ int DLLEXPORT EN_setflowunits(EN_Project p, int units)
     case MLD:
     case CMH:
     case CMD:
+    case CMS:
         p->parser.Unitsflag = SI;
         break;
     default:
@@ -1404,10 +1503,20 @@ int DLLEXPORT EN_setflowunits(EN_Project p, int units)
     }
 
     // Revise pressure units depending on flow units
-    if (p->parser.Unitsflag != SI) p->parser.Pressflag = PSI;
-    else if (p->parser.Pressflag == PSI) p->parser.Pressflag = METERS;
+    if (oldUnitFlag != p->parser.Unitsflag)
+    {
+        if (p->parser.Unitsflag == US) p->parser.Pressflag = PSI;
+        else p->parser.Pressflag = METERS;
+    }
     initunits(p);
 
+    // Update pressure units in rules
+    dcf =  Ucf[DEMAND] / dfactor;
+    pcf =  Ucf[PRESSURE] / pfactor;
+    hcf =  Ucf[HEAD] / hfactor;
+    qcf =  Ucf[FLOW] / qfactor;
+    updateruleunits(p, dcf, pcf, hcf, qcf);
+
     //update curves
     for (i = 1; i <= net->Ncurves; i++)
     {
@@ -1591,12 +1700,65 @@ int DLLEXPORT EN_settimeparam(EN_Project p, int param, long value)
         time->Qtime = value;
         break;
 
+    case EN_STARTTIME:
+        if (value > SECperDAY) return 213;
+	    time->Tstart = value;
+        break;
+
     default:
         return 251;
     }
     return 0;
 }
 
+
+/// get the time to next event, and give a reason for the time step truncation
+int  DLLEXPORT EN_timetonextevent(EN_Project p, int *eventType,
+                                  long *duration, int *elementIndex)
+/*----------------------------------------------------------------
+**  Input:   none
+**  Output:  eventType = event causing a new time step
+**                       to occur (see EN_TimestepEvent)
+**           duration  = seconds until next time step occurs
+**           elementIndex = index of tank node or simple control
+**                          that triggers a new time step
+**  Returns: error code
+**  Purpose: Get information about when the next hydraulic time step occurs
+**----------------------------------------------------------------
+*/
+{
+  Times  *time = &p->times;
+  long hydStep, tankStep, controlStep;
+  int iTank, iControl;
+  
+  hydStep = time->Hstep;
+  tankStep = hydStep;
+  controlStep = hydStep;
+
+  iTank = tanktimestep(p, &tankStep);
+  iControl = controltimestep(p, &controlStep);
+
+  // return the lesser of the three step lengths
+  if (controlStep < tankStep) {
+    *eventType = (int)EN_STEP_CONTROLEVENT;
+    *duration = controlStep;
+    *elementIndex = iControl;
+  }
+  else if (tankStep < hydStep) {
+    *eventType = (int)EN_STEP_TANKEVENT;
+    *duration = tankStep;
+    *elementIndex = iTank;
+  }
+  else {
+    *eventType = (int)EN_STEP_HYD;
+    *duration = hydStep;
+    *elementIndex = 0;
+  }
+
+  return 0;
+}
+
+
 int DLLEXPORT EN_getqualinfo(EN_Project p, int *qualType, char *chemName,
                              char *chemUnits, int *traceNode)
 /*----------------------------------------------------------------
@@ -1652,8 +1814,8 @@ int DLLEXPORT EN_getqualtype(EN_Project p, int *qualType, int *traceNode)
     return 0;
 }
 
-int DLLEXPORT EN_setqualtype(EN_Project p, int qualType, char *chemName,
-                             char *chemUnits, char *traceNode)
+int DLLEXPORT EN_setqualtype(EN_Project p, int qualType, const char *chemName,
+                             const char *chemUnits, const char *traceNode)
 /*----------------------------------------------------------------
 **  Input:   qualType = type of quality analysis to run (see EN_QualityType)
 **           chemname = name of chemical constituent
@@ -1670,7 +1832,7 @@ int DLLEXPORT EN_setqualtype(EN_Project p, int qualType, char *chemName,
     Quality *qual = &p->quality;
 
     double *Ucf = p->Ucf;
-    int i, oldQualFlag, traceNodeIndex;
+    int i, oldQualFlag, traceNodeIndex = 0;
     double ccf = 1.0;
 
     if (!p->Openflag) return 102;
@@ -1682,6 +1844,7 @@ int DLLEXPORT EN_setqualtype(EN_Project p, int qualType, char *chemName,
         if (traceNodeIndex == 0) return 212;
     }
 
+    qual->TraceNode = traceNodeIndex;
     oldQualFlag = qual->Qualflag;
     qual->Qualflag = qualType;
     qual->Ctol *= Ucf[QUALITY];
@@ -1696,8 +1859,6 @@ int DLLEXPORT EN_setqualtype(EN_Project p, int qualType, char *chemName,
     }
     if (qual->Qualflag == TRACE) // Source trace analysis
     {
-        qual->TraceNode = findnode(net, traceNode);
-        if (qual->TraceNode == 0) return 212;
         strncpy(qual->ChemName, w_TRACE, MAXID);
         strncpy(qual->ChemUnits, u_PERCENT, MAXID);
         strcpy(rpt->Field[QUALITY].Units, u_PERCENT);
@@ -1732,7 +1893,7 @@ int DLLEXPORT EN_setqualtype(EN_Project p, int qualType, char *chemName,
 
 ********************************************************************/
 
-int DLLEXPORT EN_addnode(EN_Project p, char *id, int nodeType, int *index)
+int DLLEXPORT EN_addnode(EN_Project p, const char *id, int nodeType, int *index)
 /*----------------------------------------------------------------
 **  Input:   id = node ID name
 **           nodeType = type of node (see EN_NodeType)
@@ -1761,17 +1922,21 @@ int DLLEXPORT EN_addnode(EN_Project p, char *id, int nodeType, int *index)
 
     // Check if a node with same id already exists
     if (EN_getnodeindex(p, id, &i) == 0) return 215;
-    
+
     // Check for valid node type
-    if (nodeType < EN_JUNCTION || nodeType > EN_TANK) return 251; 
+    if (nodeType < EN_JUNCTION || nodeType > EN_TANK) return 251;
 
-    // Grow node-related arrays to accomodate the new node
+    // Grow node-related arrays to accommodate the new node
     size = (net->Nnodes + 2) * sizeof(Snode);
     net->Node = (Snode *)realloc(net->Node, size);
     size = (net->Nnodes + 2) * sizeof(double);
     hyd->NodeDemand = (double *)realloc(hyd->NodeDemand, size);
     qual->NodeQual = (double *)realloc(qual->NodeQual, size);
     hyd->NodeHead = (double *)realloc(hyd->NodeHead, size);
+    hyd->FullDemand = (double *)realloc(hyd->FullDemand, size);
+    hyd->EmitterFlow = (double *)realloc(hyd->EmitterFlow, size);
+    hyd->LeakageFlow = (double *)realloc(hyd->LeakageFlow, size);
+    hyd->DemandFlow = (double *)realloc(hyd->DemandFlow, size);
 
     // Actions taken when a new Junction is added
     if (nodeType == EN_JUNCTION)
@@ -1782,7 +1947,7 @@ int DLLEXPORT EN_addnode(EN_Project p, char *id, int nodeType, int *index)
             hashtable_update(net->NodeHashTable, net->Node[i].ID, i + 1);
             net->Node[i + 1] = net->Node[i];
         }
-    
+
         // set index of new Junction node
         net->Njuncs++;
         nIdx = net->Njuncs;
@@ -1808,7 +1973,7 @@ int DLLEXPORT EN_addnode(EN_Project p, char *id, int nodeType, int *index)
             if (control->Node > net->Njuncs - 1) control->Node += 1;
         }
         // adjust indices of tanks/reservoirs in Rule premises (see RULES.C)
-        adjusttankrules(p);
+        adjusttankrules(p, 1);
     }
 
     // Actions taken when a new Tank/Reservoir is added
@@ -1840,7 +2005,7 @@ int DLLEXPORT EN_addnode(EN_Project p, char *id, int nodeType, int *index)
         tank->Pat = 0;
         tank->Vcurve = 0;
         tank->MixModel = 0;
-        tank->V1max = 10000;
+        tank->V1frac = 1;
         tank->CanOverflow = FALSE;
     }
     net->Nnodes++;
@@ -1858,6 +2023,7 @@ int DLLEXPORT EN_addnode(EN_Project p, char *id, int nodeType, int *index)
     node->X = MISSING;
     node->Y = MISSING;
     node->Comment = NULL;
+    node->Tag = NULL;                     
 
     // Insert new node into hash table
     hashtable_insert(net->NodeHashTable, node->ID, nIdx);
@@ -1917,6 +2083,7 @@ int DLLEXPORT EN_deletenode(EN_Project p, int index, int actionCode)
     freedemands(node);
     free(node->S);
     free(node->Comment);
+    free(node->Tag);                    
 
     // Shift position of higher entries in Node & Coord arrays down one
     for (i = index; i <= net->Nnodes - 1; i++)
@@ -1925,6 +2092,7 @@ int DLLEXPORT EN_deletenode(EN_Project p, int index, int actionCode)
         // ... update node's entry in the hash table
         hashtable_update(net->NodeHashTable, net->Node[i].ID, i);
     }
+    if (index < p->quality.TraceNode) (p->quality.TraceNode)--;
 
     // If deleted node is a tank, remove it from the Tank array
     if (nodeType != EN_JUNCTION)
@@ -1979,7 +2147,7 @@ int DLLEXPORT EN_deletenode(EN_Project p, int index, int actionCode)
     return 0;
 }
 
-int DLLEXPORT EN_getnodeindex(EN_Project p, char *id, int *index)
+int DLLEXPORT EN_getnodeindex(EN_Project p, const char *id, int *index)
 /*----------------------------------------------------------------
 **  Input:   id = node ID name
 **  Output:  index = node index
@@ -2011,7 +2179,7 @@ int DLLEXPORT EN_getnodeid(EN_Project p, int index, char *id)
     return 0;
 }
 
-int DLLEXPORT EN_setnodeid(EN_Project p, int index, char *newid)
+int DLLEXPORT EN_setnodeid(EN_Project p, int index, const char *newid)
 /*----------------------------------------------------------------
 **  Input:   index = node index
 **           newid = new node ID name
@@ -2074,8 +2242,10 @@ int DLLEXPORT EN_getnodevalue(EN_Project p, int index, int property, double *val
     Network *net = &p->network;
     Hydraul *hyd = &p->hydraul;
     Quality *qual = &p->quality;
+    Parser  *parser = &p->parser;
 
     double v = 0.0;
+    double ecfTmp; // Unit conversion factor for emitter pressure
     Psource source;
 
     Snode *Node = net->Node;
@@ -2120,7 +2290,8 @@ int DLLEXPORT EN_getnodevalue(EN_Project p, int index, int property, double *val
         v = 0.0;
         if (Node[index].Ke > 0.0)
         {
-            v = Ucf[FLOW] / pow((Ucf[PRESSURE] * Node[index].Ke), (1.0 / hyd->Qexp));
+            ecfTmp = (parser->Unitsflag == US) ? (PSIperFT * hyd->SpGrav) : MperFT;
+            v = Ucf[FLOW] / pow((ecfTmp * Node[index].Ke), (1.0 / hyd->Qexp));
         }
         break;
 
@@ -2157,10 +2328,12 @@ int DLLEXPORT EN_getnodevalue(EN_Project p, int index, int property, double *val
 
     case EN_MIXZONEVOL:
         v = 0.0;
-        if (index > nJuncs) v = Tank[index - nJuncs].V1max * Ucf[VOLUME];
+        if (index > nJuncs)
+            v = Tank[index - nJuncs].V1frac * Tank[index - nJuncs].Vmax *
+                Ucf[VOLUME];
         break;
 
-    case EN_DEMAND:
+    case EN_DEMAND: // Consumer Demand + Emitter Flow + Leakage Flow
         v = hyd->NodeDemand[index] * Ucf[FLOW];
         break;
 
@@ -2217,9 +2390,9 @@ int DLLEXPORT EN_getnodevalue(EN_Project p, int index, int property, double *val
 
     case EN_MIXFRACTION:
         v = 1.0;
-        if (index > nJuncs && Tank[index - nJuncs].Vmax > 0.0)
+        if (index > nJuncs)
         {
-            v = Tank[index - nJuncs].V1max / Tank[index - nJuncs].Vmax;
+            v = Tank[index - nJuncs].V1frac;
         }
         break;
 
@@ -2237,14 +2410,34 @@ int DLLEXPORT EN_getnodevalue(EN_Project p, int index, int property, double *val
         if (Node[index].Type != TANK) return 0;
         v = Tank[index - nJuncs].CanOverflow;
         break;
-        
+
     case EN_DEMANDDEFICIT:
         if (index > nJuncs) return 0;
-        // After an analysis, DemandFlow contains node's required demand
-        // while NodeDemand contains delivered demand + emitter flow
-        if (hyd->DemandFlow[index] < 0.0) return 0;
-        v = (hyd->DemandFlow[index] - 
-            (hyd->NodeDemand[index] - hyd->EmitterFlow[index])) * Ucf[FLOW];
+        // FullDemand contains node's required consumer demand
+        // while DemandFlow contains delivered consumer demand
+        if (hyd->FullDemand[index] <= 0.0) return 0;
+        v = (hyd->FullDemand[index] - hyd->DemandFlow[index]) * Ucf[FLOW];
+        if (v < 0.0) v = 0.0;
+        break;
+
+    case EN_NODE_INCONTROL:
+        v = (double)incontrols(p, NODE, index);
+        break;
+
+    case EN_EMITTERFLOW:
+        v = hyd->EmitterFlow[index] * Ucf[FLOW];
+        break;
+
+    case EN_LEAKAGEFLOW:
+        v =  hyd->LeakageFlow[index] * Ucf[FLOW];
+        break;
+
+    case EN_DEMANDFLOW:  // Consumer demand delivered
+        v = hyd->DemandFlow[index] * Ucf[FLOW];
+        break;
+        
+    case EN_FULLDEMAND:  // Consumer demand requested
+        v = hyd->FullDemand[index] * Ucf[FLOW];
         break;
         
     default:
@@ -2254,6 +2447,25 @@ int DLLEXPORT EN_getnodevalue(EN_Project p, int index, int property, double *val
     return 0;
 }
 
+int DLLEXPORT EN_getnodevalues(EN_Project p, int property, double *values)
+/*----------------------------------------------------------------
+**  Input:   property = node property code (see EN_NodeProperty)
+**  Output:  values = array of node property values
+**  Returns: error code
+**  Purpose: retrieves an array of node property values
+**----------------------------------------------------------------
+*/
+{
+    int errcode = 0, i = 0;
+
+    for (i = 1; i <= p->network.Nnodes; i++)
+    {
+        errcode = EN_getnodevalue(p, i, property, &values[i - 1]);
+        if (errcode != 0) { return errcode; }
+    }
+    return 0;
+}
+
 int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double value)
 /*----------------------------------------------------------------
 **  Input:   index = node index
@@ -2268,6 +2480,7 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
     Network *net = &p->network;
     Hydraul *hyd = &p->hydraul;
     Quality *qual = &p->quality;
+    Parser  *parser = &p->parser;
 
     Snode *Node = net->Node;
     Stank *Tank = net->Tank;
@@ -2281,8 +2494,7 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
 
     int i, j, n;
     Psource source;
-    double hTmp;
-    double vTmp;
+    double hTmp, ecfTmp;
 
     if (!p->Openflag) return 102;
     if (index <= 0 || index > nNodes) return 203;
@@ -2324,8 +2536,13 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
     case EN_EMITTER:
         if (index > nJuncs) return 0;
         if (value < 0.0) return 209;
-        if (value > 0.0) value = pow((Ucf[FLOW] / value), hyd->Qexp) / Ucf[PRESSURE];
+        if (value > 0.0)
+        {
+            ecfTmp = (parser->Unitsflag == US) ? (PSIperFT * hyd->SpGrav) : MperFT;
+            value = pow((Ucf[FLOW] / value), hyd->Qexp) / ecfTmp;
+        }
         Node[index].Ke = value;
+        if (hyd->EmitterFlow[index] == 0.0) hyd->EmitterFlow[index] = 1.0;
         break;
 
     case EN_INITQUAL:
@@ -2364,7 +2581,7 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
         break;
 
     case EN_TANKLEVEL:
-        if (index <= nJuncs) return 0;
+        if (index <= nJuncs) return 263;
         j = index - nJuncs;
         if (Tank[j].A == 0.0) /* Tank is a reservoir */
         {
@@ -2388,9 +2605,9 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
 
     case EN_TANKDIAM:
         if (value <= 0.0) return 209;                  // invalid diameter
-        if (index <= nJuncs) return 0;                 // node is not a tank
+        if (index <= nJuncs) return 263;               // node is not a tank
         j = index - nJuncs;                            // tank index
-        if (Tank[j].A == 0.0) return 0;                // tank is a reservoir
+        if (Tank[j].A == 0.0) return 263;              // tank is a reservoir
         value /= Ucf[ELEV];                            // diameter in feet
         Tank[j].A = PI * SQR(value) / 4.0;             // new tank area
         if (Tank[j].Vcurve > 0)                        // tank has a volume curve
@@ -2399,7 +2616,7 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
 
             // Since the volume curve no longer applies we assume that the tank's
             // shape below Hmin is cylindrical and Vmin equals area times Hmin
-            Tank[j].Vmin = Tank[j].A * Tank[j].Hmin;
+            Tank[j].Vmin = Tank[j].A * (Tank[j].Hmin - Node[index].El);
         }
         // Since tank's area has changed its volumes must be updated
         // NOTE: For a non-volume curve tank we can't change the Vmin
@@ -2407,16 +2624,14 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
         //       shape below Hmin. Vmin can always be changed by setting
         //       EN_MINVOLUME in a subsequent function call.
         Tank[j].V0 = tankvolume(p, j, Tank[j].H0);     // new init. volume
-        vTmp = Tank[j].Vmax;                           // old max. volume
         Tank[j].Vmax = tankvolume(p, j, Tank[j].Hmax); // new max. volume
-        Tank[j].V1max *= Tank[j].Vmax / vTmp;          // new mix zone volume
         break;
 
     case EN_MINVOLUME:
         if (value < 0.0) return 209;               // invalid volume
-        if (index <= nJuncs) return 0;             // node is not a tank
+        if (index <= nJuncs) return 263;           // node is not a tank
         j = index - nJuncs;                        // tank index
-        if (Tank[j].A == 0.0) return 0;            // tank is a reservoir
+        if (Tank[j].A == 0.0) return 263;          // tank is a reservoir
         i = Tank[j].Vcurve;                        // volume curve index
         if (i > 0)                                 // tank has a volume curve
         {
@@ -2434,14 +2649,12 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
             // If the volume supplied by the function is 0 then the tank shape
             // below Hmin is assumed to be cylindrical and a new Vmin value is
             // computed. Otherwise Vmin is set to the supplied value.
-            if (value == 0.0) Tank[j].Vmin = Tank[j].A * Tank[j].Hmin;
+            if (value == 0.0) Tank[j].Vmin = Tank[j].A * (Tank[j].Hmin - Node[index].El);
             else Tank[j].Vmin = value / Ucf[VOLUME];
 
             // Since Vmin changes the other volumes need updating
             Tank[j].V0 = tankvolume(p, j, Tank[j].H0);     // new init. volume
-            vTmp = Tank[j].Vmax;                           // old max. volume
             Tank[j].Vmax = tankvolume(p, j, Tank[j].Hmax); // new max. volume
-            Tank[j].V1max *= Tank[j].Vmax / vTmp;          // new mix zone volume
         }
         break;
 
@@ -2451,9 +2664,9 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
         i = ROUND(value);                          // curve index
         if (i <= 0 ||
             i > net->Ncurves) return 205;          // invalid curve index
-        if (index <= nJuncs) return 0;             // node not a tank
+        if (index <= nJuncs) return 263;           // node not a tank
         j = index - nJuncs;                        // tank index
-        if (Tank[j].A == 0.0) return 0;            // tank is a reservoir
+        if (Tank[j].A == 0.0) return 263;          // tank is a reservoir
         curve = &net->Curve[i];                    // curve object
 
         // Check that tank's min/max levels lie within curve
@@ -2466,18 +2679,16 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
         Tank[j].Vcurve = i;                            // assign curve to tank
         Tank[j].Vmin = tankvolume(p, j, Tank[j].Hmin); // new min. volume
         Tank[j].V0 = tankvolume(p, j, Tank[j].H0);     // new init. volume
-        vTmp = Tank[j].Vmax;                           // old max. volume
         Tank[j].Vmax = tankvolume(p, j, Tank[j].Hmax); // new max. volume
-        Tank[j].V1max *= Tank[j].Vmax / vTmp;          // new mix zone volume
-        Tank[j].A = (curve->Y[n] - curve->Y[0]) /      // nominal area 
+        Tank[j].A = (curve->Y[n] - curve->Y[0]) /      // nominal area
             (curve->X[n] - curve->X[0]);
         break;
 
     case EN_MINLEVEL:
         if (value < 0.0) return 209;               // invalid water level
-        if (index <= nJuncs) return 0;             // node not a tank
+        if (index <= nJuncs) return 263;           // node not a tank
         j = index - nJuncs;                        // tank index
-        if (Tank[j].A == 0.0) return  0;           // tank is a reservoir
+        if (Tank[j].A == 0.0) return 263;          // tank is a reservoir
         hTmp = value / Ucf[ELEV] + Node[index].El; // convert level to head
         if (hTmp >= Tank[j].Hmax ||
             hTmp > Tank[j].H0) return 225;         // invalid water levels
@@ -2496,9 +2707,9 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
 
     case EN_MAXLEVEL:
         if (value <= 0.0) return 209;              // invalid water level
-        if (index <= nJuncs) return 0;             // node not a tank
+        if (index <= nJuncs) return 263;           // node not a tank
         j = index - nJuncs;                        // tank index
-        if (Tank[j].A == 0.0) return 0;            // tank is a reservoir
+        if (Tank[j].A == 0.0) return 263;          // tank is a reservoir
         hTmp = value / Ucf[ELEV] + Node[index].El; // convert level to head
         if (hTmp < Tank[j].Hmin ||
             hTmp < Tank[j].H0) return 225;         // invalid water levels
@@ -2510,14 +2721,12 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
             if (value > curve->X[n]) return 225;   // new level is off curve
         }
         Tank[j].Hmax = hTmp;                       // new max. head
-        vTmp = Tank[j].Vmax;                       // old max. volume
         Tank[j].Vmax = tankvolume(p, j, hTmp);     // new max. volume
-        Tank[j].V1max *= Tank[j].Vmax / vTmp;      // new mix zone volume
         break;
 
     case EN_MIXMODEL:
         j = ROUND(value);
-        if (index <= nJuncs) return 0;
+        if (index <= nJuncs) return 263;
         if (j < MIX1 || j > LIFO) return 251;
         if (Tank[index - nJuncs].A > 0.0)
         {
@@ -2526,17 +2735,17 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
         break;
 
     case EN_MIXFRACTION:
-        if (index <= nJuncs) return 0;
+        if (index <= nJuncs) return 263;
         if (value < 0.0 || value > 1.0) return 209;
         j = index - nJuncs;
         if (Tank[j].A > 0.0)
         {
-            Tank[j].V1max = value * Tank[j].Vmax;
+            Tank[j].V1frac = value;
         }
         break;
 
     case EN_TANK_KBULK:
-        if (index <= nJuncs) return 0;
+        if (index <= nJuncs) return 263;
         j = index - nJuncs;
         if (Tank[j].A > 0.0)
         {
@@ -2546,7 +2755,7 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
         break;
 
     case EN_CANOVERFLOW:
-        if (Node[index].Type != TANK) return 0;
+        if (Node[index].Type != TANK) return 263;
         Tank[index - nJuncs].CanOverflow = (value != 0.0);
         break;
 
@@ -2557,7 +2766,7 @@ int DLLEXPORT EN_setnodevalue(EN_Project p, int index, int property, double valu
 }
 
 int DLLEXPORT EN_setjuncdata(EN_Project p, int index, double elev,
-                             double dmnd, char *dmndpat)
+                             double dmnd, const char *dmndpat)
 /*----------------------------------------------------------------
 **  Input:   index = junction node index
 **           elev = junction elevation
@@ -2602,7 +2811,7 @@ int DLLEXPORT EN_setjuncdata(EN_Project p, int index, double elev,
 int DLLEXPORT EN_settankdata(EN_Project p, int index, double elev,
                              double initlvl, double minlvl,
                              double maxlvl, double diam,
-                             double minvol, char *volcurve)
+                             double minvol, const char *volcurve)
 /*----------------------------------------------------------------
 **  Input:   index = tank node index
 **           elev = tank bottom elevation
@@ -2621,16 +2830,16 @@ int DLLEXPORT EN_settankdata(EN_Project p, int index, double elev,
     Network *net = &p->network;
 
     int i, j, n, curveIndex = 0;
-    double area, elevation = elev;
     double *Ucf = p->Ucf;
+    double area;
     Stank *Tank = net->Tank;
     Scurve *curve;
 
     // Check that tank exists
     if (!p->Openflag) return 102;
-    if (index <= net->Njuncs || index > net->Nnodes) return 203;
+    if (index <= net->Njuncs || index > net->Nnodes) return 263;
     j = index - net->Njuncs;
-    if (Tank[j].A == 0) return 0;  // Tank is a Reservoir
+    if (Tank[j].A == 0) return 263;  // Tank is a Reservoir
 
     // Check for valid parameter values
     if (initlvl < 0.0 || minlvl < 0.0 || maxlvl < 0.0) return 209;
@@ -2659,16 +2868,16 @@ int DLLEXPORT EN_settankdata(EN_Project p, int index, double elev,
     else area = PI * diam * diam / 4.0;
 
     // Assign parameters to tank object
-    net->Node[Tank[j].Node].El = elevation;
+    net->Node[Tank[j].Node].El = elev / Ucf[ELEV];
     Tank[j].A = area / Ucf[ELEV] / Ucf[ELEV];
-    Tank[j].H0 = elevation + initlvl / Ucf[ELEV];
-    Tank[j].Hmin = elevation + minlvl / Ucf[ELEV];
-    Tank[j].Hmax = elevation + maxlvl / Ucf[ELEV];
+    Tank[j].H0 = (elev + initlvl) / Ucf[ELEV];
+    Tank[j].Hmin = (elev + minlvl) / Ucf[ELEV];
+    Tank[j].Hmax = (elev + maxlvl) / Ucf[ELEV];
     Tank[j].Vcurve = curveIndex;
     if (curveIndex == 0)
     {
         if (minvol > 0.0) Tank[j].Vmin = minvol / Ucf[VOLUME];
-        else Tank[j].Vmin = Tank[j].A * Tank[j].Hmin;
+        else Tank[j].Vmin = Tank[j].A * (Tank[j].Hmin - elev / Ucf[ELEV]);
     }
     else Tank[j].Vmin = tankvolume(p, j, Tank[j].Hmin);
     Tank[j].V0 = tankvolume(p, j, Tank[j].H0);
@@ -2778,7 +2987,7 @@ int DLLEXPORT EN_setdemandmodel(EN_Project p, int model, double pmin,
 }
 
 int  DLLEXPORT EN_adddemand(EN_Project p, int nodeIndex, double baseDemand,
-                            char *demandPattern, char *demandName)
+                            const char *demandPattern, const char *demandName)
 /*----------------------------------------------------------------
 **  Input:   nodeIndex = node index
 **           baseDemand = baseline demand value
@@ -2865,7 +3074,7 @@ int DLLEXPORT EN_deletedemand(EN_Project p, int nodeIndex, int demandIndex)
     return 0;
 }
 
-int DLLEXPORT EN_getdemandindex(EN_Project p, int nodeIndex, char *demandName,
+int DLLEXPORT EN_getdemandindex(EN_Project p, int nodeIndex, const char *demandName,
                                 int *demandIndex)
 /*----------------------------------------------------------------
 **  Input:   nodeIndex = node index
@@ -3014,7 +3223,7 @@ int DLLEXPORT EN_getdemandname(EN_Project p, int nodeIndex, int demandIndex,
 }
 
 int DLLEXPORT EN_setdemandname(EN_Project p, int nodeIndex, int demandIndex,
-                               char *demandName)
+                               const char *demandName)
 /*----------------------------------------------------------------
 **  Input:   nodeIndex = node index
 **           demandIndex = demand category index
@@ -3104,8 +3313,8 @@ int  DLLEXPORT EN_setdemandpattern(EN_Project p, int nodeIndex, int demandIndex,
 
 ********************************************************************/
 
-int DLLEXPORT EN_addlink(EN_Project p, char *id, int linkType,
-                         char *fromNode, char *toNode, int *index)
+int DLLEXPORT EN_addlink(EN_Project p, const char *id, int linkType,
+                         const char *fromNode, const char *toNode, int *index)
 /*----------------------------------------------------------------
 **  Input:   id = link ID name
 **           type = link type (see EN_LinkType)
@@ -3137,7 +3346,7 @@ int DLLEXPORT EN_addlink(EN_Project p, char *id, int linkType,
     if (EN_getlinkindex(p, id, &i) == 0) return 215;
 
     // Check for valid link type
-    if (linkType < CVPIPE || linkType > GPV) return 251;
+    if (linkType < CVPIPE || linkType > PCV) return 251;
 
     // Lookup the link's from and to nodes
     n1 = hashtable_find(net->NodeHashTable, fromNode);
@@ -3151,7 +3360,7 @@ int DLLEXPORT EN_addlink(EN_Project p, char *id, int linkType,
         if (errcode) return errcode;
     }
 
-    // Grow link-related arrays to accomodate the new link
+    // Grow link-related arrays to accommodate the new link
     net->Nlinks++;
     p->parser.MaxLinks = net->Nlinks;
     n = net->Nlinks;
@@ -3170,7 +3379,7 @@ int DLLEXPORT EN_addlink(EN_Project p, char *id, int linkType,
     if (linkType <= PIPE) net->Npipes++;
     else if (linkType == PUMP)
     {
-        // Grow pump array to accomodate the new link
+        // Grow pump array to accommodate the new link
         net->Npumps++;
         size = (net->Npumps + 1) * sizeof(Spump);
         net->Pump = (Spump *)realloc(net->Pump, size);
@@ -3192,17 +3401,18 @@ int DLLEXPORT EN_addlink(EN_Project p, char *id, int linkType,
     }
     else
     {
-        // Grow valve array to accomodate the new link
+        // Grow valve array to accommodate the new link
         net->Nvalves++;
         size = (net->Nvalves + 1) * sizeof(Svalve);
         net->Valve = (Svalve *)realloc(net->Valve, size);
         net->Valve[net->Nvalves].Link = n;
+        net->Valve[net->Nvalves].Curve = 0;
     }
 
     link->Type = linkType;
     link->N1 = n1;
     link->N2 = n2;
-    link->Status = OPEN;
+    link->InitStatus = OPEN;
 
     if (linkType == PUMP)
     {
@@ -3231,15 +3441,19 @@ int DLLEXPORT EN_addlink(EN_Project p, char *id, int linkType,
         link->Kc = 0.0; // Valve setting.
         link->Km = 0.0; // Loss coeff
         link->Len = 0.0;
-        link->Status = ACTIVE;
+        link->InitStatus = ACTIVE;
     }
     link->Kb = 0;
     link->Kw = 0;
+    link->LeakArea = 0;
+    link->LeakExpan = 0;
+    link->InitSetting = link->Kc;
     link->R = 0;
     link->Rc = 0;
     link->Rpt = 0;
     link->ResultIndex = 0;
     link->Comment = NULL;
+    link->Tag = NULL;                     
     link->Vertices = NULL;
 
     hashtable_insert(net->LinkHashTable, link->ID, n);
@@ -3292,6 +3506,7 @@ int DLLEXPORT EN_deletelink(EN_Project p, int index, int actionCode)
 
     // Remove link's comment and vertices
     free(link->Comment);
+    free(link->Tag);                    
     freelinkvertices(link);
 
     // Shift position of higher entries in Link array down one
@@ -3312,6 +3527,12 @@ int DLLEXPORT EN_deletelink(EN_Project p, int index, int actionCode)
         if (net->Valve[i].Link > index) net->Valve[i].Link -= 1;
     }
 
+    // Reduce the number of pipes count by one if it is a pipe.
+    if (linkType == PIPE)
+    {
+        net->Npipes--;
+    }
+
     // Delete any pump associated with the deleted link
     if (linkType == PUMP)
     {
@@ -3354,7 +3575,7 @@ int DLLEXPORT EN_deletelink(EN_Project p, int index, int actionCode)
     return 0;
 }
 
-int DLLEXPORT EN_getlinkindex(EN_Project p, char *id, int *index)
+int DLLEXPORT EN_getlinkindex(EN_Project p, const char *id, int *index)
 /*----------------------------------------------------------------
 **  Input:   id = link ID name
 **  Output:  index = link index
@@ -3386,7 +3607,7 @@ int DLLEXPORT EN_getlinkid(EN_Project p, int index, char *id)
     return 0;
 }
 
-int DLLEXPORT EN_setlinkid(EN_Project p, int index, char *newid)
+int DLLEXPORT EN_setlinkid(EN_Project p, int index, const char *newid)
 /*----------------------------------------------------------------
 **  Input:   index = link index
 **           id = link ID name
@@ -3456,7 +3677,7 @@ int DLLEXPORT EN_setlinktype(EN_Project p, int *index, int linkType, int actionC
     if (p->hydraul.OpenHflag || p->quality.OpenQflag) return 262;
 
     // Check for valid input parameters
-    if (linkType < 0 || linkType > GPV || actionCode < EN_UNCONDITIONAL ||
+    if (linkType < 0 || linkType > PCV || actionCode < EN_UNCONDITIONAL ||
         actionCode > EN_CONDITIONAL)
     {
         return 251;
@@ -3480,7 +3701,7 @@ int DLLEXPORT EN_setlinktype(EN_Project p, int *index, int linkType, int actionC
     if (oldType <= PIPE && linkType <= PIPE)
     {
         net->Link[i].Type = linkType;
-        if (linkType == CVPIPE) net->Link[i].Status = OPEN;
+        if (linkType == CVPIPE) net->Link[i].InitStatus = OPEN;
         return 0;
     }
 
@@ -3583,8 +3804,6 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
     Slink *Link = net->Link;
     Spump *Pump = net->Pump;
     double *Ucf = p->Ucf;
-    double *LinkFlow = hyd->LinkFlow;
-    double *LinkSetting = hyd->LinkSetting;
 
     // Check for valid arguments
     *value = 0.0;
@@ -3622,18 +3841,19 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
         break;
 
     case EN_INITSTATUS:
-        if (Link[index].Status <= CLOSED) v = 0.0;
+        if (Link[index].InitStatus <= CLOSED) v = 0.0;
         else v = 1.0;
+        if (Link[index].Type > PUMP && Link[index].InitStatus > OPEN) v = 2.0;
         break;
 
     case EN_INITSETTING:
-        if (Link[index].Type == PIPE || Link[index].Type == CVPIPE)
-        {
-            return EN_getlinkvalue(p, index, EN_ROUGHNESS, value);
-        }
-        v = Link[index].Kc;
+        v = Link[index].InitSetting;
         switch (Link[index].Type)
         {
+        case CVPIPE:
+        case PIPE:
+            if (hyd->Formflag == DW) v = v * (1000.0 * Ucf[ELEV]);
+            break;
         case PRV:
         case PSV:
         case PBV:
@@ -3656,7 +3876,7 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
 
     case EN_FLOW:
         if (hyd->LinkStatus[index] <= CLOSED) v = 0.0;
-        else v = LinkFlow[index] * Ucf[FLOW];
+        else v = hyd->LinkFlow[index] * Ucf[FLOW];
         break;
 
     case EN_VELOCITY:
@@ -3664,7 +3884,7 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
         else if (hyd->LinkStatus[index] <= CLOSED) v = 0.0;
         else
         {
-            q = ABS(LinkFlow[index]);
+            q = ABS(hyd->LinkFlow[index]);
             a = PI * SQR(Link[index].Diam) / 4.0;
             v = q / a * Ucf[VELOCITY];
         }
@@ -3683,6 +3903,8 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
     case EN_STATUS:
         if (hyd->LinkStatus[index] <= CLOSED) v = 0.0;
         else v = 1.0;
+        if (Link[index].Type > PUMP &&
+            hyd->LinkStatus[index] > OPEN) v = 2.0;
         break;
 
     case EN_SETTING:
@@ -3690,8 +3912,8 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
         {
             return EN_getlinkvalue(p, index, EN_ROUGHNESS, value);
         }
-        if (LinkSetting[index] == MISSING) v = 0.0;
-        else v = LinkSetting[index];
+        if (hyd->LinkSetting[index] == MISSING) v = 0.0;
+        else v = hyd->LinkSetting[index];
         switch (Link[index].Type)
         {
         case PRV:
@@ -3778,6 +4000,40 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
             v = (double)Pump[findpump(&p->network, index)].Epat;
         }
         break;
+        
+    case EN_PCV_CURVE:
+        if (Link[index].Type == PCV)
+        {
+            v = net->Valve[findvalve(&p->network, index)].Curve;
+        }
+        break;
+        
+    case EN_GPV_CURVE:
+        if (Link[index].Type == GPV)
+        {
+            v = Link[index].Kc;
+        }
+        break;
+
+    case EN_LINK_INCONTROL:
+        v = (double)incontrols(p, LINK, index);
+        break;
+
+    case EN_LEAK_AREA:
+        v = Link[index].LeakArea * Ucf[LENGTH];
+        break;
+
+    case EN_LEAK_EXPAN:
+        v = Link[index].LeakExpan * Ucf[LENGTH];
+        break;
+
+    case EN_LINK_LEAKAGE:
+        v = findlinkleakage(p, index) * Ucf[FLOW];
+        break;
+        
+    case EN_VALVE_TYPE:
+        if (Link[index].Type > PUMP) v = Link[index].Type;
+        break;
 
     default:
         return 251;
@@ -3786,6 +4042,24 @@ int DLLEXPORT EN_getlinkvalue(EN_Project p, int index, int property, double *val
     return 0;
 }
 
+int DLLEXPORT EN_getlinkvalues(EN_Project p, int property, double *values)
+/*----------------------------------------------------------------
+**  Input:   property = link property code (see EN_LinkProperty)
+**  Output:  values = array of link property values
+**  Returns: error code
+**  Purpose: retrieves property values for all links
+**----------------------------------------------------------------
+*/
+{
+    int errcode = 0, i = 0;
+    for(i = 1; i <= p->network.Nlinks; i++)
+    {
+        errcode = EN_getlinkvalue(p, i, property, &values[i-1]);
+        if(errcode != 0) { return errcode; }
+    }
+    return 0;
+}
+
 int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double value)
 /*----------------------------------------------------------------
 **  Input:   index = link index
@@ -3803,10 +4077,9 @@ int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double valu
 
     Slink *Link = net->Link;
     double *Ucf = p->Ucf;
-    double *LinkSetting = hyd->LinkSetting;
     char s;
     double r;
-    int pumpIndex, patIndex, curveIndex;
+    int pumpIndex, patIndex, curveIndex, valveType;
 
     if (!p->Openflag) return 102;
     if (index <= 0 || index > net->Nlinks) return 204;
@@ -3839,14 +4112,15 @@ int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double valu
             if (value <= 0.0) return 211;
             Link[index].Kc = value;
             if (hyd->Formflag == DW) Link[index].Kc /= (1000.0 * Ucf[ELEV]);
-            resistcoeff(p, index);
+            if (p->hydraul.OpenHflag) resistcoeff(p, index);
+            else Link[index].InitSetting = Link[index].Kc;
         }
         break;
 
     case EN_MINORLOSS:
         if (Link[index].Type != PUMP)
         {
-            if (value <= 0.0) return 211;
+            if (value < 0.0) return 211;
             Link[index].Km = 0.02517 * value / SQR(Link[index].Diam) /
                              SQR(Link[index].Diam);
         }
@@ -3857,29 +4131,31 @@ int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double valu
         // Cannot set status for a check valve
         if (Link[index].Type == CVPIPE) return 207;
         s = (char)ROUND(value);
-        if (s < 0 || s > 1) return 211;
+        if (s < 0 || s > 2) return 211;
+        s = s + CLOSED;
         if (property == EN_INITSTATUS)
         {
-            setlinkstatus(p, index, s, &Link[index].Status, &Link[index].Kc);
+            Link[index].InitStatus = s;
         }
         else
         {
-            setlinkstatus(p, index, s, &hyd->LinkStatus[index], &LinkSetting[index]);
+            setlinkstatus(p, index, s, &hyd->LinkStatus[index], &hyd->LinkSetting[index]);
         }
         break;
 
     case EN_INITSETTING:
     case EN_SETTING:
-        if (value < 0.0) return 211;
         if (Link[index].Type == PIPE || Link[index].Type == CVPIPE)
         {
-            return EN_setlinkvalue(p, index, EN_ROUGHNESS, value);
+            EN_setlinkvalue(p, index, EN_ROUGHNESS, value);
+            if (property == EN_INITSETTING) Link[index].InitSetting = Link[index].Kc;
         }
         else
         {
             switch (Link[index].Type)
             {
             case PUMP:
+                if (value < 0.0) return 211;
                 break;
             case PRV:
             case PSV:
@@ -3890,6 +4166,7 @@ int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double valu
                 value /= Ucf[FLOW];
                 break;
             case TCV:
+            case PCV:
                 break;
             case GPV:
                 return 207; // Cannot modify setting for GPV
@@ -3898,12 +4175,13 @@ int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double valu
             }
             if (property == EN_INITSETTING)
             {
-                setlinksetting(p, index, value, &Link[index].Status, &Link[index].Kc);
+                Link[index].Kc = value;
+                Link[index].InitSetting = value;
             }
             else
             {
                 setlinksetting(p, index, value, &hyd->LinkStatus[index],
-                               &LinkSetting[index]);
+                               &hyd->LinkSetting[index]);
             }
         }
         break;
@@ -3942,11 +4220,6 @@ int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double valu
             net->Pump[pumpIndex].Ptype = CONST_HP;
             net->Pump[pumpIndex].Hcurve = 0;
             net->Link[index].Km = value;
-            updatepumpparams(p, pumpIndex);
-            net->Pump[pumpIndex].R /= Ucf[POWER];
-            net->Pump[pumpIndex].Q0 /= Ucf[FLOW];
-            net->Pump[pumpIndex].Qmax /= Ucf[FLOW];
-            net->Pump[pumpIndex].Hmax /= Ucf[HEAD];
         }
         break;
 
@@ -3985,6 +4258,43 @@ int DLLEXPORT EN_setlinkvalue(EN_Project p, int index, int property, double valu
             net->Pump[pumpIndex].Epat = patIndex;
         }
         break;
+        
+    case EN_PCV_CURVE:
+        if (Link[index].Type == PCV)
+        {
+            curveIndex = ROUND(value);
+            if (curveIndex < 0 || curveIndex > net->Ncurves) return 206;
+            net->Valve[findvalve(&p->network, index)].Curve = curveIndex;
+        }
+        break;
+
+    case EN_GPV_CURVE:
+        if (Link[index].Type == GPV)
+        {
+            curveIndex = ROUND(value);
+            if (curveIndex < 0 || curveIndex > net->Ncurves) return 206;
+            Link[index].Kc = curveIndex;
+            if (hyd->OpenHflag == FALSE) Link[index].InitSetting = curveIndex;
+        }
+        break;
+
+    case EN_LEAK_AREA:  // leak area in sq mm per 100 pipe length units
+        if (value < 0.0) return 211;
+        Link[index].LeakArea = value / Ucf[LENGTH];
+        break;
+
+    case EN_LEAK_EXPAN:  // leak area expansion slope (sq mm per unit of head)
+        if (value < 0.0) return 211;
+        Link[index].LeakExpan = value / Ucf[LENGTH];
+        break;
+        
+    case EN_VALVE_TYPE:
+        if (hyd->OpenHflag || qual->OpenQflag) return 262;  //Solver is running
+        if (Link[index].Type <= PUMP) return 264;           //Link not a valve
+        valveType = ROUND(value);
+        if (valveType < PRV || valveType > PCV) return 213; //Invalid valve type
+        if (valveType == Link[index].Type) return 0;        //No type change
+        return changevalvetype(p, index, valveType);        //See project.c
 
     default:
         return 251;
@@ -4043,20 +4353,20 @@ int DLLEXPORT EN_getvertexcount(EN_Project p, int index, int *count)
 */
 {
     Network *net = &p->network;
-    
+
     Slink *Link = net->Link;
     Pvertices vertices;
-    
+
     // Check that link exists
     *count = 0;
     if (!p->Openflag) return 102;
     if (index <= 0 || index > net->Nlinks) return 204;
-    
+
     // Set count to number of vertices
     vertices = Link[index].Vertices;
     if (vertices) *count = vertices->Npts;
     return 0;
-}    
+}
 
 int DLLEXPORT EN_getvertex(EN_Project p, int index, int vertex, double *x, double *y)
 /*----------------------------------------------------------------
@@ -4070,25 +4380,54 @@ int DLLEXPORT EN_getvertex(EN_Project p, int index, int vertex, double *x, doubl
 */
 {
     Network *net = &p->network;
-    
+
     Slink *Link = net->Link;
     Pvertices vertices;
-    
+
     // Check that link exists
     *x = MISSING;
     *y = MISSING;
     if (!p->Openflag) return 102;
     if (index <= 0 || index > net->Nlinks) return 204;
-    
+
     // Check that vertex exists
     vertices = Link[index].Vertices;
     if (vertices == NULL) return 255;
     if (vertex <= 0 || vertex > vertices->Npts) return 255;
     *x = vertices->X[vertex - 1];
-    *y = vertices->Y[vertex - 1];    
+    *y = vertices->Y[vertex - 1];
     return 0;
 }
-    
+
+int DLLEXPORT EN_setvertex(EN_Project p, int index, int vertex, double x, double y)
+/*----------------------------------------------------------------
+**  Input:   index = link index
+**           vertex = index of a link vertex point
+**           x = vertex point's X-coordinate
+**           y = vertex point's Y-coordinate
+**  Returns: error code
+**  Purpose: sets the coordinates of a vertex point in a link
+**----------------------------------------------------------------
+*/
+{
+    Network *net = &p->network;
+
+    Slink *Link = net->Link;
+    Pvertices vertices;
+
+    // Check that link exists
+    if (!p->Openflag) return 102;
+    if (index <= 0 || index > net->Nlinks) return 204;
+
+    // Check that vertex exists
+    vertices = Link[index].Vertices;
+    if (vertices == NULL) return 255;
+    if (vertex <= 0 || vertex > vertices->Npts) return 255;
+    vertices->X[vertex - 1] = x;
+    vertices->Y[vertex - 1] = y;
+    return 0;
+}
+
 int DLLEXPORT EN_setvertices(EN_Project p, int index, double *x, double *y, int count)
 /*----------------------------------------------------------------
 **  Input:   index = link index
@@ -4101,11 +4440,11 @@ int DLLEXPORT EN_setvertices(EN_Project p, int index, double *x, double *y, int
 */
 {
     Network *net = &p->network;
-    
+
     Slink *link;
     int i;
     int err = 0;
-    
+
     // Check that link exists
     if (!p->Openflag) return 102;
     if (index <= 0 || index > net->Nlinks) return 204;
@@ -4113,7 +4452,7 @@ int DLLEXPORT EN_setvertices(EN_Project p, int index, double *x, double *y, int
 
     // Delete existing set of vertices
     freelinkvertices(link);
-    
+
     // Add each new vertex to the link
     for (i = 0; i < count; i++)
     {
@@ -4122,7 +4461,7 @@ int DLLEXPORT EN_setvertices(EN_Project p, int index, double *x, double *y, int
     }
     if (err) freelinkvertices(link);
     return err;
-}    
+}
 
 /********************************************************************
 
@@ -4188,10 +4527,7 @@ int DLLEXPORT EN_setheadcurveindex(EN_Project p, int linkIndex, int curveIndex)
 {
     Network *net = &p->network;
 
-    double *Ucf = p->Ucf;
     int pumpIndex;
-    int oldCurveIndex;
-    int newCurveType;
     int err = 0;
     Spump *pump;
 
@@ -4201,43 +4537,12 @@ int DLLEXPORT EN_setheadcurveindex(EN_Project p, int linkIndex, int curveIndex)
     if (PUMP != net->Link[linkIndex].Type) return 0;
     if (curveIndex < 0 || curveIndex > net->Ncurves) return 206;
 
-    // Save values that need to be restored in case new curve is invalid
-    pumpIndex = findpump(net, linkIndex);
-    pump = &p->network.Pump[pumpIndex];
-    oldCurveIndex = pump->Hcurve;
-    newCurveType = p->network.Curve[curveIndex].Type;
-    
     // Assign the new curve to the pump
-    pump->Ptype = NOCURVE;
+    pumpIndex = findpump(net, linkIndex);
+    pump = &net->Pump[pumpIndex];
     pump->Hcurve = curveIndex;
-    if (curveIndex == 0) return 0;
-    
-    // Update the pump's head curve parameters (which also changes
-    // the new curve's Type to PUMP_CURVE)
-    err = updatepumpparams(p, pumpIndex);
-    
-    // If the parameter updating failed (new curve was not a valid pump curve)
-    // restore the pump's original curve and its parameters
-    if (err > 0)
-    {
-        p->network.Curve[curveIndex].Type = newCurveType;
-        pump->Ptype = NOCURVE;
-        pump->Hcurve = oldCurveIndex;
-        if (oldCurveIndex == 0) return err;
-        updatepumpparams(p, pumpIndex);
-    }    
-    
-    // Convert the units of the updated pump parameters to feet and cfs
-    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;
+    net->Link[linkIndex].Km = 0.0;
+    return 0;
 }
 
 /********************************************************************
@@ -4246,7 +4551,7 @@ int DLLEXPORT EN_setheadcurveindex(EN_Project p, int linkIndex, int curveIndex)
 
 ********************************************************************/
 
-int DLLEXPORT EN_addpattern(EN_Project p, char *id)
+int DLLEXPORT EN_addpattern(EN_Project p, const char *id)
 /*----------------------------------------------------------------
 **  Input:   id = time pattern ID name
 **  Output:  none
@@ -4294,6 +4599,70 @@ int DLLEXPORT EN_addpattern(EN_Project p, char *id)
     return 0;
 }
 
+int DLLEXPORT EN_loadpatternfile(EN_Project p, const char *filename, const char *id)
+/*----------------------------------------------------------------
+**  Input:   filename =  name of the file containing pattern data
+**           id = ID for the new pattern
+**  Output:  none
+**  Returns: error code
+**  Purpose: loads time patterns from a file into a project under a specific pattern ID
+**----------------------------------------------------------------
+*/
+{
+    FILE *file;
+    char line[MAXLINE+1];
+	char *tok;
+    int err = 0;
+    int i;
+    int len = 0;
+    double value;
+    double *values = NULL;
+    int CHUNK = 50;
+
+    if (!p->Openflag) return 102;
+
+    file = fopen(filename, "r");
+    if (file == NULL) return 302;
+
+    // Add a new pattern or use an existing pattern.
+    err = EN_getpatternindex(p, id, &i);
+    if (err == 205) {
+        if ((err = EN_addpattern(p, id)) != 0) {
+            fclose(file);
+            return err;
+        }
+        i = p->network.Npats;
+    }
+
+    // Read pattern values
+    while (fgets(line, sizeof(line), file) != NULL) {
+    
+        // Skip lines that don't contain valid numbers
+        tok = strtok(line, SEPSTR);
+        if (tok == NULL) continue;
+        if (!getfloat(tok, &value)) continue;
+        
+        // Resize multiplier array if it's full
+        if (len % CHUNK == 0) {
+            values = (double *) realloc(values, (len + CHUNK) * sizeof(double));
+
+            // Abort if memory allocation error
+            if (values == NULL) {
+                fclose(file);
+                return 101; 
+            }
+        }
+        values[len] = value;
+        len++;
+    }
+    fclose(file);
+    
+    // Transfer multipliers to pattern
+    err = EN_setpattern(p, i, values, len);
+    free(values);    
+    return err;
+}
+
 int  DLLEXPORT EN_deletepattern(EN_Project p, int index)
 /*----------------------------------------------------------------
 **  Input:   index  = index of the pattern to delete
@@ -4323,6 +4692,10 @@ int  DLLEXPORT EN_deletepattern(EN_Project p, int index)
     if (hyd->Epat == index)  hyd->Epat = 0;
     else if (hyd->Epat > index) hyd->Epat--;
 
+    // Modify global default demand pattern
+    if (hyd->DefPat == index) hyd->DefPat = 0;
+    else if (hyd->DefPat > index) hyd->DefPat--;
+
     // Free the pattern's factor array
     FREE(net->Pattern[index].F);
     FREE(net->Pattern[index].Comment);
@@ -4334,7 +4707,7 @@ int  DLLEXPORT EN_deletepattern(EN_Project p, int index)
     return 0;
 }
 
-int DLLEXPORT EN_getpatternindex(EN_Project p, char *id, int *index)
+int DLLEXPORT EN_getpatternindex(EN_Project p, const char *id, int *index)
 /*----------------------------------------------------------------
 **  Input:   id = time pattern name
 **  Output:  index = time pattern index
@@ -4375,7 +4748,7 @@ int DLLEXPORT EN_getpatternid(EN_Project p, int index, char *id)
     return 0;
 }
 
-int DLLEXPORT EN_setpatternid(EN_Project p, int index, char *id)
+int DLLEXPORT EN_setpatternid(EN_Project p, int index, const char *id)
 /*----------------------------------------------------------------
 **  Input:   index = time pattern index
 **           id = time pattern ID name
@@ -4472,7 +4845,7 @@ int DLLEXPORT EN_getaveragepatternvalue(EN_Project p, int index, double *value)
 
     *value = 0.0;
     if (!p->Openflag) return 102;
-    if (index < 1 || index > net->Npats) return 205;
+    if (index < 0 || index > net->Npats) return 205;
     for (i = 0; i < Pattern[index].Length; i++)
     {
         *value += (double)Pattern[index].F[i];
@@ -4519,7 +4892,7 @@ int DLLEXPORT EN_setpattern(EN_Project p, int index, double *values, int len)
 
 ********************************************************************/
 
-int DLLEXPORT EN_addcurve(EN_Project p, char *id)
+int DLLEXPORT EN_addcurve(EN_Project p, const char *id)
 /*----------------------------------------------------------------
 **  Input:   id = data curve ID name
 **  Output:  none
@@ -4611,7 +4984,7 @@ int  DLLEXPORT EN_deletecurve(EN_Project p, int index)
     return 0;
 }
 
-int DLLEXPORT EN_getcurveindex(EN_Project p, char *id, int *index)
+int DLLEXPORT EN_getcurveindex(EN_Project p, const char *id, int *index)
 /*----------------------------------------------------------------
 **  Input:   id = data curve name
 **  Output:  index = data curve index
@@ -4643,7 +5016,7 @@ int DLLEXPORT EN_getcurveid(EN_Project p, int index, char *id)
     return 0;
 }
 
-int DLLEXPORT EN_setcurveid(EN_Project p, int index, char *id)
+int DLLEXPORT EN_setcurveid(EN_Project p, int index, const char *id)
 /*----------------------------------------------------------------
 **  Input:   index = data curve index
 **           id = data curve ID name
@@ -4699,6 +5072,23 @@ int DLLEXPORT EN_getcurvetype(EN_Project p, int index, int *type)
     return 0;
 }
 
+int DLLEXPORT EN_setcurvetype(EN_Project p, int index, int type)
+/*----------------------------------------------------------------
+**  Input:   index = data curve index
+**           type = type of data curve (see EN_CurveType)
+**  Returns: error code
+**  Purpose: sets the type assigned to a data curve
+**----------------------------------------------------------------
+*/
+{
+    Network *net = &p->network;
+    if (!p->Openflag) return 102;
+    if (index < 1 || index > net->Ncurves) return 206;
+    if (type < 0 || type > EN_VALVE_CURVE) return 251;
+    net->Curve[index].Type = type;
+    return 0;
+}
+
 int DLLEXPORT EN_getcurvevalue(EN_Project p, int curveIndex, int pointIndex,
                                double *x, double *y)
 /*----------------------------------------------------------------
@@ -4768,9 +5158,7 @@ int DLLEXPORT EN_setcurvevalue(EN_Project p, int curveIndex, int pointIndex,
     // Insert new point into curve
     curve->X[n] = x;
     curve->Y[n] = y;
-    
-    // Adjust parameters for pumps using curve as a head curve
-    return adjustpumpparams(p, curveIndex);
+    return 0;
 }
 
 int DLLEXPORT EN_getcurve(EN_Project p, int index, char *id, int *nPoints,
@@ -4842,9 +5230,7 @@ int DLLEXPORT EN_setcurve(EN_Project p, int index, double *xValues,
         curve->X[j] = xValues[j];
         curve->Y[j] = yValues[j];
     }
-    
-    // Adjust parameters for pumps using curve as a head curve
-    return adjustpumpparams(p, index);
+    return 0;
 }
 
 /********************************************************************
@@ -4870,84 +5256,30 @@ int DLLEXPORT EN_addcontrol(EN_Project p, int type, int linkIndex, double settin
 */
 {
     Network *net = &p->network;
-    Parser *parser = &p->parser;
-
-    char status = ACTIVE;
-    int  n;
-    long t = 0;
-    double s = setting, lvl = level;
-    double *Ucf = p->Ucf;
-    Scontrol *control;
 
+    int  err, n;
+    Scontrol ctrl;
 
     // Check that project exists
     if (!p->Openflag) return 102;
 
     // Check that controlled link exists
     if (linkIndex <= 0 || linkIndex > net->Nlinks) return 204;
-
-    // Cannot control check valve
-    if (net->Link[linkIndex].Type == CVPIPE) return 207;
-
-    // Check for valid parameters
-    if (type < 0 || type > EN_TIMEOFDAY) return 251;
-    if (type == EN_LOWLEVEL || type == EN_HILEVEL)
-    {
-        if (nodeIndex < 1 || nodeIndex > net->Nnodes) return 203;
-    }
-    else nodeIndex = 0;
-    if (s < 0.0 || lvl < 0.0) return 202;
-
-    // Adjust units of control parameters
-    switch (net->Link[linkIndex].Type)
-    {
-    case PRV:
-    case PSV:
-    case PBV:
-        s /= Ucf[PRESSURE];
-        break;
-    case FCV:
-        s /= Ucf[FLOW];
-        break;
-    case GPV:
-        if (s == 0.0) status = CLOSED;
-        else if (s == 1.0) status = OPEN;
-        else return 202;
-        s = net->Link[linkIndex].Kc;
-        break;
-    case PIPE:
-    case PUMP:
-        status = OPEN;
-        if (s == 0.0) status = CLOSED;
-    default:
-        break;
-    }
-
-    if (type == LOWLEVEL || type == HILEVEL)
-    {
-        if (nodeIndex > net->Njuncs) lvl = net->Node[nodeIndex].El + level / Ucf[ELEV];
-        else lvl = net->Node[nodeIndex].El + level / Ucf[PRESSURE];
-    }
-    if (type == TIMER) t = (long)ROUND(lvl);
-    if (type == TIMEOFDAY) t = (long)ROUND(lvl) % SECperDAY;
+    
+    // Insert control properties into a temporary struct
+    err = setcontrol(p, type, linkIndex, setting, nodeIndex, level, &ctrl);
+    if (err > 0) return err;
 
     // Expand project's array of controls
     n = net->Ncontrols + 1;
     net->Control = (Scontrol *)realloc(net->Control, (n + 1) * sizeof(Scontrol));
 
     // Set properties of the new control
-    control = &net->Control[n];
-    control->Type = (char)type;
-    control->Link = linkIndex;
-    control->Node = nodeIndex;
-    control->Status = status;
-    control->Setting = s;
-    control->Grade = lvl;
-    control->Time = t;
+    net->Control[n] = ctrl;
 
     // Update number of controls
     net->Ncontrols = n;
-    parser->MaxControls = n;
+    p->parser.MaxControls = n;
 
     // Replace the control's index
     *index = n;
@@ -5030,8 +5362,8 @@ int DLLEXPORT EN_getcontrol(EN_Project p, int index, int *type, int *linkIndex,
             break;
         }
     }
-    else if (control->Status == OPEN) s = 1.0;
-    else s = 0.0;
+    else if (control->Status == OPEN) s = SET_OPEN;
+    else s = SET_CLOSED;
 
     // Retrieve level value for a node level control
     *nodeIndex = control->Node;
@@ -5053,8 +5385,8 @@ int DLLEXPORT EN_getcontrol(EN_Project p, int index, int *type, int *linkIndex,
     {
         lvl = (double)control->Time;
     }
-    *setting = (double)s;
-    *level = (double)lvl;
+    *setting = s;
+    *level = lvl;
     return 0;
 }
 
@@ -5076,81 +5408,63 @@ int DLLEXPORT EN_setcontrol(EN_Project p, int index, int type, int linkIndex,
 {
     Network *net = &p->network;
 
-    char status = ACTIVE;
-    long t = 0;
-    double s = setting, lvl = level;
-    double *Ucf = p->Ucf;
-    Slink *link;
-    Scontrol *control;
+    int err;
+    Scontrol ctrl;
 
     // Check that project exists
     if (!p->Openflag) return 102;
 
     // Check that control exists
     if (index <= 0 || index > net->Ncontrols) return 241;
-    control = &net->Control[index];
 
     // Check that controlled link exists (0 index de-activates the control)
     if (linkIndex == 0)
     {
-        control->Link = 0;
+        net->Control[index].Link = 0;
         return 0;
     }
     if (linkIndex < 0 || linkIndex > net->Nlinks) return 204;
 
-    // Cannot control check valve
-    if (net->Link[linkIndex].Type == CVPIPE) return 207;
+    // Assign new set of properties to control
+    err = setcontrol(p, type, linkIndex, setting, nodeIndex, level, &ctrl);
+    if (err > 0) return err;
+    net->Control[index] = ctrl;
+    return 0;
+}
 
-    // Check for valid control properties
-    if (type < 0 || type > EN_TIMEOFDAY) return 251;
-    if (type == EN_LOWLEVEL || type == EN_HILEVEL)
-    {
-        if (nodeIndex < 1 || nodeIndex > net->Nnodes) return 203;
-    }
-    else nodeIndex = 0;
-    if (s < 0.0 || lvl < 0.0) return 202;
 
-    // Adjust units of control's properties
-    link = &net->Link[linkIndex];
-    switch (link->Type)
-    {
-    case PRV:
-    case PSV:
-    case PBV:
-        s /= Ucf[PRESSURE];
-        break;
-    case FCV:
-        s /= Ucf[FLOW];
-        break;
-    case GPV:
-        if (s == 0.0)  status = CLOSED;
-        else if (s == 1.0) status = OPEN;
-        else return 202;
-        s = link->Kc;
-        break;
-    case PIPE:
-    case PUMP:
-        status = OPEN;
-        if (s == 0.0) status = CLOSED;
-    default:
-        break;
-    }
-    if (type == LOWLEVEL || type == HILEVEL)
-    {
-        if (nodeIndex > net->Njuncs) lvl = net->Node[nodeIndex].El + level / Ucf[ELEV];
-        else lvl = net->Node[nodeIndex].El + level / Ucf[PRESSURE];
-    }
-    if (type == TIMER) t = (long)ROUND(lvl);
-    if (type == TIMEOFDAY) t = (long)ROUND(lvl) % SECperDAY;
-
-    /* Reset control's parameters */
-    control->Type = (char)type;
-    control->Link = linkIndex;
-    control->Node = nodeIndex;
-    control->Status = status;
-    control->Setting = s;
-    control->Grade = lvl;
-    control->Time = t;
+int  DLLEXPORT EN_getcontrolenabled(EN_Project p, int index, int *enabled)
+{
+    Network *net = &p->network;
+    Scontrol *control;
+    
+    // Check for valid arguments
+    if (!p->Openflag) 
+        return 102;
+    if (index <= 0 || index > net->Ncontrols) 
+        return 241;
+
+    control = &net->Control[index];
+    *enabled = control->isEnabled;
+    return 0;
+}
+
+
+int  DLLEXPORT EN_setcontrolenabled(EN_Project p, int index, int enabled)
+{
+    Network *net = &p->network;
+    Scontrol *control;
+    
+    // Check for valid arguments
+    if (enabled != TRUE && enabled != FALSE)
+        return 202; // illegal numeric value
+    if (!p->Openflag) 
+        return 102;
+    if (index <= 0 || index > net->Ncontrols) 
+        return 241;
+
+    control = &net->Control[index];
+    control->isEnabled = enabled;
     return 0;
 }
 
@@ -5404,7 +5718,7 @@ int DLLEXPORT EN_setpremisestatus(EN_Project p, int ruleIndex, int premiseIndex,
 **  Input:   ruleIndex = rule index
 **           premiseIndex = premise index
 **           status = object status being tested against
-**                    (see EN_RuleStatus))
+**                    (see EN_RuleStatus)
 **  Output:  none
 **  Returns: error code
 **  Purpose: sets the status of an object being tested against
@@ -5456,7 +5770,7 @@ int DLLEXPORT EN_getthenaction(EN_Project p, int ruleIndex, int actionIndex,
 **  Input:   ruleIndex = rule index
 **           actionIndex = index of a rule's THEN actions
 **  Output:  linkIndex = index of link appearing in the action
-**           status = status assigned to the link (see EN_RuleStatus))
+**           status = status assigned to the link (see EN_RuleStatus)
 **           setting = setting assigned to the link
 **  Returns: error code
 **  Purpose: retrieves the properties of a rule's THEN action
@@ -5484,7 +5798,7 @@ int DLLEXPORT EN_setthenaction(EN_Project p, int ruleIndex, int actionIndex,
 **  Input:   ruleIndex = rule index
 **           actionIndex = index of a rule's THEN actions
 **           linkIndex = index of link appearing in the action
-**           status = status assigned to the link (see EN_RuleStatus))
+**           status = status assigned to the link (see EN_RuleStatus)
 **           setting = setting assigned to the link
 **  Returns: error code
 **  Purpose: sets the properties of a rule's THEN action
@@ -5512,7 +5826,7 @@ int DLLEXPORT EN_getelseaction(EN_Project p, int ruleIndex, int actionIndex,
 **  Input:   ruleIndex = rule index
 **           actionIndex = index of a rule's ELSE actions
 **  Output:  linkIndex = index of link appearing in the action
-**           status = status assigned to the link (see EN_RuleStatus))
+**           status = status assigned to the link (see EN_RuleStatus)
 **           setting = setting assigned to the link
 **  Returns: error code
 **  Purpose: retrieves the properties of a rule's ELSE action
@@ -5540,7 +5854,7 @@ int DLLEXPORT EN_setelseaction(EN_Project p, int ruleIndex, int actionIndex,
 **  Input:   ruleIndex = rule index
 **           actionIndex = index of a rule's ELSE actions
 **           linkIndex = index of link appearing in the action
-**           status = status assigned to the link (see EN_RuleStatus))
+**           status = status assigned to the link (see EN_RuleStatus)
 **           setting = setting assigned to the link
 **  Returns: error code
 **  Purpose: sets the properties of a rule's ELSE action
@@ -5576,3 +5890,41 @@ int DLLEXPORT EN_setrulepriority(EN_Project p, int index, double priority)
     p->network.Rule[index].priority = priority;
     return 0;
 }
+
+
+int  DLLEXPORT EN_getruleenabled(EN_Project p, int index, int *enabled)
+{
+    Network *net = &p->network;
+    Srule *rule;
+    
+    // Check for valid arguments
+    if (!p->Openflag) 
+        return 102;
+    if (index <= 0 || index > net->Nrules) 
+        return 241;
+
+    rule = &net->Rule[index];
+    *enabled = rule->isEnabled;
+    return 0;
+}
+
+
+int  DLLEXPORT EN_setruleenabled(EN_Project p, int index, int enabled)
+{
+    Network *net = &p->network;
+    Srule *rule;
+    
+    // Check for valid arguments
+    if (enabled != TRUE && enabled != FALSE)
+        return 202; // illegal numeric value
+    if (!p->Openflag) 
+        return 102;
+    if (index <= 0 || index > net->Nrules) 
+        return 241;
+
+    rule = &net->Rule[index];
+    rule->isEnabled = enabled;
+    return 0;
+}
+
+