FileIO::SwmmInterface Class Reference

Detailed Description

Interface for reading files used within the Storm Water Management Model (SWMM) and converting the data therein into corresponding OGS data structures. SWMM distinguishes four different object types (defined in the SwmmObject enum):

• Subcatchments
• Nodes (or junctions)
• Links (or conduits)
• System Note that each object in a SWMM input file has a name. Each of the four object types has a (different) number of parameters. There can be an arbitrary number of nodes, links or subcatchments but only ever one system. The interface can convert the SWMM input data into a geometry or a (line-)mesh. For meshes, also output data can be added to nodes and elements. The interface also provides routines for returning data as vectors as well as convenience methods for outputting data into CSV files. CSV files will either contain all parameters for one object at all time steps or all parameters for all objects of a given type at one timestep.

Definition at line 55 of file SWMMInterface.h.

#include <SWMMInterface.h>

Classes
struct	Subcatchment

Public Member Functions
MeshLib::Mesh &	getMesh () const
	Returns the mesh generated from SWMM file content.
std::string	getArrayName (SwmmObject obj_type, std::size_t var_idx) const
	Returns the name of the data array for the given object type and parameter index.
std::vector< std::string >	getNames (SwmmObject obj_type) const
	Get all the object names for a given object type.
std::string	getName (SwmmObject obj_type, std::size_t idx) const
	Returns the Name for the indexed object of the given type (or an empty string if an error occurred).
std::size_t	getNumberOfObjects (SwmmObject obj_type) const
	Returns the number of objects of the given type.
std::size_t	getNumberOfParameters (SwmmObject obj_type) const
	Returns the number of parameters (incl. pollutants) of the given type.
std::size_t	getNumberOfTimeSteps () const
	Returns the number of time steps for the simulation results.
std::vector< double >	getArrayAtTimeStep (SwmmObject obj_type, std::size_t time_step, std::size_t var_idx) const
	Returns an array for a given variable at all nodes/links from a SWMM output file for a given time step.
std::vector< double >	getArrayForObject (SwmmObject obj_type, std::size_t obj_idx, std::size_t var_idx) const
	Returns an array for a given variable for one specific object from a SWMM output file for all time steps.
bool	getNodeCoordinateVectors (std::vector< double > &x, std::vector< double > &y, std::vector< double > &z) const
	Writes the node coordinates into double vectors for writing of CSV files.
bool	getLinkPointIds (std::vector< std::size_t > &inlets, std::vector< std::size_t > &outlets) const
	Writes the inlet- and outlet IDs for links into vectors for writing of CSV files.
bool	writeCsvForTimestep (std::string const &file_name, SwmmObject obj_type, std::size_t time_step) const
	Write a CSV file for all object of the given type at one time step.
bool	writeCsvForObject (std::string const &file_name, SwmmObject obj_type, std::size_t obj_idx) const
	Write a CSV file for one object of the given type for all time steps.
bool	existsSwmmOutputFile () const
	Checks if a SWMM output file exists for the current input.
	~SwmmInterface ()
	Destructor.

Static Public Member Functions
static std::unique_ptr< SwmmInterface >	create (std::string const &file_name)
static bool	addResultsToMesh (MeshLib::Mesh &mesh, SwmmObject const type, std::string const &vec_name, std::vector< double > const &data)
static bool	isSwmmInputFile (std::string const &inp_file_name)
	Checks if file is a SWMM input file.
static std::string	swmmObjectTypeToString (SwmmObject const obj_type)
	Returns a string with the name of the object type.
static bool	convertSwmmInputToGeometry (std::string const &inp_file_name, GeoLib::GEOObjects &geo_objects, bool add_subcatchments)
	Reading a SWMM input file and conversion into OGS geometry.

Private Member Functions
	SwmmInterface (std::string const &swmm_base_name)
	Constructor.
bool	readSwmmInputToLineMesh ()
	Reading a SWMM input file and creating an OGS line mesh. This is automatically called when the object is created.
bool	readNodeData (std::ifstream &in, std::vector< MeshLib::Node * > &nodes, std::map< std::string, std::size_t > const &name_id_map, std::vector< double > &max_depth, bool read_max_depth)
	Reads input information associated with nodes (elevation, depth, etc.)
bool	readLineElements (std::ifstream &in, std::vector< MeshLib::Element * > &elements, std::vector< MeshLib::Node * > const &nodes, std::map< std::string, std::size_t > const &name_id_map)
	Reads links/conduits and returns them as a vector of OGS line elements.
bool	readSubcatchments (std::ifstream &in, std::map< std::string, std::size_t > const &name_id_map)
	Reads subcatchment information.
bool	readPollutants (std::ifstream &in)
	Reads pollutant names and parameters.
std::string	getArrayName (SwmmObject obj_type, std::size_t var_idx, std::size_t n_pollutants) const
	Returns the name of an array (or an empty string if errors occurred)
bool	addRainGaugeTimeSeriesLocations (std::ifstream &in)
	Reads the location of external rain gauge time series files.
bool	matchSubcatchmentsWithPolygons (std::vector< GeoLib::Polyline * > const &lines, std::vector< std::string > const &names)
	Matches existing subcatchment names with subsequently read polylines marking the outlines of said subcatchments.
std::vector< std::string >	getSubcatchmentNameMap () const
	Creates a temporary string vector containing all subcatchment names in correct order.

Static Private Member Functions
template<typename T>
static bool	readCoordinates (std::ifstream &in, std::vector< T * > &points, std::vector< std::string > &names)
static bool	addPointElevation (std::ifstream &in, std::vector< GeoLib::Point * > &points, std::map< std::string, std::size_t > const &name_id_map)
	During geometry conversion, this adds elevation values to the existing point vector.
static bool	readLinksAsPolylines (std::ifstream &in, std::vector< GeoLib::Polyline * > &lines, std::vector< std::string > &line_names, std::vector< GeoLib::Point * > const &points, std::map< std::string, std::size_t > const &point_names)
	During geometry conversion, this reads links (conduits/pumps/weirs) and converts them into polylines.
static bool	readPolygons (std::ifstream &in, std::vector< GeoLib::Polyline * > &lines, std::vector< std::string > &line_names, std::vector< GeoLib::Point * > &points, std::vector< std::string > &pnt_names)
static bool	isSectionFinished (std::string const &str)
	Checks if the given line string is empty. Empty strings mark the end of sections in a SWMM input file.
static bool	isCommentLine (std::string const &str)
	Checks if the given line string is a comment line.

Private Attributes
std::string const	_base_name
	All files for a given SWMM simulation have the same base name.
std::vector< std::string >	_id_nodename_map
	Vector storing the names of all nodes/junctions.
std::vector< std::string >	_id_linkname_map
	Vector storing the names of all links/conduits.
std::vector< std::string >	_pollutant_names
	Vector storing the names of all pollutants.
std::vector< Subcatchment >	_subcatchments
	Vector storing information about all subcatchments.
std::vector< GeoLib::Point * >	_subcatchment_points
	Separate node vector containing points for defining subcatchment outlines.
std::vector< std::pair< GeoLib::Station, std::string > >	_rain_gauges
	Vector containing rain gauge information as well the position of external time series files.
std::unique_ptr< MeshLib::Mesh >	_mesh
	Mesh generated from SWMM input (+ optional output data)

Constructor & Destructor Documentation

~SwmmInterface()

FileIO::SwmmInterface::~SwmmInterface

(

)

Destructor.

Definition at line 108 of file SWMMInterface.cpp.

{
    for (Subcatchment& sc : _subcatchments)
        delete sc.outline;
 
    for (GeoLib::Point* pnt : _subcatchment_points)
        delete pnt;
}

References _subcatchment_points, and _subcatchments.

