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 i, TRainStats* r);

void report_writeRdiiStats(double rainVol, double rdiiVol);

void report_writeControlActionsHeading(void);

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

void report_writeRunoffError(TRunoffTotals* totals, double totalArea);

void report_writeLoadingError(TLoadingTotals* totals);

void report_writeGwaterError(TGwaterTotals* totals, double gwArea);

void report_writeFlowError(TRoutingTotals* totals);

void report_writeQualError(TRoutingTotals* QualTotals);

void report_writeMaxStats(TMaxStats maxMassBalErrs[], TMaxStats maxCourantCrit[], 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* s);

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 i, int j, 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 j, 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 i, 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* qinflow, double* qoutflow, 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 j, 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 p, 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 p, double w, int isFlooded);

void massbal_addNodeLosses(double evapLoss, double seepLoss);

void massbal_addLinkLosses(double evapLoss, double seepLoss);

void massbal_addReactedMass(int pollutIndex, double w);

void massbal_addSeepageLoss(int pollutIndex, double w);

void massbal_addToFinalStorage(int pollutIndex, double w);

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 j, double depth);

void stats_updateConvergenceStats(int node, int converged);

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

void gage_validate(int gageIndex);

void gage_initState(int j);

void gage_setState(int j, DateTime t);

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

void gage_setReportRainfall(int gageIndex, DateTime reportDate);

DateTime gage_getNextRainDate(int gageIndex, DateTime aDate);

void gage_updatePastRain(int gageIndex, int tStep);

double gage_getPastRain(int j, int n);

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 j);

double subcatch_getEvapRate(int subcatchIndex);

double subcatch_getStorage(int subcatchIndex);

double subcatch_getDepth(int j);

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 f);

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 j, int p, double f);


int node_readParams(int nodeIndex, int type, int k, 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 j, double yNorm, double yCrit, double z);

double node_getSurfArea(int j, double d);

double node_getDepth(int nodeIndex, double v);

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 j, 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 month, int day, int hour);

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 r, int keyword, char* tok[], int nToks);

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 u);

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