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

epyt_flow/EPANET/EPANET/SRC_engines/funcs.h

@@ -1,13 +1,13 @@
 /*
  ******************************************************************************
  Project:      OWA EPANET
- Version:      2.2
+ Version:      2.3
  Module:       funcs.h
  Description:  prototypes of external functions called by various modules
  Authors:      see AUTHORS
  Copyright:    see AUTHORS
  License:      see LICENSE
- Last Updated: 11/15/2019
+ Last Updated: 04/23/2025
  ******************************************************************************
 */
 #ifndef FUNCS_H
@@ -19,6 +19,7 @@ void    initpointers(Project *);
 int     allocdata(Project *);
 void    freedata(Project *);
 
+int     openproject(Project *, const char *, const char *, const char *, int);
 int     openfiles(Project *, const char *, const char *,const char *);
 int     openhydfile(Project *);
 int     openoutfile(Project *);
@@ -28,17 +29,20 @@ int     buildadjlists(Network *);
 void    freeadjlists(Network *);
 
 int     incontrols(Project *, int, int);
+int     changevalvetype(Project *, int, int);
 int     valvecheck(Project *, int, int, int, int);
-int     findnode(Network *, char *);
-int     findlink(Network *, char *);
+int     unlinked(Project *);
+
+int     findnode(Network *, const char *);
+int     findlink(Network *, const char *);
 int     findtank(Network *, int);
 int     findvalve(Network *, int);
 int     findpump(Network *, int);
-int     findpattern(Network *, char *);
-int     findcurve(Network *, char *);
+int     findpattern(Network *, const char *);
+int     findcurve(Network *, const char *);
 
 Pdemand finddemand(Pdemand, int);
-int     adddemand(Snode *, double, int, char *);
+int     adddemand(Snode *, double, int, const char *);
 void    freedemands(Snode *);
 
 int     addlinkvertex(Slink *, double, double);
@@ -46,11 +50,13 @@ void    freelinkvertices(Slink *);
 
 void    adjustpatterns(Network *, int);
 void    adjustcurves(Network *, int);
-int     adjustpumpparams(Project *, int);
 int     resizecurve(Scurve *, int);
+int     setcontrol(Project *, int, int, double, int, double, Scontrol *);
 
 int     getcomment(Network *, int, int, char *);
 int     setcomment(Network *, int, int, const char *);
+int     gettag(Network *, int, int, char *);
+int     settag(Network *, int, int, const char *);                                                  
 
 int     namevalid(const char *);
 void    getTmpName(char *);
@@ -67,7 +73,7 @@ int     getdata(Project *);
 void    setdefaults(Project *);
 void    initreport(Report *);
 void    adjustdata(Project *);
-int     inittanks(Project *);
+void    inittanks(Project *);
 void    initunits(Project *);
 void    convertunits(Project *);
 
@@ -75,7 +81,6 @@ void    convertunits(Project *);
 
 int     netsize(Project *);
 int     readdata(Project *);
-int     updatepumpparams(Project *, int);
 int     findmatch(char *, char *[]);
 int     match(const char *, const char *);
 int     gettokens(char *, char **, int, char *);
@@ -98,6 +103,7 @@ int     controldata(Project *);
 int     energydata(Project *);
 int     sourcedata(Project *);
 int     emitterdata(Project *);
+int     leakagedata(Project *);
 int     qualdata(Project *);
 int     reactdata(Project *);
 int     mixingdata(Project *);
@@ -106,6 +112,7 @@ int     reportdata(Project *);
 int     timedata(Project *);
 int     optiondata(Project *);
 int     vertexdata(Project *);
+int     tagdata(Project *);
 
 // ------- RULES.C ------------------
 
@@ -117,28 +124,30 @@ void    freerules(Project *);
 int     ruledata(Project *);
 void    ruleerrmsg(Project *);
 void    adjustrules(Project *, int, int);
-void    adjusttankrules(Project *);
+void    adjusttankrules(Project *, int);
 Spremise *getpremise(Spremise *, int);
 Saction  *getaction(Saction *, int);
 int     writerule(Project *, FILE *, int);
 int     checkrules(Project *, long);
+void    updateruleunits(Project *pr, double dcf, double pcf, double hcf, double qcf);
 
 // ------- REPORT.C -----------------
 
 int     clearreport(Project *);
-int     copyreport(Project *, char *);
+int     copyreport(Project *, const char *);
 int     writereport(Project *);
 void    writelogo(Project *);
 void    writesummary(Project *);
 void    writehydstat(Project *, int, double);
 void    writeheader(Project *, int,int);