SwmmInterface()

FileIO::SwmmInterface::SwmmInterface ( std::string const & swmm_base_name )

private

Constructor.

Definition at line 103 of file SWMMInterface.cpp.

    : _base_name(swmm_base_name), _mesh(nullptr)
{
}

References _base_name, and _mesh.

Referenced by create().

Member Function Documentation

addPointElevation()

bool FileIO::SwmmInterface::addPointElevation ( std::ifstream & in, std::vector< GeoLib::Point * > & points, std::map< std::string, std::size_t > const & name_id_map )

staticprivate

During geometry conversion, this adds elevation values to the existing point vector.

Definition at line 260 of file SWMMInterface.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            return true;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> const split_str(BaseLib::splitString(line));
        // Junctions = 6, Outfalls = 4, Storage = 8
        if (split_str.size() < 4)
        {
            ERR("Format not recognised.");
            return false;
        }
        std::string const current_name(split_str[0]);
        auto const it = name_id_map.find(current_name);
        if (it == name_id_map.end())
        {
            ERR("SwmmInterface::addPointElevation(): Name {:s} not found in "
                "coordinates map.",
                current_name);
            return false;
        }
        std::size_t const id = it->second;
        (*points[id])[2] = BaseLib::str2number<double>(split_str[1]);
    }
    return true;
}

References ERR(), isCommentLine(), isSectionFinished(), BaseLib::splitString(), and BaseLib::str2number().

Referenced by convertSwmmInputToGeometry().

addRainGaugeTimeSeriesLocations()

bool FileIO::SwmmInterface::addRainGaugeTimeSeriesLocations ( std::ifstream & in )

private

Reads the location of external rain gauge time series files.

Definition at line 1224 of file SWMMInterface.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            break;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> const split_str(BaseLib::splitString(line));
        if (split_str.size() < 6)
        {
            ERR("Rain gauge parameter format not recognised.");
            return false;
        }
 
        for (auto& stn : _rain_gauges)
        {
            if (stn.first.getName() == split_str[0] && split_str[4] == "FILE")
                stn.second = split_str[5].substr(1, split_str[5].size() - 2);
        }
    }
 
    for (auto const& stn : _rain_gauges)
        if (stn.second.empty())
            WARN("No associated time series found for rain gauge '{:s}'.",
                 stn.first.getName());
    return true;
}

References _rain_gauges, ERR(), isCommentLine(), isSectionFinished(), BaseLib::splitString(), and WARN().

Referenced by readSwmmInputToLineMesh().

addResultsToMesh()

bool FileIO::SwmmInterface::addResultsToMesh ( MeshLib::Mesh & mesh, SwmmObject const type, std::string const & vec_name, std::vector< double > const & data )

static

If a mesh has already been created, this methods allows to add node- or link-arrays as property to that mesh. The data vectors can be created using the getArrayAtTimeStep() method.

Definition at line 983 of file SWMMInterface.cpp.

{
    if (!(swmm_type == SwmmObject::NODE || swmm_type == SwmmObject::LINK))
    {
        ERR("Information of this object type cannot be added to mesh.");
        return false;
    }
 
    if (data.empty())
    {
        ERR("Data array is empty and cannot be added to mesh.");
        return false;
    }
 
    if (swmm_type == SwmmObject::NODE && data.size() != mesh.getNumberOfNodes())
    {
        ERR("Number of mesh nodes ({:d}) does not match length of array "
            "({:d}).",
            mesh.getNumberOfNodes(), data.size());
        return false;
    }
 
    if (swmm_type == SwmmObject::LINK &&
        data.size() != mesh.getNumberOfElements())
    {
        ERR("Number of mesh elements ({:d}) does not match length of array "
            "({:d}).",
            mesh.getNumberOfElements(), data.size());
        return false;
    }
 
    MeshLib::MeshItemType const item_type = (swmm_type == SwmmObject::NODE)
                                                ? MeshLib::MeshItemType::Node
                                                : MeshLib::MeshItemType::Cell;
    MeshLib::PropertyVector<double>* prop =
        MeshLib::getOrCreateMeshProperty<double>(mesh, vec_name, item_type, 1);
    if (!prop)
    {
        ERR("Error fetching array '{:s}'.", vec_name);
        return false;
    }
    std::copy(data.cbegin(), data.cend(), prop->begin());
    return true;
}

