Namespaces
namespace	GMSH

namespace	Gocad

namespace	Legacy

Classes
class	AsciiRasterInterface

class	CsvInterface

class	FEFLOWGeoInterface

class	FEFLOWMeshInterface

class	GMSInterface
	Manages the import and export of Aquaveo GMS files into and out of GeoLib. More...

class	PetrelInterface

class	SHPInterface
	Manages the import of ESRI shape files into GeoLib. More...

class	SwmmInterface

class	TetGenInterface

class	XmlLutReader
	Reader for vtk-Lookup-Tables (in XML / ParaView Format) More...

class	XmlPrjInterface

Enumerations
enum class	SwmmObject { SUBCATCHMENT = 0 , NODE = 1 , LINK = 2 , SYSTEM = 3 }
	SWMM object types. More...

Functions
bool	createSurface (GeoLib::Polyline const &ply, GeoLib::GEOObjects &geometries, std::string const &geometry_name, std::string const &gmsh_binary)

std::unique_ptr< GeoLib::Surface >	createSurfaceWithEarClipping (GeoLib::Polyline const &line)

static std::string	readLine (std::istream &in)

static std::list< std::string >	split (std::string const &line)

static void	printListInfo (const std::list< std::string > &str_list, std::string_view const prefix, std::string_view const message)

static double	getLastNumberFromList (const std::list< std::string > &str_list)

void	readGeometryFromFile (std::string const &fname, GeoLib::GEOObjects &geo_objs, std::string const &gmsh_path)

auto	constructPointsFromNodes (std::vector< MeshLib::Node * > nodes)

void	writeGeometryToFile (std::string const &geo_name, GeoLib::GEOObjects &geo_objs, std::string const &fname)

void	addTextNode (QDomDocument &doc, QDomElement &parent, QString const &node_name, QString const &content)

bool	PVarExists (std::string const &name, std::vector< DataHolderLib::ProcessVariable > const &p_vars)

static double	readDoubleFromStream (std::istream &in)
	Reads a double replacing comma by point.

static std::optional< GeoLib::RasterHeader >	readASCHeader (std::ifstream &in)

static std::optional< std::tuple< GeoLib::RasterHeader, double, double > >	readSurferHeader (std::ifstream &in)

std::vector< std::string >	readFile (std::istream &in)

std::optional< std::array< double, 3 > >	readXyzCoordinates (std::string const &line)

GeoLib::RasterHeader	getXyzHeader (std::vector< std::string > const &lines)

static bool	allRastersExist (std::vector< std::string > const &raster_paths)
	Checks if all raster files actually exist.

std::optional< std::vector< GeoLib::Raster const * > >	readRasters (std::vector< std::string > const &raster_paths)

Variables
const std::array< std::string, 9 >	subcatchment_vars
	Variables that always exist for subcatchments. There might be more.

const std::array< std::string, 7 >	node_vars
	Variables that always exist for nodes. There might be more.

const std::array< std::string, 6 >	link_vars
	Variables that always exist for links. There might be more.

const std::array< std::string, 15 >	system_vars
	All variables that exist for the system.

std::array< std::size_t, 4 > const	n_obj_params = {8, 6, 5, 15}

Enumeration Type Documentation

◆ SwmmObject

enum class FileIO::SwmmObject

strong

SWMM object types.

Enumerator
SUBCATCHMENT
NODE
LINK
SYSTEM

Definition at line 35 of file SWMMInterface.h.

{
    SUBCATCHMENT = 0,
    NODE = 1,
    LINK = 2,
    SYSTEM = 3
};

Function Documentation

◆ addTextNode()

void FileIO::addTextNode	(	QDomDocument &	doc,
		QDomElement &	parent,
		QString const &	node_name,
		QString const &	content )

Definition at line 426 of file XmlPrjInterface.cpp.

{
    QDomElement tag = doc.createElement(node_name);
    parent.appendChild(tag);
    QDomText order_text = doc.createTextNode(content);
    tag.appendChild(order_text);
}

Referenced by FileIO::XmlPrjInterface::writeCondition(), and FileIO::XmlPrjInterface::writeProcessVariables().

