GMSHPrefsDialog::GMSHPrefsDialog(GeoLib::GEOObjects const& geoObjects, QDialog* parent)
: QDialog(parent), _allGeo(new QStringListModel), _selGeo(new QStringListModel)
{
setupUi(this);
// default parameters
this->param1->setText("2");
this->param2->setText("0.3");
this->param3->setText("0.05");
this->param4->setText("0");
// object will be deleted by Qt
auto* max_number_of_points_in_quadtree_leaf_validator(
new StrictIntValidator(1, 1000, this->param1));
param1->setValidator (max_number_of_points_in_quadtree_leaf_validator);
// object will be deleted by Qt
auto* mesh_density_scaling_pnts_validator(
new StrictDoubleValidator(0, 1, 5, this->param2));
param2->setValidator (mesh_density_scaling_pnts_validator);
// object will be deleted by Qt#
auto* mesh_density_scaling_stations_validator(
new StrictDoubleValidator(0, 1, 5, this->param3));
param3->setValidator (mesh_density_scaling_stations_validator);
std::vector<std::string> geoNames;
geoObjects.getGeometryNames(geoNames);
// get station names
std::vector<std::string> geo_station_names;
geoObjects.getStationVectorNames(geo_station_names);
for (auto& geo_station_name : geo_station_names)
geoNames.push_back(geo_station_name);
std::size_t nGeoObjects(geoNames.size());
QStringList list;
for (unsigned i = 0; i < nGeoObjects; ++i)
list.append(QString::fromStdString(geoNames[i]));
if (list.empty())
{
this->selectGeoButton->setDisabled(true);
this->deselectGeoButton->setDisabled(true);
list.append("[No geometry available.]");
}
_allGeo->setStringList(list);
this->allGeoView->setModel(_allGeo);
this->selectedGeoView->setModel(_selGeo);
this->radioAdaptive->toggle(); // default is adaptive meshing
this->on_radioAdaptive_toggled(true);
}
int main (int argc, char* argv[])
{
ApplicationsLib::LogogSetup logog_setup;
TCLAP::CmdLine cmd("Maps geometric objects to the surface of a given mesh."
"The documentation is available at https://docs.opengeosys.org/docs/tools/model-preparation/map-geometric-object-to-the-surface-of-a-mesh",
' ',
"0.1");
TCLAP::ValueArg<std::string> mesh_in("m", "mesh-file",
"the name of the file containing the mesh", true,
"", "file name");
cmd.add(mesh_in);
TCLAP::ValueArg<std::string> input_geometry_fname("i", "input-geometry",
"the name of the file containing the input geometry", true,
"", "file name");
cmd.add(input_geometry_fname);
TCLAP::ValueArg<bool> additional_insert_mapping("a", "additional-insert-mapping",
"if true advanced mapping algorithm will be applied, i.e. a new "
"geometry will be created and possibly new points will be inserted.", false,
true, "boolean value");
cmd.add(additional_insert_mapping);
TCLAP::ValueArg<std::string> output_geometry_fname("o", "output-geometry",
"the name of the file containing the input geometry", true,
"", "file name");
cmd.add(output_geometry_fname);
cmd.parse(argc, argv);
// *** read geometry
GeoLib::GEOObjects geometries;
{
GeoLib::IO::BoostXmlGmlInterface xml_io(geometries);
if (xml_io.readFile(input_geometry_fname.getValue())) {
INFO("Read geometry from file \"%s\".",
input_geometry_fname.getValue().c_str());
} else {
return EXIT_FAILURE;
}
}
std::string geo_name;
{
std::vector<std::string> geo_names;
geometries.getGeometryNames(geo_names);
geo_name = geo_names[0];
}
MeshGeoToolsLib::GeoMapper geo_mapper(geometries, geo_name);
// *** read mesh
std::unique_ptr<MeshLib::Mesh> mesh(
MeshLib::IO::readMeshFromFile(mesh_in.getValue()));
if (additional_insert_mapping.getValue()) {
geo_mapper.advancedMapOnMesh(*mesh);
} else {
geo_mapper.mapOnMesh(mesh.get());
}
{
GeoLib::IO::BoostXmlGmlInterface xml_io(geometries);
xml_io.setNameForExport(geo_name);
xml_io.writeToFile(output_geometry_fname.getValue());
}
return EXIT_SUCCESS;
}
int main (int argc, char* argv[])
{
ApplicationsLib::LogogSetup logog_setup;
TCLAP::CmdLine cmd(
"Creates boundary conditions for mesh nodes along polylines."
"The documentation is available at https://docs.opengeosys.org/docs/tools/model-preparation/create-boundary-conditions-along-a-polyline",
' ',
"0.1");
TCLAP::ValueArg<bool> gml_arg("", "gml",
"if switched on write found nodes to file in gml format", false, 0, "bool");
cmd.add(gml_arg);
TCLAP::ValueArg<std::string> output_base_fname("o", "output-base-file-name",
"the base name of the file the output (geometry (gli) and boundary"\
"condition (bc)) will be written to", true,
"", "file name");
cmd.add(output_base_fname);
TCLAP::ValueArg<std::string> bc_type("t", "type",
"the process type the boundary condition will be written for "\
"currently LIQUID_FLOW (primary variable PRESSURE1) and "\
"GROUNDWATER_FLOW (primary variable HEAD, default) are supported", true,
"",
"process type as string (LIQUID_FLOW or GROUNDWATER_FLOW (default))");
cmd.add(bc_type);
TCLAP::ValueArg<double> search_length_arg("s", "search-length",
"The size of the search length. The default value is "
"std::numeric_limits<double>::epsilon()", false,
std::numeric_limits<double>::epsilon(), "floating point number");
cmd.add(search_length_arg);
TCLAP::ValueArg<std::string> geometry_fname("i", "input-geometry",
"the name of the file containing the input geometry", true,
"", "file name");
cmd.add(geometry_fname);
TCLAP::ValueArg<std::string> mesh_arg("m", "mesh-file",
"the name of the file containing the mesh", true,
"", "file name");
cmd.add(mesh_arg);
cmd.parse(argc, argv);
// *** read mesh
INFO("Reading mesh \"%s\" ... ", mesh_arg.getValue().c_str());
MeshLib::Mesh * subsurface_mesh(FileIO::readMeshFromFile(mesh_arg.getValue()));
INFO("done.");
INFO("Extracting top surface of mesh \"%s\" ... ",
mesh_arg.getValue().c_str());
const MathLib::Vector3 dir(0,0,-1);
double const angle(90);
std::unique_ptr<MeshLib::Mesh> surface_mesh(
MeshLib::MeshSurfaceExtraction::getMeshSurface(*subsurface_mesh, dir,
angle));
INFO("done.");
delete subsurface_mesh;
subsurface_mesh = nullptr;
// *** read geometry
GeoLib::GEOObjects geometries;
FileIO::readGeometryFromFile(geometry_fname.getValue(), geometries);
std::string geo_name;
{
std::vector<std::string> geo_names;
geometries.getGeometryNames(geo_names);
geo_name = geo_names[0];
}
// *** check if the data is usable
// *** get vector of polylines
std::vector<GeoLib::Polyline*> const* plys(geometries.getPolylineVec(geo_name));
if (!plys) {
ERR("Could not get vector of polylines out of geometry \"%s\".",
geo_name.c_str());
return -1;
}
MeshGeoToolsLib::SearchLength search_length_strategy;
if (search_length_arg.isSet()) {
search_length_strategy =
MeshGeoToolsLib::SearchLength(search_length_arg.getValue());
}
GeoLib::GEOObjects geometry_sets;
MeshGeoToolsLib::MeshNodeSearcher mesh_searcher(*surface_mesh,
search_length_strategy);
for(std::size_t k(0); k<plys->size(); k++) {
std::vector<std::size_t> ids
(mesh_searcher.getMeshNodeIDsAlongPolyline(*((*plys)[k])));
if (ids.empty())
continue;
std::string geo_name("Polyline-"+std::to_string(k));
convertMeshNodesToGeometry(surface_mesh->getNodes(), ids, geo_name,
geometry_sets);
}
// merge all together
std::vector<std::string> geo_names;
geometry_sets.getGeometryNames(geo_names);
if (geo_names.empty()) {
ERR("Did not find mesh nodes along polylines.");
return -1;
}
std::string merge_name("AllMeshNodesAlongPolylines");
if (geometry_sets.mergeGeometries(geo_names, merge_name) == 2)
merge_name = geo_names[0];
GeoLib::PointVec const* pnt_vec(geometry_sets.getPointVecObj(merge_name));
std::vector<GeoLib::Point*> const* merged_pnts(pnt_vec->getVector());
std::vector<GeoLib::Point> pnts_with_id;
const std::size_t n_merged_pnts(merged_pnts->size());
for(std::size_t k(0); k<n_merged_pnts; ++k) {
pnts_with_id.emplace_back(*((*merged_pnts)[k]), k);
}
std::sort(pnts_with_id.begin(), pnts_with_id.end(),
[](GeoLib::Point const& p0, GeoLib::Point const& p1)
{ return p0 < p1; }
);
double const eps (std::numeric_limits<double>::epsilon());
auto surface_pnts = std::unique_ptr<std::vector<GeoLib::Point*>>(
new std::vector<GeoLib::Point*>);
std::map<std::string, std::size_t> *name_id_map(
new std::map<std::string, std::size_t>
);
// insert first point
surface_pnts->push_back(
new GeoLib::Point(pnts_with_id[0], surface_pnts->size()));
std::string element_name;
pnt_vec->getNameOfElementByID(0, element_name);
name_id_map->insert(
std::pair<std::string, std::size_t>(element_name,0)
);
for (std::size_t k(1); k < n_merged_pnts; ++k) {
const GeoLib::Point& p0 (pnts_with_id[k-1]);
const GeoLib::Point& p1 (pnts_with_id[k]);
if (std::abs (p0[0] - p1[0]) > eps || std::abs (p0[1] - p1[1]) > eps) {
surface_pnts->push_back(new GeoLib::Point(pnts_with_id[k],
surface_pnts->size()));
std::string element_name;
pnt_vec->getNameOfElementByID(k, element_name);
name_id_map->insert(
std::pair<std::string, std::size_t>(element_name,
surface_pnts->size()-1)
);
}
}
std::string surface_name(BaseLib::dropFileExtension(mesh_arg.getValue())+"-MeshNodesAlongPolylines");
geometry_sets.addPointVec(std::move(surface_pnts), surface_name, name_id_map, 1e-6);
// write the BCs and the merged geometry set to file
std::string const base_fname(
BaseLib::dropFileExtension(output_base_fname.getValue()));
writeBCsAndGeometry(geometry_sets, surface_name, base_fname,
bc_type.getValue(), gml_arg.getValue());
return 0;
}
bool XmlGspInterface::write()
{
GeoLib::GEOObjects* geoObjects = _project.getGEOObjects();
QFileInfo fi(QString::fromStdString(_filename));
std::string path((fi.absolutePath()).toStdString() + "/");
_out << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n"; // xml definition
_out << "<?xml-stylesheet type=\"text/xsl\" href=\"OpenGeoSysProject.xsl\"?>\n\n"; // stylefile definition
QDomDocument doc("OGS-PROJECT-DOM");
QDomElement root = doc.createElement("OpenGeoSysProject");
root.setAttribute( "xmlns:ogs", "http://www.opengeosys.org" );
root.setAttribute( "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance" );
root.setAttribute( "xsi:noNamespaceSchemaLocation",
"http://www.opengeosys.org/images/xsd/OpenGeoSysProject.xsd" );
doc.appendChild(root);
// GML
std::vector<std::string> geoNames;
geoObjects->getGeometryNames(geoNames);
for (std::vector<std::string>::const_iterator it(geoNames.begin()); it != geoNames.end(); ++it)
{
// write GLI file
XmlGmlInterface gml(*geoObjects);
std::string name(*it);
gml.setNameForExport(name);
if (gml.writeToFile(std::string(path + name + ".gml")))
{
// write entry in project file
QDomElement geoTag = doc.createElement("geo");
root.appendChild(geoTag);
QDomElement fileNameTag = doc.createElement("file");
geoTag.appendChild(fileNameTag);
QDomText fileNameText =
doc.createTextNode(QString::fromStdString(name + ".gml"));
fileNameTag.appendChild(fileNameText);
}
}
// MSH
const std::vector<MeshLib::Mesh*> msh_vec = _project.getMeshObjects();
for (std::vector<MeshLib::Mesh*>::const_iterator it(msh_vec.begin()); it != msh_vec.end(); ++it)
{
// write mesh file
Legacy::MeshIO meshIO;
meshIO.setMesh(*it);
std::string fileName(path + (*it)->getName());
meshIO.writeToFile(fileName);
// write entry in project file
QDomElement mshTag = doc.createElement("msh");
root.appendChild(mshTag);
QDomElement fileNameTag = doc.createElement("file");
mshTag.appendChild(fileNameTag);
QDomText fileNameText = doc.createTextNode(QString::fromStdString((*it)->getName()));
fileNameTag.appendChild(fileNameText);
}
// STN
std::vector<std::string> stnNames;
geoObjects->getStationVectorNames(stnNames);
for (std::vector<std::string>::const_iterator it(stnNames.begin()); it != stnNames.end(); ++it)
{
// write STN file
XmlStnInterface stn(*geoObjects);
std::string name(*it);
stn.setNameForExport(name);
if (stn.writeToFile(path + name + ".stn"))
{
// write entry in project file
QDomElement geoTag = doc.createElement("stn");
root.appendChild(geoTag);
QDomElement fileNameTag = doc.createElement("file");
geoTag.appendChild(fileNameTag);
QDomText fileNameText =
doc.createTextNode(QString::fromStdString(name + ".stn"));
fileNameTag.appendChild(fileNameText);
}
else
ERR("XmlGspInterface::writeFile(): Error writing stn-file \"%s\".", name.c_str());
}
std::string xml = doc.toString().toStdString();
_out << xml;
return true;
}