References MeshLib::PropertyVector< PROP_VAL_TYPE >::begin(), MeshLib::Cell, ERR(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::getOrCreateMeshProperty(), FileIO::LINK, FileIO::NODE, and MeshLib::Node.

Referenced by addObjectsToMesh().

convertSwmmInputToGeometry()

bool FileIO::SwmmInterface::convertSwmmInputToGeometry ( std::string const & inp_file_name, GeoLib::GEOObjects & geo_objects, bool add_subcatchments )

static

Reading a SWMM input file and conversion into OGS geometry.

Definition at line 347 of file SWMMInterface.cpp.

{
    if (!isSwmmInputFile(inp_file_name))
        return false;
 
    std::ifstream in(inp_file_name.c_str());
    if (!in.is_open())
    {
        ERR("SWMMInterface: Could not open input file {:s}.", inp_file_name);
        return false;
    }
 
    std::vector<GeoLib::Point*> points;
    std::vector<GeoLib::Polyline*> lines;
    std::vector<std::string> pnt_names;
    std::vector<std::string> line_names;
 
    std::string geo_name =
        BaseLib::extractBaseNameWithoutExtension(inp_file_name);
    std::string line;
    while (std::getline(in, line))
    {
        if (line == "[COORDINATES]" || line == "[VERTICES]" ||
            line == "[SYMBOLS]")
        {
            INFO("Reading {:s}...", line);
            if (!readCoordinates<GeoLib::Point>(in, points, pnt_names))
            {
                BaseLib::cleanupVectorElements(points, lines);
                return false;
            }
        }
        if (line == "[Polygons]" && add_subcatchments)
        {
            INFO("Reading {:s}...", line);
            if (!readPolygons(in, lines, line_names, points, pnt_names))
            {
                BaseLib::cleanupVectorElements(points, lines);
                return false;
            }
        }
    }
 
    if (points.empty())
    {
        ERR("No points found in file");
        return false;
    }
    if (points.size() != pnt_names.size())
    {
        ERR("Length of point vector and point name vector do not match.");
        BaseLib::cleanupVectorElements(points, lines);
        return false;
    }
 
    GeoLib::PointVec::NameIdMap name_id_map;
    {
        std::size_t const n_names(pnt_names.size());
        for (std::size_t i = 0; i < n_names; ++i)
        {
            if (!pnt_names[i].empty())
                name_id_map.insert(std::make_pair(pnt_names[i], i));
        }
    }
 
    // rewind stream and read links between junctions
    in.clear();
    in.seekg(0, in.beg);
 
    while (std::getline(in, line))
    {
        if (line == "[JUNCTIONS]" || line == "[OUTFALLS]" ||
            line == "[STORAGE]")
        {
            INFO("Reading {:s} elevation...", line);
            if (!addPointElevation(in, points, name_id_map))
            {
                BaseLib::cleanupVectorElements(points, lines);
                return false;
            }
        }
        if (line == "[CONDUITS]")
        {
            INFO("Reading conduits...");
            if (!readLinksAsPolylines(in, lines, line_names, points,
                                      name_id_map))
            {
                BaseLib::cleanupVectorElements(points, lines);
                return false;
            }
        }
        else if (line == "[PUMPS]")
        {
            INFO("Reading pumps...");
            if (!readLinksAsPolylines(in, lines, line_names, points,
                                      name_id_map))
            {
                BaseLib::cleanupVectorElements(points, lines);
                return false;
            }
        }
        else if (line == "[WEIRS]")
        {
            INFO("Reading weirs...");
            if (!readLinksAsPolylines(in, lines, line_names, points,
                                      name_id_map))
            {
                BaseLib::cleanupVectorElements(points, lines);
                return false;
            }
        }
    }
 
    geo_objects.addPointVec(std::move(points), geo_name,
                            std::move(name_id_map));
    if (!lines.empty())
    {
        if (lines.size() != line_names.size())
        {
            ERR("Length of line vector and line name vector do not match.");
            geo_objects.removePointVec(geo_name);
            for (auto ply : lines)
                delete ply;
            return false;
        }
        GeoLib::PolylineVec::NameIdMap line_id_map;
        {
            std::size_t const n_names(line_names.size());
            for (std::size_t i = 0; i < n_names; ++i)
            {
                line_id_map.insert(std::make_pair(line_names[i], i));
            }
        }
        std::vector<std::size_t> const& pnt_id_map(
            geo_objects.getPointVecObj(geo_name)->getIDMap());
        for (GeoLib::Polyline* polyline : lines)
        {
            for (std::size_t i = 0; i < polyline->getNumberOfPoints(); ++i)
            {
                polyline->setPointID(i, pnt_id_map[polyline->getPointID(i)]);
                if (i > 0 &&
                    polyline->getPointID(i - 1) == polyline->getPointID(i))
                {
                    polyline->removePoint(i);
                    i--;
                }
            }
            if (polyline->getPointID(0) ==
                polyline->getPointID(polyline->getNumberOfPoints() - 1))
            {
                polyline->removePoint(polyline->getNumberOfPoints() - 1);
                polyline->addPoint(polyline->getPointID(0));
            }
        }
        geo_objects.addPolylineVec(std::move(lines), geo_name,
                                   std::move(line_id_map));
    }
    return true;
}

References addPointElevation(), GeoLib::GEOObjects::addPointVec(), GeoLib::GEOObjects::addPolylineVec(), BaseLib::cleanupVectorElements(), ERR(), BaseLib::extractBaseNameWithoutExtension(), GeoLib::PointVec::getIDMap(), GeoLib::GEOObjects::getPointVecObj(), INFO(), isSwmmInputFile(), readCoordinates(), readLinksAsPolylines(), readPolygons(), and GeoLib::GEOObjects::removePointVec().

Referenced by writeGeoOutput().

create()

std::unique_ptr< SwmmInterface > FileIO::SwmmInterface::create ( std::string const & file_name )

static

Basic method to create the interface (containing a mesh) from a SWMM file Other non-static methods rely on this being called in the beginning.

Definition at line 80 of file SWMMInterface.cpp.

{
    // The input/output methods take a base name and check if the corresponding
    // i/o file for that base name exists. This check takes any swmm project
    // file, i.e. [base name].[extension] which needs to be at least 5 chars
    // because the extension is always 3 chars.
    if (file_name.length() < 5)
        return nullptr;
 
    if (!SwmmInterface::isSwmmInputFile(file_name))
        return nullptr;
 
    std::string const base_name(file_name.substr(0, file_name.length() - 4));
    SwmmInterface* swmm = new SwmmInterface(base_name);
    if (swmm->readSwmmInputToLineMesh())
        return std::unique_ptr<SwmmInterface>(swmm);
 
    ERR("Error creating mesh from SWMM file.");
    delete swmm;
    return nullptr;
}

References SwmmInterface(), ERR(), isSwmmInputFile(), and readSwmmInputToLineMesh().

Referenced by writeCsvOutput(), and writeMeshOutput().

existsSwmmOutputFile()

bool FileIO::SwmmInterface::existsSwmmOutputFile

(

)

const

Checks if a SWMM output file exists for the current input.

Definition at line 161 of file SWMMInterface.cpp.

{
    std::string const outfile(_base_name + ".out");
    if (OpenSwmmOutFile(const_cast<char*>(outfile.c_str())) != 0)
        return false;
    return true;
}

References _base_name.

getArrayAtTimeStep()

std::vector< double > FileIO::SwmmInterface::getArrayAtTimeStep	(	SwmmObject	obj_type,
		std::size_t	time_step,
		std::size_t	var_idx ) const

Returns an array for a given variable at all nodes/links from a SWMM output file for a given time step.

Definition at line 1031 of file SWMMInterface.cpp.

{
    std::vector<double> data;
    std::string const outfile(_base_name + ".out");
    if (OpenSwmmOutFile(const_cast<char*>(outfile.c_str())) != 0)
        return data;
 
    if (time_step >= SWMM_Nperiods)
    {
        ERR("Time step {:d} not available, file contains only {:d} periods.",
            time_step, SWMM_Nperiods);
        return data;
    }
 
    bool is_var_idx_okay = true;
    int obj_type_id;
    std::size_t n_objects;
    switch (obj_type)
    {
        case SwmmObject::SUBCATCHMENT:
            obj_type_id = 0;
            n_objects = SWMM_Nsubcatch;
            if (var_idx > (n_obj_params[obj_type_id] - 1 + SWMM_Npolluts))
                is_var_idx_okay = false;
            break;
        case SwmmObject::NODE:
            obj_type_id = 1;
            n_objects = SWMM_Nnodes;
            if (var_idx > (n_obj_params[obj_type_id] + SWMM_Npolluts))
                is_var_idx_okay = false;
            break;
        case SwmmObject::LINK:
            obj_type_id = 2;
            n_objects = SWMM_Nlinks;
            if (var_idx > (n_obj_params[obj_type_id] + SWMM_Npolluts))
                is_var_idx_okay = false;
            break;
        case SwmmObject::SYSTEM:
            obj_type_id = 3;
            n_objects = 1;
            if (var_idx > n_obj_params[obj_type_id])
                is_var_idx_okay = false;
            break;
        default:
            ERR("Object type not recognised.");
            CloseSwmmOutFile();
            return data;
    }
 
    if (!is_var_idx_okay)
    {
        ERR("Requested variable does not exist.");
        CloseSwmmOutFile();
        return data;
    }
 
    INFO("Fetching '{:s}'-data for time step {:d}...",
         getArrayName(obj_type, var_idx, SWMM_Npolluts), time_step);
 
    for (std::size_t i = 0; i < n_objects; ++i)
    {
        float val;
        GetSwmmResult(obj_type_id, i, var_idx, time_step, &val);
        data.push_back(static_cast<double>(val));
    }
 
    CloseSwmmOutFile();
    return data;
}

References _base_name, ERR(), getArrayName(), INFO(), FileIO::LINK, FileIO::n_obj_params, FileIO::NODE, FileIO::SUBCATCHMENT, and FileIO::SYSTEM.

Referenced by addObjectsToMesh(), and writeCsvForTimestep().

getArrayForObject()

std::vector< double > FileIO::SwmmInterface::getArrayForObject	(	SwmmObject	obj_type,
		std::size_t	obj_idx,
		std::size_t	var_idx ) const

Returns an array for a given variable for one specific object from a SWMM output file for all time steps.

Definition at line 1103 of file SWMMInterface.cpp.

{
    std::vector<double> data;
    std::string const outfile(_base_name + ".out");
    if (OpenSwmmOutFile(const_cast<char*>(outfile.c_str())) != 0)
        return data;
 
    bool is_var_idx_okay = true;
    bool is_obj_idx_okay = true;
    int obj_type_id;
    switch (obj_type)
    {
        case SwmmObject::SUBCATCHMENT:
            obj_type_id = 0;
            if (obj_idx >= SWMM_Nsubcatch)
                is_obj_idx_okay = false;
            if (var_idx > (n_obj_params[obj_type_id] + SWMM_Npolluts))
                is_var_idx_okay = false;
            break;
        case SwmmObject::NODE:
            obj_type_id = 1;
            if (obj_idx >= SWMM_Nnodes)
                is_obj_idx_okay = false;
            if (var_idx > (n_obj_params[obj_type_id] + SWMM_Npolluts))
                is_var_idx_okay = false;
            break;
        case SwmmObject::LINK:
            obj_type_id = 2;
            if (obj_idx >= SWMM_Nlinks)
                is_obj_idx_okay = false;
            if (var_idx > (n_obj_params[obj_type_id] + SWMM_Npolluts))
                is_var_idx_okay = false;
            break;
        case SwmmObject::SYSTEM:
            obj_type_id = 3;
            if (obj_idx >= 1)
                is_obj_idx_okay = false;
            if (var_idx > n_obj_params[obj_type_id])
                is_var_idx_okay = false;
            break;
        default:
            ERR("Object type not recognised.");
            CloseSwmmOutFile();
            return data;
    }
 
    if (!is_obj_idx_okay)
    {
        ERR("Requested object index does not exist.");
        CloseSwmmOutFile();
        return data;
    }
 
    if (!is_var_idx_okay)
    {
        ERR("Requested variable does not exist.");
        CloseSwmmOutFile();
        return data;
    }
 
    std::size_t const n_time_steps(static_cast<std::size_t>(SWMM_Nperiods));
    for (std::size_t i = 0; i < n_time_steps; ++i)
    {
        float val;
        GetSwmmResult(obj_type_id, obj_idx, var_idx, i, &val);
        data.push_back(static_cast<double>(val));
    }
 
    CloseSwmmOutFile();
    return data;
}

References _base_name, ERR(), FileIO::LINK, FileIO::n_obj_params, FileIO::NODE, FileIO::SUBCATCHMENT, and FileIO::SYSTEM.

Referenced by writeCsvForObject().

getArrayName() [1/2]

std::string FileIO::SwmmInterface::getArrayName	(	SwmmObject	obj_type,
		std::size_t	var_idx ) const

Returns the name of the data array for the given object type and parameter index.

Definition at line 1177 of file SWMMInterface.cpp.

{
    std::string const outfile(_base_name + ".out");
    if (OpenSwmmOutFile(const_cast<char*>(outfile.c_str())) != 0)
        return std::string("");
 
    std::string const name = getArrayName(obj_type, var_idx, SWMM_Npolluts);
    CloseSwmmOutFile();
    return name;
}

References _base_name, and getArrayName().

Referenced by addObjectsToMesh(), getArrayAtTimeStep(), getArrayName(), writeCsvForObject(), and writeCsvForTimestep().

getArrayName() [2/2]

std::string FileIO::SwmmInterface::getArrayName ( SwmmObject obj_type, std::size_t var_idx, std::size_t n_pollutants ) const

private

Returns the name of an array (or an empty string if errors occurred)

Definition at line 1189 of file SWMMInterface.cpp.

{
    if (obj_type == SwmmObject::SUBCATCHMENT)
    {
        if (var_idx < n_obj_params[0])
            return subcatchment_vars[var_idx];
        if (var_idx < n_obj_params[0] + n_pollutants)
            return _pollutant_names[var_idx - n_obj_params[0]];
    }
    if (obj_type == SwmmObject::NODE)
    {
        if (var_idx < n_obj_params[1])
            return node_vars[var_idx];
        if (var_idx < n_obj_params[1] + n_pollutants)
            return std::string("Node_" +
                               _pollutant_names[var_idx - n_obj_params[1]]);
    }
    if (obj_type == SwmmObject::LINK)
    {
        if (var_idx < n_obj_params[2])
            return link_vars[var_idx];
        if (var_idx < n_obj_params[2] + n_pollutants)
            return std::string("Link_" +
                               _pollutant_names[var_idx - n_obj_params[2]]);
    }
    if (obj_type == SwmmObject::SYSTEM && var_idx < n_obj_params[3])
    {
        return system_vars[var_idx];
    }
    ERR("SwmmInterface::getArrayName() - Index error, no name found.");
    return std::string("");
}

References _pollutant_names, ERR(), FileIO::LINK, FileIO::link_vars, FileIO::n_obj_params, FileIO::NODE, FileIO::node_vars, FileIO::SUBCATCHMENT, FileIO::subcatchment_vars, FileIO::SYSTEM, and FileIO::system_vars.

getLinkPointIds()

bool FileIO::SwmmInterface::getLinkPointIds	(	std::vector< std::size_t > &	inlets,
		std::vector< std::size_t > &	outlets ) const

Writes the inlet- and outlet IDs for links into vectors for writing of CSV files.

Definition at line 1309 of file SWMMInterface.cpp.

{
    std::vector<MeshLib::Element*> const& elements(_mesh->getElements());
    for (MeshLib::Element const* const elem : elements)
    {
        if (elem->getGeomType() != MeshLib::MeshElemType::LINE)
        {
            ERR("Non line-element found in mesh.");
            return false;
        }
        inlets.push_back(getNodeIndex(*elem, 0));
        outlets.push_back(getNodeIndex(*elem, 1));
    }
    return true;
}

References _mesh, ERR(), and MeshLib::LINE.

getMesh()

MeshLib::Mesh & FileIO::SwmmInterface::getMesh ( ) const

inline

Returns the mesh generated from SWMM file content.

Definition at line 68 of file SWMMInterface.h.

{ return *_mesh; }

References _mesh.

getName()

std::string FileIO::SwmmInterface::getName	(	SwmmObject	obj_type,
		std::size_t	idx ) const

Returns the Name for the indexed object of the given type (or an empty string if an error occurred).

Definition at line 900 of file SWMMInterface.cpp.

{
    switch (obj_type)
    {
        case SwmmObject::NODE:
            if (idx < _id_nodename_map.size())
                return _id_nodename_map[idx];
        case SwmmObject::LINK:
            if (idx < _id_linkname_map.size())
                return _id_linkname_map[idx];
        case SwmmObject::SUBCATCHMENT:
            if (idx < _subcatchments.size())
                return _subcatchments[idx].name;
        case SwmmObject::SYSTEM:
            if (idx == 0)
                return std::string("System");
    }
    ERR("Index out of bounds.");
    return std::string("");
}

References _id_linkname_map, _id_nodename_map, _subcatchments, ERR(), FileIO::LINK, FileIO::NODE, FileIO::SUBCATCHMENT, and FileIO::SYSTEM.

Referenced by writeObjectsOfSwmmTypeToCsv().

getNames()

std::vector< std::string > FileIO::SwmmInterface::getNames

(

SwmmObject

obj_type

)

const

Get all the object names for a given object type.

Definition at line 881 of file SWMMInterface.cpp.

{
    switch (obj_type)
    {
        case SwmmObject::NODE:
            return _id_nodename_map;
        case SwmmObject::LINK:
            return _id_linkname_map;
        case SwmmObject::SUBCATCHMENT:
            return getSubcatchmentNameMap();
        case SwmmObject::SYSTEM:
            std::vector<std::string> system_name{"System"};
            return system_name;
    }
    ERR("Object type has no name map");
    std::vector<std::string> empty_vec;
    return empty_vec;
}

References _id_linkname_map, _id_nodename_map, ERR(), getSubcatchmentNameMap(), FileIO::LINK, FileIO::NODE, FileIO::SUBCATCHMENT, and FileIO::SYSTEM.

Referenced by writeCsvForTimestep().

getNodeCoordinateVectors()

bool FileIO::SwmmInterface::getNodeCoordinateVectors	(	std::vector< double > &	x,
		std::vector< double > &	y,
		std::vector< double > &	z ) const

Writes the node coordinates into double vectors for writing of CSV files.

Definition at line 1295 of file SWMMInterface.cpp.

{
    std::vector<MeshLib::Node*> const& nodes(_mesh->getNodes());
    for (MeshLib::Node const* const node : nodes)
    {
        x.push_back((*node)[0]);
        y.push_back((*node)[1]);
        z.push_back((*node)[2]);
    }
    return true;
}

References _mesh.

getNumberOfObjects()

std::size_t FileIO::SwmmInterface::getNumberOfObjects

(

SwmmObject

obj_type

)

const

Returns the number of objects of the given type.

Definition at line 921 of file SWMMInterface.cpp.

{
    std::string const outfile(_base_name + ".out");
    if (OpenSwmmOutFile(const_cast<char*>(outfile.c_str())) != 0)
        return 0;
 
    switch (obj_type)
    {
        case SwmmObject::SUBCATCHMENT:
            return SWMM_Nsubcatch;
        case SwmmObject::NODE:
            return SWMM_Nnodes;
        case SwmmObject::LINK:
            return SWMM_Nlinks;
        case SwmmObject::SYSTEM:
            return 1;
        default:
            ERR("Object type not recognised.");
    }
    CloseSwmmOutFile();
    return 0;
}

References _base_name, ERR(), FileIO::LINK, FileIO::NODE, FileIO::SUBCATCHMENT, and FileIO::SYSTEM.

Referenced by writeCsvForTimestep(), and writeObjectsOfSwmmTypeToCsv().

getNumberOfParameters()

std::size_t FileIO::SwmmInterface::getNumberOfParameters

(

SwmmObject

obj_type

)

const

Returns the number of parameters (incl. pollutants) of the given type.

Definition at line 944 of file SWMMInterface.cpp.

{
    std::string const outfile(_base_name + ".out");
    std::size_t n_time_steps(std::numeric_limits<std::size_t>::max());
    if (OpenSwmmOutFile(const_cast<char*>(outfile.c_str())) != 0)
        return 0;
 
    std::size_t n_params(0);
    switch (obj_type)
    {
        case SwmmObject::SUBCATCHMENT:
            n_params = n_obj_params[0] + SWMM_Npolluts;
            break;
        case SwmmObject::NODE:
            n_params = n_obj_params[1] + SWMM_Npolluts;
            break;
        case SwmmObject::LINK:
            n_params = n_obj_params[2] + SWMM_Npolluts;
            break;
        case SwmmObject::SYSTEM:
            n_params = n_obj_params[3];
            break;
        default:
            ERR("Object type not recognised.");
    }
    CloseSwmmOutFile();
    return n_params;
}

References _base_name, ERR(), FileIO::LINK, FileIO::n_obj_params, FileIO::NODE, FileIO::SUBCATCHMENT, and FileIO::SYSTEM.

Referenced by addObjectsToMesh(), writeCsvForObject(), and writeCsvForTimestep().

getNumberOfTimeSteps()

std::size_t FileIO::SwmmInterface::getNumberOfTimeSteps

(

)

const

Returns the number of time steps for the simulation results.

Definition at line 973 of file SWMMInterface.cpp.

{
    std::string const outfile(_base_name + ".out");
    if (OpenSwmmOutFile(const_cast<char*>(outfile.c_str())) != 0)
        return std::numeric_limits<std::size_t>::max();
    std::size_t const n_time_steps(static_cast<std::size_t>(SWMM_Nperiods));
    CloseSwmmOutFile();
    return n_time_steps;
}

References _base_name.

Referenced by writeCsvForObject().

getSubcatchmentNameMap()

std::vector< std::string > FileIO::SwmmInterface::getSubcatchmentNameMap ( ) const

private

Creates a temporary string vector containing all subcatchment names in correct order.

Definition at line 871 of file SWMMInterface.cpp.

{
    std::vector<std::string> names;
    names.reserve(_subcatchments.size());
    std::transform(_subcatchments.begin(), _subcatchments.end(),
                   std::back_inserter(names),
                   [](auto const& sc) { return sc.name; });
    return names;
}

References _subcatchments.

Referenced by getNames().

isCommentLine()

bool FileIO::SwmmInterface::isCommentLine ( std::string const & str )

staticprivate

Checks if the given line string is a comment line.

Definition at line 1290 of file SWMMInterface.cpp.

{
    return (str.compare(str.find_first_not_of(' ', 0), 1, ";") == 0);
}

Referenced by addPointElevation(), addRainGaugeTimeSeriesLocations(), isSwmmInputFile(), readCoordinates(), readLineElements(), readLinksAsPolylines(), readNodeData(), readPollutants(), readPolygons(), and readSubcatchments().

isSectionFinished()

bool FileIO::SwmmInterface::isSectionFinished ( std::string const & str )

staticprivate

Checks if the given line string is empty. Empty strings mark the end of sections in a SWMM input file.

Definition at line 1278 of file SWMMInterface.cpp.

{
    if (str.empty())
        return true;
 
    std::size_t const pos_beg = str.find_first_not_of(' ', 0);
    if (pos_beg == str.find_first_of(" \n", pos_beg))
        return true;
 
    return false;
}

Referenced by addPointElevation(), addRainGaugeTimeSeriesLocations(), readCoordinates(), readLineElements(), readLinksAsPolylines(), readNodeData(), readPollutants(), readPolygons(), and readSubcatchments().

isSwmmInputFile()

bool FileIO::SwmmInterface::isSwmmInputFile ( std::string const & inp_file_name )

static

Checks if file is a SWMM input file.

Definition at line 117 of file SWMMInterface.cpp.

{
    if (!boost::iequals(BaseLib::getFileExtension(inp_file_name), ".inp"))
    {
        ERR("SWMMInterface: {:s} is not a SWMM input file.", inp_file_name);
        return false;
    }
 
    std::ifstream in(inp_file_name.c_str());
    if (!in.is_open())
    {
        ERR("SWMMInterface: Could not open input file {:s}.", inp_file_name);
        return false;
    }
 
    std::string line;
    bool header_found(false);
    std::size_t pos_end(0);
    while (!header_found)
    {
        if (!std::getline(in, line))
            return false;
 
        std::size_t const pos_beg = line.find_first_not_of(' ', pos_end);
        pos_end = line.find_first_of(" \n", pos_beg);
 
        // skip empty or comment lines at the beginning of the file
        if (line.empty() || pos_beg == pos_end || isCommentLine(line))
            continue;
 
        if (line == "[TITLE]")
            header_found = true;
        else
        {
            INFO("SWMMInterface: input file type {:s} not recognised.",
                 BaseLib::getFileExtension(inp_file_name));
            return false;
        }
    }
 
    in.close();
    return true;
}

References ERR(), BaseLib::getFileExtension(), INFO(), and isCommentLine().

Referenced by convertSwmmInputToGeometry(), create(), and readSwmmInputToLineMesh().

matchSubcatchmentsWithPolygons()

bool FileIO::SwmmInterface::matchSubcatchmentsWithPolygons ( std::vector< GeoLib::Polyline * > const & lines, std::vector< std::string > const & names )

private

Matches existing subcatchment names with subsequently read polylines marking the outlines of said subcatchments.

Definition at line 838 of file SWMMInterface.cpp.

{
    std::size_t const n_lines(lines.size());
    std::size_t const n_subcatchments(_subcatchments.size());
 
    if (n_lines != n_subcatchments)
    {
        ERR("Number of subcatchments does not match number of outlines.");
        return false;
    }
    for (std::size_t i = 0; i < n_lines; ++i)
    {
        bool found = false;
        for (std::size_t j = 0; j < n_subcatchments; ++j)
        {
            if (names[i] == _subcatchments[j].name)
            {
                _subcatchments[j].outline = lines[i];
                found = true;
                break;
            }
        }
        if (found == false)
        {
            ERR("No match in subcatcments for outline '{:s}'.", names[i]);
            return false;
        }
    }
    return true;
}

References _subcatchments, and ERR().

Referenced by readSwmmInputToLineMesh().

readCoordinates()

template<typename T>

bool FileIO::SwmmInterface::readCoordinates ( std::ifstream & in, std::vector< T * > & points, std::vector< std::string > & names )

staticprivate

Reading points from SWMM input file and converting them into OGS point-type vector. This method is shared by geometry- and mesh conversion.

Definition at line 170 of file SWMMInterface.cpp.

{
    std::size_t id(points.size());
    std::string line;
 
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            return true;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> split_str(BaseLib::splitString(line));
        if (split_str.size() != 3)
        {
            ERR("Format not recognised.");
            return false;
        }
        names.push_back(split_str[0]);
 
        double const x = BaseLib::str2number<double>(split_str[1]);
        double const y = BaseLib::str2number<double>(split_str[2]);
        T* pnt = new T(x, y, 0, id);
        points.push_back(pnt);
        id++;
    }
    return true;
}

