funcs.h

Go to the documentation of this file.

 
#ifndef FUNCS_H
#define FUNCS_H



void project_open(const char *inp_file, const char *rpt_file, const char *out_file);

void project_close(void);

void project_readInput(void);

int project_readOption(char *s1, char *s2);

void project_validate(void);

int project_init(void);

int project_addObject(int type, char *id, int n);

int project_findObject(int type, const char *id);

char *project_findID(int type, char *id);

double **project_createMatrix(int nrows, int ncols);

void project_freeMatrix(double **m);


int input_countObjects(void);

int input_readData(void);


int report_readOptions(char *tok[], int ntoks);

void report_writeLine(const char *line);

void report_writeSysTime(void);

void report_writeLogo(void);

void report_writeTitle(void);

void report_writeOptions(void);

void report_writeReport(void);

void report_writeRainStats(int gage, TRainStats *rainStats);

void report_writeRdiiStats(double totalRain, double totalRdii);

void report_writeControlActionsHeading(void);

void report_writeControlAction(DateTime aDate, char *linkID, double value,
                               char *ruleID);

void report_writeRunoffError(TRunoffTotals *totals, double area);

void report_writeLoadingError(TLoadingTotals *totals);

void report_writeGwaterError(TGwaterTotals *totals, double area);

void report_writeFlowError(TRoutingTotals *totals);

void report_writeQualError(TRoutingTotals *totals);

void report_writeMaxStats(TMaxStats massBalErrs[], TMaxStats CourantCrit[],
                          int nMaxStats);

void report_writeMaxFlowTurns(TMaxStats flowTurns[], int nMaxStats);

void report_writeNonconvergedStats(TMaxStats maxNonconverged[],
                                   int nMaxStats);

void report_writeTimeStepStats(TTimeStepStats *timeStepStats);

void report_writeErrorMsg(int code, char *msg);

void report_writeErrorCode(void);

void report_writeInputErrorMsg(int k, int sect, char *line, long lineCount);

void report_writeWarningMsg(char *msg, char *id);

void report_invokeWarningCallback(const char *msg);

void report_writeTseriesErrorMsg(int code, TTable *tseries);

void inputrpt_writeInput(void);

void statsrpt_writeReport(void);


int climate_readParams(char *tok[], int ntoks);

int climate_readEvapParams(char *tok[], int ntoks);

int climate_readAdjustments(char *tok[], int ntoks);

void climate_validate(void);

void climate_openFile(void);

void climate_initState(void);

void climate_setState(DateTime theDate);

DateTime climate_getNextEvapDate(void);



void rain_open(void);

void rain_close(void);



int snow_readMeltParams(char *tok[], int ntoks);

int snow_createSnowpack(int subcatchIndex, int snowIndex);

void snow_validateSnowmelt(int snowIndex);

void snow_initSnowpack(int subcatchIndex);

void snow_initSnowmelt(int snowIndex);

void snow_getState(int subcatchIndex, int subAreaIndex, double x[]);

void snow_setState(int subcatchIndex, int subAreaIndex, double x[]);

void snow_setMeltCoeffs(int snowIndex, double season);

void snow_plowSnow(int subcatchIndex, double tStep);

double snow_getSnowMelt(int subcatchIndex, double rainfall, double snowfall,
                        double tStep, double netPrecip[]);

double snow_getSnowCover(int subcatchIndex);

int runoff_open(void);

void runoff_execute(void);

void runoff_close(void);


int routing_open(void);

double routing_getRoutingStep(int routingModel, double fixedStep);

void routing_execute(int routingModel, double routingStep);

void routing_close(int routingModel);


int output_open(void);

void output_end(void);

void output_close(void);

void output_saveResults(double reportTime);

void output_updateAvgResults(void);

void output_readDateTime(long period, DateTime *days);

void output_readSubcatchResults(long period, int index);

void output_readNodeResults(long period, int index);

void output_readLinkResults(long period, int index);


int gwater_readAquiferParams(int aquiferIndex, char *tok[], int ntoks);

int gwater_readGroundwaterParams(char *tok[], int ntoks);

int gwater_readFlowExpression(char *tok[], int ntoks);

void gwater_deleteFlowExpression(int subcatchIndex);

void gwater_validateAquifer(int aquiferIndex);

void gwater_validate(int subcatchIndex);

void gwater_initState(int subcatchIndex);

void gwater_getState(int subcatchIndex, double x[]);

void gwater_setState(int subcatchIndex, double x[]);

void gwater_getGroundwater(int subcatchIndex, double evap, double infil,
                           double tStep);

double gwater_getVolume(int subcatchIndex);


int rdii_readRdiiInflow(char *tok[], int ntoks);

void rdii_deleteRdiiInflow(int nodeIndex);

