epanet-plus 0.2.1__cp311-cp311-macosx_11_0_arm64.whl

epanet-src/types.h

@@ -0,0 +1,928 @@
+/*
+ ******************************************************************************
+ Project:      OWA EPANET
+ Version:      2.3
+ Module:       types.h
+ Description:  symbolic constants and data types used throughout EPANET
+ Authors:      see AUTHORS
+ Copyright:    see AUTHORS
+ License:      see LICENSE
+ Last Updated: 09/03/2025
+ ******************************************************************************
+*/
+
+#ifndef TYPES_H
+#define TYPES_H
+
+#include <stdio.h>
+
+#include "hash.h"
+
+/*
+-------------------------------------------
+   Definition of 4-byte integers & reals
+-------------------------------------------
+*/
+typedef  float        REAL4;
+typedef  int          INT4;
+
+/*
+----------------------------------------------
+   Various constants
+----------------------------------------------
+*/
+#define   CODEVERSION        20302
+#define   MAGICNUMBER        516114521
+#define   ENGINE_VERSION     201   // Used for binary hydraulics file
+#define   EOFMARK            0x1A  // Use 0x04 for UNIX systems
+#define   MAXTITLE  3        // Max. # title lines
+#define   TITLELEN  79       // Max. # characters in a title line
+#define   MAXID     31       // Max. # characters in ID name
+#define   MAXMSG    255      // Max. # characters in message text
+#define   MAXLINE   1024     // Max. # characters read from input line
+#define   MAXFNAME  259      // Max. # characters in file name
+#define   MAXTOKS   40       // Max. items per line of input
+#define   TRUE      1
+#define   FALSE     0
+#define   FULL      2
+#define   BIG       1.E10
+#define   TINY      1.E-6
+#define   MISSING   -1.E10     // Missing value indicator
+#define   SET_CLOSED -1.E10    // Link set closed indicator
+#define   SET_OPEN    1.E10    // Link set open indicator
+
+#define   DIFFUS    1.3E-8     // Diffusivity of chlorine
+                               // @ 20 deg C (sq ft/sec)
+#define   VISCOS    1.1E-5     // Kinematic viscosity of water
+                               // @ 20 deg C (sq ft/sec)
+#define   MINPDIFF  0.1        // PDA min. pressure difference (psi or m)
+#define   SEPSTR    " \t\n\r"  // Token separator characters
+#ifdef M_PI
+  #define   PI        M_PI
+#else
+  #define   PI        3.141592654
+#endif
+
+/*
+----------------------------------------------
+   Flow units conversion factors
+----------------------------------------------
+*/
+#define   GPMperCFS   448.831
+#define   AFDperCFS   1.9837
+#define   MGDperCFS   0.64632
+#define   IMGDperCFS  0.5382
+#define   LPSperCFS   28.317
+#define   LPMperCFS   1699.0
+#define   CMSperCFS   0.028317
+#define   CMHperCFS   101.94
+#define   CMDperCFS   2446.6
+#define   MLDperCFS   2.4466
+#define   M3perFT3    0.028317
+#define   LperFT3     28.317
+#define   MperFT      0.3048
+#define   PSIperFT    0.4333
+#define   KPAperPSI   6.895
+#define   BARperPSI   0.068948
+#define   KWperHP     0.7457
+#define   SECperDAY   86400
+
+/*
+---------------------------------------------------------------------
+   Macros to test for successful allocation of memory and to free it
+---------------------------------------------------------------------
+*/
+#define  MEMCHECK(x)  (((x) == NULL) ? 101 : 0 )
+#define  FREE(x) do { free(x); (x) = NULL; } while(0)
+
+/*
+---------------------------------------------------------------------
+   Conversion macros to be used in place of functions
+---------------------------------------------------------------------
+*/
+#define INT(x)   ((int)(x))                   // integer portion of x
+#define FRAC(x)  ((x)-(int)(x))               // fractional part of x
+#define ABS(x)   (((x)<0) ? -(x) : (x))       // absolute value of x
+#define MIN(x,y) (((x)<=(y)) ? (x) : (y))     // minimum of x and y
+#define MAX(x,y) (((x)>=(y)) ? (x) : (y))     // maximum of x and y
+#define ROUND(x) (((x)>=0) ? (int)((x)+.5) : (int)((x)-.5))
+                                              // round-off of x
+#define MOD(x,y) ((x)%(y))                    // x modulus y
+#define SQR(x)   ((x)*(x))                    // x-squared
+#define SGN(x)   (((x)<0) ? (-1) : (1))       // sign of x
+#define UCHAR(x) (((x) >= 'a' && (x) <= 'z') ? ((x)&~32) : (x))
+                                              // uppercase char of x
+/*
+------------------------------------------------------
+   Macro to evaluate function x with error checking
+   (Fatal errors are numbered higher than 100)
+------------------------------------------------------
+*/
+#define ERRCODE(x) (errcode = ((errcode>100) ? (errcode) : (x)))
+
+/*
+----------------------------------------------
+   Enumerated Data Types
+----------------------------------------------
+*/
+
+typedef enum {
+  NODE,
+  LINK,
+  TIMEPAT,
+  CURVE,
+  CONTROL,
+  RULE
+} ObjectType;
+
+typedef enum {
+  JUNCTION,
+  RESERVOIR,
+  TANK
+} NodeType;
+
+typedef enum {
+  CVPIPE,        // pipe with check valve
+  PIPE,          // pipe
+  PUMP,          // pump
+  PRV,           // pressure reducing valve
+  PSV,           // pressure sustaining valve
+  PBV,           // pressure breaker valve
+  FCV,           // flow control valve
+  TCV,           // throttle control valve
+  GPV,           // general purpose valve
+  PCV            // positional control valve
+} LinkType;
+
+typedef enum {
+  USE,           // use hydraulics file from previous run
+  SAVE,          // save hydraulics file after current run
+  SCRATCH        // use temporary hydraulics file
+} HydFiletype;
+
+typedef enum {
+  NONE,          // no quality analysis
+  CHEM,          // analyze a chemical
+  AGE,           // analyze water age
+  TRACE          // trace % of flow from a source
+} QualType;
+
+typedef enum {
+  VOLUME_CURVE,  // volume curve
+  PUMP_CURVE,    // pump curve
+  EFFIC_CURVE,   // efficiency curve
+  HLOSS_CURVE,   // head loss curve
+  GENERIC_CURVE, // generic curve
+  VALVE_CURVE    // positional valve loss curve
+} CurveType;
+
+typedef enum {
+  CONST_HP,      // constant horsepower
+  POWER_FUNC,    // power function
+  CUSTOM,        // user-defined custom curve
+  NOCURVE
+} PumpType;
+
+typedef enum {
+  CONCEN,        // inflow concentration
+  MASS,          // mass inflow booster
+  SETPOINT,      // setpoint booster
+  FLOWPACED      // flow paced booster
+} SourceType;
+
+typedef enum {
+  LOWLEVEL,      // act when grade below set level
+  HILEVEL,       // act when grade above set level
+  TIMER,         // act when set time reached
+  TIMEOFDAY      // act when time of day occurs
+} ControlType;
+
+typedef enum {
+  XHEAD,         // pump cannot deliver head (closed)
+  TEMPCLOSED,    // temporarily closed
+  CLOSED,        // closed
+  OPEN,          // open
+  ACTIVE,        // valve active (partially open)
+  XFLOW,         // pump exceeds maximum flow
+  XFCV,          // FCV cannot supply flow
+  XPRESSURE,     // valve cannot supply pressure
+  FILLING,       // tank filling
+  EMPTYING,      // tank emptying
+  OVERFLOWING    // tank overflowing
+} StatusType;
+
+typedef enum {
+  HW,            // Hazen-Williams
+  DW,            // Darcy-Weisbach
+  CM             // Chezy-Manning
+} HeadLossType;
+
+typedef enum {
+  US,            // US
+  SI             // SI (metric)
+} UnitsType;
+
+typedef enum {
+  CFS,           // cubic feet per second
+  GPM,           // gallons per minute
+  MGD,           // million gallons per day
+  IMGD,          // imperial million gal. per day
+  AFD,           // acre-feet per day
+  LPS,           // liters per second
+  LPM,           // liters per minute
+  MLD,           // megaliters per day
+  CMH,           // cubic meters per hour
+  CMD,           // cubic meters per day
+  CMS            // cubic meters per second
+} FlowUnitsType;
+
+typedef enum {
+  PSI,           // pounds per square inch
+  KPA,           // kiloPascals
+  METERS,        // meters
+  BAR,           // bar
+  FEET,          // feet
+  DEFAULTUNIT    // default based on unit system (SI or US)
+} PressureUnitsType;
+
+typedef enum {
+  LOW,           // lower limit
+  HI,            // upper limit
+  PREC           // precision
+} RangeType;
+
+typedef enum {
+  MIX1,          // complete mix model
+  MIX2,          // 2-compartment model
+  FIFO,          // first in, first out model
+  LIFO           // last in, first out model
+} MixType;
+
+typedef enum {
+  SERIES,        // point time series
+  AVG,           // time-averages
+  MIN,           // minimum values
+  MAX,           // maximum values
+  RANGE          // max - min values
+} StatisticType;
+
+typedef enum {
+  ELEV = 0,      // nodal elevation
+  DEMAND,        // nodal demand flow
+  HEAD,          // nodal hydraulic head
+  PRESSURE,      // nodal pressure
+  QUALITY,       // nodal water quality
+
+  LENGTH,        // link length
+  DIAM,          // link diameter
+  FLOW,          // link flow rate
+  VELOCITY,      // link flow velocity
+  HEADLOSS,      // link head loss
+  LINKQUAL,      // avg. water quality in link
+  STATUS,        // link status
+  SETTING,       // pump/valve setting
+  REACTRATE,     // avg. reaction rate in link
+  FRICTION,      // link friction factor
+
+  POWER,         // pump power output
+  TIME,          // simulation time
+  VOLUME,        // tank volume
+  CLOCKTIME,     // simulation time of day
+  FILLTIME,      // time to fill a tank
+  DRAINTIME,     // time to drain a tank
+  MAXVAR         // total number of variable fields
+} FieldType;
+
+typedef enum {
+  _TITLE, _JUNCTIONS, _RESERVOIRS, _TANKS, _PIPES, _PUMPS,
+  _VALVES, _CONTROLS, _RULES, _DEMANDS, _SOURCES, _EMITTERS,
+  _PATTERNS, _CURVES, _QUALITY, _STATUS, _ROUGHNESS, _ENERGY,
+  _REACTIONS, _MIXING, _REPORT, _TIMES, _OPTIONS,
+    _COORDS, _VERTICES, _LABELS, _BACKDROP, _TAGS, _LEAKAGE, _END
+} SectionType;
+
+typedef enum {
+  STATHDR,       // hydraulic status header
+  ENERHDR,       // energy usage header
+  NODEHDR,       // node results header
+  LINKHDR        // link results header
+} HdrType;
+
+typedef enum {
+  NEGATIVE  = -1,  // flow in reverse of pre-assigned direction
+  ZERO_FLOW = 0,   // zero flow
+  POSITIVE  = 1    // flow in pre-assigned direction
+} FlowDirection;
+
+typedef enum {
+  DDA,           // demand driven analysis
+  PDA            // pressure driven analysis
+} DemandModelType;
+
+/*
+------------------------------------------------------
+   Fundamental Data Structures
+------------------------------------------------------
+*/
+
+struct IDstring            // Holds component ID label
+{
+  char ID[MAXID+1];
+};
+
+typedef struct             // Time Pattern Object
+{
+  char   ID[MAXID+1];      // pattern ID
+  char   *Comment;         // pattern comment
+  int    Length;           // pattern length
+  double *F;               // pattern factors
+} Spattern;
+
+typedef struct             // Curve Object
+{
+  char      ID[MAXID+1];   // curve ID
+  char      *Comment;      // curve comment
+  CurveType Type;          // curve type
+  int       Npts;          // number of points
+  int       Capacity;      // size of X & Y arrays
+  double    *X;            // x-values
+  double    *Y;            // y-values
+} Scurve;
+
+struct Sdemand             // Demand List Item
+{
+  double Base;             // baseline demand
+  int    Pat;              // pattern index
+  char   *Name;            // demand category name
+  struct Sdemand *next;    // next demand list item
+};
+typedef struct Sdemand *Pdemand; // Pointer to demand list
+
+typedef struct             // Energy Usage Object
+{
+  double TimeOnLine;       // hours pump is online
+  double Efficiency;       // total time wtd. efficiency
+  double KwHrsPerFlow;     // total kw-hrs per unit of flow
+  double KwHrs;            // total kw-hrs consumed
+  double MaxKwatts;        // max. kw consumed
+  double TotalCost;        // total pumping cost
+  double CurrentPower;     // current pump power (kw)
+  double CurrentEffic;     // current pump efficiency
+} Senergy;
+
+struct Ssource             // Water Quality Source Object
+{
+    double     C0;         // base concentration/mass
+    int        Pat;        // pattern index
+    double     Smass;      // actual mass flow rate
+    SourceType Type;       // type of source
+};
+typedef struct Ssource *Psource; // Pointer to source object
+
+struct Svertices           // Coordinates of a link's vertices
+{
+  double *X;               // array of x-coordinates
+  double *Y;               // array of y-coordinates
+  int    Npts;             // number of vertex points
+  int    Capacity;         // capacity of coordinate arrays
+};
+typedef struct Svertices *Pvertices; // Pointer to a link's vertices
+
+typedef struct             // Node Object
+{
+  char     ID[MAXID+1];    // node ID
+  double   X;              // x-coordinate
+  double   Y;              // y-coordinate
+  double   El;             // elevation
+  Pdemand  D;              // demand pointer
+  Psource  S;              // source pointer
+  double   C0;             // initial quality
+  double   Ke;             // emitter coeff.
+  int      Rpt;            // reporting flag
+  int      ResultIndex;    // saved result index
+  NodeType Type;           // node type
+  char     *Comment;       // node comment
+  char     *Tag;           // optional category tag                                                   
+} Snode;
+
+typedef struct             // Link Object
+{
+  char     ID[MAXID+1];    // link ID
+  int      N1;             // start node index
+  int      N2;             // end node index
+  double   Diam;           // diameter
+  double   Len;            // length
+  double   Kc;             // pipe roughness, pump speed, valve setting
+  double   Km;             // minor loss coeff.
+  double   Kb;             // bulk react. coeff.
+  double   Kw;             // wall react. coef.
+  double   R;              // flow resistance
+  double   Rc;             // reaction coeff.
+  double   LeakArea;       // leak area (sq mm per 100 pipe length units
+  double   LeakExpan;      // leak expansion (sq mm per unit of head)
+  LinkType Type;           // link type
+  StatusType InitStatus;   // initial status
+  double     InitSetting;  // initial setting
+  Pvertices  Vertices;     // internal vertex coordinates
+  int      Rpt;            // reporting flag
+  int      ResultIndex;    // saved result index
+  char     *Comment;       // link comment
+  char     *Tag;           // optional category tag                                                   
+} Slink;
+
+typedef struct             // Tank Object
+{
+  int     Node;            // node index of tank
+  double  A;               // tank area
+  double  Hmin;            // minimum water elev
+  double  Hmax;            // maximum water elev
+  double  H0;              // initial water elev
+  double  Vmin;            // minimum volume
+  double  Vmax;            // maximum volume
+  double  V0;              // initial volume
+  double  Kb;              // bulk reaction coeff.
+  double  V;               // tank volume
+  double  C;               // concentration
+  int     Pat;             // fixed grade time pattern
+  int     Vcurve;          // volume v. elev. curve index
+  MixType MixModel;        // type of mixing model
+  double  V1frac;          // mixing compartment fraction
+  int     CanOverflow;     // tank can overflow or not
+} Stank;
+
+typedef struct             // Pump Object
+{
+  int     Link;            // link index of pump
+  int     Ptype;           // pump curve type
+  double  Q0;              // initial flow
+  double  Qmax;            // maximum flow
+  double  Hmax;            // maximum head
+  double  H0;              // shutoff head
+  double  R;               // flow coeffic.
+  double  N;               // flow exponent
+  int     Hcurve;          // head v. flow curve index
+  int     Ecurve;          // effic. v. flow curve index
+  int     Upat;            // utilization pattern index
+  int     Epat;            // energy cost pattern index
+  double  Ecost;           // unit energy cost
+  Senergy Energy;          // energy usage statistics
+} Spump;
+
+typedef struct             // Valve Object
+{
+  int Link;                // link index of valve
+  int Curve;               // positional loss coeff. curve
+} Svalve;
+
+typedef struct             // Control Statement
+{
+    int         Link;      // link index
+    int         Node;      // control node index
+    long        Time;      // control time
+    double      Grade;     // control grade
+    double      Setting;   // new link setting
+    StatusType  Status;    // new link status
+    ControlType Type;      // control type
+    int         isEnabled; // control enabled?
+} Scontrol;
+
+typedef struct             // Field Object of Report Table
+{
+    char   Name[MAXID+1];  // name of reported variable
+    char   Units[MAXID+1]; // units of reported variable
+    int    Enabled;        // enabled if in table
+    int    Precision;      // number of decimal places
+    double RptLim[2];      // lower/upper report limits
+} SField;
+
+struct Sadjlist            // Node Adjacency List Item
+{
+    int    node;           // index of connecting node
+    int    link;           // index of connecting link
+    struct Sadjlist *next; // next item in list
+};
+typedef struct Sadjlist *Padjlist; // Pointer to adjacency list
+
+struct  Sseg               // Pipe Segment List Item
+{
+    double  v;             // segment volume
+    double  c;             // segment water quality
+    struct  Sseg *prev;    // previous segment in list
+};
+typedef struct Sseg *Pseg; // Pointer to pipe segment list
+
+typedef struct s_Premise       // Rule Premise Clause
+{
+    int      logop;            // logical operator (IF, AND, OR)
+    int      object;           // NODE or LINK
+    int      index;            // object's index
+    int      variable;         // pressure, flow, etc.
+    int      relop;            // relational operator (=, >, <, etc.)
+    int      status;           // variable's status (OPEN, CLOSED)
+    double   value;            // variable's value
+    struct   s_Premise *next;  // next premise clause
+} Spremise;
+
+typedef struct s_Action        // Rule Action Clause
+{
+    int     link;              // link index
+    int     status;            // link's status
+    double  setting;           // link's setting
+    struct  s_Action *next;
+} Saction;
+
+typedef struct                 // Control Rule Structure
+{
+    char     label[MAXID+1];   // rule label
+    double   priority;         // priority level
+    int      isEnabled;        // is the rule enabled?
+    Spremise *Premises;        // list of premises
+    Saction  *ThenActions;     // list of THEN actions
+    Saction  *ElseActions;     // list of ELSE actions
+} Srule;
+
+typedef struct s_ActionItem    // Action List Item
+{
+    int     ruleIndex;           // index of rule action belongs to
+    Saction *action;             // an action clause
+    struct  s_ActionItem *next;  // next action on the list
+} SactionList;
+
+typedef struct                 // Mass Balance Components
+{
+    double    initial;         // initial mass in system
+    double    inflow;          // mass inflow to system
+    double    outflow;         // mass outflow from system
+    double    reacted;         // mass reacted in system
+    double    final;           // final mass in system
+    double    ratio;           // ratio of mass added to mass lost
+    int       segCount;        // total number of pipe segments used                       
+} SmassBalance;
+
+typedef struct
+{
+    double    totalInflow;
+    double    totalOutflow;
+    double    consumerDemand;
+    double    emitterDemand;
+    double    leakageDemand;
+    double    deficitDemand;
+    double    storageDemand;
+    double    ratio;
+} SflowBalance;    
+
+typedef struct                 // Node Leakage Object
+{
+  double qfa;                  // fixed area leakage flow
+  double qva;                  // variable area leakage flow
+  double cfa;                  // fixed area leakage coeff.
+  double cva;                  // variable area leakage coeff.
+} Sleakage;
+
+/*
+------------------------------------------------------
+  Wrapper Data Structures
+------------------------------------------------------
+*/
+
+// Input File Parser Wrapper
+typedef struct {
+  FILE *InFile;            // Input file handle
+
+  char
+      DefPatID[MAXID + 1],     // Default demand pattern ID
+      InpFname[MAXFNAME + 1],  // Input file name
+      *Tok[MAXTOKS],           // Array of token strings
+      Comment[MAXMSG + 1],     // Comment text
+      LineComment[MAXMSG + 1]; // Full line comment
+
+  int
+    MaxNodes,              // Node count   from input file */
+    MaxLinks,              // Link count    "    "    "
+    MaxJuncs,              // Junction count "   "    "
+    MaxPipes,              // Pipe count    "    "    "
+    MaxTanks,              // Tank count    "    "    "
+    MaxPumps,              // Pump count    "    "    "
+    MaxValves,             // Valve count   "    "    "
+    MaxControls,           // Control count "   "     "
+    MaxRules,              // Rule count    "   "     "
+    MaxPats,               // Pattern count "   "     "
+    MaxCurves,             // Curve count   "   "     "
+    Ntokens,               // Number of tokens in line of input
+    Ntitle,                // Number of title lines
+    ErrTok,                // Index of error-producing token
+    Unitsflag,             // Unit system flag
+    Flowflag,              // Flow units flag
+    Pressflag;             // Pressure units flag
+
+  Spattern *PrevPat;       // Previous pattern processed
+  Scurve   *PrevCurve;     // Previous curve processed
+  double *X;               // Temporary array for curve data
+
+} Parser;
+
+// Time Step Wrapper
+typedef struct {
+
+  long
+    Tstart,                // Starting time of day
+    Hstep,                 // Nominal hyd. time step
+    Pstep,                 // Time pattern time step
+    Pstart,                // Starting pattern time
+    Rstep,                 // Reporting time step
+    Rstart,                // Time when reporting starts
+    Rtime,                 // Next reporting time
+    Htime,                 // Current hyd. time
+    Hydstep,               // Actual hydraulic time step
+    Qstep,                 // Quality time step
+    Qtime,                 // Current quality time
+    Rulestep,              // Rule evaluation time step
+    Dur;                   // Duration of simulation
+
+} Times;
+
+// Reporting Wrapper
+typedef struct {
+
+  FILE *RptFile;           // Report file handle
+
+  int
+    Nperiods,              // Number of reporting periods
+    PageSize,              // Lines/page in output report/
+    Rptflag,               // Report flag
+    Tstatflag,             // Report time series statistic flag
+    Summaryflag,           // Report summary flag
+    Messageflag,           // Error/warning message flag
+    Statflag,              // Status report flag
+    Energyflag,            // Energy report flag
+    Nodeflag,              // Node report flag
+    Linkflag,              // Link report flag
+    Fprinterr;             // File write error flag
+
+  long
+    LineNum,               // Current line number
+    PageNum;               // Current page number
+
+  char
+    Atime[13],             // Clock time (hrs:min:sec)
+    Rpt1Fname[MAXFNAME+1], // Primary report file name
+    Rpt2Fname[MAXFNAME+1], // Secondary report file name
+    DateStamp[26];         // Current date & time
+
+    SField   Field[MAXVAR];  // Output reporting fields
+
+    void (*reportCallback)(void*,void*,const char*); // user-supplied reporting callback
+    void *reportCallbackUserData;  // user-supplied reporting context
+
+} Report;
+
+// Output File Wrapper
+typedef struct {
+
+  char
+    HydFname[MAXFNAME+1],  // Hydraulics file name
+    OutFname[MAXFNAME+1];  // Binary output file name
+
+  int
+    Outflag,               // Output file flag
+    Hydflag,               // Hydraulics flag
+    SaveHflag,             // Hydraulic results saved flag
+    SaveQflag,             // Quality results saved flag
+    Saveflag;              // General purpose save flag
+
+  long
+    HydOffset,             // Hydraulics file byte offset
+    OutOffset1,            // 1st output file byte offset
+    OutOffset2;            // 2nd output file byte offset
+
+  FILE
+    *OutFile,              // Output file handle
+    *HydFile,              // Hydraulics file handle
+    *TmpOutFile;           // Temporary file handle
+
+} Outfile;
+
+// Rule-Based Controls Wrapper
+typedef struct {
+
+    SactionList *ActionList;     // Linked list of action items
+    int         RuleState;       // State of rule interpreter
+    int         Errcode;         // Rule parser error code
+    long        Time1;           // Start of rule evaluation time interval
+    Spremise    *LastPremise;    // Previous premise clause
+    Saction     *LastThenAction; // Previous THEN action
+    Saction     *LastElseAction; // Previous ELSE action
+
+} Rules;
+
+// Sparse Matrix Wrapper
+typedef struct {
+
+  double
+    *Aii,        // Diagonal matrix coeffs.
+    *Aij,        // Non-zero, off-diagonal matrix coeffs.
+    *F,          // Right hand side vector
+    *temp;       // Array used by linear eqn. solver
+
+  int
+    Ncoeffs,     // Number of non-zero matrix coeffs
+    *Order,      // Node-to-row of re-ordered matrix
+    *Row,        // Row-to-node of re-ordered matrix
+    *Ndx,        // Index of link's coeff. in Aij
+    *XLNZ,       // Start position of each column in NZSUB
+    *NZSUB,      // Row index of each coeff. in each column
+    *LNZ,        // Position of each coeff. in Aij array
+    *link,       // Array used by linear eqn. solver
+    *first;      // Array used by linear eqn. solver
+
+} Smatrix;
+
+// Hydraulics Solver Wrapper
+typedef struct {
+
+  double
+    *NodeHead,             // Node hydraulic heads
+    *NodeDemand,           // Node total demand (consumer + emitter + leakage)
+    *FullDemand,           // Required consumer demand
+    *DemandFlow,           // Demand flow from nodes
+    *EmitterFlow,          // Emitter flow from nodes
+    *LeakageFlow,          // Leakage flow from nodes
+    *LinkFlow,             // Link flows
+    *LinkSetting,          // Link settings
+    Htol,                  // Hydraulic head tolerance
+    Qtol,                  // Flow rate tolerance
+    RQtol,                 // Flow resistance tolerance
+    Hexp,                  // Exponent in headloss formula
+    Qexp,                  // Exponent in emitter formula
+    Pexp,                  // Exponent in demand formula
+    Pmin,                  // Pressure needed for any demand
+    Preq,                  // Pressure needed for full demand
+    Dmult,                 // Demand multiplier
+    Hacc,                  // Relative flow change limit
+    FlowChangeLimit,       // Absolute flow change limit
+    HeadErrorLimit,        // Hydraulic head error limit
+    DampLimit,             // Solution damping threshold
+    Viscos,                // Kin. viscosity (sq ft/sec)
+    SpGrav,                // Specific gravity
+    Epump,                 // Global pump efficiency
+    Dsystem,               // Total system demand
+    Ecost,                 // Base energy cost per kwh
+    Dcost,                 // Energy demand charge/kw/day
+    Emax,                  // Peak energy usage
+    RelativeError,         // Total flow change / total flow
+    MaxHeadError,          // Max. error for link head loss
+    MaxFlowChange,         // Max. change in link flow
+    DemandReduction,       // % demand reduction at pressure deficient nodes
+    LeakageLoss,           // % system leakage loss
+    RelaxFactor,           // Relaxation factor for flow updating
+    *P,                    // Inverse of head loss derivatives
+    *Y,                    // Flow correction factors
+    *Xflow;                // Inflow - outflow at each node
+
+  int
+    DefPat,                // Default demand pattern
+    Epat,                  // Energy cost time pattern
+    DemandModel,           // Fixed or pressure dependent
+    Formflag,              // Head loss formula flag
+    EmitBackFlag,          // Emitter backflow flag
+    Iterations,            // Number of hydraulic trials taken
+    MaxIter,               // Max. hydraulic trials allowed
+    ExtraIter,             // Extra hydraulic trials
+    CheckFreq,             // Hydraulic trials between status checks
+    MaxCheck,              // Hydraulic trials limit on status checks
+    OpenHflag,             // Hydraulic system opened flag
+    Haltflag,              // Flag to halt simulation
+    DeficientNodes,        // Number of pressure deficient nodes
+    HasLeakage;            // TRUE if project has non-zero leakage parameters
+    
+  Sleakage *Leakage;       // Array of node leakage parameters
+
+  StatusType
+    *LinkStatus,           // Link status
+    *OldStatus;            // Previous link/tank status
+
+  SflowBalance
+    FlowBalance;           // Flow balance components
+
+  Smatrix smatrix;         // Sparse matrix storage
+
+} Hydraul;
+
+// Forward declaration of the Mempool structure defined in mempool.h
+struct Mempool;
+
+// Water Quality Solver Wrapper
+typedef struct {
+
+  int
+    Qualflag,              // Water quality analysis flag
+    OpenQflag,             // Quality system opened flag
+    Reactflag,             // Reaction indicator
+    OutOfMemory,           // Out of memory indicator
+    TraceNode,             // Source node for flow tracing
+    *SortedNodes;          // Topologically sorted node indexes
+
+  char
+    ChemName[MAXID + 1],   // Name of chemical
+    ChemUnits[MAXID + 1];  // Units of chemical
+
+  double
+    Ctol,                  // Water quality tolerance
+    Diffus,                // Diffusivity (sq ft/sec)
+    Wbulk,                 // Avg. bulk reaction rate
+    Wwall,                 // Avg. wall reaction rate
+    Wtank,                 // Avg. tank reaction rate
+    Wsource,               // Avg. mass inflow
+    Rfactor,               // Roughness-reaction factor
+    Sc,                    // Schmidt Number
+    Bucf,                  // Bulk reaction units conversion factor
+    Tucf,                  // Tank reaction units conversion factor
+    BulkOrder,             // Bulk flow reaction order
+    WallOrder,             // Pipe wall reaction order
+    TankOrder,             // Tank reaction order
+    Kbulk,                 // Global bulk reaction coeff.
+    Kwall,                 // Global wall reaction coeff.
+    Climit,                // Limiting potential quality
+    SourceQual,            // External source quality
+    *NodeQual,             // Reported node quality state
+    *PipeRateCoeff;        // Pipe reaction rate coeffs.
+
+  struct Mempool
+    *SegPool;              // Memory pool for water quality segments
+
+  Pseg
+    FreeSeg,               // Pointer to unused segment
+    *FirstSeg,             // First (downstream) segment in each pipe
+    *LastSeg;              // Last (upstream) segment in each pipe
+
+  FlowDirection
+    *FlowDir;              // Flow direction for each pipe
+
+  SmassBalance
+    MassBalance;           // Mass balance components
+
+} Quality;
+
+// Pipe Network Wrapper
+typedef struct {
+
+  int
+    Nnodes,                // Number of network nodes
+    Ntanks,                // Number of tanks
+    Njuncs,                // Number of junction nodes
+    Nlinks,                // Number of network links
+    Npipes,                // Number of pipes
+    Npumps,                // Number of pumps
+    Nvalves,               // Number of valves
+    Ncontrols,             // Number of simple controls
+    Nrules,                // Number of control rules
+    Npats,                 // Number of time patterns
+    Ncurves;               // Number of data curves
+
+  Snode    *Node;          // Node array
+  Slink    *Link;          // Link array
+  Stank    *Tank;          // Tank array
+  Spump    *Pump;          // Pump array
+  Svalve   *Valve;         // Valve array
+  Spattern *Pattern;       // Time pattern array
+  Scurve   *Curve;         // Data curve array
+  Scontrol *Control;       // Simple controls array
+  Srule    *Rule;          // Rule-based controls array
+  HashTable
+    *NodeHashTable,        // Hash table for Node ID names
+    *LinkHashTable;        // Hash table for Link ID names
+  Padjlist *Adjlist;       // Node adjacency lists
+
+} Network;
+
+// Overall Project Wrapper
+typedef struct Project {
+
+  Network    network;            // Pipe network wrapper
+  Parser     parser;             // Input file parser wrapper
+  Times      times;              // Time step wrapper
+  Report     report;             // Reporting wrapper
+  Outfile    outfile;            // Output file wrapper
+  Rules      rules;              // Rule-based controls wrapper
+  Hydraul    hydraul;            // Hydraulics solver wrapper
+  Quality    quality;            // Water quality solver wrapper
+
+  double Ucf[MAXVAR];            // Unit conversion factors
+
+  int
+    Openflag,                    // Project open flag
+    Warnflag;                    // Warning flag
+
+  char
+    Msg[MAXMSG+1],               // General-purpose string: errors, messages
+    Title[MAXTITLE][TITLELEN+1], // Project title
+    MapFname[MAXFNAME+1],        // Map file name
+    TmpHydFname[MAXFNAME+1],     // Temporary hydraulics file name
+    TmpOutFname[MAXFNAME+1],     // Temporary output file name
+    TmpStatFname[MAXFNAME+1];    // Temporary statistic file name
+
+  void (* viewprog) (char *);    // Pointer to progress viewing function
+
+} Project, *EN_Project;
+
+#endif