//-----------------------------------------------------------------------------
|
//
|
// epanet_output.c -- API for reading results from EPANET binary output file
|
//
|
// Version: 0.40
|
// Date 04/02/2019
|
// 09/06/2017
|
// 06/17/2016
|
// 08/05/2014
|
// 05/21/2014
|
//
|
// Author: Michael E. Tryby
|
// US EPA - ORD/NRMRL
|
//
|
// Modified: Maurizio Cingi
|
// University of Modena
|
//
|
// Purpose: Output API provides an interface for retrieving results from an
|
// EPANET binary output file.
|
//
|
// Output data in the binary file are aligned on a 4 byte word size.
|
// Therefore all values both integers and reals are 32 bits in length.
|
//
|
// All values returned by the output API are indexed from 0 to n-1. This
|
// differs from how node and link elements are indexed by the binary file
|
// writer found in EPANET. Times correspond to reporting periods are indexed
|
// from 0 to number of reporting periods minus one. Node and link elements
|
// are indexed from 0 to nodeCount minus one and 0 to linkCount minus one
|
// respectively.
|
//
|
// The Output API functions provide a convenient way to select "slices" of
|
// data from the output file. As such they return arrays of data. The API
|
// functions automatically allocate memory for the array to be returned. The
|
// caller is responsible for deallocating memory. The function ENR_free() is
|
// provided for that purpose.
|
//
|
//-----------------------------------------------------------------------------
|
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <string.h>
|
|
#include "util/errormanager.h"
|
#include "util/filemanager.h"
|
|
#include "epanet_output.h"
|
#include "messages.h"
|
|
|
// NOTE: These depend on machine data model and may change when porting
|
#define INT4 int // Must be a 4 byte / 32 bit integer type
|
#define REAL4 float // Must be a 4 byte / 32 bit real type
|
#define WORDSIZE 4 // Memory alignment 4 byte word size for both int and real
|
|
#define MINNREC 14 // Minimum allowable number of records
|
#define PROLOGUE 884 // Preliminary fixed length section of header
|
#define MAXID_P1 32 // EPANET max characters in ID name PLUS 1
|
#define MAXMSG_P1 80 // EPANET max characters in message text PLUS 1
|
|
#define NELEMENTTYPES 5 // Number of element types
|
#define NENERGYRESULTS 6 // Number of energy results
|
#define NNODERESULTS 4 // number of result fields for nodes
|
#define NLINKRESULTS 8 // number of result fields for links
|
#define NREACTRESULTS 4 // number of net reaction results
|
|
#define MEMCHECK(x) (((x) == NULL) ? 411 : 0 )
|
|
// Typedefs for opaque pointer
|
typedef struct data_s {
|
INT4 nodeCount, tankCount, linkCount, pumpCount, valveCount, nPeriods;
|
F_OFF outputStartPos; // starting file position of output data
|
F_OFF bytesPerPeriod; // bytes saved per simulation time period
|
|
error_handle_t *error_handle;
|
file_handle_t *file_handle;
|
} data_t;
|
|
//-----------------------------------------------------------------------------
|
// Local functions
|
//-----------------------------------------------------------------------------
|
void errorLookup(int errcode, char* errmsg, int length);
|
int validateFile(ENR_Handle);
|
float getNodeValue(ENR_Handle, int, int, int);
|
float getLinkValue(ENR_Handle, int, int, int);
|
|
float *newFloatArray(int n);
|
int *newIntArray(int n);
|
char *newCharArray(int n);
|
|
|
int EXPORT_OUT_API ENR_init(ENR_Handle *dp_handle)
|
// Purpose: Initialized pointer for the opaque ENR_Handle.
|
//
|
// Returns: Error code 0 on success, -1 on failure
|
//
|
// Note: The existence of this function has been carefully considered.
|
// Don't change it.
|
//
|
{
|
int errorcode = 0;
|
data_t* p_data;
|
|
// Allocate memory for private data
|
p_data = (data_t*)calloc(1, sizeof(data_t));
|
|
if (p_data != NULL){
|
p_data->error_handle = create_error_manager(&errorLookup);
|
p_data->file_handle = create_file_manager();
|
*dp_handle = p_data;
|
}
|
else
|
errorcode = -1;
|
|
// TODO: Need to handle errors during initialization better.
|
return errorcode;
|
}
|
|
int EXPORT_OUT_API ENR_close(ENR_Handle *p_handle)
|
/*------------------------------------------------------------------------
|
** Input: *p_handle = pointer to ENR_Handle struct
|
**
|
** Returns: Error code 0 on success, -1 on failure
|
**
|
** Purpose: Close the output binary file, dellocate ENR_Handle struc
|
** and nullify pointer to ENR_Handle struct
|
**
|
** NOTE: ENR_close must be called before program end
|
** after calling ENR_close data in ENR_Handle struct are no more
|
** accessible
|
**-------------------------------------------------------------------------
|
*/
|
{
|
data_t* p_data;
|
int errorcode = 0;
|
|
p_data = (data_t*)(*p_handle);
|
|
if (p_data == NULL || p_data->file_handle == NULL)
|
errorcode = -1;
|
|
else
|
{
|
close_file(p_data->file_handle);
|
|
delete_error_manager(p_data->error_handle);
|
delete_file_manager(p_data->file_handle);
|
|
free(p_data);
|
|
*p_handle = NULL;
|
}
|
|
return errorcode;
|
}
|
|
int EXPORT_OUT_API ENR_open(ENR_Handle p_handle, const char* path)
|
/*------------------------------------------------------------------------
|
** Input: path
|
** Output: p_handle = pointer to ENR_Handle struct
|
** Returns: warning / error code
|
** Purpose: Opens the output binary file and reads prologue and epilogue
|
**
|
** NOTE: ENR_init must be called before anyother ENR_* functions
|
**-------------------------------------------------------------------------
|
*/
|
{
|
int err, errorcode = 0;
|
F_OFF bytecount;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else
|
{
|
// Attempt to open binary output file for reading only
|
if ((open_file(p_data->file_handle, path, "rb")) != 0)
|
errorcode = 434;
|
|
// Perform checks to insure the file is valid
|
else if ((err = validateFile(p_data)) != 0) errorcode = err;
|
|
// If a warning is encountered read file header
|
if (errorcode < 400 ) {
|
// read network size
|
seek_file(p_data->file_handle, 2*WORDSIZE, SEEK_SET);
|
read_file(&(p_data->nodeCount), WORDSIZE, 1, p_data->file_handle);
|
read_file(&(p_data->tankCount), WORDSIZE, 1, p_data->file_handle);
|
read_file(&(p_data->linkCount), WORDSIZE, 1, p_data->file_handle);
|
read_file(&(p_data->pumpCount), WORDSIZE, 1, p_data->file_handle);
|
read_file(&(p_data->valveCount), WORDSIZE, 1, p_data->file_handle);
|
|
// Compute positions and offsets for retrieving data
|
// fixed portion of header + title section + filenames + chem names
|
bytecount = PROLOGUE;
|
// node names + link names
|
bytecount += MAXID_P1*p_data->nodeCount + MAXID_P1*p_data->linkCount;
|
// network connectivity + tank nodes + tank areas
|
bytecount += 3*WORDSIZE*p_data->linkCount + 2*WORDSIZE*p_data->tankCount;
|
// node elevations + link lengths and link diameters
|
bytecount += WORDSIZE*p_data->nodeCount + 2*WORDSIZE*p_data->linkCount;
|
// pump energy summary
|
bytecount += 7*WORDSIZE*p_data->pumpCount + WORDSIZE;
|
p_data->outputStartPos= bytecount;
|
|
p_data->bytesPerPeriod = NNODERESULTS*WORDSIZE*p_data->nodeCount +
|
NLINKRESULTS*WORDSIZE*p_data->linkCount;
|
}
|
}
|
// If error close the binary file
|
if (errorcode > 400) {
|
set_error(p_data->error_handle, errorcode);
|
ENR_close(&p_handle);
|
}
|
|
return errorcode;
|
}
|
|
int EXPORT_OUT_API ENR_getVersion(ENR_Handle p_handle, int* version)
|
/*------------------------------------------------------------------------
|
** Input: p_handle = pointer to ENR_Handle struct
|
** Output: version Epanet version
|
** Returns: error code
|
**
|
** Purpose: Returns Epanet version that wrote EBOFile
|
**--------------element codes-------------------------------------------
|
*/
|
{
|
int errorcode = 0;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else
|
{
|
seek_file(p_data->file_handle, 1*WORDSIZE, SEEK_SET);
|
if (read_file(version, WORDSIZE, 1, p_data->file_handle) != 1)
|
errorcode = 436;
|
}
|
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getNetSize(ENR_Handle p_handle, int** elementCount, int* length)
|
/*------------------------------------------------------------------------
|
** Input: p_handle = pointer to ENR_Handle struct
|
** Output: array of element counts (nodes, tanks, links, pumps, valves)
|
** Returns: error code
|
** Purpose: Returns an array of count values
|
**-------------------------------------------------------------------------
|
*/
|
{
|
int errorcode = 0;
|
int* temp = newIntArray(NELEMENTTYPES);
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else
|
{
|
temp[0] = p_data->nodeCount;
|
temp[1] = p_data->tankCount;
|
temp[2] = p_data->linkCount;
|
temp[3] = p_data->pumpCount;
|
temp[4] = p_data->valveCount;
|
|
*elementCount = temp;
|
*length = NELEMENTTYPES;
|
}
|
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getUnits(ENR_Handle p_handle, ENR_Units code, int* unitFlag)
|
/*------------------------------------------------------------------------
|
** Input: p_handle = pointer to ENR_Handle struct
|
** code
|
** Output: count
|
** Returns: unitFlag
|
** Purpose: Returns pressure or flow unit flag
|
**--------------pressure unit flags----------------------------------------
|
** 0 = psi
|
** 1 = meters
|
** 2 = kPa
|
**------------------flow unit flags----------------------------------------
|
** 0 = cubic feet/second
|
** 1 = gallons/minute
|
** 2 = million gallons/day
|
** 3 = Imperial million gallons/day
|
** 4 = acre-ft/day
|
** 5 = liters/second
|
** 6 = liters/minute
|
** 7 = megaliters/day
|
** 8 = cubic meters/hour
|
** 9 = cubic meters/day
|
**-------------------------------------------------------------------------
|
*/
|
{
|
int errorcode = 0;
|
F_OFF offset;
|
char temp[MAXID_P1];
|
data_t* p_data;
|
|
*unitFlag = -1;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else
|
{
|
switch (code)
|
{
|
case ENR_flowUnits:
|
seek_file(p_data->file_handle, 9*WORDSIZE, SEEK_SET);
|
read_file(unitFlag, WORDSIZE, 1, p_data->file_handle);
|
break;
|
|
case ENR_pressUnits:
|
seek_file(p_data->file_handle, 10*WORDSIZE, SEEK_SET);
|
read_file(unitFlag, WORDSIZE, 1, p_data->file_handle);
|
break;
|
|
case ENR_qualUnits:
|
offset = 7*WORDSIZE;
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(unitFlag, WORDSIZE, 1, p_data->file_handle);
|
|
if (*unitFlag == 0) *unitFlag = ENR_NONE;
|
|
else if (*unitFlag == 1) {
|
offset = 15*WORDSIZE + 3*MAXMSG_P1 + 2*(MAXFNAME+1) + MAXID_P1;
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(temp, MAXID_P1, 1, p_data->file_handle);
|
|
if (!strcmp(temp, "mg/L")) *unitFlag = ENR_MGL;
|
else *unitFlag = ENR_UGL;
|
}
|
|
else if (*unitFlag == 2) *unitFlag = ENR_HOURS;
|
|
else *unitFlag = ENR_PRCNT;
|
|
break;
|
|
default: errorcode = 421;
|
}
|
}
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getTimes(ENR_Handle p_handle, ENR_Time code, int* time)
|
/*------------------------------------------------------------------------
|
** Input: p_handle = pointer to ENR_Handle struct
|
** code = element code
|
** Output: time
|
** Returns: error code
|
** Purpose: Returns report and simulation time related parameters.
|
**-------------------------------------------------------------------------
|
*/
|
{
|
int errorcode = 0;
|
data_t* p_data;
|
|
*time = -1;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else
|
{
|
switch (code)
|
{
|
case ENR_reportStart:
|
seek_file(p_data->file_handle, 12*WORDSIZE, SEEK_SET);
|
read_file(time, WORDSIZE, 1, p_data->file_handle);
|
break;
|
|
case ENR_reportStep:
|
seek_file(p_data->file_handle, 13*WORDSIZE, SEEK_SET);
|
read_file(time, WORDSIZE, 1, p_data->file_handle);
|
break;
|
|
case ENR_simDuration:
|
seek_file(p_data->file_handle, 14*WORDSIZE, SEEK_SET);
|
read_file(time, WORDSIZE, 1, p_data->file_handle);
|
break;
|
|
case ENR_numPeriods:
|
*time = p_data->nPeriods;
|
break;
|
|
default:
|
errorcode = 421;
|
}
|
}
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getChemData(ENR_Handle p_handle, char** name, int* length)
|
{
|
return 0;
|
}
|
|
int EXPORT_OUT_API ENR_getElementName(ENR_Handle p_handle, ENR_ElementType type,
|
int elementIndex, char** name, int* length)
|
/*------------------------------------------------------------------------
|
** Input: p_handle = pointer to ENR_Handle struct
|
** type = ENR_node or ENR_link
|
** elementIndex from 1 to nodeCount or 1 to linkCount
|
** Output: name = elementName
|
** Returns: error code
|
** Purpose: Retrieves Name of a specified node or link element
|
** NOTE: 'name' must be able to hold MAXID characters
|
** TODO: Takes EPANET indexing from 1 to n not 0 to n-1
|
**-------------------------------------------------------------------------
|
*/
|
{
|
F_OFF offset;
|
int errorcode = 0;
|
char* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
/* Allocate memory for name */
|
else if MEMCHECK(temp = newCharArray(MAXID_P1)) errorcode = 411;
|
|
else
|
{
|
switch (type)
|
{
|
case ENR_node:
|
if (elementIndex < 1 || elementIndex > p_data->nodeCount)
|
errorcode = 423;
|
else offset = PROLOGUE + (elementIndex - 1)*MAXID_P1;
|
break;
|
|
case ENR_link:
|
if (elementIndex < 1 || elementIndex > p_data->linkCount)
|
errorcode = 423;
|
else
|
offset = PROLOGUE + p_data->nodeCount*MAXID_P1 +
|
(elementIndex - 1)*MAXID_P1;
|
break;
|
|
default:
|
errorcode = 421;
|
}
|
|
if (!errorcode)
|
{
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(temp, 1, MAXID_P1, p_data->file_handle);
|
|
*name = temp;
|
*length = MAXID_P1;
|
}
|
}
|
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getEnergyUsage(ENR_Handle p_handle, int pumpIndex,
|
int* linkIndex, float** outValues, int* length)
|
/*
|
* Purpose: Returns pump energy usage statistics.
|
*
|
* Energy usage statistics:
|
* 0 = pump utilization
|
* 1 = avg. efficiency
|
* 2 = avg. kW/flow
|
* 3 = avg. kwatts
|
* 4 = peak kwatts
|
* 5 = cost/day
|
*/
|
{
|
F_OFF offset;
|
int errorcode = 0;
|
float* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
// Check for valid pump index
|
else if (pumpIndex < 1 || pumpIndex > p_data->pumpCount) errorcode = 423;
|
// Check memory for outValues
|
else if MEMCHECK(temp = newFloatArray(NENERGYRESULTS)) errorcode = 411;
|
|
else
|
{
|
// Position offset to start of pump energy summary
|
offset = p_data->outputStartPos - (p_data->pumpCount*(WORDSIZE + 6*WORDSIZE) + WORDSIZE);
|
// Adjust offset by pump index
|
offset += (pumpIndex - 1)*(WORDSIZE + 6*WORDSIZE);
|
|
// Power summary is 1 int and 6 floats for each pump
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(linkIndex, WORDSIZE, 1, p_data->file_handle);
|
read_file(temp, WORDSIZE, 6, p_data->file_handle);
|
|
*outValues = temp;
|
*length = NENERGYRESULTS;
|
}
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getNetReacts(ENR_Handle p_handle, float** outValues, int* length)
|
/*
|
* Purpose: Returns network wide average reaction rates and average
|
* source mass inflow:
|
* 0 = bulk
|
* 1 = wall
|
* 2 = tank
|
* 3 = source
|
*/
|
{
|
F_OFF offset;
|
int errorcode = 0;
|
float* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
// Check memory for outValues
|
else if MEMCHECK(temp = newFloatArray(NREACTRESULTS)) errorcode = 411;
|
|
else
|
{
|
// Reaction summary is 4 floats located right before epilogue.
|
// This offset is relative to the end of the file.
|
offset = - 3*WORDSIZE - 4*WORDSIZE;
|
seek_file(p_data->file_handle, offset, SEEK_END);
|
read_file(temp, WORDSIZE, 4, p_data->file_handle);
|
|
*outValues = temp;
|
*length = NREACTRESULTS;
|
}
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
void EXPORT_OUT_API ENR_free(void** array)
|
//
|
// Purpose: Frees memory allocated by API calls
|
//
|
{
|
if (array != NULL) {
|
free(*array);
|
*array = NULL;
|
}
|
}
|
|
int EXPORT_OUT_API ENR_getNodeSeries(ENR_Handle p_handle, int nodeIndex, ENR_NodeAttribute attr,
|
int startPeriod, int endPeriod, float** outValueSeries, int* dim)
|
//
|
// Purpose: Get time series results for particular attribute. Specify series
|
// start and length using seriesStart and seriesLength respectively.
|
//
|
// NOTE: The node index argument corresponds to the EPANET node index from 1 to
|
// nnodes. The series returned is indexed from 0 to nperiods - 1.
|
//
|
{
|
int k, length, errorcode = 0;
|
float* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else if (nodeIndex < 1 || nodeIndex > p_data->nodeCount) errorcode = 423;
|
else if (startPeriod < 0 || endPeriod >= p_data->nPeriods ||
|
endPeriod <= startPeriod) errorcode = 422;
|
// Check memory for outValues
|
else if MEMCHECK(temp = newFloatArray(length = endPeriod - startPeriod)) errorcode = 411;
|
else
|
{
|
// loop over and build time series
|
for (k = 0; k < length; k++)
|
temp[k] = getNodeValue(p_handle, startPeriod + k,
|
nodeIndex, attr);
|
|
*outValueSeries = temp;
|
*dim = length;
|
}
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getLinkSeries(ENR_Handle p_handle, int linkIndex, ENR_LinkAttribute attr,
|
int startPeriod, int endPeriod, float** outValueSeries, int* dim)
|
//
|
// Purpose: Get time series results for particular attribute. Specify series
|
// start and length using seriesStart and seriesLength respectively.
|
//
|
// NOTE:
|
// The link index argument corresponds to the EPANET link index from 1 to
|
// nlinks. The series returned is indexed from 0 to nperiods - 1.
|
//
|
{
|
int k, length, errorcode = 0;
|
float* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else if (linkIndex < 1 || linkIndex > p_data->linkCount) errorcode = 423;
|
else if (startPeriod < 0 || endPeriod >= p_data->nPeriods ||
|
endPeriod <= startPeriod) errorcode = 422;
|
// Check memory for outValues
|
else if MEMCHECK(temp = newFloatArray(length = endPeriod - startPeriod)) errorcode = 411;
|
else
|
{
|
// loop over and build time series
|
for (k = 0; k < length; k++)
|
temp[k] = getLinkValue(p_handle, startPeriod + k, linkIndex, attr);
|
|
*outValueSeries = temp;
|
*dim = length;
|
}
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getNodeAttribute(ENR_Handle p_handle, int periodIndex,
|
ENR_NodeAttribute attr, float** outValueArray, int* length)
|
//
|
// Purpose:
|
// For all nodes at given time, get a particular attribute
|
//
|
// Returns:
|
// Error code
|
// OutValueArray of results is indexed from 0 to nodeCount
|
//
|
// Warning:
|
// Caller must free memory allocated for outValueArray
|
//
|
// NOTE:
|
// The array returned is indexed from 0 to nnodes - 1. So to access
|
// node values by their EPANET index, the index value must be
|
// decremented by one.
|
//
|
{
|
F_OFF offset;
|
int errorcode = 0;
|
float * temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
// if the time index is out of range return an error
|
else if (periodIndex < 0 || periodIndex >= p_data->nPeriods) errorcode = 422;
|
// Check memory for outValues
|
else if MEMCHECK(temp = newFloatArray(p_data->nodeCount)) errorcode = 411;
|
|
else
|
{
|
// calculate byte offset to start time for series
|
offset = p_data->outputStartPos + (periodIndex)*p_data->bytesPerPeriod;
|
// add offset for node and attribute
|
offset += ((attr - 1)*p_data->nodeCount)*WORDSIZE;
|
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(temp, WORDSIZE, p_data->nodeCount, p_data->file_handle);
|
|
*outValueArray = temp;
|
*length = p_data->nodeCount;
|
}
|
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getLinkAttribute(ENR_Handle p_handle, int periodIndex,
|
ENR_LinkAttribute attr, float** outValueArray, int* length)
|
//
|
// Purpose:
|
// For all links at given time, get a particular attribute
|
//
|
// Returns:
|
// Error code
|
// OutValueArray of results is indexed from 0 to linkCount
|
//
|
// Warning:
|
// Caller must free memory allocated for outValueArray
|
//
|
// NOTE:
|
// The array returned is indexed from 0 to nlinks - 1. So to access
|
// link values by their EPANET index, the index value must be
|
// decremented by one.
|
//
|
{
|
F_OFF offset;
|
int errorcode = 0;
|
float* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
// if the time index is out of range return an error
|
else if (periodIndex < 0 || periodIndex >= p_data->nPeriods) errorcode = 422;
|
// Check memory for outValues
|
else if MEMCHECK(temp = newFloatArray(p_data->linkCount)) errorcode = 411;
|
|
else
|
{
|
// calculate byte offset to start time for series
|
offset = p_data->outputStartPos + (periodIndex)*p_data->bytesPerPeriod
|
+ (NNODERESULTS*p_data->nodeCount)*WORDSIZE;
|
// add offset for link and attribute
|
offset += ((attr - 1)*p_data->linkCount)*WORDSIZE;
|
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(temp, WORDSIZE, p_data->linkCount, p_data->file_handle);
|
|
*outValueArray = temp;
|
*length = p_data->linkCount;
|
}
|
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getNodeResult(ENR_Handle p_handle, int periodIndex,
|
int nodeIndex, float** outValueArray, int* length)
|
//
|
// Purpose: For a node at given time, get all attributes.
|
//
|
// NOTE:
|
//
|
{
|
int j, errorcode = 0;
|
float* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else if (periodIndex < 0 || periodIndex >= p_data->nPeriods) errorcode = 422;
|
else if (nodeIndex < 1 || nodeIndex > p_data->nodeCount) errorcode = 423;
|
else if MEMCHECK(temp = newFloatArray(NNODERESULTS)) errorcode = 411;
|
else
|
{
|
for (j = 0; j < NNODERESULTS; j++)
|
temp[j] = getNodeValue(p_handle, periodIndex, nodeIndex, j);
|
|
*outValueArray = temp;
|
*length = NNODERESULTS;
|
}
|
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
int EXPORT_OUT_API ENR_getLinkResult(ENR_Handle p_handle, int periodIndex,
|
int linkIndex, float** outValueArray, int* length)
|
//
|
// Purpose: For a link at given time, get all attributes
|
//
|
{
|
int j, errorcode = 0;
|
float* temp;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
else if (periodIndex < 0 || periodIndex >= p_data->nPeriods) errorcode = 422;
|
else if (linkIndex < 1 || linkIndex > p_data->linkCount) errorcode = 423;
|
else if MEMCHECK(temp = newFloatArray(NLINKRESULTS)) errorcode = 411;
|
else
|
{
|
for (j = 0; j < NLINKRESULTS; j++)
|
temp[j] = getLinkValue(p_handle, periodIndex, linkIndex, j);
|
|
*outValueArray = temp;
|
*length = NLINKRESULTS;
|
}
|
return set_error(p_data->error_handle, errorcode);
|
}
|
|
void EXPORT_OUT_API ENR_clearError(ENR_Handle p_handle)
|
{
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
clear_error(p_data->error_handle);
|
}
|
|
int EXPORT_OUT_API ENR_checkError(ENR_Handle p_handle, char** msg_buffer)
|
{
|
data_t* p_data;
|
p_data = (data_t*)p_handle;
|
|
if (p_data == NULL) return -1;
|
|
return check_error(p_data->error_handle, msg_buffer);
|
}
|
|
|
void errorLookup(int errcode, char* dest_msg, int dest_len)
|
//
|
// Purpose: takes error code returns error message
|
//
|
{
|
const char* msg;
|
|
switch (errcode)
|
{
|
case 10: msg = WARN10;
|
break;
|
case 411: msg = ERR411;
|
break;
|
case 412: msg = ERR412;
|
break;
|
case 421: msg = ERR421;
|
break;
|
case 422: msg = ERR422;
|
break;
|
case 423: msg = ERR423;
|
break;
|
case 434: msg = ERR434;
|
break;
|
case 435: msg = ERR435;
|
break;
|
case 436: msg = ERR436;
|
break;
|
default: msg = ERRERR;
|
}
|
|
strncpy(dest_msg, msg, MSG_MAXLEN);
|
}
|
|
int validateFile(ENR_Handle p_handle)
|
// Returns:
|
// Error code: 435, 436
|
// Warning code: 10
|
{
|
INT4 magic1, magic2, hydcode;
|
int errorcode = 0;
|
F_OFF filepos;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
// Read magic number from beginning of file
|
seek_file(p_data->file_handle, 0L, SEEK_SET);
|
read_file(&magic1, WORDSIZE, 1, p_data->file_handle);
|
|
// Fast forward to end and read file epilogue
|
seek_file(p_data->file_handle, -3*WORDSIZE, SEEK_END);
|
read_file(&(p_data->nPeriods), WORDSIZE, 1, p_data->file_handle);
|
read_file(&hydcode, WORDSIZE, 1, p_data->file_handle);
|
read_file(&magic2, WORDSIZE, 1, p_data->file_handle);
|
|
filepos = tell_file(p_data->file_handle);
|
|
// Is the file an EPANET binary file?
|
if (magic1 != magic2) errorcode = 435;
|
// Does the binary file contain results?
|
else if (filepos < MINNREC*WORDSIZE || p_data->nPeriods == 0)
|
errorcode = 436;
|
// Issue warning if there were problems with the model run.
|
else if (hydcode != 0) errorcode = 10;
|
|
return errorcode;
|
}
|
|
float getNodeValue(ENR_Handle p_handle, int periodIndex, int nodeIndex,
|
int attr)
|
//
|
// Purpose: Retrieves an attribute value at a specified node and time
|
//
|
{
|
F_OFF offset;
|
REAL4 y;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
// calculate byte offset to start time for series
|
offset = p_data->outputStartPos + periodIndex*p_data->bytesPerPeriod;
|
// add byte position for attribute and node
|
offset += ((attr - 1)*p_data->nodeCount + (nodeIndex - 1))*WORDSIZE;
|
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(&y, WORDSIZE, 1, p_data->file_handle);
|
|
return y;
|
}
|
|
float getLinkValue(ENR_Handle p_handle, int periodIndex, int linkIndex,
|
int attr)
|
//
|
// Purpose: Retrieves an attribute value at a specified link and time
|
//
|
{
|
F_OFF offset;
|
REAL4 y;
|
data_t* p_data;
|
|
p_data = (data_t*)p_handle;
|
|
// Calculate byte offset to start time for series
|
offset = p_data->outputStartPos + periodIndex*p_data->bytesPerPeriod
|
+ (NNODERESULTS*p_data->nodeCount)*WORDSIZE;
|
// add byte position for attribute and link
|
offset += ((attr - 1)*p_data->linkCount + (linkIndex - 1))*WORDSIZE;
|
|
seek_file(p_data->file_handle, offset, SEEK_SET);
|
read_file(&y, WORDSIZE, 1, p_data->file_handle);
|
|
return y;
|
}
|
|
float* newFloatArray(int n)
|
//
|
// Warning: Caller must free memory allocated by this function.
|
//
|
{
|
return (float*) malloc((n)*sizeof(float));
|
}
|
|
int* newIntArray(int n)
|
//
|
// Warning: Caller must free memory allocated by this function.
|
//
|
{
|
return (int*) malloc((n)*sizeof(int));
|
}
|
|
char* newCharArray(int n)
|
//
|
// Warning: Caller must free memory allocated by this function.
|
//
|
{
|
return (char*) malloc((n)*sizeof(char));
|
}
|