void rdii_initUnitHyd(int unitHydIndex);

int rdii_readUnitHydParams(char *tok[], int ntoks);

void rdii_openRdii(void);

void rdii_closeRdii(void);

int rdii_getNumRdiiFlows(DateTime aDate);

void rdii_getRdiiFlow(int index, int *nodeIndex, double *q);


int landuse_readParams(int landuseIndex, char *tok[], int ntoks);

int landuse_readPollutParams(int pollutIndex, char *tok[], int ntoks);

int landuse_readBuildupParams(char *tok[], int ntoks);

int landuse_readWashoffParams(char *tok[], int ntoks);

void landuse_getInitBuildup(TLandFactor *landFactor, double *initBuildup,
                            double area, double curb);

double landuse_getBuildup(int landuseIndex, int pollutIndex, double area, double curb,
                          double buildup, double tStep);

double landuse_getWashoffLoad(int landuse, int p, double area,
                              TLandFactor landFactor[], double runoff, double vOutflow);

double landuse_getAvgBmpEffic(int subcatchIndex, int pollutIndex);

double landuse_getCoPollutLoad(int p, double washoff[]);


void flowrout_init(int routingModel);

void flowrout_close(int routingModel);

double flowrout_getRoutingStep(int routingModel, double fixedStep);

int flowrout_execute(int links[], int routingModel, double tStep);

void toposort_sortLinks(int sortedLinks[]);

int kinwave_execute(int linkIndex, double *qin, double *qout, double tStep);

void dynwave_validate(void);

void dynwave_init(void);

void dynwave_close(void);

double dynwave_getRoutingStep(double fixedStep);

int dynwave_execute(double tStep);

void dwflow_findConduitFlow(int linkIndex, int steps, double omega, double dt);

void qualrout_init(void);

void qualrout_execute(double tStep);


int treatmnt_open(void);

void treatmnt_close(void);

int treatmnt_readExpression(char *tok[], int ntoks);

void treatmnt_delete(int nodeIndex);

void treatmnt_treat(int nodeIndex, double q, double v, double tStep);

void treatmnt_setInflow(double qIn, double wIn[]);


int massbal_open(void);

void massbal_close(void);

void massbal_report(void);

void massbal_updateRunoffTotals(int flowType, double v);

void massbal_updateLoadingTotals(int type, int pollutIndex, double w);

void massbal_updateGwaterTotals(double vInfil, double vUpperEvap,
                                double vLowerEvap, double vLowerPerc, double vGwater);

void massbal_updateRoutingTotals(double tStep);

void massbal_initTimeStepTotals(void);

void massbal_addInflowFlow(int type, double q);

void massbal_addInflowQual(int type, int pollutIndex, double w);

void massbal_addOutflowFlow(double q, int isFlooded);

void massbal_addOutflowQual(int pollutIndex, double mass, int isFlooded);

void massbal_addNodeLosses(double evapLoss, double infilLoss);

void massbal_addLinkLosses(double evapLoss, double infilLoss);

void massbal_addReactedMass(int pollutIndex, double mass);

void massbal_addSeepageLoss(int pollutIndex, double seepLoss);

void massbal_addToFinalStorage(int pollutIndex, double mass);

double massbal_getStepFlowError(void);

double massbal_getRunoffError(void);

double massbal_getFlowError(void);

int stats_open(void);

void stats_close(void);

void stats_report(void);

void stats_updateCriticalTimeCount(int nodeIndex, int linkIndex);

void stats_updateFlowStats(double tStep, DateTime aDate);

void stats_updateTimeStepStats(double tStep, int trialsCount, int steadyState);

void stats_updateSubcatchStats(int subcatchIndex, double rainVol,
                               double runonVol, double evapVol, double infilVol,
                               double impervVol, double pervVol, double runoffVol, double runoff);

void stats_updateGwaterStats(int subcatchIndex, double infil, double evap,
                             double latFlow, double deepFlow, double theta, double waterTable,
                             double tStep);

void stats_updateMaxRunoff(void);

void stats_updateMaxNodeDepth(int nodeIndex, double depth);

void stats_updateConvergenceStats(int nodeIndex, int converged);

int gage_readParams(int gageIndex, char *tok[], int ntoks);

void gage_validate(int gageIndex);

void gage_initState(int gageIndex);

void gage_setState(int gageIndex, DateTime aDate);

double gage_getPrecip(int gageIndex, double *rainfall, double *snowfall);

void gage_setReportRainfall(int gageIndex, DateTime aDate);

DateTime gage_getNextRainDate(int gageIndex, DateTime aDate);

void gage_updatePastRain(int gageIndex, int tStep);

double gage_getPastRain(int gageIndex, int hrs);

