toolkitAPI.h

Go to the documentation of this file.

#ifndef TOOLKITAPI_H
#define TOOLKITAPI_H

#ifdef WINDOWS
#ifdef __MINGW32__
#define DLLEXPORT __declspec(dllexport) __cdecl
#else
#define DLLEXPORT __declspec(dllexport) __stdcall
#endif
#else
#define DLLEXPORT
#endif

#ifdef __cplusplus
extern "C" {
#endif

#define _CRT_SECURE_NO_DEPRECATE

#include "../src/datetime.h"

typedef enum {
    SM_GAGE         = 0,  
    SM_SUBCATCH     = 1,  
    SM_NODE         = 2,  
    SM_LINK         = 3,  
    SM_POLLUT       = 4,  
    SM_LANDUSE      = 5,  
    SM_TIMEPATTERN  = 6,  
    SM_CURVE        = 7,  
    SM_TSERIES      = 8,  
    SM_CONTROL      = 9,  
    SM_TRANSECT     = 10, 
    SM_AQUIFER      = 11, 
    SM_UNITHYD      = 12, 
    SM_SNOWMELT     = 13, 
    SM_SHAPE        = 14, 
    SM_LID          = 15  
} SM_ObjectType;

typedef enum {
    SM_JUNCTION    = 0,  
    SM_OUTFALL     = 1,  
    SM_STORAGE     = 2,  
    SM_DIVIDER     = 3   
} SM_NodeType;

typedef enum {
    SM_CONDUIT     = 0,  
    SM_PUMP        = 1,  
    SM_ORIFICE     = 2,  
    SM_WEIR        = 3,  
    SM_OUTLET      = 4   
} SM_LinkType;

typedef enum {
    SM_STARTDATE    = 0, 
    SM_ENDDATE      = 1, 
    SM_REPORTDATE   = 2  
} SM_TimePropety;

typedef enum {
    SM_SYSTEMUNIT   = 0, 
    SM_FLOWUNIT     = 1, 
} SM_Units;

typedef enum {
    SM_ALLOWPOND    = 0, 
    SM_SKIPSTEADY   = 1, 
    SM_IGNORERAIN   = 2, 
    SM_IGNORERDII   = 3, 
    SM_IGNORESNOW   = 4, 
    SM_IGNOREGW     = 5, 
    SM_IGNOREROUTE  = 6, 
    SM_IGNORERQUAL  = 7  
} SM_SimOption;

typedef enum {
    SM_ROUTESTEP     = 0,  
    SM_MINROUTESTEP  = 1,  
    SM_LENGTHSTEP    = 2,  
    SM_STARTDRYDAYS  = 3,  
    SM_COURANTFACTOR = 4,  
    SM_MINSURFAREA   = 5,  
    SM_MINSLOPE      = 6,  
    SM_RUNOFFERROR   = 7,  
    SM_GWERROR       = 8,  
    SM_FLOWERROR     = 9,  
    SM_QUALERROR     = 10, 
    SM_HEADTOL       = 11, 
    SM_SYSFLOWTOL    = 12, 
    SM_LATFLOWTOL    = 13  
} SM_SimSetting;

typedef enum {
    SM_INVERTEL     = 0,  
    SM_FULLDEPTH    = 1,  
    SM_SURCHDEPTH   = 2,  
    SM_PONDAREA     = 3,  
    SM_INITDEPTH    = 4,  
} SM_NodeProperty;

typedef enum {
    SM_OFFSET1      = 0,  
    SM_OFFSET2      = 1,  
    SM_INITFLOW     = 2,  
    SM_FLOWLIMIT    = 3,  
    SM_INLETLOSS    = 4,  
    SM_OUTLETLOSS   = 5,  
    SM_AVELOSS      = 6,  
} SM_LinkProperty;

typedef enum {
    SM_WIDTH        = 0,  
    SM_AREA         = 1,  
    SM_FRACIMPERV   = 2,  
    SM_SLOPE        = 3,  
    SM_CURBLEN      = 4   
} SM_SubcProperty;

typedef enum {
    SM_TOTALINFLOW    = 0,  
    SM_TOTALOUTFLOW   = 1,  
    SM_LOSSES         = 2,  
    SM_NODEVOL        = 3,  
    SM_NODEFLOOD      = 4,  
    SM_NODEDEPTH      = 5,  
    SM_NODEHEAD       = 6,  
    SM_LATINFLOW      = 7   
} SM_NodeResult;

typedef enum {
    SM_LINKFLOW        = 0,  
    SM_LINKDEPTH       = 1,  
    SM_LINKVOL         = 2,  
    SM_USSURFAREA      = 3,  
    SM_DSSURFAREA      = 4,  
    SM_SETTING         = 5,  
    SM_TARGETSETTING   = 6,  
    SM_FROUDE          = 7   
} SM_LinkResult;

typedef enum {
    SM_SUBCRAIN      = 0,  
    SM_SUBCEVAP      = 1,  
    SM_SUBCINFIL     = 2,  
    SM_SUBCRUNON     = 3,  
    SM_SUBCRUNOFF    = 4,  
    SM_SUBCSNOW      = 5,  
} SM_SubcResult;

typedef enum {
    SM_BUILDUP      = 0,  
    SM_CPONDED      = 1,  
} SM_SubcPollut;

typedef enum {
    SM_TOTALPRECIP   = 0,  
    SM_RAINFALL      = 1,  
    SM_SNOWFALL      = 2   
} SM_GagePrecip;

typedef enum {
    SM_SURFACE      = 0,  
    SM_SOIL         = 1,  
    SM_STOR         = 2,  
    SM_PAVE         = 3,  
    SM_DRAIN        = 4,  
    SM_DRAINMAT     = 5,  
} SM_LidLayer;

typedef enum {
    SM_THICKNESS    = 0,  
    SM_VOIDFRAC     = 1,  
    SM_ROUGHNESS    = 2,  
    SM_SURFSLOPE    = 3,  
    SM_SIDESLOPE    = 4,  
    SM_ALPHA        = 5,  
    SM_POROSITY     = 6,  
    SM_FIELDCAP     = 7,  
    SM_WILTPOINT    = 8,  
    SM_SUCTION      = 9,  
    SM_KSAT         = 10, 
    SM_KSLOPE       = 11, 
    SM_CLOGFACTOR   = 12, 
    SM_IMPERVFRAC   = 13, 
    SM_COEFF        = 14, 
    SM_EXPON        = 15, 
    SM_OFFSET       = 16, 
    SM_DELAY        = 17, 
    SM_HOPEN        = 18, 
    SM_HCLOSE       = 19, 
    SM_QCURVE       = 20, 
    SM_REGENDAYS    = 21, 
    SM_REGENDEGREE  = 22, 
} SM_LidLayerProperty;

typedef enum {
    SM_UNITAREA     = 0,  
    SM_FWIDTH       = 1,  
    SM_BWIDTH       = 2,  
    SM_INITSAT      = 3,  
    SM_FROMIMPERV   = 4,  
    SM_FROMPERV     = 5,  
} SM_LidUProperty;

typedef enum {
    SM_INDEX        = 0,  
    SM_NUMBER       = 1,  
    SM_TOPERV       = 2,  
    SM_DRAINSUB     = 3,  
    SM_DRAINNODE    = 4,  
} SM_LidUOptions;

typedef enum {
    SM_INFLOW       = 0,  
    SM_EVAP         = 1,  
    SM_INFIL        = 2,  
    SM_SURFFLOW     = 3,  
    SM_DRAINFLOW    = 4,  
    SM_INITVOL      = 5,  
    SM_FINALVOL     = 6,  
    SM_SURFDEPTH    = 7,  
    SM_PAVEDEPTH    = 8,  
    SM_SOILMOIST    = 9,  
    SM_STORDEPTH    = 10, 
    SM_DRYTIME      = 11, 
    SM_OLDDRAINFLOW = 12, 
    SM_NEWDRAINFLOW = 13, 
    SM_PERVAREA     = 14, 
    SM_FLOWTOPERV   = 15, 
    SM_EVAPRATE     = 16, 
    SM_NATIVEINFIL  = 17, 
    SM_SURFINFLOW   = 18, 
    SM_SURFINFIL    = 19, 
    SM_SURFEVAP     = 20, 
    SM_SURFOUTFLOW  = 21, 
    SM_PAVEEVAP     = 22, 
    SM_PAVEPERC     = 23, 
    SM_SOILEVAP     = 24, 
    SM_SOILPERC     = 25, 
    SM_STORAGEINFLOW= 26, 
    SM_STORAGEEXFIL = 27, 
    SM_STORAGEEVAP  = 28, 
    SM_STORAGEDRAIN = 29, 
} SM_LidResult;

// --- Define the SWMM toolkit structures

typedef struct
{
   double        avgDepth;
   double        maxDepth;
   DateTime      maxDepthDate;
   double        maxRptDepth;
   double        volFlooded;
   double        timeFlooded;
   double        timeSurcharged;
   double        timeCourantCritical;
   double        totLatFlow;
   double        maxLatFlow;
   double        maxInflow;
   double        maxOverflow;
   double        maxPondedVol;
   DateTime      maxInflowDate;
   DateTime      maxOverflowDate;
}  SM_NodeStats;

typedef struct
{
   double        initVol;
   double        avgVol;
   double        maxVol;
   double        maxFlow;
   double        evapLosses;
   double        exfilLosses;
   DateTime      maxVolDate;
}  SM_StorageStats;

typedef struct
{
   double       avgFlow;
   double       maxFlow;
   double*      totalLoad;
   int          totalPeriods;
}  SM_OutfallStats;

typedef struct
{
   double        maxFlow;
   DateTime      maxFlowDate;
   double        maxVeloc;
   double        maxDepth;
   double        timeNormalFlow;
   double        timeInletControl;
   double        timeSurcharged;
   double        timeFullUpstream;
   double        timeFullDnstream;
   double        timeFullFlow;
   double        timeCapacityLimited;
   double        timeInFlowClass[7];
   double        timeCourantCritical;
   long          flowTurns;
   int           flowTurnSign;
}  SM_LinkStats;

typedef struct
{
   double       utilized;
   double       minFlow;
   double       avgFlow;
   double       maxFlow;
   double       volume;
   double       energy;
   double       offCurveLow;
   double       offCurveHigh;
   int          startUps;
   int          totalPeriods;
}  SM_PumpStats;

typedef struct
{
    double       precip;
    double       runon;
    double       evap;
    double       infil;
    double       runoff;
    double       maxFlow;
}  SM_SubcatchStats;

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;
}  SM_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;
}  SM_RunoffTotals;