◆ allRastersExist()

static bool FileIO::allRastersExist ( std::vector< std::string > const & raster_paths )

static

Checks if all raster files actually exist.

Definition at line 381 of file AsciiRasterInterface.cpp.

{
    return std::all_of(raster_paths.begin(), raster_paths.end(),
                       [](std::string const& raster_path)
                       {
                           if (BaseLib::IsFileExisting(raster_path))
                           {
                               return true;
                           }
                           ERR("Opening raster file {} failed.", raster_path);
                           return false;
                       });
}

References ERR().

Referenced by readRasters().

◆ constructPointsFromNodes()

auto FileIO::constructPointsFromNodes ( std::vector< MeshLib::Node * > nodes )

Definition at line 36 of file TetGenInterface.cpp.

{
    std::vector<GeoLib::Point*> points;
    points.reserve(nodes.size());
    std::transform(nodes.begin(), nodes.end(), std::back_inserter(points),
                   [](auto const* node)
                   { return new GeoLib::Point(*node, node->getID()); });
    return points;
}

Referenced by FileIO::TetGenInterface::readTetGenGeometry().

◆ createSurface()

bool FileIO::createSurface	(	GeoLib::Polyline const &	ply,
		GeoLib::GEOObjects &	geometries,
		std::string const &	geometry_name,
		std::string const &	gmsh_binary )

Creates a plane surface from the given polyline. The polyline has to be closed, i.e. the first and the last point have to be the identical. The triangulation of the polyline is done by the finite element meshing tool Gmsh. Finally, the resulting mesh is converted into a GeoLib::Surface which is inserted into the GeoLib::GEOObjects instance geometries using the name geometry_name.

Definition at line 33 of file createSurface.cpp.

{
    if (!ply.isClosed())
    {
        WARN("Error in createSurface() - Polyline is not closed.");
        return false;
    }
 
    if (ply.getNumberOfPoints() <= 2)
    {
        WARN(
            "Error in createSurface() - Polyline consists of less "
            "than three points and therefore cannot be triangulated.");
        return false;
    }
 
    // create new GEOObjects and insert a copy of the polyline
    std::vector<GeoLib::Point*> polyline_points;
    GeoLib::GEOObjects geo;
    auto ply_points = ply.getPointsVec();
    std::transform(ply_points.begin(), ply_points.end(),
                   std::back_inserter(polyline_points),
                   [](auto const* p) { return new GeoLib::Point(*p); });
    std::string ply_name = "temporary_polyline_name";
    geo.addPointVec(std::move(polyline_points), ply_name,
                    std::map<std::string, std::size_t>{});
    auto polyline =
        std::make_unique<GeoLib::Polyline>(*geo.getPointVec(ply_name));
    for (std::size_t k(0); k < ply.getNumberOfPoints(); ++k)
    {
        polyline->addPoint(ply.getPointID(k));
    }
    std::vector<GeoLib::Polyline*> polylines;
    polylines.push_back(polyline.release());
    geo.addPolylineVec(std::move(polylines), ply_name,
                       GeoLib::PolylineVec::NameIdMap{});
 
    // use GMSHInterface to create a mesh from the closed polyline
    auto const geo_names = geo.getGeometryNames();
    FileIO::GMSH::GMSHInterface gmsh_io(
        geo, false, FileIO::GMSH::MeshDensityAlgorithm::FixedMeshDensity, 0.0,
        0.0, 0, geo_names, false, false);
 
    // write to random file in temp directory
    auto geo_file = std::filesystem::temp_directory_path() /=
        BaseLib::randomString(32);
    auto msh_file = std::filesystem::temp_directory_path() /=
        BaseLib::randomString(32);
 
    BaseLib::IO::writeStringToFile(gmsh_io.writeToString(), geo_file);
    // Using GMSH's vtk output here so we don't have to deal with GMSH and it's
    // various file format versions here
    std::string gmsh_command = "\"" + gmsh_binary +
                               "\" -2 -algo meshadapt -format vtk -o " +
                               msh_file.string() + " " + geo_file.string();
 
    int const gmsh_return_value = std::system(gmsh_command.c_str());
    if (gmsh_return_value != 0)
    {
        WARN("Call to '{:s}' returned non-zero value {:d}.", gmsh_command,
             gmsh_return_value);
    }
    auto const* surface_mesh = MeshLib::IO::readMeshFromFile(
        msh_file.string(), true /* compute_element_neighbors */);
    if (!surface_mesh)
    {
        WARN("The surface mesh could not be created.");
        return false;
    }
    if (!(std::filesystem::remove(geo_file) &&
          std::filesystem::remove(msh_file)))
    {
        WARN("Could not remove temporary files in createSurface.");
    }
 
    // convert the surface mesh into a geometric surface
    if (!MeshToolsLib::convertMeshToGeo(*surface_mesh, geometries,
                                        std::numeric_limits<double>::epsilon()))
    {
        WARN("The surface mesh could not be converted to a geometry.");
        return false;
    }
    std::string merged_geometry_name("geometry_with_surfaces");
    geometries.mergeGeometries({geometry_name, surface_mesh->getName()},
                               merged_geometry_name);
    geometries.removeSurfaceVec(geometry_name);
    geometries.removePolylineVec(geometry_name);
    geometries.removePointVec(geometry_name);
    geometries.removeSurfaceVec(surface_mesh->getName());
    geometries.removePolylineVec(surface_mesh->getName());
    geometries.removePointVec(surface_mesh->getName());
    geometries.renameGeometry(merged_geometry_name, geometry_name);
 
    return true;
}