int subcatch_readParams(int subcatchIndex, char *tok[], int ntoks);

int subcatch_readSubareaParams(char *tok[], int ntoks);

int subcatch_readLanduseParams(char *tok[], int ntoks);

int subcatch_readInitBuildup(char *tok[], int ntoks);

void subcatch_validate(int subcatchIndex);

void subcatch_initState(int subcatchIndex);

void subcatch_setOldState(int subcatchIndex);

double subcatch_getFracPerv(int subcatchIndex);

double subcatch_getEvapRate(int subcatchIndex);

double subcatch_getStorage(int subcatchIndex);

double subcatch_getDepth(int subcatchIndex);

void subcatch_getRunon(int subcatchIndex);

void subcatch_addRunonFlow(int subcatchIndex, double flow);

double subcatch_getRunoff(int subcatchIndex, double tStep);

double subcatch_getWtdOutflow(int subcatchIndex, double wt);

void subcatch_getResults(int subcatchIndex, double wt, float x[]);

void surfqual_initState(int subcatchIndex);

void surfqual_getWashoff(int subcatchIndex, double runoff, double tStep);

void surfqual_getBuildup(int subcatchIndex, double tStep);

void surfqual_applyAPIBuildup(int subcatchIndex);

void surfqual_sweepBuildup(int subcatchIndex, DateTime aDate);

double surfqual_getWtdWashoff(int subcatchIndex, int pollutIndex, double wt);


int node_readParams(int nodeIndex, int type, int subIndex, char *tok[], int ntoks);

void node_validate(int nodeIndex);

void node_initState(int nodeIndex);

void node_initFlows(int nodeIndex, double tStep);

void node_setOldHydState(int nodeIndex);

void node_setOldQualState(int nodeIndex);

void node_setOutletDepth(int nodeIndex, double yNorm, double yCrit, double z);

double node_getSurfArea(int nodeIndex, double depth);

double node_getDepth(int nodeIndex, double volume);

double node_getVolume(int nodeIndex, double depth);

double node_getPondedArea(int nodeIndex, double depth);

double node_getOutflow(int nodeIndex, int linkIndex);

double node_getLosses(int nodeIndex, double tStep);

double node_getMaxOutflow(int nodeIndex, double q, double tStep);

double node_getSystemOutflow(int nodeIndex, int *isFlooded);

void node_getResults(int nodeIndex, double wt, float x[]);

int inflow_readExtInflow(char *tok[], int ntoks);

int inflow_readDwfInflow(char *tok[], int ntoks);

int inflow_readDwfPattern(char *tok[], int ntoks);

int inflow_setExtInflow(int nodeIndex, int param, int type, int tSeries,
                        int basePat, double cf, double baseline, double sf);

void inflow_initDwfInflow(TDwfInflow *inflow);

void inflow_initDwfPattern(int patternIndex);

double inflow_getExtInflow(TExtInflow *inflow, DateTime aDate);

double inflow_getDwfInflow(TDwfInflow *inflow, int m, int d, int h);

void inflow_deleteExtInflows(int nodeIndex);

void inflow_deleteDwfInflows(int nodeIndex);
 
//-----------------------------------------------------------------------------
//   Routing Interface File Methods
//-----------------------------------------------------------------------------
int iface_readFileParams(char *tok[], int ntoks);
void iface_openRoutingFiles(void);
void iface_closeRoutingFiles(void);
int iface_getNumIfaceNodes(DateTime aDate);
int iface_getIfaceNode(int index);
double iface_getIfaceFlow(int index);
double iface_getIfaceQual(int index, int pollut);
void iface_saveOutletResults(DateTime reportDate, FILE *file);
 
//-----------------------------------------------------------------------------
//   Hot Start File Methods
//-----------------------------------------------------------------------------
int hotstart_open(void);
void hotstart_save(void);
int hotstart_save_to_file(const char *hotstartFile);
int hotstart_is_valid(const char *hotstartFile, int *inputFileVersion);
void hotstart_close(void);
 
//-----------------------------------------------------------------------------
//   Conveyance System Link Methods
//-----------------------------------------------------------------------------
int link_readParams(int link, int type, int subIndex, char *tok[], int ntoks);
int link_readXsectParams(char *tok[], int ntoks);
int link_readLossParams(char *tok[], int ntoks);
 
void link_validate(int link);
void link_initState(int link);
void link_setOldHydState(int link);
void link_setOldQualState(int link);
 
void link_setTargetSetting(int j);
void link_setSetting(int j, double tstep);
int link_setFlapGate(int link, int n1, int n2, double q);
 
