/*
|
******************************************************************************
|
Project: OWA EPANET
|
Version: 2.2
|
Module: input1.c
|
Description: retrieves network data from an EPANET input file
|
Authors: see AUTHORS
|
Copyright: see AUTHORS
|
License: see LICENSE
|
Last Updated: 07/08/2019
|
******************************************************************************
|
*/
|
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <math.h>
|
|
#include "types.h"
|
#include "funcs.h"
|
#include "hash.h"
|
#include "text.h"
|
|
// Default values
|
#define MAXITER 200 // Default max. # hydraulic iterations
|
#define HACC 0.001 // Default hydraulics convergence ratio
|
#define HTOL 0.0005 // Default hydraulic head tolerance (ft)
|
#define QTOL 0.0001 // Default flow rate tolerance (cfs)
|
#define AGETOL 0.01 // Default water age tolerance (hrs)
|
#define CHEMTOL 0.01 // Default concentration tolerance
|
#define PAGESIZE 0 // Default uses no page breaks
|
#define SPGRAV 1.0 // Default specific gravity
|
#define EPUMP 75 // Default pump efficiency
|
#define DEFPATID "1" // Default demand pattern ID
|
#define RQTOL 1E-7 // Default low flow resistance tolerance
|
#define CHECKFREQ 2 // Default status check frequency
|
#define MAXCHECK 10 // Default # iterations for status checks
|
#define DAMPLIMIT 0 // Default damping threshold
|
|
// Defined in ENUMSTXT.H
|
extern char *Fldname[];
|
extern char *RptFlowUnitsTxt[];
|
|
int getdata(Project *pr)
|
/*
|
**----------------------------------------------------------------
|
** Input: none
|
** Output: returns error code
|
** Purpose: reads in network data from disk file
|
**----------------------------------------------------------------
|
*/
|
{
|
int errcode = 0;
|
|
// Assign default data values & reporting options
|
setdefaults(pr);
|
initreport(&pr->report);
|
|
// Read in network data
|
rewind(pr->parser.InFile);
|
ERRCODE(readdata(pr));
|
|
// Adjust data and convert it to internal units
|
if (!errcode) adjustdata(pr);
|
if (!errcode) initunits(pr);
|
ERRCODE(inittanks(pr));
|
if (!errcode) convertunits(pr);
|
return errcode;
|
}
|
|
void setdefaults(Project *pr)
|
/*
|
**----------------------------------------------------------------
|
** Input: none
|
** Output: none
|
** Purpose: assigns default values to a project's variables
|
**----------------------------------------------------------------
|
*/
|
{
|
Parser *parser = &pr->parser;
|
Report *rpt = &pr->report;
|
Hydraul *hyd = &pr->hydraul;
|
Quality *qual = &pr->quality;
|
Times *time = &pr->times;
|
Outfile *out = &pr->outfile;
|
|
strncpy(pr->Title[0], "", TITLELEN);
|
strncpy(pr->Title[1], "", TITLELEN);
|
strncpy(pr->Title[2], "", TITLELEN);
|
strncpy(out->HydFname, "", MAXFNAME);
|
strncpy(pr->MapFname, "", MAXFNAME);
|
strncpy(qual->ChemName, t_CHEMICAL, MAXID);
|
strncpy(qual->ChemUnits, u_MGperL, MAXID);
|
strncpy(parser->DefPatID, DEFPATID, MAXID);
|
|
pr->Warnflag = FALSE; // Warning flag is off
|
parser->Unitsflag = US; // US unit system
|
parser->Flowflag = GPM; // Flow units are gpm
|
parser->Pressflag = PSI; // Pressure units are psi
|
parser->DefPat = 0; // Default demand pattern index
|
out->Hydflag = SCRATCH; // No external hydraulics file
|
rpt->Tstatflag = SERIES; // Generate time series output
|
|
hyd->Formflag = HW; // Use Hazen-Williams formula
|
hyd->Htol = HTOL; // Default head tolerance
|
hyd->Qtol = QTOL; // Default flow tolerance
|
hyd->Hacc = HACC; // Default hydraulic accuracy
|
hyd->FlowChangeLimit = 0.0; // Default flow change limit
|
hyd->HeadErrorLimit = 0.0; // Default head error limit
|
hyd->DemandModel = DDA; // Demand driven analysis
|
hyd->Pmin = 0.0; // Minimum demand pressure (ft)
|
hyd->Preq = MINPDIFF; // Required demand pressure (ft)
|
hyd->Pexp = 0.5; // Pressure function exponent
|
hyd->MaxIter = MAXITER; // Default max. hydraulic trials
|
hyd->ExtraIter = -1; // Stop if network unbalanced
|
hyd->Viscos = MISSING; // Temporary viscosity
|
hyd->SpGrav = SPGRAV; // Default specific gravity
|
hyd->Epat = 0; // No energy price pattern
|
hyd->Ecost = 0.0; // Zero unit energy cost
|
hyd->Dcost = 0.0; // Zero energy demand charge
|
hyd->Epump = EPUMP; // Default pump efficiency
|
hyd->Emax = 0.0; // Zero peak energy usage
|
hyd->Qexp = 2.0; // Flow exponent for emitters
|
hyd->Dmult = 1.0; // Demand multiplier
|
hyd->RQtol = RQTOL; // Default hydraulics parameters
|
hyd->CheckFreq = CHECKFREQ;
|
hyd->MaxCheck = MAXCHECK;
|
hyd->DampLimit = DAMPLIMIT;
|
|
qual->Qualflag = NONE; // No quality simulation
|
qual->Ctol = MISSING; // No pre-set quality tolerance
|
qual->TraceNode = 0; // No source tracing
|
qual->BulkOrder = 1.0; // 1st-order bulk reaction rate
|
qual->WallOrder = 1.0; // 1st-order wall reaction rate
|
qual->TankOrder = 1.0; // 1st-order tank reaction rate
|
qual->Kbulk = 0.0; // No global bulk reaction
|
qual->Kwall = 0.0; // No global wall reaction
|
qual->Climit = 0.0; // No limiting potential quality
|
qual->Diffus = MISSING; // Temporary diffusivity
|
qual->Rfactor = 0.0; // No roughness-reaction factor
|
qual->MassBalance.ratio = 0.0;
|
|
time->Dur = 0; // 0 sec duration (steady state)
|
time->Tstart = 0; // Starting time of day
|
time->Pstart = 0; // Starting pattern period
|
time->Hstep = 3600; // 1 hr hydraulic time step
|
time->Qstep = 0; // No pre-set quality time step
|
time->Pstep = 3600; // 1 hr time pattern period
|
time->Rstep = 3600; // 1 hr reporting period
|
time->Rulestep = 0; // No pre-set rule time step
|
time->Rstart = 0; // Start reporting at time 0
|
}
|
|
void initreport(Report *rpt)
|
/*
|
**----------------------------------------------------------------------
|
** Input: none
|
** Output: none
|
** Purpose: initializes reporting options
|
**----------------------------------------------------------------------
|
*/
|
{
|
int i;
|
strncpy(rpt->Rpt2Fname, "", MAXFNAME);
|
|
// Initialize general reporting options
|
rpt->PageSize = PAGESIZE; // Default page size for report
|
rpt->Summaryflag = TRUE; // Write summary report
|
rpt->Messageflag = TRUE; // Report error/warning messages
|
rpt->Statflag = FALSE; // No hydraulic status reports
|
rpt->Energyflag = FALSE; // No energy usage report
|
rpt->Nodeflag = 0; // No reporting on nodes
|
rpt->Linkflag = 0; // No reporting on links
|
|
// Initialize options for each reported variable field
|
for (i = 0; i < MAXVAR; i++)
|
{
|
strncpy(rpt->Field[i].Name, Fldname[i], MAXID);
|
rpt->Field[i].Enabled = FALSE; // Not included in report
|
rpt->Field[i].Precision = 2; // 2 decimal precision
|
rpt->Field[i].RptLim[LOW] = SQR(BIG); // No reporting limits
|
rpt->Field[i].RptLim[HI] = -SQR(BIG);
|
}
|
rpt->Field[FRICTION].Precision = 3;
|
|
// Set default set of variables reported on
|
for (i = DEMAND; i <= QUALITY; i++)
|
{
|
rpt->Field[i].Enabled = TRUE;
|
}
|
for (i = FLOW; i <= HEADLOSS; i++)
|
{
|
rpt->Field[i].Enabled = TRUE;
|
}
|
}
|
|
void adjustdata(Project *pr)
|
/*
|
**----------------------------------------------------------------------
|
** Input: none
|
** Output: none
|
** Purpose: adjusts project data after input file has been processed
|
**----------------------------------------------------------------------
|
*/
|
{
|
Network *net = &pr->network;
|
Hydraul *hyd = &pr->hydraul;
|
Quality *qual = &pr->quality;
|
Times *time = &pr->times;
|
Parser *parser = &pr->parser;
|
Report *rpt = &pr->report;
|
|
int i;
|
double ucf; // Unit conversion factor
|
Pdemand demand; // Pointer to demand record
|
Slink *link;
|
Snode *node;
|
Stank *tank;
|
|
// Use 1 hr pattern & report time step if none specified
|
if (time->Pstep <= 0) time->Pstep = 3600;
|
if (time->Rstep == 0) time->Rstep = time->Pstep;
|
|
// Hydraulic time step cannot be greater than pattern or report time step
|
if (time->Hstep <= 0) time->Hstep = 3600;
|
if (time->Hstep > time->Pstep) time->Hstep = time->Pstep;
|
if (time->Hstep > time->Rstep) time->Hstep = time->Rstep;
|
|
// Report start time cannot be greater than simulation duration
|
if (time->Rstart > time->Dur) time->Rstart = 0;
|
|
// No water quality analysis for single period run
|
if (time->Dur == 0) qual->Qualflag = NONE;
|
|
// If no quality timestep, then make it 1/10 of hydraulic timestep
|
if (time->Qstep == 0) time->Qstep = time->Hstep / 10;
|
|
// If no rule time step then make it 1/10 of hydraulic time step
|
// but not greater than hydraulic time step
|
if (time->Rulestep == 0) time->Rulestep = time->Hstep / 10;
|
time->Rulestep = MIN(time->Rulestep, time->Hstep);
|
|
// Quality timestep cannot exceed hydraulic timestep
|
time->Qstep = MIN(time->Qstep, time->Hstep);
|
|
// If no quality tolerance, then use default values
|
if (qual->Ctol == MISSING)
|
{
|
if (qual->Qualflag == AGE) qual->Ctol = AGETOL;
|
else qual->Ctol = CHEMTOL;
|
}
|
|
// Determine units system based on flow units
|
switch (parser->Flowflag)
|
{
|
case LPS: // Liters/sec
|
case LPM: // Liters/min
|
case MLD: // megaliters/day
|
case CMH: // cubic meters/hr
|
case CMD: // cubic meters/day
|
parser->Unitsflag = SI;
|
break;
|
default:
|
parser->Unitsflag = US;
|
}
|
|
// Revise pressure units depending on flow units
|
if (parser->Unitsflag != SI) parser->Pressflag = PSI;
|
else if (parser->Pressflag == PSI) parser->Pressflag = METERS;
|
|
// Store value of viscosity & diffusivity
|
ucf = 1.0;
|
if (parser->Unitsflag == SI) ucf = SQR(MperFT);
|
if (hyd->Viscos == MISSING)
|
{
|
hyd->Viscos = VISCOS; // No viscosity supplied
|
}
|
else if (hyd->Viscos > 1.e-3)
|
{
|
hyd->Viscos = hyd->Viscos * VISCOS; // Multiplier supplied
|
}
|
else hyd->Viscos = hyd->Viscos / ucf; // Actual value supplied
|
if (qual->Diffus == MISSING)
|
{
|
qual->Diffus = DIFFUS; // No viscosity supplied
|
}
|
else if (qual->Diffus > 1.e-4)
|
{
|
qual->Diffus = qual->Diffus * DIFFUS; // Multiplier supplied
|
}
|
else qual->Diffus = qual->Diffus / ucf; // Actual value supplied
|
|
// Set exponent in head loss equation and adjust flow-resistance tolerance.
|
if (hyd->Formflag == HW) hyd->Hexp = 1.852;
|
else hyd->Hexp = 2.0;
|
|
// See if default reaction coeffs. apply
|
for (i = 1; i <= net->Nlinks; i++)
|
{
|
link = &net->Link[i];
|
if (link->Type > PIPE) continue;
|
if (link->Kb == MISSING) link->Kb = qual->Kbulk; // Bulk coeff.
|
if (link->Kw == MISSING) // Wall coeff.
|
{
|
// Rfactor is the pipe roughness correlation factor
|
if (qual->Rfactor == 0.0) link->Kw = qual->Kwall;
|
else if ((link->Kc > 0.0) && (link->Diam > 0.0))
|
{
|
if (hyd->Formflag == HW) link->Kw = qual->Rfactor / link->Kc;
|
if (hyd->Formflag == DW)
|
{
|
link->Kw = qual->Rfactor / ABS(log(link->Kc / link->Diam));
|
}
|
if (hyd->Formflag == CM) link->Kw = qual->Rfactor * link->Kc;
|
}
|
else link->Kw = 0.0;
|
}
|
}
|
for (i = 1; i <= net->Ntanks; i++)
|
{
|
tank = &net->Tank[i];
|
if (tank->Kb == MISSING) tank->Kb = qual->Kbulk;
|
}
|
|
// Use default pattern if none assigned to a demand
|
parser->DefPat = findpattern(net, parser->DefPatID);
|
if (parser->DefPat > 0) for (i = 1; i <= net->Nnodes; i++)
|
{
|
node = &net->Node[i];
|
for (demand = node->D; demand != NULL; demand = demand->next)
|
{
|
if (demand->Pat == 0) demand->Pat = parser->DefPat;
|
}
|
}
|
|
// Remove QUALITY as a reporting variable if no WQ analysis
|
if (qual->Qualflag == NONE) rpt->Field[QUALITY].Enabled = FALSE;
|
}
|
|
int inittanks(Project *pr)
|
/*
|
**---------------------------------------------------------------
|
** Input: none
|
** Output: returns error code
|
** Purpose: initializes volumes in non-cylindrical tanks
|
**---------------------------------------------------------------
|
*/
|
{
|
Network *net = &pr->network;
|
|
int i, j, n = 0;
|
double a;
|
int errcode = 0, levelerr;
|
char errmsg[MAXMSG+1] = "";
|
Stank *tank;
|
Scurve *curve;
|
|
for (j = 1; j <= net->Ntanks; j++)
|
{
|
tank = &net->Tank[j];
|
if (tank->A == 0.0) continue; // Skip reservoirs
|
|
// Check for valid lower/upper tank levels
|
levelerr = 0;
|
if (tank->H0 > tank->Hmax ||
|
tank->Hmin > tank->Hmax ||
|
tank->H0 < tank->Hmin
|
) levelerr = 1;
|
|
// Check that tank heights are within volume curve
|
i = tank->Vcurve;
|
if (i > 0)
|
{
|
curve = &net->Curve[i];
|
n = curve->Npts - 1;
|
if (tank->Hmin < curve->X[0] || tank->Hmax > curve->X[n])
|
{
|
levelerr = 1;
|
}
|
|
else
|
{
|
// Find min., max., and initial volumes from curve
|
tank->Vmin = interp(curve->Npts, curve->X, curve->Y, tank->Hmin);
|
tank->Vmax = interp(curve->Npts, curve->X, curve->Y, tank->Hmax);
|
tank->V0 = interp(curve->Npts, curve->X, curve->Y, tank->H0);
|
|
// Find a "nominal" diameter for tank
|
a = (curve->Y[n] - curve->Y[0]) / (curve->X[n] - curve->X[0]);
|
tank->A = sqrt(4.0 * a / PI);
|
}
|
}
|
|
// Report error in levels if found
|
if (levelerr)
|
{
|
sprintf(pr->Msg, "Error 225: %s node %s", geterrmsg(225, errmsg),
|
net->Node[tank->Node].ID);
|
writeline(pr, pr->Msg);
|
errcode = 200;
|
}
|
}
|
return errcode;
|
}
|
|
void initunits(Project *pr)
|
/*
|
**--------------------------------------------------------------
|
** Input: none
|
** Output: none
|
** Purpose: determines unit conversion factors
|
**--------------------------------------------------------------
|
*/
|
{
|
Parser *parser = &pr->parser;
|
Report *rpt = &pr->report;
|
Hydraul *hyd = &pr->hydraul;
|
Quality *qual = &pr->quality;
|
Times *time = &pr->times;
|
|
double dcf, // distance conversion factor
|
ccf, // concentration conversion factor
|
qcf, // flow conversion factor
|
hcf, // head conversion factor
|
pcf, // pressure conversion factor
|
wcf; // energy conversion factor
|
|
if (parser->Unitsflag == SI) // SI units
|
{
|
strcpy(rpt->Field[DEMAND].Units, RptFlowUnitsTxt[parser->Flowflag]);
|
strcpy(rpt->Field[ELEV].Units, u_METERS);
|
strcpy(rpt->Field[HEAD].Units, u_METERS);
|
if (parser->Pressflag == METERS) strcpy(rpt->Field[PRESSURE].Units, u_METERS);
|
else strcpy(rpt->Field[PRESSURE].Units, u_KPA);
|
strcpy(rpt->Field[LENGTH].Units, u_METERS);
|
strcpy(rpt->Field[DIAM].Units, u_MMETERS);
|
strcpy(rpt->Field[FLOW].Units, RptFlowUnitsTxt[parser->Flowflag]);
|
strcpy(rpt->Field[VELOCITY].Units, u_MperSEC);
|
strcpy(rpt->Field[HEADLOSS].Units, u_per1000M);
|
strcpy(rpt->Field[FRICTION].Units, "");
|
strcpy(rpt->Field[POWER].Units, u_KW);
|
|
dcf = 1000.0 * MperFT;
|
qcf = LPSperCFS;
|
if (parser->Flowflag == LPM) qcf = LPMperCFS;
|
if (parser->Flowflag == MLD) qcf = MLDperCFS;
|
if (parser->Flowflag == CMH) qcf = CMHperCFS;
|
if (parser->Flowflag == CMD) qcf = CMDperCFS;
|
|
hcf = MperFT;
|
if (parser->Pressflag == METERS) pcf = MperFT * hyd->SpGrav;
|
else pcf = KPAperPSI * PSIperFT * hyd->SpGrav;
|
wcf = KWperHP;
|
}
|
else // US units
|
{
|
strcpy(rpt->Field[DEMAND].Units, RptFlowUnitsTxt[parser->Flowflag]);
|
strcpy(rpt->Field[ELEV].Units, u_FEET);
|
strcpy(rpt->Field[HEAD].Units, u_FEET);
|
strcpy(rpt->Field[PRESSURE].Units, u_PSI);
|
strcpy(rpt->Field[LENGTH].Units, u_FEET);
|
strcpy(rpt->Field[DIAM].Units, u_INCHES);
|
strcpy(rpt->Field[FLOW].Units, RptFlowUnitsTxt[parser->Flowflag]);
|
strcpy(rpt->Field[VELOCITY].Units, u_FTperSEC);
|
strcpy(rpt->Field[HEADLOSS].Units, u_per1000FT);
|
strcpy(rpt->Field[FRICTION].Units, "");
|
strcpy(rpt->Field[POWER].Units, u_HP);
|
|
dcf = 12.0;
|
qcf = 1.0;
|
if (parser->Flowflag == GPM) qcf = GPMperCFS;
|
if (parser->Flowflag == MGD) qcf = MGDperCFS;
|
if (parser->Flowflag == IMGD) qcf = IMGDperCFS;
|
if (parser->Flowflag == AFD) qcf = AFDperCFS;
|
hcf = 1.0;
|
pcf = PSIperFT * hyd->SpGrav;
|
wcf = 1.0;
|
}
|
|
strcpy(rpt->Field[QUALITY].Units, "");
|
ccf = 1.0;
|
if (qual->Qualflag == CHEM)
|
{
|
ccf = 1.0 / LperFT3;
|
strncpy(rpt->Field[QUALITY].Units, qual->ChemUnits, MAXID);
|
strncpy(rpt->Field[REACTRATE].Units, qual->ChemUnits, MAXID);
|
strcat(rpt->Field[REACTRATE].Units, t_PERDAY);
|
}
|
else if (qual->Qualflag == AGE) strcpy(rpt->Field[QUALITY].Units, u_HOURS);
|
else if (qual->Qualflag == TRACE) strcpy(rpt->Field[QUALITY].Units, u_PERCENT);
|
|
pr->Ucf[DEMAND] = qcf;
|
pr->Ucf[ELEV] = hcf;
|
pr->Ucf[HEAD] = hcf;
|
pr->Ucf[PRESSURE] = pcf;
|
pr->Ucf[QUALITY] = ccf;
|
pr->Ucf[LENGTH] = hcf;
|
pr->Ucf[DIAM] = dcf;
|
pr->Ucf[FLOW] = qcf;
|
pr->Ucf[VELOCITY] = hcf;
|
pr->Ucf[HEADLOSS] = hcf;
|
pr->Ucf[LINKQUAL] = ccf;
|
pr->Ucf[REACTRATE] = ccf;
|
pr->Ucf[FRICTION] = 1.0;
|
pr->Ucf[POWER] = wcf;
|
pr->Ucf[VOLUME] = hcf * hcf * hcf;
|
|
// Report time in minutes if hyd. time step < 1/2 hr.
|
if (time->Hstep < 1800)
|
{
|
pr->Ucf[TIME] = 1.0 / 60.0;
|
strcpy(rpt->Field[TIME].Units, u_MINUTES);
|
}
|
else
|
{
|
pr->Ucf[TIME] = 1.0 / 3600.0;
|
strcpy(rpt->Field[TIME].Units, u_HOURS);
|
}
|
}
|
|
void convertunits(Project *pr)
|
/*
|
**--------------------------------------------------------------
|
** Input: none
|
** Output: none
|
** Purpose: converts units of input data
|
**--------------------------------------------------------------
|
*/
|
{
|
Network *net = &pr->network;
|
Hydraul *hyd = &pr->hydraul;
|
Quality *qual = &pr->quality;
|
Parser *parser = &pr->parser;
|
|
int i, j, k;
|
double ucf; // Unit conversion factor
|
Pdemand demand; // Pointer to demand record
|
Snode *node;
|
Stank *tank;
|
Slink *link;
|
Spump *pump;
|
Scontrol *control;
|
|
// Convert nodal elevations & initial WQ
|
// (WQ source units are converted in QUALITY.C
|
for (i = 1; i <= net->Nnodes; i++)
|
{
|
node = &net->Node[i];
|
node->El /= pr->Ucf[ELEV];
|
node->C0 /= pr->Ucf[QUALITY];
|
}
|
|
// Convert demands
|
for (i = 1; i <= net->Njuncs; i++)
|
{
|
node = &net->Node[i];
|
for (demand = node->D; demand != NULL; demand = demand->next)
|
{
|
demand->Base /= pr->Ucf[DEMAND];
|
}
|
}
|
|
// Convert PDA pressure limits
|
hyd->Pmin /= pr->Ucf[PRESSURE];
|
hyd->Preq /= pr->Ucf[PRESSURE];
|
|
// Convert emitter discharge coeffs. to head loss coeff.
|
ucf = pow(pr->Ucf[FLOW], hyd->Qexp) / pr->Ucf[PRESSURE];
|
for (i = 1; i <= net->Njuncs; i++)
|
{
|
node = &net->Node[i];
|
if (node->Ke > 0.0) node->Ke = ucf / pow(node->Ke, hyd->Qexp);
|
}
|
|
// Initialize tank variables (convert tank levels to elevations)
|
for (j = 1; j <= net->Ntanks; j++)
|
{
|
tank = &net->Tank[j];
|
i = tank->Node;
|
node = &net->Node[i];
|
tank->H0 = node->El + tank->H0 / pr->Ucf[ELEV];
|
tank->Hmin = node->El + tank->Hmin / pr->Ucf[ELEV];
|
tank->Hmax = node->El + tank->Hmax / pr->Ucf[ELEV];
|
tank->A = PI * SQR(tank->A / pr->Ucf[ELEV]) / 4.0;
|
tank->V0 /= pr->Ucf[VOLUME];
|
tank->Vmin /= pr->Ucf[VOLUME];
|
tank->Vmax /= pr->Ucf[VOLUME];
|
tank->Kb /= SECperDAY;
|
tank->V = tank->V0;
|
tank->C = node->C0;
|
tank->V1max *= tank->Vmax;
|
}
|
|
// Convert hydraulic convergence criteria
|
hyd->FlowChangeLimit /= pr->Ucf[FLOW];
|
hyd->HeadErrorLimit /= pr->Ucf[HEAD];
|
|
// Convert water quality concentration options
|
qual->Climit /= pr->Ucf[QUALITY];
|
qual->Ctol /= pr->Ucf[QUALITY];
|
|
// Convert global reaction coeffs.
|
qual->Kbulk /= SECperDAY;
|
qual->Kwall /= SECperDAY;
|
|
// Convert units of link parameters
|
for (k = 1; k <= net->Nlinks; k++)
|
{
|
link = &net->Link[k];
|
if (link->Type <= PIPE)
|
{
|
// Convert D-W roughness from millifeet (or mm) to ft
|
if (hyd->Formflag == DW) link->Kc /= (1000.0 * pr->Ucf[ELEV]);
|
link->Diam /= pr->Ucf[DIAM];
|
link->Len /= pr->Ucf[LENGTH];
|
|
// Convert minor loss coeff. from V^2/2g basis to Q^2 basis
|
link->Km = 0.02517 * link->Km / SQR(link->Diam) / SQR(link->Diam);
|
|
// Convert units on reaction coeffs.
|
link->Kb /= SECperDAY;
|
link->Kw /= SECperDAY;
|
}
|
|
else if (link->Type == PUMP)
|
{
|
// Convert units for pump curve parameters
|
i = findpump(net, k);
|
pump = &net->Pump[i];
|
if (pump->Ptype == CONST_HP)
|
{
|
// For constant hp pump, convert kw to hp
|
if (parser->Unitsflag == SI) pump->R /= pr->Ucf[POWER];
|
}
|
else
|
{
|
// For power curve pumps, convert shutoff head and flow coeff.
|
if (pump->Ptype == POWER_FUNC)
|
{
|
pump->H0 /= pr->Ucf[HEAD];
|
pump->R *= (pow(pr->Ucf[FLOW], pump->N) / pr->Ucf[HEAD]);
|
}
|
|
// Convert flow range & max. head units
|
pump->Q0 /= pr->Ucf[FLOW];
|
pump->Qmax /= pr->Ucf[FLOW];
|
pump->Hmax /= pr->Ucf[HEAD];
|
}
|
}
|
else
|
{
|
// For flow control valves, convert flow setting
|
// while for other valves convert pressure setting
|
link->Diam /= pr->Ucf[DIAM];
|
link->Km = 0.02517 * link->Km / SQR(link->Diam) / SQR(link->Diam);
|
if (link->Kc != MISSING) switch (link->Type)
|
{
|
case FCV:
|
link->Kc /= pr->Ucf[FLOW];
|
break;
|
case PRV:
|
case PSV:
|
case PBV:
|
link->Kc /= pr->Ucf[PRESSURE];
|
break;
|
default:
|
break;
|
}
|
}
|
}
|
|
// Convert units on control settings
|
for (i = 1; i <= net->Ncontrols; i++)
|
{
|
control = &net->Control[i];
|
if ((k = control->Link) == 0) continue;
|
link = &net->Link[k];
|
if ((j = control->Node) > 0)
|
{
|
node = &net->Node[j];
|
// control is based on tank level
|
if (j > net->Njuncs)
|
{
|
control->Grade = node->El + control->Grade / pr->Ucf[ELEV];
|
}
|
// control is based on nodal pressure
|
else control->Grade = node->El + control->Grade / pr->Ucf[PRESSURE];
|
}
|
|
// Convert units on valve settings
|
if (control->Setting != MISSING)
|
{
|
switch (link->Type)
|
{
|
case PRV:
|
case PSV:
|
case PBV:
|
control->Setting /= pr->Ucf[PRESSURE];
|
break;
|
case FCV:
|
control->Setting /= pr->Ucf[FLOW];
|
default:
|
break;
|
}
|
}
|
}
|
}
|