Referenced by FileIO::SHPInterface::readPolygons(), and FileIO::Legacy::readSurfaces().

◆ createSurfaceWithEarClipping()

std::unique_ptr< GeoLib::Surface > FileIO::createSurfaceWithEarClipping ( GeoLib::Polyline const & line )

Creates a plane surface from the given polyline. The polyline has to be closed, i.e. the first and the last point have to be the identical. The triangulation of the polyline is done via a simple ear clipping algorithm.

Definition at line 132 of file createSurface.cpp.

{
    if (!line.isClosed())
    {
        WARN("Error in Surface::createSurface() - Polyline is not closed.");
        return nullptr;
    }
 
    if (line.getNumberOfPoints() <= 2)
    {
        WARN(
            "Error in Surface::createSurface() - Polyline consists of less "
            "than three points and therefore cannot be triangulated.");
        return nullptr;
    }
 
    // create empty surface
    auto sfc = std::make_unique<GeoLib::Surface>(line.getPointsVec());
    auto polygon = std::make_unique<GeoLib::Polygon>(GeoLib::Polygon(line));
    std::list<GeoLib::Polygon*> const& list_of_simple_polygons =
        polygon->computeListOfSimplePolygons();
 
    for (auto const& simple_polygon : list_of_simple_polygons)
    {
        std::list<GeoLib::Triangle> triangles;
        GeoLib::EarClippingTriangulation(*simple_polygon, triangles);
 
        // add Triangles to Surface
        for (auto const& t : triangles)
        {
            sfc->addTriangle(t[0], t[1], t[2]);
        }
    }
    if (sfc->getNumberOfTriangles() == 0)
    {
        WARN(
            "Surface::createSurface(): Triangulation does not contain any "
            "triangles.");
        return nullptr;
    }
    return sfc;
}

References GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPointsVec(), GeoLib::Polyline::isClosed(), and WARN().

Referenced by GEOModels::connectPolylineSegments().

◆ getLastNumberFromList()

static double FileIO::getLastNumberFromList ( const std::list< std::string > & str_list )

static

Definition at line 137 of file PetrelInterface.cpp.

{
    return std::stod(*(--str_list.end()));
}

Referenced by FileIO::PetrelInterface::readPetrelWellTrace().

◆ getXyzHeader()

GeoLib::RasterHeader FileIO::getXyzHeader ( std::vector< std::string > const & lines )

Definition at line 273 of file AsciiRasterInterface.cpp.