-void    writeline(Project *, char *);
+void    writeline(Project *, const char *);
 void    writerelerr(Project *, int, double);
 void    writestatchange(Project *, int,char,char);
 void    writecontrolaction(Project *, int, int);
 void    writeruleaction(Project *, int, char *);
 int     writehydwarn(Project *, int,double);
 void    writehyderr(Project *, int);
+void    writeflowbalance(Project *);
 void    writemassbalance(Project *);
 void    writetime(Project *, char *);
 char    *clocktime(char *, long);
@@ -153,6 +162,7 @@ void    closehyd(Project *);
 void    setlinkstatus(Project *, int, char, StatusType *, double *);
 void    setlinksetting(Project *, int, double, StatusType *, double *);
 int     tanktimestep(Project *, long *);
+int     controltimestep(Project *, long *);
 void    getenergy(Project *, int, double *, double *);
 double  tankvolume(Project *, int, double);
 double  tankgrade(Project *, int, double);
@@ -162,8 +172,9 @@ double  tankgrade(Project *, int, double);
 void    resistcoeff(Project *, int);
 void    headlosscoeffs(Project *);
 void    matrixcoeffs(Project *);
-void    emitterheadloss(Project *, int, double *, double *);           
+void    emitterheadloss(Project *, int, double *, double *);
 void    demandheadloss(Project *, int, double, double, double *, double *);
+double  pcvlosscoeff(Project *, int, double);
 
 // ------- QUALITY.C --------------------
 
@@ -190,4 +201,19 @@ int     savefinaloutput(Project *);
 
 int     saveinpfile(Project *, const char *);
 
+// ------- LEAKAGE.C --------------------
+
+int     openleakage(Project *);
+void    closeleakage(Project *);
+double  findlinkleakage(Project *, int);
+void    leakagecoeffs(Project *);
+double  leakageflowchange(Project *, int);
+int     leakagehasconverged(Project *);
+
+// ------- FLOWBALANCE.C-----------------
+
+void    startflowbalance(Project *);
+void    updateflowbalance(Project *, long);
+void    endflowbalance(Project *);
+
 #endif

epyt_flow/EPANET/EPANET/SRC_engines/hash.c

