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_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_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