{
    double x_min = std::numeric_limits<double>::max();
    double x_max = -std::numeric_limits<double>::max();
    double y_min = std::numeric_limits<double>::max();
    double y_max = -std::numeric_limits<double>::max();
    double cellsize = std::numeric_limits<double>::max();
    std::optional<std::array<double, 3>> coords;
 
    std::size_t const n_lines(lines.size());
    for (std::size_t i = 0; i < n_lines; ++i)
    {
        coords = readXyzCoordinates(lines[i]);
        if (coords == std::nullopt)
        {
            MathLib::Point3d org(std::array<double, 3>{{0, 0, 0}});
            GeoLib::RasterHeader fail = {0, 0, 0, org, 0, 0};
            return fail;
        }
        double const diff = (*coords)[0] - x_min;
        if (diff > 0)
        {
            cellsize = std::min(cellsize, diff);
        }
        x_min = std::min((*coords)[0], x_min);
        x_max = std::max((*coords)[0], x_max);
        y_min = std::min((*coords)[1], y_min);
        y_max = std::max((*coords)[1], y_max);
    }
 
    GeoLib::RasterHeader header;
    header.cell_size = cellsize;
    header.no_data = -9999;
    header.n_cols = static_cast<std::size_t>(((x_max - x_min) / cellsize) + 1);
    header.n_rows = static_cast<std::size_t>(((y_max - y_min) / cellsize) + 1);
    header.n_depth = 1;
    header.origin[0] = x_min;
    header.origin[1] = y_min;
    return header;
}

References GeoLib::RasterHeader::cell_size, GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_depth, GeoLib::RasterHeader::n_rows, GeoLib::RasterHeader::no_data, GeoLib::RasterHeader::origin, and readXyzCoordinates().

Referenced by FileIO::AsciiRasterInterface::getRasterFromXyzFile().

◆ printListInfo()

static void FileIO::printListInfo	(	const std::list< std::string > &	str_list,
		std::string_view const	prefix,
		std::string_view const	message )

static

Definition at line 127 of file PetrelInterface.cpp.

{
    for (auto const& str : str_list)
    {
        INFO("PetrelInterface::{:s}(): {:s}: {:s}.", prefix, message, str);
    }
}

References INFO().

Referenced by FileIO::PetrelInterface::readPetrelWellTrace(), and FileIO::PetrelInterface::readPetrelWellTraceData().

◆ PVarExists()

bool FileIO::PVarExists	(	std::string const &	name,
		std::vector< DataHolderLib::ProcessVariable > const &	p_vars )

Definition at line 437 of file XmlPrjInterface.cpp.

{
    return std::any_of(p_vars.begin(), p_vars.end(),
                       [&](auto const& p_var) { return p_var.name == name; });
}

Referenced by FileIO::XmlPrjInterface::getPrimaryVariableVec().

◆ readASCHeader()

static std::optional< GeoLib::RasterHeader > FileIO::readASCHeader ( std::ifstream & in )

static

Reads the header of a Esri asc-file. If the return value is empty, reading was not successful.

Definition at line 56 of file AsciiRasterInterface.cpp.

{
    GeoLib::RasterHeader header;
 
    std::string tag;
    std::string value;
 
    in >> tag;
    if (tag == "ncols")
    {
        in >> value;
        header.n_cols = atoi(value.c_str());
    }
    else
    {
        return {};
    }
 
    in >> tag;
    if (tag == "nrows")
    {
        in >> value;
        header.n_rows = atoi(value.c_str());
    }
    else
    {
        return {};
    }
 
    header.n_depth = 1;
 
    in >> tag;
    if (tag == "xllcorner" || tag == "xllcenter")
    {
        header.origin[0] = readDoubleFromStream(in);
    }
    else
    {
        return {};
    }
 
    in >> tag;
    if (tag == "yllcorner" || tag == "yllcenter")
    {
        header.origin[1] = readDoubleFromStream(in);
    }
    else
    {
        return {};
    }
    header.origin[2] = 0;
 
    in >> tag;
    if (tag == "cellsize")
    {
        header.cell_size = readDoubleFromStream(in);
    }
    else
    {
        return {};
    }
 
    in >> tag;
    if (tag == "NODATA_value" || tag == "nodata_value")
    {
        header.no_data = readDoubleFromStream(in);
    }
    else
    {
        return {};
    }
 
    return header;
}