void DLLEXPORT swmm_getAPIError(int errcode, char *s);

int DLLEXPORT swmm_project_findObject(int type, char *id, int *index);

int DLLEXPORT swmm_getSimulationUnit(int type, int *value);

int DLLEXPORT swmm_getSimulationAnalysisSetting(int type, int *value);

int DLLEXPORT swmm_getSimulationParam(int type, double *value);

int DLLEXPORT swmm_countObjects(int type, int *count);

int DLLEXPORT swmm_getObjectId(int type, int index, char *id);

int DLLEXPORT swmm_getObjectIndex(SM_ObjectType type, char *id, int *index);

int DLLEXPORT swmm_getNodeType(int index, int *Ntype);

int DLLEXPORT swmm_getLinkType(int index, int *Ltype);

int DLLEXPORT swmm_getLinkConnections(int index, int *Node1, int *Node2);

int DLLEXPORT swmm_getLinkDirection(int index, signed char *value);

int DLLEXPORT swmm_getSubcatchOutConnection(int index, int *type, int *out_index);

int DLLEXPORT swmm_getLidUCount(int index, int *value);

int DLLEXPORT swmm_getLidUParam(int index, int lidIndex, int Param, double *value);

int DLLEXPORT swmm_setLidUParam(int index, int lidIndex, int Param, double value);

