diff --git a/Applications/DataExplorer/mainwindow.cpp b/Applications/DataExplorer/mainwindow.cpp
index 9ea909a42079866fa8d7b1efd2b039a18d7989f4..61c7062a3493f636572cc3a486582d1d50b30945 100644
--- a/Applications/DataExplorer/mainwindow.cpp
+++ b/Applications/DataExplorer/mainwindow.cpp
@@ -60,14 +60,15 @@
#include "InSituLib/VtkMappedMeshSource.h"
// FileIO includes
-#include "FileIO/FEFLOWInterface.h"
#include "FileIO/GMSInterface.h"
+#include "MeshLib/IO/FEFLOW/FEFLOWMeshInterface.h"
#include "MeshLib/IO/Legacy/MeshIO.h"
#include "MeshLib/IO/readMeshFromFile.h"
#include "FileIO/GMSHInterface.h"
#include "FileIO/TetGenInterface.h"
#include "FileIO/PetrelInterface.h"
#include "FileIO/XmlIO/Qt/XmlGspInterface.h"
+#include "GeoLib/IO/FEFLOW/FEFLOWGeoInterface.h"
#include "GeoLib/IO/XmlIO/Qt/XmlGmlInterface.h"
#include "GeoLib/IO/XmlIO/Qt/XmlStnInterface.h"
@@ -521,13 +522,15 @@ void MainWindow::loadFile(ImportFileType::type t, const QString &fileName)
{
if (fi.suffix().toLower() == "fem") // FEFLOW model files
{
- FileIO::FEFLOWInterface feflowIO(&_project.getGEOObjects());
+ MeshLib::IO::FEFLOWMeshInterface feflowMeshIO;
std::unique_ptr<MeshLib::Mesh> mesh(
- feflowIO.readFEFLOWFile(fileName.toStdString()));
+ feflowMeshIO.readFEFLOWFile(fileName.toStdString()));
if (mesh)
_meshModel->addMesh(std::move(mesh));
else
OGSError::box("Failed to load a FEFLOW mesh.");
+ GeoLib::IO::FEFLOWGeoInterface feflowGeoIO;
+ feflowGeoIO.readFEFLOWFile(fileName.toStdString(), _project.getGEOObjects());
}
settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
diff --git a/Applications/Utils/FileConverter/FEFLOW2OGS.cpp b/Applications/Utils/FileConverter/FEFLOW2OGS.cpp
index 6c288f8981e0de381996198fd6b5629b9edce01f..d550b73808e36df567017c24a91190d67a6caa7d 100644
--- a/Applications/Utils/FileConverter/FEFLOW2OGS.cpp
+++ b/Applications/Utils/FileConverter/FEFLOW2OGS.cpp
@@ -23,7 +23,7 @@
#endif
// FileIO
-#include "FileIO/FEFLOWInterface.h"
+#include "MeshLib/IO/FEFLOW/FEFLOWMeshInterface.h"
#include "MeshLib/IO/writeMeshToFile.h"
#include "MeshLib/IO/Legacy/MeshIO.h"
@@ -64,7 +64,7 @@ int main (int argc, char* argv[])
#endif
BaseLib::RunTime run_time;
run_time.start();
- FileIO::FEFLOWInterface feflowIO(nullptr);
+ MeshLib::IO::FEFLOWMeshInterface feflowIO;
std::unique_ptr<MeshLib::Mesh const> mesh(
feflowIO.readFEFLOWFile(feflow_mesh_arg.getValue()));
diff --git a/FileIO/FEFLOWInterface.h b/FileIO/FEFLOWInterface.h
deleted file mode 100644
index c924c51f752fa051304f48a8d186076f0c2b5b1d..0000000000000000000000000000000000000000
--- a/FileIO/FEFLOWInterface.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/**
- * \copyright
- * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
- * Distributed under a Modified BSD License.
- * See accompanying file LICENSE.txt or
- * http://www.opengeosys.org/project/license
- */
-
-#ifndef FEFLOWINTERFACE_H_
-#define FEFLOWINTERFACE_H_
-
-#include <iosfwd>
-#include <memory>
-#include <string>
-#include <vector>
-
-//#include "MeshLib/MeshEnums.h"
-
-class QDomElement;
-class QString;
-
-namespace GeoLib
-{
- class GEOObjects;
- class Point;
- class Polyline;
-}
-
-namespace MeshLib
-{
- class Mesh;
- class Element;
- class Node;
- enum class MeshElemType;
-}
-
-namespace FileIO
-{
-
-/**
- * Read FEFLOW model files (*.fem) into OGS data structure. Currently this class supports
- * only import of mesh data and some geometry given in Supermesh section.
- */
-class FEFLOWInterface
-{
-public:
- /// Constructor
- explicit FEFLOWInterface(GeoLib::GEOObjects* obj = nullptr)
- : _geoObjects(obj)
- {
- }
-
- /**
- * read a FEFLOW Model file (*.fem) in ASCII format (Version 5.4)
- *
- * This function reads mesh data in addition to geometry data given in Supermesh.
- *
- * @param filename FEFLOW file name
- * @return a pointer to a created OGS mesh
- */
- MeshLib::Mesh* readFEFLOWFile(const std::string &filename);
-
-private:
- // CLASS
- struct FEM_CLASS
- {
- unsigned problem_class;
- unsigned time_mode;
- unsigned orientation;
- unsigned dimension;
- unsigned n_layers3d;
- unsigned saturation_flag;
- unsigned save_fsize_rreal;
- unsigned save_fsize_creal;
-
- FEM_CLASS()
- {
- problem_class = 0;
- time_mode = 0;
- orientation = 0;
- dimension = 0;
- n_layers3d = 0;
- saturation_flag = 0;
- save_fsize_rreal = 0;
- save_fsize_creal = 0;
- }
- };
-
- // DIMENSION
- struct FEM_DIM
- {
- std::size_t n_nodes;
- std::size_t n_elements;
- std::size_t obs;
- std::size_t np_cor;
- unsigned n_nodes_of_element;
- unsigned n_steps;
- unsigned icrank;
- unsigned upwind;
- unsigned optim;
- unsigned aquifer_type;
- unsigned nwca;
- unsigned adaptive_mesh;
- unsigned sp_fem_pcs_id;
- unsigned sorption_type;
- unsigned reaction_type;
- unsigned dispersion_type;
-
- FEM_DIM()
- {
- n_nodes = 0;
- n_elements = 0;
- n_nodes_of_element = 0;
- n_steps = 0;
- icrank = 0;
- upwind = 0;
- obs = 0;
- optim = 0;
- aquifer_type = 0;
- nwca = 0;
- np_cor = 0;
- adaptive_mesh = 0;
- sp_fem_pcs_id = 0;
- sorption_type = 0;
- reaction_type = 0;
- dispersion_type = 0;
- }
- };
-
- /// read node indices and create a mesh element
- MeshLib::Element* readElement(const FEM_DIM &fem_dim, const MeshLib::MeshElemType elem_type, const std::string& line, const std::vector<MeshLib::Node*> &nodes);
-
- /// read node coordinates
- void readNodeCoordinates(std::ifstream &in, const FEM_CLASS &fem_class, const FEM_DIM &fem_dim, std::vector<MeshLib::Node*> &nodes);
-
- /// read elevation data
- void readElevation(std::ifstream &in, const FEM_CLASS &fem_class, const FEM_DIM &fem_dim, std::vector<MeshLib::Node*> &vec_nodes);
-
- //// parse node lists
- std::vector<std::size_t> getIndexList(const std::string &str_ranges);
-
- /// parse ELEMENTALSETS
- void readELEMENTALSETS(std::ifstream &in, std::vector<std::vector<std::size_t>> &vec_elementsets);
-
- /// read Supermesh data
- ///
- /// A super mesh is a collection of polygons, lines and points in the 2D plane
- /// and will be used for mesh generation and to define the modeling region
- void readSuperMesh(std::ifstream &feflow_file, const FEM_CLASS &fem_class, std::vector<GeoLib::Point*>** points, std::vector<GeoLib::Polyline*>** lines);
-
- //// read point data in Supermesh
- void readPoints(QDomElement &nodesEle, const std::string &tag, int dim, std::vector<GeoLib::Point*> &points);
-
- void setMaterialIDs(FEM_CLASS const& fem_class,
- FEM_DIM const& fem_dim,
- std::vector<GeoLib::Polyline*>* const& lines,
- std::vector<std::vector<std::size_t>> const& vec_elementsets,
- std::vector<MeshLib::Element*> const& vec_elements,
- std::vector<int> & material_ids);
-
- //// Geometric objects
- GeoLib::GEOObjects* _geoObjects;
-};
-} // end namespace FileIO
-
-#endif /* FEFLOWINTERFACE_H_ */
diff --git a/GeoLib/CMakeLists.txt b/GeoLib/CMakeLists.txt
index ce9bfc4975c081dda7836eec31d9c242544ab6a1..2748a2e7a26e58d12a74e80d84f00124b005b001 100644
--- a/GeoLib/CMakeLists.txt
+++ b/GeoLib/CMakeLists.txt
@@ -13,6 +13,8 @@ set(SOURCES ${SOURCES} ${SOURCES_IO_BASE_XML} ${SOURCES_IO_BOOST_XML})
if(QT4_FOUND)
GET_SOURCE_FILES(SOURCES_IO_QT_XML IO/XmlIO/Qt)
set(SOURCES ${SOURCES} ${SOURCES_IO_QT_XML})
+ GET_SOURCE_FILES(SOURCES_IO_FEFLOW IO/FEFLOW)
+ SET(SOURCES ${SOURCES} ${SOURCES_IO_FEFLOW})
endif()
# Create the library
diff --git a/GeoLib/IO/FEFLOW/FEFLOWGeoInterface.cpp b/GeoLib/IO/FEFLOW/FEFLOWGeoInterface.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3275c0fc2c90f1fa2aa7cdcb585e67f3e30b62f8
--- /dev/null
+++ b/GeoLib/IO/FEFLOW/FEFLOWGeoInterface.cpp
@@ -0,0 +1,220 @@
+/**
+ * \copyright
+ * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
+ * Distributed under a Modified BSD License.
+ * See accompanying file LICENSE.txt or
+ * http://www.opengeosys.org/project/license
+ */
+
+#include "FEFLOWGeoInterface.h"
+
+#include <cctype>
+#include <memory>
+
+#include <QDomElement>
+#include <QString>
+#include <QtXml>
+
+#include <logog/include/logog.hpp>
+
+#include "BaseLib/FileTools.h"
+#include "BaseLib/StringTools.h"
+
+#include "GeoLib/GEOObjects.h"
+#include "GeoLib/Point.h"
+#include "GeoLib/Polygon.h"
+
+namespace GeoLib
+{
+namespace IO
+{
+void FEFLOWGeoInterface::readFEFLOWFile(const std::string& filename,
+ GeoLib::GEOObjects& geoObjects)
+{
+ std::ifstream in(filename.c_str());
+ if (!in)
+ {
+ ERR("FEFLOWGeoInterface::readFEFLOWFile(): Could not open file %s.",
+ filename.c_str());
+ return;
+ }
+
+ unsigned dimension = 0;
+ std::vector<GeoLib::Point*>* points = nullptr;
+ std::vector<GeoLib::Polyline*>* lines = nullptr;
+
+ bool isXZplane = false;
+
+ std::string line_string;
+ std::stringstream line_stream;
+ while (!in.eof())
+ {
+ getline(in, line_string);
+ //....................................................................
+ // CLASS: the version number follows afterward, e.g. CLASS (v.5.313)
+ if (line_string.find("CLASS") != std::string::npos)
+ {
+ getline(in, line_string);
+ line_stream.str(line_string);
+ // problem class, time mode, problem orientation, dimension, ...
+ unsigned dummy = 0;
+ for (int i = 0; i < 3; i++)
+ line_stream >> dummy;
+ line_stream >> dimension;
+ line_stream.clear();
+ }
+ //....................................................................
+ // GRAVITY
+ else if (line_string.compare("GRAVITY") == 0)
+ {
+ getline(in, line_string);
+ line_stream.str(line_string);
+ double vec[3] = {};
+ line_stream >> vec[0] >> vec[1] >> vec[2];
+ if (vec[0] == 0.0 && vec[1] == -1.0 && vec[2] == 0.0)
+ // x-z plane
+ isXZplane = true;
+ line_stream.clear();
+ }
+ //....................................................................
+ // SUPERMESH
+ else if (line_string.compare("SUPERMESH") == 0)
+ {
+ readSuperMesh(in, dimension, points, lines);
+ }
+ //....................................................................
+ }
+ in.close();
+
+ std::string project_name(
+ BaseLib::extractBaseNameWithoutExtension(filename));
+ if (points)
+ geoObjects.addPointVec(
+ std::unique_ptr<std::vector<GeoLib::Point*>>(points), project_name);
+ if (lines)
+ geoObjects.addPolylineVec(
+ std::unique_ptr<std::vector<GeoLib::Polyline*>>(lines),
+ project_name);
+
+ if (isXZplane && points)
+ {
+ for (auto* pt : *points)
+ {
+ (*pt)[2] = (*pt)[1];
+ (*pt)[1] = .0;
+ }
+ }
+}
+
+void FEFLOWGeoInterface::readPoints(QDomElement& nodesEle,
+ const std::string& tag,
+ int dim,
+ std::vector<GeoLib::Point*>& points)
+{
+ QDomElement xmlEle =
+ nodesEle.firstChildElement(QString::fromStdString(tag));
+ if (xmlEle.isNull())
+ return;
+ QString str_pt_list1 = xmlEle.text();
+ std::istringstream ss(str_pt_list1.toStdString());
+ std::string line_str;
+ while (!ss.eof())
+ {
+ std::getline(ss, line_str);
+ BaseLib::trim(line_str, ' ');
+ if (line_str.empty())
+ continue;
+ std::istringstream line_ss(line_str);
+ std::size_t pt_id = 0;
+ std::array<double, 3> pt_xyz;
+ line_ss >> pt_id;
+ for (int i = 0; i < dim; i++)
+ line_ss >> pt_xyz[i];
+ points[pt_id - 1] = new GeoLib::Point(pt_xyz, pt_id);
+ }
+}
+
+void FEFLOWGeoInterface::readSuperMesh(std::ifstream& in,
+ unsigned dimension,
+ std::vector<GeoLib::Point*>*& points,
+ std::vector<GeoLib::Polyline*>*& lines)
+{
+ // get XML strings
+ std::ostringstream oss;
+ std::string line_string;
+ while (true)
+ {
+ getline(in, line_string);
+ BaseLib::trim(line_string);
+ oss << line_string << "\n";
+ if (line_string.find("</supermesh>") != std::string::npos)
+ break;
+ }
+ const QString strXML(oss.str().c_str());
+
+ // convert string to XML
+ QDomDocument doc;
+ if (!doc.setContent(strXML))
+ {
+ ERR("FEFLOWGeoInterface::readSuperMesh(): Illegal XML format error");
+ return;
+ }
+
+ // get geometry data from XML
+ QDomElement docElem = doc.documentElement(); // #supermesh
+ // #nodes
+ points = new std::vector<GeoLib::Point*>();
+ QDomElement nodesEle = docElem.firstChildElement("nodes");
+ if (nodesEle.isNull())
+ return;
+
+ {
+ const QString str = nodesEle.attribute("count");
+ const long n_points = str.toLong();
+ points->resize(n_points);
+ // fixed
+ readPoints(nodesEle, "fixed", dimension, *points);
+ readPoints(nodesEle, "linear", dimension, *points);
+ readPoints(nodesEle, "parabolic", dimension, *points);
+ }
+
+ // #polygons
+ lines = new std::vector<GeoLib::Polyline*>();
+ QDomElement polygonsEle = docElem.firstChildElement("polygons");
+ if (polygonsEle.isNull())
+ return;
+
+ {
+ QDomNode child = polygonsEle.firstChild();
+ while (!child.isNull())
+ {
+ if (child.nodeName() != "polygon")
+ {
+ child = child.nextSibling();
+ continue;
+ }
+ QDomElement xmlEle = child.firstChildElement("nodes");
+ if (xmlEle.isNull())
+ continue;
+ const QString str = xmlEle.attribute("count");
+ const std::size_t n_points = str.toLong();
+ QString str_ptId_list = xmlEle.text().simplified();
+ {
+ GeoLib::Polyline* line = new GeoLib::Polyline(*points);
+ lines->push_back(line);
+ std::istringstream ss(str_ptId_list.toStdString());
+ for (std::size_t i = 0; i < n_points; i++)
+ {
+ int pt_id = 0;
+ ss >> pt_id;
+ line->addPoint(pt_id - 1);
+ }
+ line->addPoint(line->getPointID(0));
+ }
+ child = child.nextSibling();
+ }
+ }
+}
+
+} // IO
+} // GeoLib
diff --git a/GeoLib/IO/FEFLOW/FEFLOWGeoInterface.h b/GeoLib/IO/FEFLOW/FEFLOWGeoInterface.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb0603361c822bdd9b673483c46cc68ec9e2091c
--- /dev/null
+++ b/GeoLib/IO/FEFLOW/FEFLOWGeoInterface.h
@@ -0,0 +1,64 @@
+/**
+ * \copyright
+ * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
+ * Distributed under a Modified BSD License.
+ * See accompanying file LICENSE.txt or
+ * http://www.opengeosys.org/project/license
+ */
+
+#ifndef FEFLOWGEOINTERFACE_H_
+#define FEFLOWGEOINTERFACE_H_
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+class QDomElement;
+
+namespace GeoLib
+{
+class GEOObjects;
+class Point;
+class Polyline;
+}
+
+namespace GeoLib
+{
+namespace IO
+{
+/**
+ * Interface to geometric data in FEFLOW files
+ */
+class FEFLOWGeoInterface
+{
+public:
+ /**
+ * read a FEFLOW Model file (*.fem) in ASCII format (Version 5.4)
+ *
+ * This function reads geometry data given in Supermesh.
+ *
+ * @param filename FEFLOW file name
+ * @param geo_objects Geometric objects where imported geometry data are
+ * added
+ */
+ void readFEFLOWFile(const std::string& filename,
+ GeoLib::GEOObjects& geo_objects);
+
+ /// read points and polylines in Supermesh section
+ ///
+ /// A super mesh is a collection of polygons, lines and points in the 2D
+ /// plane and will be used for mesh generation and to define the modeling
+ /// region
+ static void readSuperMesh(std::ifstream& feflow_file, unsigned dimension,
+ std::vector<GeoLib::Point*>*& points,
+ std::vector<GeoLib::Polyline*>*& lines);
+
+private:
+ //// read point data in Supermesh
+ static void readPoints(QDomElement& nodesEle, const std::string& tag,
+ int dim, std::vector<GeoLib::Point*>& points);
+};
+} // IO
+} // GeoLib
+
+#endif /* FEFLOWGEOINTERFACE_H_ */
diff --git a/MeshLib/CMakeLists.txt b/MeshLib/CMakeLists.txt
index 643a6926a67e2fa7e9d2e51bce9c2f19d1e19476..1b23db93238608f23a042117ff9019c0061cca93 100644
--- a/MeshLib/CMakeLists.txt
+++ b/MeshLib/CMakeLists.txt
@@ -20,6 +20,11 @@ set(SOURCES ${SOURCES_MESHLIB} ${SOURCES_ELEMENTS} ${SOURCES_EDITING}
${SOURCES_GENERATORS} ${SOURCES_QUALITY} ${SOURCES_SEARCH}
${SOURCES_IO} ${SOURCES_IO_LEGACY} ${SOURCES_IO_VTKIO})
+if(QT4_FOUND)
+ GET_SOURCE_FILES(SOURCES_IO_FEFLOW IO/FEFLOW)
+ SET(SOURCES ${SOURCES} ${SOURCES_IO_FEFLOW})
+endif()
+
# It could be used for other MPI based DDC approach in future.
if(OGS_USE_PETSC)
GET_SOURCE_FILES(SOURCES_MPI_IO IO/MPI_IO)
diff --git a/FileIO/FEFLOWInterface.cpp b/MeshLib/IO/FEFLOW/FEFLOWMeshInterface.cpp
similarity index 58%
rename from FileIO/FEFLOWInterface.cpp
rename to MeshLib/IO/FEFLOW/FEFLOWMeshInterface.cpp
index ff8d1f286e7705974d3294b9efd3221b0b2e75ed..4d38d038c95c0e49f4ddc526f4d165f45837ab2c 100644
--- a/FileIO/FEFLOWInterface.cpp
+++ b/MeshLib/IO/FEFLOW/FEFLOWMeshInterface.cpp
@@ -6,17 +6,17 @@
* http://www.opengeosys.org/project/license
*/
-#include "FEFLOWInterface.h"
+#include "FEFLOWMeshInterface.h"
#include <cctype>
-#include <QtXml>
+#include <memory>
#include <logog/include/logog.hpp>
#include "BaseLib/FileTools.h"
#include "BaseLib/StringTools.h"
-#include "GeoLib/GEOObjects.h"
+#include "GeoLib/IO/FEFLOW/FEFLOWGeoInterface.h"
#include "GeoLib/Point.h"
#include "GeoLib/Polygon.h"
@@ -24,22 +24,24 @@
#include "MeshLib/Mesh.h"
#include "MeshLib/Node.h"
-namespace FileIO
+namespace MeshLib
{
-
-MeshLib::Mesh* FEFLOWInterface::readFEFLOWFile(const std::string &filename)
+namespace IO
+{
+MeshLib::Mesh* FEFLOWMeshInterface::readFEFLOWFile(const std::string& filename)
{
std::ifstream in(filename.c_str());
if (!in)
{
- ERR("FEFLOWInterface::readFEFLOWFile(): Could not open file %s.", filename.c_str());
+ ERR("FEFLOWMeshInterface::readFEFLOWFile(): Could not open file %s.",
+ filename.c_str());
return nullptr;
}
FEM_CLASS fem_class;
FEM_DIM fem_dim;
- std::vector<GeoLib::Point*>* points = NULL;
- std::vector<GeoLib::Polyline*>* lines = NULL;
+ std::vector<GeoLib::Point*>* points = nullptr;
+ std::vector<GeoLib::Polyline*>* lines = nullptr;
bool isXZplane = false;
@@ -54,13 +56,17 @@ MeshLib::Mesh* FEFLOWInterface::readFEFLOWFile(const std::string &filename)
{
getline(in, line_string);
//....................................................................
- // CLASS
- if (line_string.find("CLASS") != std::string::npos) // the version number follows afterward, e.g. CLASS (v.5.313)
+ // CLASS: the version number follows afterward, e.g. CLASS (v.5.313)
+ if (line_string.find("CLASS") != std::string::npos)
{
getline(in, line_string);
line_stream.str(line_string);
- // problem class, time mode, problem orientation, dimension, nr. layers for 3D, saturation switch, precision of results, precision of coordinates
- line_stream >> fem_class.problem_class >> fem_class.time_mode >> fem_class.orientation >> fem_class.dimension >> fem_class.n_layers3d;
+ // problem class, time mode, problem orientation, dimension, nr.
+ // layers for 3D, saturation switch, precision of results, precision
+ // of coordinates
+ line_stream >> fem_class.problem_class >> fem_class.time_mode >>
+ fem_class.orientation >> fem_class.dimension >>
+ fem_class.n_layers3d;
line_stream.clear();
}
//....................................................................
@@ -70,13 +76,18 @@ MeshLib::Mesh* FEFLOWInterface::readFEFLOWFile(const std::string &filename)
// DIMENS
getline(in, line_string);
line_stream.str(line_string);
- line_stream >> fem_dim.n_nodes >> fem_dim.n_elements >> fem_dim.n_nodes_of_element >> std::ws;
- // create node pointers with dummy coordinates to create element objects.
+ line_stream >> fem_dim.n_nodes >> fem_dim.n_elements >>
+ fem_dim.n_nodes_of_element >> std::ws;
+ // create node pointers with dummy coordinates to create element
+ // objects.
// True coordinates are set later in COOR and ELEV_I.
vec_nodes.resize(fem_dim.n_nodes);
std::size_t count = 0;
double dummy_coords[3] = {};
- std::generate(vec_nodes.begin(), vec_nodes.end(), [&]() { return new MeshLib::Node(dummy_coords, count++); });
+ std::generate(vec_nodes.begin(), vec_nodes.end(), [&]()
+ {
+ return new MeshLib::Node(dummy_coords, count++);
+ });
line_stream.clear();
}
//....................................................................
@@ -90,27 +101,39 @@ MeshLib::Mesh* FEFLOWInterface::readFEFLOWFile(const std::string &filename)
eleType = MeshLib::MeshElemType::LINE;
else if (fem_dim.n_nodes_of_element == 3)
eleType = MeshLib::MeshElemType::TRIANGLE;
- else if (fem_dim.n_nodes_of_element == 4 && fem_class.dimension == 2)
+ else if (fem_dim.n_nodes_of_element == 4 &&
+ fem_class.dimension == 2)
eleType = MeshLib::MeshElemType::QUAD;
- else if (fem_dim.n_nodes_of_element == 4 && fem_class.dimension == 3)
+ else if (fem_dim.n_nodes_of_element == 4 &&
+ fem_class.dimension == 3)
eleType = MeshLib::MeshElemType::TETRAHEDRON;
- else if (fem_dim.n_nodes_of_element == 6 && fem_class.dimension == 3)
+ else if (fem_dim.n_nodes_of_element == 6 &&
+ fem_class.dimension == 3)
eleType = MeshLib::MeshElemType::PRISM;
- else if (fem_dim.n_nodes_of_element == 8 && fem_class.dimension == 3)
+ else if (fem_dim.n_nodes_of_element == 8 &&
+ fem_class.dimension == 3)
eleType = MeshLib::MeshElemType::HEXAHEDRON;
- if (eleType == MeshLib::MeshElemType::INVALID) {
- ERR("FEFLOWInterface::readFEFLOWFile(): Unsupported element type with the number of node = %d and dim = %d", fem_dim.n_nodes_of_element, fem_class.dimension);
- std::for_each(vec_nodes.begin(), vec_nodes.end(), [](MeshLib::Node* nod) { delete nod;});
+ if (eleType == MeshLib::MeshElemType::INVALID)
+ {
+ ERR("FEFLOWInterface::readFEFLOWFile(): Unsupported element "
+ "type with the number of node = %d and dim = %d",
+ fem_dim.n_nodes_of_element, fem_class.dimension);
+ std::for_each(vec_nodes.begin(), vec_nodes.end(),
+ [](MeshLib::Node* nod)
+ {
+ delete nod;
+ });
vec_nodes.clear();
return nullptr;
}
vec_elements.reserve(fem_dim.n_elements);
- for (std::size_t i=0; i<fem_dim.n_elements; i++)
+ for (std::size_t i = 0; i < fem_dim.n_elements; i++)
{
getline(in, line_string);
- vec_elements.push_back(readElement(fem_dim, eleType, line_string, vec_nodes));
+ vec_elements.push_back(
+ readElement(fem_dim, eleType, line_string, vec_nodes));
}
}
//....................................................................
@@ -133,7 +156,7 @@ MeshLib::Mesh* FEFLOWInterface::readFEFLOWFile(const std::string &filename)
{
getline(in, line_string);
line_stream.str(line_string);
- double vec[3] = { };
+ double vec[3] = {};
line_stream >> vec[0] >> vec[1] >> vec[2];
if (vec[0] == 0.0 && vec[1] == -1.0 && vec[2] == 0.0)
// x-z plane
@@ -150,34 +173,29 @@ MeshLib::Mesh* FEFLOWInterface::readFEFLOWFile(const std::string &filename)
// SUPERMESH
else if (line_string.compare("SUPERMESH") == 0)
{
- readSuperMesh(in, fem_class, &points, &lines);
+ GeoLib::IO::FEFLOWGeoInterface::readSuperMesh(
+ in, fem_class.dimension, points, lines);
}
//....................................................................
}
in.close();
+ INFO("Create mesh");
std::string project_name(
BaseLib::extractBaseNameWithoutExtension(filename));
- if (_geoObjects && points)
- _geoObjects->addPointVec(
- std::unique_ptr<std::vector<GeoLib::Point*>>(points), project_name);
- if (_geoObjects && lines)
- _geoObjects->addPolylineVec(
- std::unique_ptr<std::vector<GeoLib::Polyline*>>(lines),
- project_name);
-
- INFO("Create mesh");
auto mesh(std::unique_ptr<MeshLib::Mesh>(
new MeshLib::Mesh(project_name, vec_nodes, vec_elements)));
INFO("Set values for material property.");
auto opt_material_ids(mesh->getProperties().createNewPropertyVector<int>(
- "MaterialIDs", MeshLib::MeshItemType::Cell, 1)
- );
- if (!opt_material_ids) {
+ "MaterialIDs", MeshLib::MeshItemType::Cell, 1));
+ if (!opt_material_ids)
+ {
WARN("Could not create PropertyVector for MaterialIDs in Mesh.");
- } else {
+ }
+ else
+ {
setMaterialIDs(fem_class, fem_dim, lines, vec_elementsets, vec_elements,
- *opt_material_ids);
+ *opt_material_ids);
}
if (isXZplane)
@@ -200,17 +218,22 @@ MeshLib::Mesh* FEFLOWInterface::readFEFLOWFile(const std::string &filename)
return mesh.release();
}
-
-void FEFLOWInterface::readNodeCoordinates(std::ifstream &in, const FEM_CLASS &fem_class, const FEM_DIM &fem_dim, std::vector<MeshLib::Node*> &vec_nodes)
+void FEFLOWMeshInterface::readNodeCoordinates(
+ std::ifstream& in, const FEM_CLASS& fem_class, const FEM_DIM& fem_dim,
+ std::vector<MeshLib::Node*>& vec_nodes)
{
- const std::size_t no_nodes_per_layer = (fem_class.dimension == 2) ? fem_dim.n_nodes : fem_dim.n_nodes / (fem_class.n_layers3d + 1);
- assert(no_nodes_per_layer>0);
- const std::size_t n_lines = (no_nodes_per_layer-1) / 12 + 1;
- const std::size_t n_layers = (fem_class.dimension == 3) ? fem_class.n_layers3d + 1 : 1;
+ const std::size_t no_nodes_per_layer =
+ (fem_class.dimension == 2)
+ ? fem_dim.n_nodes
+ : fem_dim.n_nodes / (fem_class.n_layers3d + 1);
+ assert(no_nodes_per_layer > 0);
+ const std::size_t n_lines = (no_nodes_per_layer - 1) / 12 + 1;
+ const std::size_t n_layers =
+ (fem_class.dimension == 3) ? fem_class.n_layers3d + 1 : 1;
std::string line_string;
std::stringstream line_stream;
double x;
- char dummy_char; // for comma(,)
+ char dummy_char; // for comma(,)
// x, y
for (unsigned k = 0; k < 2; k++)
{
@@ -239,27 +262,34 @@ void FEFLOWInterface::readNodeCoordinates(std::ifstream &in, const FEM_CLASS &fe
}
}
-std::vector<std::size_t> FEFLOWInterface::getIndexList(const std::string &str_ranges)
+std::vector<std::size_t> FEFLOWMeshInterface::getIndexList(
+ const std::string& str_ranges)
{
std::vector<std::size_t> vec_node_IDs;
// insert space before and after minus for splitting
- std::string str_ranges2(BaseLib::replaceString("-", " # ", str_ranges));
+ std::string str_ranges2(BaseLib::replaceString("-", " # ", str_ranges));
BaseLib::trim(str_ranges2);
auto splitted_str = BaseLib::splitString(str_ranges2, ' ');
bool is_range = false;
for (auto str : splitted_str)
{
- if (str.empty()) continue;
- if (str[0]=='#') {
+ if (str.empty())
+ continue;
+ if (str[0] == '#')
+ {
is_range = true;
- } else if (is_range) {
+ }
+ else if (is_range)
+ {
const std::size_t start = vec_node_IDs.back();
const std::size_t end = BaseLib::str2number<std::size_t>(str);
- for (std::size_t i=start+1; i<end+1; i++)
+ for (std::size_t i = start + 1; i < end + 1; i++)
vec_node_IDs.push_back(i);
is_range = false;
- } else {
+ }
+ else
+ {
BaseLib::trim(str);
vec_node_IDs.push_back(BaseLib::str2number<std::size_t>(str));
}
@@ -268,15 +298,20 @@ std::vector<std::size_t> FEFLOWInterface::getIndexList(const std::string &str_ra
return vec_node_IDs;
}
-void FEFLOWInterface::readElevation(std::ifstream &in, const FEM_CLASS &fem_class, const FEM_DIM &fem_dim, std::vector<MeshLib::Node*> &vec_nodes)
+void FEFLOWMeshInterface::readElevation(std::ifstream& in,
+ const FEM_CLASS& fem_class,
+ const FEM_DIM& fem_dim,
+ std::vector<MeshLib::Node*>& vec_nodes)
{
- const std::size_t no_nodes_per_layer = fem_dim.n_nodes / (fem_class.n_layers3d + 1);
+ const std::size_t no_nodes_per_layer =
+ fem_dim.n_nodes / (fem_class.n_layers3d + 1);
double z = .0;
std::string str_nodeList;
std::string line_string;
std::stringstream line_stream;
std::size_t l = 0;
- unsigned mode = 0; // 0: exit, 1: slice no, 2: elevation value, 3: continued line of mode 2
+ unsigned mode = 0; // 0: exit, 1: slice no, 2: elevation value, 3:
+ // continued line of mode 2
int pos_prev_line = 0;
while (true)
{
@@ -289,15 +324,16 @@ void FEFLOWInterface::readElevation(std::ifstream &in, const FEM_CLASS &fem_clas
mode = 0;
else if (line_string.empty())
continue;
- else if (line_string[0]=='\t')
+ else if (line_string[0] == '\t')
mode = 3;
- else if (columns.size()==1)
+ else if (columns.size() == 1)
mode = 1;
- else // columns.size()>1
+ else // columns.size()>1
mode = 2;
// process stocked data
- if (mode != 3 && !str_nodeList.empty()) {
+ if (mode != 3 && !str_nodeList.empty())
+ {
// process previous lines
auto vec_nodeIDs = getIndexList(str_nodeList);
for (auto n0 : vec_nodeIDs)
@@ -308,20 +344,27 @@ void FEFLOWInterface::readElevation(std::ifstream &in, const FEM_CLASS &fem_clas
str_nodeList.clear();
}
- if (mode == 0) {
+ if (mode == 0)
+ {
break;
- } else if (mode == 1) {
+ }
+ else if (mode == 1)
+ {
// slice number
l++;
- assert(l+1==BaseLib::str2number<std::size_t>(columns.front()));
- } else if (mode == 2) {
+ assert(l + 1 == BaseLib::str2number<std::size_t>(columns.front()));
+ }
+ else if (mode == 2)
+ {
// parse current line
line_stream.str(line_string);
line_stream >> z;
getline(line_stream, str_nodeList);
BaseLib::trim(str_nodeList, '\t');
line_stream.clear();
- } else if (mode == 3) {
+ }
+ else if (mode == 3)
+ {
// continue reading node range
BaseLib::trim(line_string, '\t');
str_nodeList += " " + line_string;
@@ -333,9 +376,9 @@ void FEFLOWInterface::readElevation(std::ifstream &in, const FEM_CLASS &fem_clas
in.seekg(pos_prev_line);
}
-MeshLib::Element* FEFLOWInterface::readElement(const FEM_DIM &fem_dim,
- const MeshLib::MeshElemType elem_type, const std::string& line,
- const std::vector<MeshLib::Node*> &nodes)
+MeshLib::Element* FEFLOWMeshInterface::readElement(
+ const FEM_DIM& fem_dim, const MeshLib::MeshElemType elem_type,
+ const std::string& line, const std::vector<MeshLib::Node*>& nodes)
{
std::stringstream ss(line);
@@ -348,14 +391,15 @@ MeshLib::Element* FEFLOWInterface::readElement(const FEM_DIM &fem_dim,
{
default:
for (unsigned k(0); k < fem_dim.n_nodes_of_element; ++k)
- ele_nodes[k] = nodes[idx[k]-1];
+ ele_nodes[k] = nodes[idx[k] - 1];
break;
case MeshLib::MeshElemType::HEXAHEDRON:
case MeshLib::MeshElemType::PRISM:
- const unsigned n_half_nodes = fem_dim.n_nodes_of_element/2;
- for (unsigned k(0); k < n_half_nodes; ++k) {
- ele_nodes[k] = nodes[idx[k+n_half_nodes]-1];
- ele_nodes[k+n_half_nodes] = nodes[idx[k]-1];
+ const unsigned n_half_nodes = fem_dim.n_nodes_of_element / 2;
+ for (unsigned k(0); k < n_half_nodes; ++k)
+ {
+ ele_nodes[k] = nodes[idx[k + n_half_nodes] - 1];
+ ele_nodes[k + n_half_nodes] = nodes[idx[k] - 1];
}
break;
}
@@ -380,36 +424,16 @@ MeshLib::Element* FEFLOWInterface::readElement(const FEM_DIM &fem_dim,
}
}
-void FEFLOWInterface::readPoints(QDomElement &nodesEle, const std::string &tag, int dim, std::vector<GeoLib::Point*> &points)
+void FEFLOWMeshInterface::readELEMENTALSETS(
+ std::ifstream& in, std::vector<std::vector<std::size_t>>& vec_elementsets)
{
- QDomElement xmlEle = nodesEle.firstChildElement(QString::fromStdString(tag));
- if (xmlEle.isNull())
- return;
- QString str_pt_list1 = xmlEle.text();
- std::istringstream ss(str_pt_list1.toStdString());
- std::string line_str;
- while (!ss.eof())
+ auto compressSpaces = [](std::string const& str)
{
- std::getline(ss, line_str);
- BaseLib::trim(line_str, ' ');
- if (line_str.empty()) continue;
- std::istringstream line_ss(line_str);
- std::size_t pt_id = 0;
- std::array<double,3> pt_xyz;
- line_ss >> pt_id;
- for (int i = 0; i < dim; i++)
- line_ss >> pt_xyz[i];
- points[pt_id - 1] = new GeoLib::Point(pt_xyz, pt_id);
- }
-}
-
-void FEFLOWInterface::readELEMENTALSETS(std::ifstream &in, std::vector<std::vector<std::size_t>> &vec_elementsets)
-{
- auto compressSpaces = [](std::string const& str) {
std::stringstream ss(str);
std::string new_str;
std::string word;
- while (ss) {
+ while (ss)
+ {
ss >> word;
new_str += " " + word;
}
@@ -426,45 +450,55 @@ void FEFLOWInterface::readELEMENTALSETS(std::ifstream &in, std::vector<std::vect
unsigned mode = 0;
if (!in)
- mode = 0; // reached the end of the file
+ mode = 0; // reached the end of the file
else if (line_string.empty())
- continue; // skip and see what comes next
+ continue; // skip and see what comes next
else if (std::isalpha(line_string[0]))
- mode = 0; // reached the next section
+ mode = 0; // reached the next section
else if (line_string[0] == ' ')
- mode = 1; // start of the element set definition
+ mode = 1; // start of the element set definition
else if (line_string[0] == '\t')
- mode = 2; // continue the definition
+ mode = 2; // continue the definition
else
{
- ERR("Failed during parsing of an ELEMENTALSETS section in a FEFLOW file");
+ ERR("Failed during parsing of an ELEMENTALSETS section in a FEFLOW "
+ "file");
break;
}
- if (mode!=2 && !str_idList.empty()) {
+ if (mode != 2 && !str_idList.empty())
+ {
vec_elementsets.push_back(getIndexList(str_idList));
str_idList.clear();
}
- if (mode == 0) {
+ if (mode == 0)
+ {
break;
- } else if (mode == 1) {
+ }
+ else if (mode == 1)
+ {
// starting a new set
std::string set_name;
std::string ids;
BaseLib::trim(line_string, ' ');
- if (line_string[0]=='"') { // multiple words
+ if (line_string[0] == '"')
+ { // multiple words
auto pos = line_string.find_last_of('"');
- set_name = line_string.substr(1, pos-1); // without quotation
- ids = line_string.substr(pos+1);
- } else { // single word
+ set_name = line_string.substr(1, pos - 1); // without quotation
+ ids = line_string.substr(pos + 1);
+ }
+ else
+ { // single word
auto pos = line_string.find_first_of(' ');
set_name = line_string.substr(0, pos);
- ids = line_string.substr(pos+1);
+ ids = line_string.substr(pos + 1);
}
INFO("Found an element group - %s", set_name.data());
str_idList += compressSpaces(ids);
- } else {
+ }
+ else
+ {
// continue reading a element ids
BaseLib::trim(line_string, '\t');
str_idList += compressSpaces(line_string);
@@ -473,105 +507,28 @@ void FEFLOWInterface::readELEMENTALSETS(std::ifstream &in, std::vector<std::vect
// move stream position to previous line
if (std::isalpha(line_string[0]))
in.seekg(pos_prev_line);
-
-}
-
-//
-void FEFLOWInterface::readSuperMesh(std::ifstream &in, const FEM_CLASS &fem_class, std::vector<GeoLib::Point*>** p_points, std::vector<GeoLib::Polyline*>** p_lines)
-{
- // get XML strings
- std::ostringstream oss;
- std::string line_string;
- while (true)
- {
- getline(in, line_string);
- BaseLib::trim(line_string);
- oss << line_string << "\n";
- if (line_string.find("</supermesh>") != std::string::npos)
- break;
- }
- const QString strXML(oss.str().c_str());
-
- // convert string to XML
- QDomDocument doc;
- if (!doc.setContent(strXML))
- {
- ERR("FEFLOWInterface::readSuperMesh(): Illegal XML format error");
- return;
- }
-
- // get geometry data from XML
- QDomElement docElem = doc.documentElement(); // #supermesh
- // #nodes
- *p_points = new std::vector<GeoLib::Point*>();
- std::vector<GeoLib::Point*>* points = *p_points;
- QDomElement nodesEle = docElem.firstChildElement("nodes");
- if (nodesEle.isNull())
- return;
-
- {
- const QString str = nodesEle.attribute("count");
- const long n_points = str.toLong();
- points->resize(n_points);
- //fixed
- readPoints(nodesEle, "fixed", fem_class.dimension, *points);
- readPoints(nodesEle, "linear", fem_class.dimension, *points);
- readPoints(nodesEle, "parabolic", fem_class.dimension, *points);
- }
-
- // #polygons
- *p_lines = new std::vector<GeoLib::Polyline*>();
- std::vector<GeoLib::Polyline*>* lines = *p_lines;
- QDomElement polygonsEle = docElem.firstChildElement("polygons");
- if (polygonsEle.isNull())
- return;
-
- {
- QDomNode child = polygonsEle.firstChild();
- while (!child.isNull())
- {
- if (child.nodeName() != "polygon")
- {
- child = child.nextSibling();
- continue;
- }
- QDomElement xmlEle = child.firstChildElement("nodes");
- if (xmlEle.isNull())
- continue;
- const QString str = xmlEle.attribute("count");
- const std::size_t n_points = str.toLong();
- QString str_ptId_list = xmlEle.text().simplified();
- {
- GeoLib::Polyline* line = new GeoLib::Polyline(*points);
- lines->push_back(line);
- std::istringstream ss(str_ptId_list.toStdString());
- for (std::size_t i = 0; i < n_points; i++)
- {
- int pt_id = 0;
- ss >> pt_id;
- line->addPoint(pt_id - 1);
- }
- line->addPoint(line->getPointID(0));
- }
- child = child.nextSibling();
- }
- }
}
-void FEFLOWInterface::setMaterialIDs(FEM_CLASS const& fem_class,
+void FEFLOWMeshInterface::setMaterialIDs(
+ FEM_CLASS const& fem_class,
FEM_DIM const& fem_dim,
std::vector<GeoLib::Polyline*>* const& lines,
std::vector<std::vector<std::size_t>> const& vec_elementsets,
std::vector<MeshLib::Element*> const& vec_elements,
- std::vector<int> & material_ids)
+ std::vector<int>& material_ids)
{
- if (!vec_elementsets.empty()) {
- for (std::size_t matid=0; matid<vec_elementsets.size(); ++matid) {
- auto &eids = vec_elementsets[matid];
+ if (!vec_elementsets.empty())
+ {
+ for (std::size_t matid = 0; matid < vec_elementsets.size(); ++matid)
+ {
+ auto& eids = vec_elementsets[matid];
for (auto eid : eids)
- material_ids[eid-1] = matid; // Element IDs given by FEFLOW starts from one!
+ material_ids[eid - 1] =
+ matid; // Element IDs given by FEFLOW starts from one!
}
- } else if (lines && !lines->empty()) {
+ }
+ else if (lines && !lines->empty())
+ {
for (std::size_t i = 0; i < vec_elements.size(); ++i)
{
MeshLib::Element const* e = vec_elements[i];
@@ -592,13 +549,16 @@ void FEFLOWInterface::setMaterialIDs(FEM_CLASS const& fem_class,
}
material_ids[i] = matId;
}
- } else if (fem_class.n_layers3d>0) {
- const std::size_t no_nodes_per_layer = fem_dim.n_nodes / (fem_class.n_layers3d + 1);
+ }
+ else if (fem_class.n_layers3d > 0)
+ {
+ const std::size_t no_nodes_per_layer =
+ fem_dim.n_nodes / (fem_class.n_layers3d + 1);
for (std::size_t i = 0; i < vec_elements.size(); i++)
{
MeshLib::Element* e = vec_elements[i];
unsigned e_min_nodeID = std::numeric_limits<unsigned>::max();
- for (std::size_t j=0; j<e->getNBaseNodes(); j++)
+ for (std::size_t j = 0; j < e->getNBaseNodes(); j++)
e_min_nodeID = std::min(e_min_nodeID, e->getNodeIndex(j));
std::size_t layer_id = e_min_nodeID / no_nodes_per_layer;
material_ids[i] = layer_id;
@@ -606,4 +566,5 @@ void FEFLOWInterface::setMaterialIDs(FEM_CLASS const& fem_class,
}
}
-} // end namespace FileIO
+} // IO
+} // MeshLib
diff --git a/MeshLib/IO/FEFLOW/FEFLOWMeshInterface.h b/MeshLib/IO/FEFLOW/FEFLOWMeshInterface.h
new file mode 100644
index 0000000000000000000000000000000000000000..59654d57fcbd047ab08aa3854965914854af8b51
--- /dev/null
+++ b/MeshLib/IO/FEFLOW/FEFLOWMeshInterface.h
@@ -0,0 +1,124 @@
+/**
+ * \copyright
+ * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
+ * Distributed under a Modified BSD License.
+ * See accompanying file LICENSE.txt or
+ * http://www.opengeosys.org/project/license
+ */
+
+#ifndef FEFLOWMESHINTERFACE_H_
+#define FEFLOWMESHINTERFACE_H_
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace GeoLib
+{
+class Point;
+class Polyline;
+}
+
+namespace MeshLib
+{
+class Mesh;
+class Element;
+class Node;
+enum class MeshElemType;
+}
+
+namespace MeshLib
+{
+namespace IO
+{
+/**
+ * Read FEFLOW model files (*.fem) into OGS data structure. Currently this class
+ * supports only import of mesh data and some geometry given in Supermesh section.
+ */
+class FEFLOWMeshInterface
+{
+public:
+ /**
+ * read a FEFLOW Model file (*.fem) in ASCII format (Version 5.4)
+ *
+ * This function reads mesh data in addition to geometry data given in
+ * Supermesh.
+ *
+ * @param filename FEFLOW file name
+ * @return a pointer to a created OGS mesh
+ */
+ MeshLib::Mesh* readFEFLOWFile(const std::string& filename);
+
+private:
+ // CLASS
+ struct FEM_CLASS
+ {
+ unsigned problem_class = 0;
+ unsigned time_mode = 0;
+ unsigned orientation = 0;
+ unsigned dimension = 0;
+ unsigned n_layers3d = 0;
+ unsigned saturation_flag = 0;
+ unsigned save_fsize_rreal = 0;
+ unsigned save_fsize_creal = 0;
+ };
+
+ // DIMENSION
+ struct FEM_DIM
+ {
+ std::size_t n_nodes = 0;
+ std::size_t n_elements = 0;
+ std::size_t obs = 0;
+ std::size_t np_cor = 0;
+ unsigned n_nodes_of_element = 0;
+ unsigned n_steps = 0;
+ unsigned icrank = 0;
+ unsigned upwind = 0;
+ unsigned optim = 0;
+ unsigned aquifer_type = 0;
+ unsigned nwca = 0;
+ unsigned adaptive_mesh = 0;
+ unsigned sp_fem_pcs_id = 0;
+ unsigned sorption_type = 0;
+ unsigned reaction_type = 0;
+ unsigned dispersion_type = 0;
+ };
+
+ /// read node indices and create a mesh element
+ MeshLib::Element* readElement(const FEM_DIM& fem_dim,
+ const MeshLib::MeshElemType elem_type,
+ const std::string& line,
+ const std::vector<MeshLib::Node*>& nodes);
+
+ /// read node coordinates
+ void readNodeCoordinates(std::ifstream& in,
+ const FEM_CLASS& fem_class,
+ const FEM_DIM& fem_dim,
+ std::vector<MeshLib::Node*>& nodes);
+
+ /// read elevation data
+ void readElevation(std::ifstream& in,
+ const FEM_CLASS& fem_class,
+ const FEM_DIM& fem_dim,
+ std::vector<MeshLib::Node*>& vec_nodes);
+
+ //// parse node lists
+ std::vector<std::size_t> getIndexList(const std::string& str_ranges);
+
+ /// parse ELEMENTALSETS
+ void readELEMENTALSETS(
+ std::ifstream& in,
+ std::vector<std::vector<std::size_t>>& vec_elementsets);
+
+ void setMaterialIDs(
+ FEM_CLASS const& fem_class,
+ FEM_DIM const& fem_dim,
+ std::vector<GeoLib::Polyline*>* const& lines,
+ std::vector<std::vector<std::size_t>> const& vec_elementsets,
+ std::vector<MeshLib::Element*> const& vec_elements,
+ std::vector<int>& material_ids);
+};
+} // IO
+} // MeshLib
+
+#endif /* FEFLOWMESHINTERFACE_H_ */