References GeoLib::RasterHeader::cell_size, GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_depth, GeoLib::RasterHeader::n_rows, GeoLib::RasterHeader::no_data, GeoLib::RasterHeader::origin, and readDoubleFromStream().

Referenced by FileIO::AsciiRasterInterface::getRasterFromASCFile().

◆ readDoubleFromStream()

static double FileIO::readDoubleFromStream ( std::istream & in )

static

Reads a double replacing comma by point.

Definition at line 46 of file AsciiRasterInterface.cpp.

{
    std::string value;
    in >> value;
    return std::strtod(BaseLib::replaceString(",", ".", value).c_str(),
                       nullptr);
}

References BaseLib::replaceString().

Referenced by FileIO::AsciiRasterInterface::getRasterFromASCFile(), FileIO::AsciiRasterInterface::getRasterFromSurferFile(), and readASCHeader().

◆ readFile()

std::vector< std::string > FileIO::readFile ( std::istream & in )

Definition at line 247 of file AsciiRasterInterface.cpp.

{
    std::vector<std::string> lines;
    std::string line("");
    while (std::getline(in, line))
    {
        lines.emplace_back(line);
    }
    return lines;
}

Referenced by FileIO::AsciiRasterInterface::getRasterFromXyzFile().

◆ readGeometryFromFile()

void FileIO::readGeometryFromFile	(	std::string const &	fname,
		GeoLib::GEOObjects &	geo_objs,
		std::string const &	gmsh_path )

Definition at line 24 of file readGeometryFromFile.cpp.

{
    if (BaseLib::getFileExtension(fname) == ".gml")
    {
        GeoLib::IO::BoostXmlGmlInterface xml(geo_objs);
        xml.readFile(fname);
    }
    else
    {
        std::vector<std::string> errors;
        std::string geo_name;  // geo_name is output of the reading function
        FileIO::Legacy::readGLIFileV4(
            fname, geo_objs, geo_name, errors, gmsh_path);
    }
 
    if (geo_objs.getGeometryNames().empty())
    {
        OGS_FATAL(
            "GEOObjects has no geometry name after reading the geometry file. "
            "Something is wrong in the reading function.");
    }
}

References BaseLib::getFileExtension(), GeoLib::GEOObjects::getGeometryNames(), OGS_FATAL, GeoLib::IO::BoostXmlGmlInterface::readFile(), and FileIO::Legacy::readGLIFileV4().

Referenced by main().

◆ readLine()

static std::string FileIO::readLine ( std::istream & in )

static

Definition at line 77 of file PetrelInterface.cpp.

{
    std::string line;
    std::getline(in, line);
    return line;
}

Referenced by FileIO::PetrelInterface::readPetrelSurfacePoints(), FileIO::PetrelInterface::readPetrelWellTrace(), and FileIO::PetrelInterface::readPetrelWellTraceData().

◆ readRasters()

std::optional< std::vector< GeoLib::Raster const * > > FileIO::readRasters ( std::vector< std::string > const & raster_paths )

Reads a vector of rasters given by file names. On error nothing is returned, otherwise the returned vector contains pointers to the read rasters.

Definition at line 395 of file AsciiRasterInterface.cpp.

{
    if (!allRastersExist(raster_paths))
    {
        return std::nullopt;
    }
 
    std::vector<GeoLib::Raster const*> rasters;
    rasters.reserve(raster_paths.size());
    std::transform(raster_paths.begin(), raster_paths.end(),
                   std::back_inserter(rasters),
                   [](auto const& path)
                   { return FileIO::AsciiRasterInterface::readRaster(path); });
    return std::make_optional(rasters);
}

References allRastersExist().

Referenced by MeshLayerEditDialog::createPrismMesh(), MeshLayerEditDialog::createTetMesh(), and main().

◆ readSurferHeader()

static std::optional< std::tuple< GeoLib::RasterHeader, double, double > > FileIO::readSurferHeader ( std::ifstream & in )

static

Reads the header of a Surfer grd-file with minimum and maximum values. If the return value is empty, reading was not successful.

