/* ****************************************************************************** Project: OWA HYDRAULIC Version: 2.2 Module: types.h Description: symbolic constants and data types used throughout HYDRAULIC Authors: see AUTHORS Copyright: see AUTHORS License: see LICENSE Last Updated: 10/29/2019 ****************************************************************************** */ #ifndef TYPES_H #define TYPES_H #include #include "hash.h" /* ------------------------------------------- Definition of 4-byte integers & reals ------------------------------------------- */ typedef float REAL4; typedef int INT4; /* ---------------------------------------------- Various constants ---------------------------------------------- */ #define CODEVERSION 20200 #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 MAXMSGTEXT 8192 // Max. # characters read from input line #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 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 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 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 } 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 } 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 } FlowUnitsType; typedef enum { PSI, // pounds per square inch KPA, // kiloPascals METERS // meters } 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, _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 } 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 } 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; // roughness double Km; // minor loss coeff. double Kb; // bulk react. coeff. double Kw; // wall react. coef. double R; // flow resistance double Rc; // reaction coeff. LinkType Type; // link type StatusType Status; // initial status Pvertices Vertices; // internal vertex coordinates int Rpt; // reporting flag int ResultIndex; // saved result index char *Comment; // link comment } 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 V1max; // mixing compartment size 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 } 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 } 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 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 } SmassBalance; /* ------------------------------------------------------ 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 DefPat; // Default demand pattern 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 } 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 *Degree, // Number of links adjacent to each node *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 demand + emitter flows ½ÚµãÐèÇó + ÅçÉäÆ÷Á÷Á¿ * DemandFlow, // Work array of demand flows ¹¤×÷Êý×éµÄÐèÇóÁ÷Á¿ * EmitterFlow, // Emitter outflows ÅçÉäÆ÷³öÁ÷Á¿ * 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 ѹÁ¦²»×ã½ÚµãµÄÐèÇó¼õÉÙ°Ù·Ö±È RelaxFactor, // Relaxation factor for flow updating ¸üÐÂÁ÷Á¿µÄ·ÅËÉÒò×Ó * P, // Inverse of head loss derivatives ˮͷËðʧµ¼ÊýµÄµ¹Êý * Y, // Flow correction factors Á÷Á¿Ð£ÕýÒò×Ó * Xflow; // Inflow - outflow at each node ÿ¸ö½ÚµãµÄÁ÷ÈëÁ¿ - Á÷³öÁ¿ int Epat, // Energy cost time pattern ÄÜÔ´³É±¾Ê±¼äģʽ DemandModel, // Fixed or pressure dependent ¹Ì¶¨»òѹÁ¦ÒÀÀµÐÍ Formflag, // Head loss formula 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 ѹÁ¦²»×ãµÄ½ÚµãÊýÁ¿ StatusType * LinkStatus, // Link status ¹ÜµÀ״̬ * OldStatus; // Previous link/tank status ÒÔÇ°µÄ¹ÜµÀ/Ë®Ïä״̬ 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 int isReport; 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 MsgText[MAXMSGTEXT + 1]; void (* viewprog) (char *); // Pointer to progress viewing function } Project, *EN_Project; #endif