References ERR(), isCommentLine(), isSectionFinished(), BaseLib::splitString(), and BaseLib::str2number().

Referenced by convertSwmmInputToGeometry(), and readSwmmInputToLineMesh().

readLineElements()

bool FileIO::SwmmInterface::readLineElements ( std::ifstream & in, std::vector< MeshLib::Element * > & elements, std::vector< MeshLib::Node * > const & nodes, std::map< std::string, std::size_t > const & name_id_map )

private

Reads links/conduits and returns them as a vector of OGS line elements.

Definition at line 550 of file SWMMInterface.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            return true;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> const split_str(BaseLib::splitString(line));
        // Conduits = 9, Pumps = 7, Weirs = 8
        if (split_str.size() < 7)
        {
            ERR("Conduit format not recognised.");
            return false;
        }
 
        std::string const inlet(split_str[1]);
        auto const i_it = name_id_map.find(inlet);
        if (i_it == name_id_map.end())
        {
            ERR("SwmmInterface::readLineElements(): Inlet node {:s} not found "
                "in coordinates map.",
                inlet);
            return false;
        }
 
        std::string const outlet(split_str[2]);
        auto const o_it = name_id_map.find(outlet);
        if (o_it == name_id_map.end())
        {
            ERR("SwmmInterface::readLineElements(): Outlet node {:s} not found "
                "in coordinates map.",
                outlet);
            return false;
        }
 
        std::array<MeshLib::Node*, 2> const line_nodes = {nodes[i_it->second],
                                                          nodes[o_it->second]};
        elements.push_back(new MeshLib::Line(line_nodes));
        _id_linkname_map.push_back(split_str[0]);
    }
    return true;
}