@@ -1,177 +1,177 @@
- /*
-  ******************************************************************************
-  Project:      OWA EPANET
-  Version:      2.2
-  Module:       hash.c
-  Description:  implementation of a simple hash table
-  Authors:      see AUTHORS
-  Copyright:    see AUTHORS
-  License:      see LICENSE
-  Last Updated: 05/15/2019
- ******************************************************************************
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include "hash.h"
-
-#define HASHTABLEMAXSIZE 128000
-
-// An entry in the hash table
-typedef struct DataEntryStruct
-{
-    char   *key;
-    int    data;
-    struct DataEntryStruct *next;
-} DataEntry;
-
-// Hash a string to an integer
-unsigned int gethash(char *str)
-{
-    unsigned int hash = 5381;
-    unsigned int retHash;
-    int c;
-    while ((c = *str++))
-    {
-        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
-    }
-    retHash = hash % HASHTABLEMAXSIZE;
-    return retHash;
-}
-
-// Produce a duplicate string
-char *dupstr(const char *s)
-{
-    size_t size = strlen(s) + 1;
-    char *p = malloc(size);
-    if (p) memcpy(p, s, size);
-    return p;
-}
-
-// Create a hash table
-HashTable *hashtable_create()
-{
-    int i;
-    HashTable *ht = (HashTable *) calloc(HASHTABLEMAXSIZE, sizeof(HashTable));
-    if (ht != NULL)
-    {
-        for (i = 0; i < HASHTABLEMAXSIZE; i++) ht[i] = NULL;
-    }
-    return ht;
-}
-
-// Insert an entry into the hash table
-int hashtable_insert(HashTable *ht, char *key, int data)
-{
-    unsigned int i = gethash(key);
-    DataEntry *entry;
-    if ( i >= HASHTABLEMAXSIZE ) return 0;
-    entry = (DataEntry *) malloc(sizeof(DataEntry));
-    if (entry == NULL) return(0);
-    entry->key = dupstr(key);
-    entry->data = data;
-    entry->next = ht[i];
-    ht[i] = entry;
-    return 1;
-}
-
-// Change the hash table's data entry for a particular key
-int hashtable_update(HashTable *ht, char *key, int new_data)
-{
-    unsigned int i = gethash(key);
-    DataEntry *entry;
-
-    if ( i >= HASHTABLEMAXSIZE ) return NOTFOUND;
-    entry = ht[i];
-    while (entry != NULL)
-    {
-        if ( strcmp(entry->key, key) == 0 )
-        {
-            entry->data = new_data;
-            return 1;
-        }
-        entry = entry->next;
-    }
-    return NOTFOUND;
-}
-
-// Delete an entry in the hash table
-int hashtable_delete(HashTable *ht, char *key)
-{
-    unsigned int i = gethash(key);
-    DataEntry *entry, *preventry;
-
-    if ( i >= HASHTABLEMAXSIZE ) return NOTFOUND;
-
-    preventry = NULL;
-    entry = ht[i];
-    while (entry != NULL)
-    {
-        if (strcmp(entry->key, key) == 0)
-        {
-            if (preventry == NULL) ht[i] = entry->next;
-            else preventry->next = entry->next;
-            free(entry->key);
-            free(entry);
-            return 1;
-        }
-        preventry = entry;
-        entry = entry->next;
-    }
-    return NOTFOUND;
-}
-
-// Find the data for a particular key
-int hashtable_find(HashTable *ht, char *key)
-{
-    unsigned int i = gethash(key);
-    DataEntry *entry;
-
-    if ( i >= HASHTABLEMAXSIZE ) return NOTFOUND;
-    entry = ht[i];
-    while (entry != NULL)
-    {
-        if ( strcmp(entry->key, key) == 0 )
-        {
-            return entry->data;
-        }
-        entry = entry->next;
-    }
-    return NOTFOUND;
-}
-
-// Find a particular key in the hash table
-char *hashtable_findkey(HashTable *ht, char *key)
-{
-    unsigned int i = gethash(key);
-    DataEntry *entry;
-    if ( i >= HASHTABLEMAXSIZE ) return NULL;
-    entry = ht[i];
-    while (entry != NULL)
-    {
-        if ( strcmp(entry->key, key) == 0 ) return entry->key;
-        entry = entry->next;
-    }
-    return NULL;
-}
-
-// Delete a hash table and free all of its memory
-void hashtable_free(HashTable *ht)
-{
-    DataEntry *entry, *nextentry;
-    int i;
-
-    for (i = 0; i < HASHTABLEMAXSIZE; i++)
-    {
-        entry = ht[i];
-        while (entry != NULL)
-        {
-            nextentry = entry->next;
-            free(entry->key);
-            free(entry);
-            entry = nextentry;
-        }
-        ht[i] = NULL;
-    }
-    free(ht);
-}
+ /*
+  ******************************************************************************
+  Project:      OWA EPANET
+  Version:      2.3
+  Module:       hash.c
+  Description:  implementation of a simple hash table
+  Authors:      see AUTHORS
+  Copyright:    see AUTHORS
+  License:      see LICENSE
+  Last Updated: 05/15/2019
+ ******************************************************************************
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "hash.h"
+
+#define HASHTABLEMAXSIZE 128000
+
+// An entry in the hash table
+typedef struct DataEntryStruct
+{
+    char   *key;
+    int    data;
+    struct DataEntryStruct *next;
+} DataEntry;
+
+// Hash a string to an integer
+unsigned int gethash(const char *str)
+{
+    unsigned int hash = 5381;
+    unsigned int retHash;
+    int c;
+    while ((c = *str++))
+    {
+        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+    }
+    retHash = hash % HASHTABLEMAXSIZE;
+    return retHash;
+}
+
+// Produce a duplicate string
+char *dupstr(const char *s)
+{
+    size_t size = strlen(s) + 1;
+    char *p = malloc(size);
+    if (p) memcpy(p, s, size);
+    return p;
+}
+
+// Create a hash table
+HashTable *hashtable_create()
+{
+    int i;
+    HashTable *ht = (HashTable *) calloc(HASHTABLEMAXSIZE, sizeof(HashTable));
+    if (ht != NULL)
+    {
+        for (i = 0; i < HASHTABLEMAXSIZE; i++) ht[i] = NULL;
+    }
+    return ht;
+}
+
+// Insert an entry into the hash table
+int hashtable_insert(HashTable *ht, const char *key, int data)
+{
+    unsigned int i = gethash(key);
+    DataEntry *entry;
+    if ( i >= HASHTABLEMAXSIZE ) return 0;
+    entry = (DataEntry *) malloc(sizeof(DataEntry));
+    if (entry == NULL) return(0);
+    entry->key = dupstr(key);
+    entry->data = data;
+    entry->next = ht[i];
+    ht[i] = entry;
+    return 1;
+}
+
+// Change the hash table's data entry for a particular key
+int hashtable_update(HashTable *ht, const char *key, int new_data)
+{
+    unsigned int i = gethash(key);
+    DataEntry *entry;
+
+    if ( i >= HASHTABLEMAXSIZE ) return NOTFOUND;
+    entry = ht[i];
+    while (entry != NULL)
+    {
+        if ( strcmp(entry->key, key) == 0 )
+        {
+            entry->data = new_data;
+            return 1;
+        }
+        entry = entry->next;
+    }
+    return NOTFOUND;
+}
+
+// Delete an entry in the hash table
+int hashtable_delete(HashTable *ht, const char *key)
+{
+    unsigned int i = gethash(key);
+    DataEntry *entry, *preventry;
+
+    if ( i >= HASHTABLEMAXSIZE ) return NOTFOUND;
+
+    preventry = NULL;
+    entry = ht[i];
+    while (entry != NULL)
+    {
+        if (strcmp(entry->key, key) == 0)
+        {
+            if (preventry == NULL) ht[i] = entry->next;
+            else preventry->next = entry->next;
+            free(entry->key);
+            free(entry);
+            return 1;
+        }
+        preventry = entry;
+        entry = entry->next;
+    }
+    return NOTFOUND;
+}
+
+// Find the data for a particular key
+int hashtable_find(HashTable *ht, const char *key)
+{
+    unsigned int i = gethash(key);
+    DataEntry *entry;
+
+    if ( i >= HASHTABLEMAXSIZE ) return NOTFOUND;
+    entry = ht[i];
+    while (entry != NULL)
+    {
+        if ( strcmp(entry->key, key) == 0 )
+        {
+            return entry->data;
+        }
+        entry = entry->next;
+    }
+    return NOTFOUND;
+}
+
+// Find a particular key in the hash table
+char *hashtable_findkey(HashTable *ht, const char *key)
+{
+    unsigned int i = gethash(key);
+    DataEntry *entry;
+    if ( i >= HASHTABLEMAXSIZE ) return NULL;
+    entry = ht[i];
+    while (entry != NULL)
+    {
+        if ( strcmp(entry->key, key) == 0 ) return entry->key;
+        entry = entry->next;
+    }
+    return NULL;
+}
+
+// Delete a hash table and free all of its memory
+void hashtable_free(HashTable *ht)
+{
+    DataEntry *entry, *nextentry;
+    int i;
+
+    for (i = 0; i < HASHTABLEMAXSIZE; i++)
+    {
+        entry = ht[i];
+        while (entry != NULL)
+        {
+            nextentry = entry->next;
+            free(entry->key);
+            free(entry);
+            entry = nextentry;
+        }
+        ht[i] = NULL;
+    }
+    free(ht);
+}

epyt_flow/EPANET/EPANET/SRC_engines/hash.h

@@ -1,28 +1,28 @@
-/*
- ******************************************************************************
- Project:      OWA EPANET
- Version:      2.2
- Module:       hash.h
- Description:  header for a simple hash table
- Authors:      see AUTHORS
- Copyright:    see AUTHORS
- License:      see LICENSE
- Last Updated: 11/27/2018
- ******************************************************************************
-*/
-#ifndef HASH_H
-#define HASH_H
-
-#define NOTFOUND  0
-
-typedef struct DataEntryStruct *HashTable;
-
-HashTable *hashtable_create(void);
-int       hashtable_insert(HashTable *, char *, int);
-int       hashtable_find(HashTable *, char *);
-char      *hashtable_findkey(HashTable *, char *);
-void      hashtable_free(HashTable *);
-int       hashtable_update(HashTable *ht, char *key, int new_data);
-int       hashtable_delete(HashTable *ht, char *key);
-
-#endif
+/*
+ ******************************************************************************
+ Project:      OWA EPANET
+ Version:      2.3
+ Module:       hash.h
+ Description:  header for a simple hash table
+ Authors:      see AUTHORS
+ Copyright:    see AUTHORS
+ License:      see LICENSE
+ Last Updated: 11/27/2018
+ ******************************************************************************
+*/
+#ifndef HASH_H
+#define HASH_H
+
+#define NOTFOUND  0
+
+typedef struct DataEntryStruct *HashTable;
+
+HashTable *hashtable_create(void);
+int       hashtable_insert(HashTable *, const char *, int);
+int       hashtable_find(HashTable *, const char *);
+char      *hashtable_findkey(HashTable *, const char *);
+void      hashtable_free(HashTable *);
+int       hashtable_update(HashTable *ht, const char *key, int new_data);
+int       hashtable_delete(HashTable *ht, const char *key);
+
+#endif