types.h

/*
 ******************************************************************************
 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: 04/19/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        20301
#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