References _id_linkname_map, ERR(), isCommentLine(), isSectionFinished(), and BaseLib::splitString().

Referenced by readSwmmInputToLineMesh().

readLinksAsPolylines()

bool FileIO::SwmmInterface::readLinksAsPolylines ( std::ifstream & in, std::vector< GeoLib::Polyline * > & lines, std::vector< std::string > & line_names, std::vector< GeoLib::Point * > const & points, std::map< std::string, std::size_t > const & point_names )

staticprivate

During geometry conversion, this reads links (conduits/pumps/weirs) and converts them into polylines.

Definition at line 295 of file SWMMInterface.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            return true;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> const split_str(BaseLib::splitString(line));
        // Conduits = 9, Pumps = 7, Weirs = 8
        if (split_str.size() < 7)
        {
            ERR("Conduit format not recognised.");
            return false;
        }
 
        std::string const inlet(split_str[1]);
        auto const i_it = point_names.find(inlet);
        if (i_it == point_names.end())
        {
            ERR("SwmmInterface::readLineElements(): Inlet node {:s} not found "
                "in coordinates map.",
                inlet);
            return false;
        }
 
        std::string const outlet(split_str[2]);
        auto const o_it = point_names.find(outlet);
        if (o_it == point_names.end())
        {
            ERR("SwmmInterface::readLineElements(): Outlet node {:s} not found "
                "in coordinates map.",
                outlet);
            return false;
        }
        GeoLib::Polyline* ply = new GeoLib::Polyline(points);
        std::size_t a(i_it->second);
        ply->addPoint(i_it->second);
        ply->addPoint(o_it->second);
        lines.push_back(ply);
        line_names.push_back(split_str[0]);
    }
    return true;
}

