openswmm_solver.h

Go to the documentation of this file.

 
#ifndef OPENSWMMCORE_SOLVER_H_
#define OPENSWMMCORE_SOLVER_H_
 
#include "openswmmcore_solver_export.h"
 
// --- use "C" linkage for C++ programs
#ifdef __cplusplus
extern "C" { 
#endif
 
typedef enum
{
    swmm_GAGE,
    swmm_SUBCATCH,
    swmm_NODE,
    swmm_LINK,
    swmm_POLLUTANT,
    swmm_LANDUSE,
    swmm_TIME_PATTERN,
    swmm_CURVE,
    swmm_TIMESERIES,
    swmm_CONTROL_RULE,
    swmm_TRANSECT,
    swmm_AQUIFER,
    swmm_UNIT_HYDROGRAPH,
    swmm_SNOWPACK,
    smmm_XSECTION_SHAPE,
    swmm_LID,
    swmm_STREET,
    swmm_INLET,
    swmm_SYSTEM = 100
} swmm_Object;
 
typedef enum
{
    swmm_JUNCTION = 0,
    swmm_OUTFALL = 1,
    swmm_STORAGE = 2,
    swmm_DIVIDER = 3
} swmm_NodeType;
 
typedef enum
{
    swmm_CONDUIT = 0,
    swmm_PUMP = 1,
    swmm_ORIFICE = 2,
    swmm_WEIR = 3,
    swmm_OUTLET = 4
} swmm_LinkType;
 
typedef enum
{
    swmm_GAGE_TOTAL_PRECIPITATION = 100,
    swmm_GAGE_RAINFALL,
    swmm_GAGE_SNOWFALL,
} swmm_GageProperty;
 
typedef enum
{
    swmm_SUBCATCH_AREA = 200,
    swmm_SUBCATCH_RAINGAGE,
    swmm_SUBCATCH_RAINFALL,
    swmm_SUBCATCH_EVAP,
    swmm_SUBCATCH_INFIL,
    swmm_SUBCATCH_RUNOFF,
    swmm_SUBCATCH_RPTFLAG,
    swmm_SUBCATCH_WIDTH,
    swmm_SUBCATCH_SLOPE,
    swmm_SUBCATCH_OUTLET_TYPE,
    swmm_SUBCATCH_OUTLET_INDEX,
    swmm_SUBCATCH_INFILTRATION_MODEL,
    swmm_SUBCATCH_FRACTION_IMPERVIOUS,
    swmm_SUBCATCH_SUB_AREA_ROUTE_TO,
    swmm_SUBCATCH_SUB_AREA_FRACTION_OUTLET,
    swmm_SUBCATCH_SUB_AREA_MANNINGS_N,
    swmm_SUBCATCH_SUB_AREA_FRACTION_AREA,
    swmm_SUBCATCH_SUB_AREA_DEPRESSION_STORAGE,
    swmm_SUBCATCH_SUB_AREA_INFLOW,
    swmm_SUBCATCH_SUB_AREA_RUNOFF,
    swmm_SUBCATCH_SUB_AREA_DEPTH,
    swmm_SUBCATCH_LID_UNITS_COUNT,
    swmm_SUBCATCH_LID_UNITS_PERV_AREA,
    swmm_SUBCATCH_LID_UNITS_FLOW_TO_PERV_AREA,
    swmm_SUBCATCH_LID_UNITS_DRAIN_FLOW,
    swmm_SUBCATCH_LID_UNIT_REPLICATES,
    swmm_SUBCATCH_LID_UNIT_AREA,
    swmm_SUBCATCH_LID_UNIT_FULL_WIDTH,
    swmm_SUBCATCH_LID_UNIT_BOTTOM_WIDTH,
    swmm_SUBCATCH_LID_UNIT_INIT_SATURATION,
    swmm_SUBCATCH_LID_UNIT_FROM_IMPERVIOUS,
    swmm_SUBCATCH_LID_UNIT_FROM_PERVIOUS,
    swmm_SUBCATCH_LID_UNIT_TO_PERVIOUS,
    swmm_SUBCATCH_LID_UNIT_RECEIVING_OUTLET_TYPE,
    swmm_SUBCATCH_LID_UNIT_RECEIVING_OUTLET_INDEX,
    swmm_SUBCATCH_LID_UNIT_SURFACE_DEPTH,
    swmm_SUBCATCH_LID_UNIT_SOIL_MOISTURE,
    swmm_SUBCATCH_LID_UNIT_GREEN_AMPT_CAPILLARY_SUCTION,
    swmm_SUBCATCH_LID_UNIT_GREEN_AMPT_SATURATED_CONDUCTIVITY,
    swmm_SUBCATCH_LID_UNIT_GREEN_AMPT_MAXIMUM_SOIL_MOISTURE_DEFICIT,
    swmm_SUBCATCH_CURB_LENGTH,
    swmm_SUBCATCH_API_RAINFALL,
    swmm_SUBCATCH_API_SNOWFALL,
    swmm_SUBCATCH_POLLUTANT_BUILDUP,
    swmm_SUBCATCH_EXTERNAL_POLLUTANT_BUILDUP,
    swmm_SUBCATCH_POLLUTANT_RUNOFF_CONCENTRATION,
    swmm_SUBCATCH_POLLUTANT_PONDED_CONCENTRATION,
    swmm_SUBCATCH_POLLUTANT_TOTAL_LOAD,
} swmm_SubcatchProperty;
 
typedef enum
{
    swmm_NODE_TYPE = 300,
    swmm_NODE_ELEV,
    swmm_NODE_MAXDEPTH,
    swmm_NODE_DEPTH,
    swmm_NODE_HEAD,
    swmm_NODE_VOLUME,
    swmm_NODE_LATFLOW,
    swmm_NODE_INFLOW,
    swmm_NODE_OVERFLOW,
    swmm_NODE_RPTFLAG,
    swmm_NODE_SURCHARGE_DEPTH,
    swmm_NODE_PONDED_AREA,
    swmm_NODE_INITIAL_DEPTH,
    swmm_NODE_POLLUTANT_CONCENTRATION,
    swmm_NODE_POLLUTANT_LATMASS_FLUX,
} swmm_NodeProperty;
 
typedef enum
{
    swmm_LINK_TYPE = 400,
    swmm_LINK_NODE1 = 401,
    swmm_LINK_NODE2 = 402,
    swmm_LINK_LENGTH = 403,
    swmm_LINK_SLOPE = 404,
    swmm_LINK_FULLDEPTH = 405,
    swmm_LINK_FULLFLOW = 406,
    swmm_LINK_SETTING = 407,
    swmm_LINK_TIMEOPEN = 408,
    swmm_LINK_TIMECLOSED = 409,
    swmm_LINK_FLOW = 410,
    swmm_LINK_DEPTH = 411,
    swmm_LINK_VELOCITY = 412,
    swmm_LINK_TOPWIDTH = 413,
    swmm_LINK_VOLUME = 414,
    swmm_LINK_CAPACITY = 415,
    swmm_LINK_RPTFLAG = 416,
    swmm_LINK_OFFSET1 = 417,
    swmm_LINK_OFFSET2 = 418,
    swmm_LINK_INITIAL_FLOW = 419,
    swmm_LINK_FLOW_LIMIT = 420,
    swmm_LINK_INLET_LOSS = 421,
    swmm_LINK_OUTLET_LOSS = 422,
    swmm_LINK_AVERAGE_LOSS = 423,
    swmm_LINK_SEEPAGE_RATE = 424,
    swmm_LINK_HAS_FLAPGATE = 425,
    swmm_LINK_POLLUTANT_CONCENTRATION = 426,
    swmm_LINK_POLLUTANT_LOAD = 427,
    swmm_LINK_POLLUTANT_LATMASS_FLUX = 428,
} swmm_LinkProperty;
 
typedef enum
{
    swmm_STARTDATE = 0,
    swmm_CURRENTDATE = 1,
    swmm_ELAPSEDTIME = 2,
    swmm_ROUTESTEP = 3,
    swmm_MAXROUTESTEP = 4,
    swmm_REPORTSTEP = 5,
    swmm_TOTALSTEPS = 6,
    swmm_NOREPORT = 7,
    swmm_FLOWUNITS = 8,
    swmm_ENDDATE = 9,
    swmm_REPORTSTART = 10,
    swmm_UNITSYSTEM = 11,
    swmm_SURCHARGEMETHOD = 12,
    swmm_ALLOWPONDING = 13,
    swmm_INERTIADAMPING = 14,
    swmm_NORMALFLOWLTD = 15,
    swmm_SKIPSTEADYSTATE = 16,
    swmm_IGNORERAINFALL = 17,
    swmm_IGNORERDII = 18,
    swmm_IGNORESNOWMELT = 19,
    swmm_IGNOREGROUNDWATER = 20,
    swmm_IGNOREROUTING = 21,
    swmm_IGNOREQUALITY = 22,
    swmm_ERROR_CODE = 23,
    swmm_RULESTEP = 24,
    swmm_SWEEPSTART = 25,
    swmm_SWEEPEND = 26,
    swmm_MAXTRIALS = 27,
    swmm_NUMTHREADS = 28,
    swmm_MINROUTESTEP = 29,
    swmm_LENGTHENINGSTEP = 30,
    swmm_STARTDRYDAYS = 31,
    swmm_COURANTFACTOR = 32,
    swmm_MINSURFAREA = 33,
    swmm_MINSLOPE = 34,
    swmm_RUNOFFERROR = 35,
    swmm_FLOWERROR = 36,
    swmm_QUALERROR = 37,
    swmm_HEADTOL = 38,
    swmm_SYSFLOWTOL = 39,
    swmm_LATFLOWTOL = 40,
} swmm_SystemProperty;
 
typedef enum
{
    swmm_CFS = 0,
    swmm_GPM = 1,
    swmm_MGD = 2,
    swmm_CMS = 3,
    swmm_LPS = 4,
    swmm_MLD = 5
} swmm_FlowUnitsProperty;
 
typedef enum
{
    ERR_API_NOT_OPEN = -999901,
    ERR_API_NOT_STARTED = -999902,
    ERR_API_NOT_ENDED = -999903,
    ERR_API_OBJECT_TYPE = -999904,
    ERR_API_OBJECT_INDEX = -999905,
    ERR_API_OBJECT_NAME = -999906,
    ERR_API_PROPERTY_TYPE = -999907,
    ERR_API_PROPERTY_VALUE = -999908,
    ERR_API_TIME_PERIOD = -999909,
    ERR_API_HOTSTART_FILE_OPEN = -999910,
    ERR_API_HOTSTART_FILE_FORMAT = -999911,
    ERR_API_IS_RUNNING = -999912,
} swmm_API_Errors;
 
/* ====================================================================
 *  Statistics and mass balance structures
 * ==================================================================== */
 
#define SWMM_MAX_FLOW_CLASSES 7
 
typedef struct
{
    double precip;           
    double runon;            
    double evap;             
    double infil;            
    double runoff;           
    double maxFlow;          
    double impervRunoff;     
    double pervRunoff;       
} swmm_SubcatchStats;
 
typedef struct
{
    double avgDepth;             
    double maxDepth;             
    double maxDepthDate;         
    double maxRptDepth;          
    double volFlooded;           
    double timeFlooded;          
    double timeSurcharged;       
    double timeCourantCritical;  
    double totLatFlow;           
    double maxLatFlow;           
    double maxInflow;            
    double maxOverflow;          
    double maxPondedVol;         
    double maxInflowDate;        
    double maxOverflowDate;      
} swmm_NodeStats;
 
typedef struct
{
    double initVol;      
    double avgVol;       
    double maxVol;       
    double maxFlow;      
    double evapLosses;   
    double exfilLosses;  
    double maxVolDate;   
} swmm_StorageStats;
 
typedef struct
{
    double  avgFlow;      
    double  maxFlow;      
    double *totalLoad;    
    int     totalPeriods; 
} swmm_OutfallStats;
 
typedef struct
{
    double maxFlow;              
    double maxFlowDate;          
    double maxVeloc;             
    double maxDepth;             
    double timeNormalFlow;       
    double timeInletControl;     
    double timeSurcharged;       
    double timeFullUpstream;     
    double timeFullDnstream;     
    double timeFullFlow;         
    double timeCapacityLimited;  
    double timeInFlowClass[SWMM_MAX_FLOW_CLASSES]; 
    double timeCourantCritical;  
    long   flowTurns;            
    int    flowTurnSign;         
} swmm_LinkStats;
 
typedef struct
{
    double utilized;     
    double minFlow;      
    double avgFlow;      
    double maxFlow;      
    double volume;       
    double energy;       
    double offCurveLow;  
    double offCurveHigh; 
    int    startUps;     
    int    totalPeriods; 
} swmm_PumpStats;
 
typedef struct
{
    double dwInflow;     
    double wwInflow;     
    double gwInflow;     
    double iiInflow;     
    double exInflow;     
    double flooding;     
    double outflow;      
    double evapLoss;     
    double seepLoss;     
    double reacted;      
    double initStorage;  
    double finalStorage; 
    double pctError;     
} swmm_RoutingTotals;
 
typedef struct
{
    double rainfall;       
    double evap;           
    double infil;          
    double runoff;         
    double drains;         
    double runon;          
    double initStorage;    
    double finalStorage;   
    double initSnowCover;  
    double finalSnowCover; 
    double snowRemoved;    
    double pctError;       
} swmm_RunoffTotals;
 
typedef void (*progress_callback)(double progress);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_run(const char *inputFile, const char *reportFile, const char *outputFile);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_run_with_callback(
    const char *inputFile, const char *reportFile, const char *outputFile, progress_callback callback);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_open(const char *inputFile, const char *reportFile, const char *outputFile);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_start(int saveFlag);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_step(double *elapsedTime);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_stride(int strideStep, double *elapsedTime);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_useHotStart(const char *hotStartFile);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_saveHotStart(const char *hotStartFile);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_end(void);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_report(void);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_close(void);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getMassBalErr(float *runoffErr, float *flowErr, float *qualErr);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getVersion(void);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getError(char *errMsg, int msgLen);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getErrorFromCode(int error_code, char *outErrMsg[1024]);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getWarnings(void);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getCount(int objType);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getName(int objType, int index, char *name, int size);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getIndex(int objType, const char *name);
 
double EXPORT_OPENSWMMCORE_SOLVER_API swmm_getValue(int property, int index);
 
double EXPORT_OPENSWMMCORE_SOLVER_API swmm_getValueExpanded(int objType, int property, int index, int subIndex, int pollutantIndex);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_setValue(int property, int index, double value);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_setValueExpanded(int objType, int property, int index, int subIndex, int pollutantIndex, double value);
 
double EXPORT_OPENSWMMCORE_SOLVER_API swmm_getSavedValue(int property, int index, int period);
 
void EXPORT_OPENSWMMCORE_SOLVER_API swmm_writeLine(const char *line);
 
void EXPORT_OPENSWMMCORE_SOLVER_API swmm_decodeDate(double date, int *year, int *month, int *day,
                               int *hour, int *minute, int *second, int *dayOfWeek);
 
double EXPORT_OPENSWMMCORE_SOLVER_API swmm_encodeDate(int year, int month, int day,
                                 int hour, int minute, int second);
 
/* ====================================================================
 *  Statistics and mass balance API functions
 *
 *  Call these after swmm_end() but before swmm_close().
 * ==================================================================== */
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getSubcatchStats(int index, swmm_SubcatchStats *stats);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getNodeStats(int index, swmm_NodeStats *stats);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getStorageStats(int index, swmm_StorageStats *stats);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getOutfallStats(int index, swmm_OutfallStats *stats);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getLinkStats(int index, swmm_LinkStats *stats);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getPumpStats(int index, swmm_PumpStats *stats);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getSystemRoutingTotals(swmm_RoutingTotals *totals);
 
int EXPORT_OPENSWMMCORE_SOLVER_API swmm_getSystemRunoffTotals(swmm_RunoffTotals *totals);
 
#ifdef __cplusplus
} // matches the linkage specification from above */
#endif
 
#endif // OPENSWMMCORE_SOLVER_H_