FileIO Namespace Reference

Detailed Description

Copyright

Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Contains the interfaces for all file types that can be read and/or written using OpenGeoSys.

See also

GMSH

Legacy

Namespaces
	GMSH
	Gocad
	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
static double	readDoubleFromStream (std::istream &in)
	Reads a double replacing comma by point. More...
static std::optional< GeoLib::RasterHeader >	readASCHeader (std::ifstream &in)
static std::optional< std::tuple< GeoLib::RasterHeader, double, double > >	readSurferHeader (std::ifstream &in)
static bool	allRastersExist (std::vector< std::string > const &raster_paths)
	Checks if all raster files actually exist. More...
std::optional< std::vector< GeoLib::Raster const * > >	readRasters (std::vector< std::string > const &raster_paths)
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)
void	readGeometryFromFile (std::string const &fname, GeoLib::GEOObjects &geo_objs, std::string const &gmsh_path)
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)

Variables
const std::array< std::string, 9 >	subcatchment_vars
	Variables that always exist for subcatchments. There might be more. More...
const std::array< std::string, 7 >	node_vars
	Variables that always exist for nodes. There might be more. More...
const std::array< std::string, 6 >	link_vars
	Variables that always exist for links. There might be more. More...
const std::array< std::string, 15 >	system_vars
	All variables that exist for the system. More...
std::array< std::size_t, 4 > const	n_obj_params = {8, 6, 5, 15}

Enumeration Type Documentation

SwmmObject

enum FileIO::SwmmObject

strong

SWMM object types.

Enumerator
SUBCATCHMENT
NODE
LINK
SYSTEM

Definition at line 34 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 276 of file AsciiRasterInterface.cpp.

{
    for (const auto& raster_path : raster_paths)
    {
        std::ifstream file_stream(raster_path, std::ifstream::in);
        if (!file_stream.good())
        {
            return false;
        }
        file_stream.close();
    }
    return true;
}

Referenced by readRasters().

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
    auto polyline_points = std::make_unique<std::vector<GeoLib::Point*>>();
    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);
    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));
    }
    auto polylines = std::make_unique<std::vector<GeoLib::Polyline*>>();
    polylines->push_back(polyline.release());
    geo.addPolylineVec(std::move(polylines), ply_name);
 
    // 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 = fs::temp_directory_path() /= BaseLib::randomString(32);
    auto msh_file = fs::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 surface_mesh = MeshLib::IO::readMeshFromFile(msh_file.string());
    if (!surface_mesh)
    {
        WARN("The surface mesh could not be created.");
        return false;
    }
    if (!(fs::remove(geo_file) && fs::remove(msh_file)))
    {
        WARN("Could not remove temporary files in createSurface.");
    }
 
    // convert the surface mesh into a geometric surface
    if (!MeshLib::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;
}

References MeshLib::convertMeshToGeo(), FileIO::GMSH::FixedMeshDensity, GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPointID(), GeoLib::Polyline::getPointsVec(), GeoLib::Polyline::isClosed(), GeoLib::GEOObjects::mergeGeometries(), BaseLib::randomString(), MeshLib::IO::readMeshFromFile(), GeoLib::GEOObjects::removePointVec(), GeoLib::GEOObjects::removePolylineVec(), GeoLib::GEOObjects::removeSurfaceVec(), GeoLib::GEOObjects::renameGeometry(), WARN(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Referenced by main(), 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 126 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().

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 50 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 40 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().

readGeometryFromFile()

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

Definition at line 23 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().

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 290 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 164 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 = min - 1;
    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().

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 20 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 55 of file SWMMInterface.cpp.

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 82 of file SWMMInterface.cpp.

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 46 of file SWMMInterface.cpp.

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 34 of file SWMMInterface.cpp.

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 63 of file SWMMInterface.cpp.

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