References GeoLib::Polyline::addPoint(), ERR(), isCommentLine(), isSectionFinished(), and BaseLib::splitString().

Referenced by convertSwmmInputToGeometry().

readNodeData()

bool FileIO::SwmmInterface::readNodeData ( std::ifstream & in, std::vector< MeshLib::Node * > & nodes, std::map< std::string, std::size_t > const & name_id_map, std::vector< double > & max_depth, bool read_max_depth )

private

Reads input information associated with nodes (elevation, depth, etc.)

Definition at line 509 of file SWMMInterface.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            return true;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> const split_str(BaseLib::splitString(line));
        // Junctions = 6, Outfalls = 4, Storage = 8
        if (split_str.size() < 3)
        {
            ERR("Format not recognised.");
            return false;
        }
        std::string const current_name(split_str[0]);
        auto const it = name_id_map.find(current_name);
        if (it == name_id_map.end())
        {
            ERR("SwmmInterface::readNodeData(): Name {:s} not found in "
                "coordinates map.",
                current_name);
            return false;
        }
        std::size_t const id = it->second;
        (*nodes[id])[2] = BaseLib::str2number<double>(split_str[1]);
 
        if (read_max_depth)
            max_depth[id] = BaseLib::str2number<double>(split_str[2]);
        else
            max_depth[id] = 0;
    }
    return true;
}

References ERR(), isCommentLine(), isSectionFinished(), BaseLib::splitString(), and BaseLib::str2number().

Referenced by readSwmmInputToLineMesh().

readPollutants()

bool FileIO::SwmmInterface::readPollutants ( std::ifstream & in )

private

Reads pollutant names and parameters.

Definition at line 1256 of file SWMMInterface.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            return true;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> split_str(BaseLib::splitString(line));
        if (split_str.size() < 6)
        {
            ERR("Parameter format for pollutants not recognised.");
            return false;
        }
        _pollutant_names.push_back(split_str[0]);
    }
    return true;
}

References _pollutant_names, ERR(), isCommentLine(), isSectionFinished(), and BaseLib::splitString().

Referenced by readSwmmInputToLineMesh().

readPolygons()

bool FileIO::SwmmInterface::readPolygons ( std::ifstream & in, std::vector< GeoLib::Polyline * > & lines, std::vector< std::string > & line_names, std::vector< GeoLib::Point * > & points, std::vector< std::string > & pnt_names )

staticprivate

During geometry conversion, this reads polygones representing subcatchments from the SWMM input file and converts them into OGS polyline vector.

Definition at line 201 of file SWMMInterface.cpp.

{
    bool finished(false);
    std::size_t id(points.size());
    std::string line;
    std::string polygon_name("");
    GeoLib::Polyline* p(nullptr);
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            break;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> split_str(BaseLib::splitString(line));
        if (split_str.size() != 3)
        {
            ERR("Polygon format not recognised.");
            delete p;
            return false;
        }
 
        // if a new polygon starts, add the old one to the vector
        if (split_str[0] != polygon_name)
        {
            if (p != nullptr)
            {
                p->addPoint(p->getPointID(0));
                lines.push_back(p);
            }
 
            polygon_name = split_str[0];
            p = new GeoLib::Polyline(points);
            ply_names.push_back(polygon_name);
        }
 
        double const x = BaseLib::str2number<double>(split_str[1]);
        double const y = BaseLib::str2number<double>(split_str[2]);
        points.push_back(new GeoLib::Point(x, y, 0, id));
        p->addPoint(points.size() - 1);
        pnt_names.push_back("");
        id++;
    }
 
    // when the section is finished, add the last polygon
    if (p != nullptr)
    {
        p->addPoint(p->getPointID(0));
        lines.push_back(p);
    }
 
    return true;
}