Definition at line 170 of file AsciiRasterInterface.cpp.

{
    std::string tag;
 
    in >> tag;
 
    if (tag != "DSAA")
    {
        ERR("Error in readSurferHeader() - No Surfer file.");
        return {};
    }
 
    GeoLib::RasterHeader header;
    in >> header.n_cols >> header.n_rows;
    double min, max;
    in >> min >> max;
    header.origin[0] = min;
    header.cell_size = (max - min) / static_cast<double>(header.n_cols);
 
    in >> min >> max;
    header.origin[1] = min;
    header.origin[2] = 0;
 
    if (ceil((max - min) / static_cast<double>(header.n_rows)) ==
        ceil(header.cell_size))
    {
        header.cell_size = ceil(header.cell_size);
    }
    else
    {
        ERR("Error in readSurferHeader() - Anisotropic cellsize detected.");
        return {};
    }
    header.n_depth = 1;
    header.no_data = -9999;
    in >> min >> max;
 
    return {{header, min, max}};
}

References GeoLib::RasterHeader::cell_size, ERR(), GeoLib::RasterHeader::n_cols, GeoLib::RasterHeader::n_depth, GeoLib::RasterHeader::n_rows, GeoLib::RasterHeader::no_data, and GeoLib::RasterHeader::origin.

Referenced by FileIO::AsciiRasterInterface::getRasterFromSurferFile().

◆ readXyzCoordinates()

std::optional< std::array< double, 3 > > FileIO::readXyzCoordinates ( std::string const & line )

Definition at line 258 of file AsciiRasterInterface.cpp.

{
    std::array<double, 3> coords = {0, 0, 0};
    if (auto const n = std::sscanf(line.c_str(), "%lf %lf %lf", &coords[0],
                                   &coords[1], &coords[2]);
        n != 3)
    {
        ERR("Raster::readXyzCoordinates() - Read {:d} doubles out of 3 "
            "expected from the following line:\n{:s}",
            n, line);
        return std::nullopt;
    }
    return coords;
}

References ERR().

Referenced by FileIO::AsciiRasterInterface::getRasterFromXyzFile(), and getXyzHeader().

◆ split()

static std::list< std::string > FileIO::split ( std::string const & line )

static

Definition at line 84 of file PetrelInterface.cpp.

{
    return BaseLib::splitString(line, ' ');
}

References BaseLib::splitString().

Referenced by FileIO::PetrelInterface::readPetrelWellTrace(), and FileIO::PetrelInterface::readPetrelWellTraceData().

◆ writeGeometryToFile()

void FileIO::writeGeometryToFile	(	std::string const &	geo_name,
		GeoLib::GEOObjects &	geo_objs,
		std::string const &	fname )

Write geometry given by the geo_objs object and specified by the name stored in param geo_name either to a gml or a gli file. If the extension given in the fname parameter is "gml" or "GML" a gml file is written. In case the extension is "gli" or "GLI" a gli file is written.

Definition at line 21 of file writeGeometryToFile.cpp.

{
    std::string const extension(BaseLib::getFileExtension(fname));
    if (extension == ".gml" || extension == ".GML")
    {
        GeoLib::IO::BoostXmlGmlInterface xml(geo_objs);
        xml.export_name = geo_name;
        BaseLib::IO::writeStringToFile(xml.writeToString(), fname);
    }
    else if (extension == "gli" || extension == "GLI")
    {
        FileIO::Legacy::writeGLIFileV4(fname, geo_name, geo_objs);
    }
    else
    {
        ERR("Writing of geometry failed, since it was not possible to determine"
            " the required format from file extension.");
    }
}