int DLLEXPORT swmm_getLidUOption(int index, int lidIndex, int Param, int *value);

int DLLEXPORT swmm_setLidUOption(int index, int lidIndex, int Param, int value);

int DLLEXPORT swmm_getLidCOverflow(int lidControlIndex, char *condition);

int DLLEXPORT swmm_setLidCOverflow(int lidControlIndex, char condition);

int DLLEXPORT swmm_getLidCParam(int lidControlIndex, int layerIndex, int Param, double *value);

int DLLEXPORT swmm_setLidCParam(int lidControlIndex, int layerIndex, int Param, double value);

int DLLEXPORT swmm_getLidUFluxRates(int index, int lidIndex, int layerIndex, double *result);

int DLLEXPORT swmm_getLidGResult(int index, int type, double *result);

int DLLEXPORT swmm_getLidUResult(int index, int lidIndex, int type, double *result);

int DLLEXPORT swmm_getNodeParam(int index, int Param, double *value);

int DLLEXPORT swmm_setNodeParam(int index, int Param, double value);

int DLLEXPORT swmm_getLinkParam(int index, int Param, double *value);

int DLLEXPORT swmm_setLinkParam(int index, int Param, double value);

int DLLEXPORT swmm_getSubcatchParam(int index, int Param, double *value);