References GeoLib::Polyline::addPoint(), ERR(), GeoLib::Polyline::getPointID(), isCommentLine(), isSectionFinished(), BaseLib::splitString(), and BaseLib::str2number().

Referenced by convertSwmmInputToGeometry(), and readSwmmInputToLineMesh().

readSubcatchments()

bool FileIO::SwmmInterface::readSubcatchments ( std::ifstream & in, std::map< std::string, std::size_t > const & name_id_map )

private

Reads subcatchment information.

Definition at line 600 of file SWMMInterface.cpp.

{
    std::string line;
    while (std::getline(in, line))
    {
        if (isSectionFinished(line))
            return true;
 
        if (isCommentLine(line))
            continue;
 
        std::vector<std::string> const split_str(BaseLib::splitString(line));
        if (split_str.size() < 8)
        {
            ERR("Subcatchment format not recognised.");
            return false;
        }
 
        Subcatchment sc;
        sc.name = split_str[0];
        sc.rain_gauge = std::numeric_limits<std::size_t>::max();
        std::size_t const n_gauges(_rain_gauges.size());
        for (std::size_t i = 0; i < n_gauges; ++i)
        {
            if (_rain_gauges[i].first.getName() == split_str[1])
            {
                sc.rain_gauge = i;
                break;
            }
        }
        if (sc.rain_gauge == std::numeric_limits<std::size_t>::max())
        {
            ERR("Rain gauge for subcatchment '{:s}' not found.", split_str[0]);
            return false;
        }
 
        auto const it = name_id_map.find(split_str[2]);
        if (it == name_id_map.end())
        {
            ERR("Outlet node for subcatchment '{:s}' not found.", split_str[0]);
            return false;
        }
        sc.outlet = it->second;
        sc.area = BaseLib::str2number<double>(split_str[3]);
        _subcatchments.push_back(sc);
    }
 
    return true;
}

References _rain_gauges, _subcatchments, FileIO::SwmmInterface::Subcatchment::area, ERR(), isCommentLine(), isSectionFinished(), FileIO::SwmmInterface::Subcatchment::name, FileIO::SwmmInterface::Subcatchment::outlet, FileIO::SwmmInterface::Subcatchment::rain_gauge, BaseLib::splitString(), and BaseLib::str2number().

Referenced by readSwmmInputToLineMesh().

readSwmmInputToLineMesh()

bool FileIO::SwmmInterface::readSwmmInputToLineMesh ( )

private

Reading a SWMM input file and creating an OGS line mesh. This is automatically called when the object is created.

Definition at line 651 of file SWMMInterface.cpp.