References ERR(), BaseLib::IO::XMLInterface::export_name, BaseLib::getFileExtension(), FileIO::Legacy::writeGLIFileV4(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Referenced by main(), and writeBCsAndGeometry().

Variable Documentation

◆ link_vars

const std::array<std::string, 6> FileIO::link_vars

Initial value:

= {"flow rate",
                                              "flow depth",
                                              "flow velocity",
                                              "flow volume",
                                              "fraction conduit/non-conduit",
                                              "concentration of pollutant"}

Variables that always exist for links. There might be more.

Definition at line 57 of file SWMMInterface.cpp.

                                         {"flow rate",
                                              "flow depth",
                                              "flow velocity",
                                              "flow volume",
                                              "fraction conduit/non-conduit",
                                              "concentration of pollutant"};

Referenced by FileIO::SwmmInterface::getArrayName().

◆ n_obj_params

std::array<std::size_t, 4> const FileIO::n_obj_params = {8, 6, 5, 15}

Number of base variables for the four object types (subcatchments/nodes/links/system).

Definition at line 84 of file SWMMInterface.cpp.

84{8, 6, 5, 15};

Referenced by FileIO::SwmmInterface::getArrayAtTimeStep(), FileIO::SwmmInterface::getArrayForObject(), FileIO::SwmmInterface::getArrayName(), and FileIO::SwmmInterface::getNumberOfParameters().

◆ node_vars

const std::array<std::string, 7> FileIO::node_vars

Initial value:

= {"water depth",
                                              "hydraulic head",
                                              "volume of stored water",
                                              "lateral inflow",
                                              "total inflow",
                                              "flow lost to flooding",
                                              "concentration of pollutant"}

Variables that always exist for nodes. There might be more.

Definition at line 48 of file SWMMInterface.cpp.

                                         {"water depth",
                                              "hydraulic head",
                                              "volume of stored water",
                                              "lateral inflow",
                                              "total inflow",
                                              "flow lost to flooding",
                                              "concentration of pollutant"};

Referenced by FileIO::SwmmInterface::getArrayName().

◆ subcatchment_vars

const std::array<std::string, 9> FileIO::subcatchment_vars

Initial value:

= {
    "rainfall",
    "snow depth",
    "evaporation loss",
    "infiltration losses",
    "runoff rate",
    "groundwater outflow",
    "groundwater head",
    "moisture content",
    "concentration of pollutant"}

Variables that always exist for subcatchments. There might be more.

Definition at line 36 of file SWMMInterface.cpp.

                                                 {
    "rainfall",
    "snow depth",
    "evaporation loss",
    "infiltration losses",
    "runoff rate",
    "groundwater outflow",
    "groundwater head",
    "moisture content",
    "concentration of pollutant"};

Referenced by FileIO::SwmmInterface::getArrayName().

◆ system_vars

const std::array<std::string, 15> FileIO::system_vars

Initial value:

= {
    "air temperature",
    "rainfall",
    "snow depth",
    "evaporation + infiltration loss",
    "runoff flow",
    "dry weather inflow",
    "groundwater inflow",
    "RDII inflow",
    "direct inflow",
    "total lateral inflow",
    "flow lost to flooding",
    "flow leaving through outfalls",
    "volume of stored water",
    "actual evaporation rate",
    "potential evaporation rate"}

All variables that exist for the system.

Definition at line 65 of file SWMMInterface.cpp.

                                            {
    "air temperature",
    "rainfall",
    "snow depth",
    "evaporation + infiltration loss",
    "runoff flow",
    "dry weather inflow",
    "groundwater inflow",
    "RDII inflow",
    "direct inflow",
    "total lateral inflow",
    "flow lost to flooding",
    "flow leaving through outfalls",
    "volume of stored water",
    "actual evaporation rate",
    "potential evaporation rate"};

Referenced by FileIO::SwmmInterface::getArrayName().

Namespaces

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ SwmmObject

Function Documentation

◆ addTextNode()

◆ allRastersExist()

◆ constructPointsFromNodes()

◆ createSurface()

◆ createSurfaceWithEarClipping()

◆ getLastNumberFromList()

◆ getXyzHeader()

◆ printListInfo()

◆ PVarExists()

◆ readASCHeader()

◆ readDoubleFromStream()

◆ readFile()

◆ readGeometryFromFile()

◆ readLine()

◆ readRasters()

◆ readSurferHeader()

◆ readXyzCoordinates()

◆ split()

◆ writeGeometryToFile()

Variable Documentation

◆ link_vars

◆ n_obj_params

◆ node_vars

◆ subcatchment_vars

◆ system_vars