double link_getInflow(int link);
void link_setOutfallDepth(int link);
double link_getLength(int link);
double link_getYcrit(int link, double q);
double link_getYnorm(int link, double q);
double link_getVelocity(int link, double q, double y);
double link_getFroude(int link, double v, double y);
double link_getPower(int link);
double link_getLossRate(int link, int routeModel, double q, double tstep);
char link_getFullState(double a1, double a2, double aFull);
 
void link_getResults(int link, double wt, float x[]);
 
//-----------------------------------------------------------------------------
//   Link Cross-Section Methods
//-----------------------------------------------------------------------------
int xsect_isOpen(int type);
int xsect_setParams(TXsect *xsect, int type, double p[], double ucf);
void xsect_setIrregXsectParams(TXsect *xsect);
void xsect_setCustomXsectParams(TXsect *xsect);
void xsect_setStreetXsectParams(TXsect *xsect);
double xsect_getAmax(TXsect *xsect);
 
double xsect_getSofA(TXsect *xsect, double area);
double xsect_getYofA(TXsect *xsect, double area);
double xsect_getRofA(TXsect *xsect, double area);
double xsect_getAofS(TXsect *xsect, double sFactor);
double xsect_getdSdA(TXsect *xsect, double area);
double xsect_getAofY(TXsect *xsect, double y);
double xsect_getRofY(TXsect *xsect, double y);
double xsect_getWofY(TXsect *xsect, double y);
double xsect_getYcrit(TXsect *xsect, double q);
 
//-----------------------------------------------------------------------------
//   Culvert/Roadway Methods
//-----------------------------------------------------------------------------
double culvert_getInflow(int link, double q, double h);
double roadway_getInflow(int link, double dir, double hcrest, double h1,
                         double h2);
 
//-----------------------------------------------------------------------------
//   Force Main Methods
//-----------------------------------------------------------------------------
double forcemain_getEquivN(int j, int k);
double forcemain_getRoughFactor(int j, double lengthFactor);
double forcemain_getFricSlope(int j, double v, double hrad);
 
//-----------------------------------------------------------------------------
//   Cross-Section Transect Methods
//-----------------------------------------------------------------------------
int transect_create(int n);
void transect_delete(void);
int transect_readParams(int *count, char *tok[], int ntoks);
void transect_validate(int j);
void transect_createStreetTransect(TStreet *street);
 
//-----------------------------------------------------------------------------
//   Street Cross-Section Methods
//-----------------------------------------------------------------------------
int street_create(int nStreets);
void street_delete();
int street_readParams(char *tok[], int ntoks);
double street_getExtentFilled(int link);
 
//-----------------------------------------------------------------------------
//   Custom Shape Cross-Section Methods
//-----------------------------------------------------------------------------
int shape_validate(TShape *shape, TTable *curve);


void controls_init(void);

void controls_addToCount(char *s);

int controls_create(int n);

void controls_delete(void);

int controls_addVariable(char *tok[], int ntoks);

int controls_addExpression(char *tok[], int ntoks);

int controls_addRuleClause(int rule, int keyword, char *Tok[], int nTokens);

int controls_evaluate(DateTime currentTime, DateTime elapsedTime,
                      double tStep);
 
//-----------------------------------------------------------------------------
//   Table & Time Series Methods
//-----------------------------------------------------------------------------
int table_readCurve(char *tok[], int ntoks);
int table_readTimeseries(char *tok[], int ntoks);
 
int table_addEntry(TTable *table, double x, double y);
int table_getFirstEntry(TTable *table, double *x, double *y);
int table_getNextEntry(TTable *table, double *x, double *y);
void table_deleteEntries(TTable *table);
 
void table_init(TTable *table);
int table_validate(TTable *table);
 
double table_lookup(TTable *table, double x);
double table_lookupEx(TTable *table, double x);
double table_intervalLookup(TTable *table, double x);
double table_inverseLookup(TTable *table, double y);
 
double table_getSlope(TTable *table, double x);
double table_getMaxY(TTable *table, double x);
double table_getStorageVolume(TTable *table, double x);
double table_getStorageDepth(TTable *table, double v);
 
void table_tseriesInit(TTable *table);
double table_tseriesLookup(TTable *table, double t, char extend);


double UCF(int quantity);

int getInt(char *s, int *y);

int getFloat(char *s, float *y);

int getDouble(char *s, double *y);

char *getTempFileName(char *fname);

int findmatch(char *s, char *keyword[]);

int match(char *str, char *substr);

int strcomp(const char *s1, const char *s2);

size_t sstrncpy(char *dest, const char *src, size_t n);

size_t sstrcat(char *dest, const char *src, size_t destsize);

void writecon(const char *s);

void getElapsedTime(DateTime aDate,  int *days, int *hrs, int *mins);

DateTime getDateTime(double elapsedMsec);

char *addAbsolutePath(char *fname); // add full path to a file name

 
#endif // FUNCS_H