{
    if (_mesh != nullptr)
    {
        ERR("Mesh already exists.");
        return false;
    }
 
    std::string const inp_file_name(_base_name + ".inp");
    if (!isSwmmInputFile(inp_file_name))
        return false;
 
    std::ifstream in(inp_file_name.c_str());
    if (!in.is_open())
    {
        ERR("SWMMInterface: Could not open input file {:s}.", inp_file_name);
        return false;
    }
 
    _id_nodename_map.clear();
    std::vector<MeshLib::Node*> nodes;
    std::string line;
    while (std::getline(in, line))
    {
        if (line == "[COORDINATES]")
        {
            INFO("Reading coordinates...");
            if (!readCoordinates<MeshLib::Node>(in, nodes, _id_nodename_map))
                return false;
        }
        /* TODO: check if needed
        else if (line == "[VERTICES]")
        {
            INFO ("Reading vertices...");
            if (!readCoordinates(in, nodes, _id_nodename_map))
                return false;
        }
        */
        else if (line == "[SYMBOLS]")
        {
            INFO("Reading symbols...");
            std::vector<GeoLib::Point*> points;
            std::vector<std::string> names;
            if (!readCoordinates(in, points, names))
                return false;
            for (std::size_t i = 0; i < points.size(); ++i)
            {
                GeoLib::Station stn(points[i], names[i]);
                _rain_gauges.push_back(
                    std::pair<GeoLib::Station, std::string>(stn, ""));
            }
        }
    }
 
    if (nodes.empty())
        return false;
 
    // After end of file is reached, create name-id-map and
    // start reading again to get line elements and node data.
    std::map<std::string, std::size_t> name_id_map;
    std::size_t const n_nodes(nodes.size());
    for (std::size_t i = 0; i < n_nodes; ++i)
        name_id_map[_id_nodename_map[i]] = i;
    in.clear();
    in.seekg(0, in.beg);
 
    std::vector<MeshLib::Element*> elements;
    std::vector<double> max_depth(n_nodes);
    std::size_t const n_types = 3;
    std::array<std::size_t, n_types> n_elem_types{{0, 0, 0}};
    while (std::getline(in, line))
    {
        if (line == "[RAINGAGES]")
        {
            if (!_rain_gauges.empty())
                addRainGaugeTimeSeriesLocations(in);
        }
        else if (line == "[SUBCATCHMENTS]")
        {
            INFO("Reading subcatchment information...");
            if (!readSubcatchments(in, name_id_map))
                return false;
        }
        else if (line == "[SUBAREAS]")
        {
            // more subcatchment variables, not yet implemented
        }
        else if (line == "[INFILTRATION]")
        {
            // more subcatchment variables, not yet implemented
        }
        else if (line == "[JUNCTIONS]")
        {
            INFO("Reading junctions...");
            if (!readNodeData(in, nodes, name_id_map, max_depth, true))
                return false;
        }
        else if (line == "[OUTFALLS]")
        {
            INFO("Reading outfalls...");
            if (!readNodeData(in, nodes, name_id_map, max_depth, false))
                return false;
        }
        else if (line == "[STORAGE]")
        {
            INFO("Reading storages...");
            if (!readNodeData(in, nodes, name_id_map, max_depth, true))
                return false;
        }
        else if (line == "[CONDUITS]")
        {
            INFO("Reading conduits...");
            if (!readLineElements(in, elements, nodes, name_id_map))
                return false;
            n_elem_types[0] = elements.size();
        }
        else if (line == "[PUMPS]")
        {
            INFO("Reading pumps...");
            if (!readLineElements(in, elements, nodes, name_id_map))
                return false;
            n_elem_types[1] = elements.size();
        }
        else if (line == "[WEIRS]")
        {
            INFO("Reading weirs...");
            if (!readLineElements(in, elements, nodes, name_id_map))
                return false;
            n_elem_types[2] = elements.size();
        }
        else if (line == "[POLLUTANTS]")
        {
            if (!readPollutants(in))
                return false;
        }
        else if (line == "[Polygons]")
        {
            INFO("Reading subcatchments...");
            std::vector<GeoLib::Polyline*> lines;
            std::vector<std::string> line_names;
            std::vector<std::string>
                tmp_names;  // polygon points are nameless but the method
                            // requires a vector
            if (!readPolygons(in, lines, line_names, _subcatchment_points,
                              tmp_names))
                return false;
 
            if (!matchSubcatchmentsWithPolygons(lines, line_names))
                return false;
        }
    }
 
    if (elements.empty())
    {
        for (MeshLib::Node* node : nodes)
            delete node;
        return false;
    }
 
    MeshLib::Properties props;
    auto* const mat_ids = props.createNewPropertyVector<int>(
        "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
    mat_ids->resize(elements.size(), 0);
    for (std::size_t i = 1; i < n_types; ++i)
    {
        if (n_elem_types[i] > 0)
            std::fill(mat_ids->begin() + n_elem_types[i - 1],
                      mat_ids->begin() + n_elem_types[i], i);
    }
 
    if (nodes.size() == max_depth.size())
    {
        auto* const depth = props.createNewPropertyVector<double>(
            "Max Depth", MeshLib::MeshItemType::Node, 1);
        depth->assign(max_depth);
        assert(depth->size() == max_depth.size());
    }
    else
        ERR("Size of max depth array does not fit number of elements. Skipping "
            "array.");
 
    _mesh.reset(new MeshLib::Mesh(_base_name, nodes, elements,
                                  false /* compute_element_neighbors */,
                                  props));
    return true;
}

References _base_name, _id_nodename_map, _mesh, _rain_gauges, _subcatchment_points, addRainGaugeTimeSeriesLocations(), MeshLib::PropertyVector< PROP_VAL_TYPE >::assign(), MeshLib::Cell, MeshLib::Properties::createNewPropertyVector(), ERR(), INFO(), isSwmmInputFile(), matchSubcatchmentsWithPolygons(), MeshLib::Node, readCoordinates(), readLineElements(), readNodeData(), readPollutants(), readPolygons(), readSubcatchments(), and MeshLib::PropertyVector< PROP_VAL_TYPE >::resize().

Referenced by create().

swmmObjectTypeToString()

std::string FileIO::SwmmInterface::swmmObjectTypeToString ( SwmmObject const obj_type )

static

Returns a string with the name of the object type.

Definition at line 1326 of file SWMMInterface.cpp.

{
    if (obj_type == SwmmObject::NODE)
        return "node";
    if (obj_type == SwmmObject::LINK)
        return "link";
    if (obj_type == SwmmObject::SUBCATCHMENT)
        return "subcatchment";
    if (obj_type == SwmmObject::SYSTEM)
        return "system";
    return "undefined";
}

References FileIO::LINK, FileIO::NODE, FileIO::SUBCATCHMENT, and FileIO::SYSTEM.

Referenced by writeCsvForObject(), and writeObjectsOfSwmmTypeToCsv().

writeCsvForObject()

bool FileIO::SwmmInterface::writeCsvForObject	(	std::string const &	file_name,
		SwmmObject	obj_type,
		std::size_t	obj_idx ) const

Write a CSV file for one object of the given type for all time steps.

Definition at line 1362 of file SWMMInterface.cpp.

{
    FileIO::CsvInterface csv;
    INFO("Writing data for {:s} {:d}.", swmmObjectTypeToString(obj_type),
         obj_idx);
    csv.addIndexVectorForWriting(getNumberOfTimeSteps());
    std::size_t const n_params(getNumberOfParameters(obj_type));
    for (std::size_t i = 0; i < n_params; ++i)
    {
        std::vector<double> data = getArrayForObject(obj_type, obj_idx, i);
        if (!data.empty())
            csv.addVectorForWriting<double>(getArrayName(obj_type, i), data);
    }
    if (csv.getNArrays() < 2)
    {
        ERR("No data to write");
        return false;
    }
    BaseLib::IO::writeStringToFile(csv.writeToString(), file_name);
    return true;
}

References FileIO::CsvInterface::addIndexVectorForWriting(), FileIO::CsvInterface::addVectorForWriting(), ERR(), getArrayForObject(), getArrayName(), FileIO::CsvInterface::getNArrays(), getNumberOfParameters(), getNumberOfTimeSteps(), INFO(), swmmObjectTypeToString(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Referenced by writeObjectsOfSwmmTypeToCsv().

writeCsvForTimestep()

bool FileIO::SwmmInterface::writeCsvForTimestep	(	std::string const &	file_name,
		SwmmObject	obj_type,
		std::size_t	time_step ) const

Write a CSV file for all object of the given type at one time step.

Definition at line 1339 of file SWMMInterface.cpp.

{
    FileIO::CsvInterface csv;
    csv.addIndexVectorForWriting(getNumberOfObjects(obj_type));
    csv.addVectorForWriting("Name", getNames(obj_type));
    std::size_t const n_params(getNumberOfParameters(obj_type));
    for (std::size_t i = 0; i < n_params; ++i)
    {
        std::vector<double> data = getArrayAtTimeStep(obj_type, time_step, i);
        if (!data.empty())
            csv.addVectorForWriting<double>(getArrayName(obj_type, i), data);
    }
    if (csv.getNArrays() < 2)
    {
        ERR("No data to write");
        return false;
    }
    BaseLib::IO::writeStringToFile(csv.writeToString(), file_name);
    return true;
}

References FileIO::CsvInterface::addIndexVectorForWriting(), FileIO::CsvInterface::addVectorForWriting(), ERR(), getArrayAtTimeStep(), getArrayName(), getNames(), FileIO::CsvInterface::getNArrays(), getNumberOfObjects(), getNumberOfParameters(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Member Data Documentation

_base_name

std::string const FileIO::SwmmInterface::_base_name

private

All files for a given SWMM simulation have the same base name.

Definition at line 196 of file SWMMInterface.h.

Referenced by SwmmInterface(), existsSwmmOutputFile(), getArrayAtTimeStep(), getArrayForObject(), getArrayName(), getNumberOfObjects(), getNumberOfParameters(), getNumberOfTimeSteps(), and readSwmmInputToLineMesh().

_id_linkname_map

std::vector<std::string> FileIO::SwmmInterface::_id_linkname_map

private

Vector storing the names of all links/conduits.

Definition at line 200 of file SWMMInterface.h.

Referenced by getName(), getNames(), and readLineElements().

_id_nodename_map

std::vector<std::string> FileIO::SwmmInterface::_id_nodename_map

private

Vector storing the names of all nodes/junctions.

Definition at line 198 of file SWMMInterface.h.

Referenced by getName(), getNames(), and readSwmmInputToLineMesh().

_mesh

std::unique_ptr<MeshLib::Mesh> FileIO::SwmmInterface::_mesh

private

Mesh generated from SWMM input (+ optional output data)

Definition at line 210 of file SWMMInterface.h.

Referenced by SwmmInterface(), getLinkPointIds(), getMesh(), getNodeCoordinateVectors(), and readSwmmInputToLineMesh().

_pollutant_names

std::vector<std::string> FileIO::SwmmInterface::_pollutant_names

private

Vector storing the names of all pollutants.

Definition at line 202 of file SWMMInterface.h.

Referenced by getArrayName(), and readPollutants().

_rain_gauges

std::vector< std::pair<GeoLib::Station, std::string> > FileIO::SwmmInterface::_rain_gauges

private

Vector containing rain gauge information as well the position of external time series files.

Definition at line 208 of file SWMMInterface.h.

Referenced by addRainGaugeTimeSeriesLocations(), readSubcatchments(), and readSwmmInputToLineMesh().

_subcatchment_points

std::vector<GeoLib::Point*> FileIO::SwmmInterface::_subcatchment_points

private

Separate node vector containing points for defining subcatchment outlines.

Definition at line 206 of file SWMMInterface.h.

Referenced by ~SwmmInterface(), and readSwmmInputToLineMesh().

_subcatchments

std::vector<Subcatchment> FileIO::SwmmInterface::_subcatchments

private

Vector storing information about all subcatchments.

Definition at line 204 of file SWMMInterface.h.

Referenced by ~SwmmInterface(), getName(), getSubcatchmentNameMap(), matchSubcatchmentsWithPolygons(), and readSubcatchments().

---

The documentation for this class was generated from the following files:

• SWMMInterface.h
• SWMMInterface.cpp