int DLLEXPORT swmm_setSubcatchParam(int index, int Param, double value);

int DLLEXPORT swmm_getSimulationDateTime(int timetype, int *year, int *month,
                                         int *day, int *hour, int *minute,
                                         int *second);

int DLLEXPORT swmm_setSimulationDateTime(int timetype, char *dtimestr);

int DLLEXPORT swmm_getCurrentDateTimeStr(char *dtimestr);

int DLLEXPORT swmm_getNodeResult(int index, int type, double *result);

int DLLEXPORT swmm_getLinkResult(int index, int type, double *result);

int DLLEXPORT swmm_getSubcatchResult(int index, int type, double *result);

int DLLEXPORT swmm_getSubcatchPollut(int index, int type, double **PollutArray);

int DLLEXPORT swmm_getGagePrecip(int index, double **GageArray);

int DLLEXPORT swmm_getNodeStats(int index, SM_NodeStats *nodeStats);

int DLLEXPORT swmm_getNodeTotalInflow(int index, double *value);

int DLLEXPORT swmm_getStorageStats(int index, SM_StorageStats *storageStats);

int DLLEXPORT swmm_getOutfallStats(int index, SM_OutfallStats *outfallStats);

void DLLEXPORT swmm_freeOutfallStats(SM_OutfallStats *outfallStats);

int DLLEXPORT swmm_getLinkStats(int index, SM_LinkStats *linkStats);

int DLLEXPORT swmm_getPumpStats(int index, SM_PumpStats *pumpStats);

int DLLEXPORT swmm_getSubcatchStats(int index, SM_SubcatchStats **subcatchStats);

int DLLEXPORT swmm_getSystemRoutingStats(SM_RoutingTotals *routingTot);

int DLLEXPORT swmm_getSystemRunoffStats(SM_RunoffTotals *runoffTot);

int DLLEXPORT swmm_setLinkSetting(int index, double setting);

int DLLEXPORT swmm_setNodeInflow(int index, double flowrate);

int DLLEXPORT swmm_setOutfallStage(int index, double stage);

int DLLEXPORT swmm_setGagePrecip(int index, double total_precip);

void DLLEXPORT freeArray(void** array);

#ifdef __cplusplus
}    // matches the linkage specification from above */
#endif


#endif