int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Converts VTK mesh into OGS mesh.", ' ', "0.1"); TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file", "the name of the file containing the input mesh", true, "", "file name of input mesh"); cmd.add(mesh_in); TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file", "the name of the file the mesh will be written to", true, "", "file name of output mesh"); cmd.add(mesh_out); cmd.parse(argc, argv); MeshLib::Mesh* mesh (FileIO::BoostVtuInterface::readVTUFile(mesh_in.getValue())); INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements()); FileIO::Legacy::MeshIO meshIO; meshIO.setMesh(mesh); meshIO.writeToFile(mesh_out.getValue()); delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 0; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd( "Creates a new file for material properties and sets the material ids in the msh-file to 0", ' ', "0.1"); TCLAP::ValueArg<std::string> mesh_arg("m", "mesh", "the mesh to open from a file", false, "", "filename for mesh input"); cmd.add( mesh_arg ); cmd.parse( argc, argv ); // read mesh MeshLib::Mesh* mesh(FileIO::readMeshFromFile(mesh_arg.getValue())); std::vector<MeshLib::Element*> &elems = *(const_cast<std::vector<MeshLib::Element*>*>(&(mesh->getElements()))); std::size_t nElems(elems.size()); std::string name = BaseLib::extractBaseNameWithoutExtension(mesh_arg.getValue()); // create file std::string new_matname(name + "_prop"); std::ofstream out_prop( new_matname.c_str(), std::ios::out ); if (out_prop.is_open()) { for (std::size_t i=0; i<nElems; i++) out_prop << i << "\t" << elems[i]->getValue() << "\n"; out_prop.close(); } else { ERR("Could not create property \"%s\" file.", new_matname.c_str()); return -1; } // set mat ids to 0 and write new msh file for (std::size_t i=0; i<nElems; i++) elems[i]->setValue(0); std::string new_mshname(name + "_new.vtu"); INFO("Writing mesh to file \"%s\".", new_mshname.c_str()); FileIO::VtuInterface mesh_io(mesh); mesh_io.writeToFile (new_mshname); INFO("New files \"%s\" and \"%s\" written.", new_mshname.c_str(), new_matname.c_str()); std::cout << "Conversion finished." << std::endl; return 1; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Converts TIN file into VTU file.", ' ', BaseLib::BuildInfo::git_describe); TCLAP::ValueArg<std::string> inArg("i", "input-tin-file", "the name of the file containing the input TIN", true, "", "string"); cmd.add(inArg); TCLAP::ValueArg<std::string> outArg("o", "output-vtu-file", "the name of the file the mesh will be written to", true, "", "string"); cmd.add(outArg); cmd.parse(argc, argv); INFO("reading the TIN file..."); const std::string tinFileName(inArg.getValue()); auto pnt_vec = std::unique_ptr<std::vector<GeoLib::Point*>>( new std::vector<GeoLib::Point*>); GeoLib::PointVec point_vec("SurfacePoints", std::move(pnt_vec)); std::unique_ptr<GeoLib::Surface> sfc(FileIO::TINInterface::readTIN(tinFileName, point_vec)); if (!sfc) return 1; INFO("TIN read: %d points, %d triangles", pnt_vec->size(), sfc->getNTriangles()); INFO("converting to mesh data"); std::unique_ptr<MeshLib::Mesh> mesh(MeshLib::convertSurfaceToMesh(*sfc, BaseLib::extractBaseNameWithoutExtension(tinFileName), std::numeric_limits<double>::epsilon())); INFO("Mesh created: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements()); INFO("Write it into VTU"); FileIO::VtuInterface writer(mesh.get()); writer.writeToFile(outArg.getValue()); delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 0; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Remove mesh elements.", ' ', "0.1"); // Bounding box params TCLAP::ValueArg<double> zLargeArg("", "z-max", "largest allowed extent in z-dimension", false, std::numeric_limits<double>::max(), "value"); cmd.add(zLargeArg); TCLAP::ValueArg<double> zSmallArg("", "z-min", "smallest allowed extent in z-dimension", false, -1 * std::numeric_limits<double>::max(), "value"); cmd.add(zSmallArg); TCLAP::ValueArg<double> yLargeArg("", "y-max", "largest allowed extent in y-dimension", false, std::numeric_limits<double>::max(), "value"); cmd.add(yLargeArg); TCLAP::ValueArg<double> ySmallArg("", "y-min", "smallest allowed extent in y-dimension", false, -1 * std::numeric_limits<double>::max(), "value"); cmd.add(ySmallArg); TCLAP::ValueArg<double> xLargeArg("", "x-max", "largest allowed extent in x-dimension", false, std::numeric_limits<double>::max(), "value"); cmd.add(xLargeArg); TCLAP::ValueArg<double> xSmallArg("", "x-min", "smallest allowed extent in x-dimension", false, -1 * std::numeric_limits<double>::max(), "value"); cmd.add(xSmallArg); // Non-bounding-box params TCLAP::SwitchArg zveArg("z", "zero-volume", "remove zero volume elements", false); cmd.add(zveArg); TCLAP::MultiArg<std::string> eleTypeArg("t", "element-type", "element type to be removed", false, "element type"); cmd.add(eleTypeArg); TCLAP::MultiArg<unsigned> matIDArg("m", "material-id", "material id", false, "material id"); cmd.add(matIDArg); // I/O params TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file", "the name of the file the mesh will be written to", true, "", "file name of output mesh"); cmd.add(mesh_out); TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file", "the name of the file containing the input mesh", true, "", "file name of input mesh"); cmd.add(mesh_in); cmd.parse(argc, argv); MeshLib::Mesh const*const mesh (FileIO::readMeshFromFile(mesh_in.getValue())); INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements()); MeshLib::ElementSearch ex(*mesh); // search elements IDs to be removed if (zveArg.isSet()) { const std::size_t n_removed_elements = ex.searchByContent(); INFO("%d zero volume elements found.", n_removed_elements); } if (eleTypeArg.isSet()) { const std::vector<std::string> eleTypeNames = eleTypeArg.getValue(); for (auto typeName : eleTypeNames) { const MeshLib::MeshElemType type = MeshLib::String2MeshElemType(typeName); if (type == MeshLib::MeshElemType::INVALID) continue; const std::size_t n_removed_elements = ex.searchByElementType(type); INFO("%d %s elements found.", n_removed_elements, typeName.c_str()); } } if (matIDArg.isSet()) { const std::vector<unsigned> vec_matID = matIDArg.getValue(); for (auto matID : vec_matID) { const std::size_t n_removed_elements = ex.searchByMaterialID(matID); INFO("%d elements with material ID %d found.", n_removed_elements, matID); } } if (xSmallArg.isSet() || xLargeArg.isSet() || ySmallArg.isSet() || yLargeArg.isSet() || zSmallArg.isSet() || zLargeArg.isSet()) { bool aabb_error (false); if (xSmallArg.getValue() >= xLargeArg.getValue()) { ERR ("Minimum x-extent larger than maximum x-extent."); aabb_error = true; } if (ySmallArg.getValue() >= yLargeArg.getValue()) { ERR ("Minimum y-extent larger than maximum y-extent."); aabb_error = true; } if (zSmallArg.getValue() >= zLargeArg.getValue()) { ERR ("Minimum z-extent larger than maximum z-extent."); aabb_error = true; } if (aabb_error) return 1; std::array<MathLib::Point3d, 2> extent({{ MathLib::Point3d(std::array<double,3>{{xSmallArg.getValue(), ySmallArg.getValue(), zSmallArg.getValue()}}), MathLib::Point3d(std::array<double,3>{{xLargeArg.getValue(), yLargeArg.getValue(), zLargeArg.getValue()}})}}); const std::size_t n_removed_elements = ex.searchByBoundingBox( GeoLib::AABB(extent.begin(), extent.end())); INFO("%d elements found.", n_removed_elements); } // remove the elements and create a new mesh object. MeshLib::Mesh const*const new_mesh = MeshLib::removeElements(*mesh, ex.getSearchedElementIDs(), mesh->getName()); // write into a file FileIO::Legacy::MeshIO meshIO; meshIO.setMesh(new_mesh); meshIO.writeToFile(mesh_out.getValue()); delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 0; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Add EMI data as a scalar cell array to a 2d mesh.", ' ', "0.1"); // I/O params TCLAP::ValueArg<std::string> poly_out("o", "polydata-output-file", "the name of the file the data will be written to", true, "", "file name of polydata file"); cmd.add(poly_out); TCLAP::ValueArg<std::string> csv_in("i", "csv-input-file", "csv-file containing EMI data", true, "", "name of the csv input file"); cmd.add(csv_in); TCLAP::ValueArg<std::string> dem_in("s", "DEM-file", "Surface DEM for mapping ERT data", false, "", "file name of the Surface DEM"); cmd.add(dem_in); cmd.parse(argc, argv); MeshLib::Mesh* mesh (nullptr); if (dem_in.isSet()) { mesh = FileIO::VtuInterface::readVTUFile(dem_in.getValue()); if (mesh == nullptr) { ERR ("Error reading mesh file."); return -2; } if (mesh->getDimension() != 2) { ERR ("This utility can handle only 2d meshes at this point."); delete mesh; return -3; } INFO("Surface mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements()); } GeoLib::GEOObjects geo_objects; FileIO::XmlGmlInterface xml(geo_objects); //std::vector<GeoLib::Polyline*> *lines = new std::vector<GeoLib::Polyline*>; std::array<char, 2> dipol = {{ 'H', 'V' }}; std::array<char,3> const regions = {{'A', 'B', 'C'}}; for (std::size_t j=0; j<dipol.size(); ++j) { std::vector<GeoLib::Point*> *points = new std::vector<GeoLib::Point*>; for (std::size_t i=0; i<regions.size(); ++i) { //std::size_t const start_idx (points->size()); getPointsFromFile(*points, csv_in.getValue(), dipol[j], regions[i]); //std::size_t const end_idx (points->size()); //GeoLib::Polyline* line = new GeoLib::Polyline(*points); //for (std::size_t j=start_idx; j<end_idx; ++j) // line->addPoint(j); //lines->push_back(line); } std::string geo_name (std::string("EMI Data ").append(1,dipol[j])); geo_objects.addPointVec(points, geo_name); //geo_objects.addPolylineVec(lines, geo_name); if (mesh != nullptr) { GeoMapper mapper(geo_objects, geo_name); mapper.mapOnMesh(mesh); } xml.setNameForExport(geo_name); std::string const output_name = poly_out.getValue() + "_" + dipol[j] + ".gml"; xml.writeToFile(output_name); std::vector<double> emi; for (std::size_t i=0; i<regions.size(); ++i) getMeasurements(emi, csv_in.getValue(), dipol[j], regions[i]); writeMeasurementsToFile(emi, poly_out.getValue(), dipol[j]); std::for_each(points->begin(), points->end(), std::default_delete<GeoLib::Point>()); delete points; } delete mesh; delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 0; }
int main(int argc, char *argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Simple mesh search test", ' ', "0.1"); // Define a value argument and add it to the command line. // A value arg defines a flag and a type of value that it expects, // such as "-m meshfile". TCLAP::ValueArg<std::string> mesh_arg("m","mesh","input mesh file",true,"test.msh","string"); // Add the argument mesh_arg to the CmdLine object. The CmdLine object // uses this Arg to parse the command line. cmd.add( mesh_arg ); TCLAP::ValueArg<unsigned> number_arg("n","number-of-test-points","the number of test points",true,10000,"positive number"); cmd.add( number_arg ); TCLAP::ValueArg<bool> contiguous_arg("c","use-contiguous-memory","use a contiguous memory for the test",false,true,"yes or no | 1 or 0"); cmd.add( contiguous_arg ); cmd.parse( argc, argv ); std::string fname (mesh_arg.getValue()); FileIO::MeshIO mesh_io; #ifndef WIN32 BaseLib::MemWatch mem_watch; unsigned long mem_without_mesh (mem_watch.getVirtMemUsage()); #endif BaseLib::RunTime run_time; run_time.start(); MeshLib::Mesh* mesh (mesh_io.loadMeshFromFile(fname)); #ifndef WIN32 unsigned long mem_with_mesh (mem_watch.getVirtMemUsage()); INFO ("mem for mesh: %i MB", (mem_with_mesh - mem_without_mesh)/(1024*1024)); #endif run_time.stop(); INFO ("time for reading: %f s", run_time.elapsed()); // *** preparing test data std::vector<MeshLib::Node*> const& nodes(mesh->getNodes()); std::vector<GeoLib::Point*> pnts_for_search; unsigned n(std::min(static_cast<unsigned>(nodes.size()), number_arg.getValue())); for (size_t k(0); k<n; k++) { pnts_for_search.push_back(new GeoLib::Point(nodes[k]->getCoords())); } std::vector<size_t> idx_found_nodes; testMeshGridAlgorithm(mesh, pnts_for_search, idx_found_nodes, contiguous_arg.getValue()); for (size_t k(0); k<n; k++) { delete pnts_for_search[k]; } delete mesh; delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Append line elements into a mesh.", ' ', "0.1"); TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file", "the name of the file containing the input mesh", true, "", "file name of input mesh"); cmd.add(mesh_in); TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file", "the name of the file the mesh will be written to", true, "", "file name of output mesh"); cmd.add(mesh_out); TCLAP::ValueArg<std::string> geoFileArg("g", "geo-file", "the name of the geometry file which contains polylines", true, "", "the name of the geometry file"); cmd.add(geoFileArg); // parse arguments cmd.parse(argc, argv); // read GEO objects GeoLib::GEOObjects geo_objs; FileIO::BoostXmlGmlInterface xml(geo_objs); xml.readFile(geoFileArg.getValue()); std::vector<std::string> geo_names; geo_objs.getGeometryNames (geo_names); if (geo_names.empty ()) { std::cout << "no geometries found" << std::endl; return -1; } const GeoLib::PolylineVec* ply_vec (geo_objs.getPolylineVecObj(geo_names[0])); if (!ply_vec) { std::cout << "could not found polylines" << std::endl; return -1; } // read a mesh MeshLib::Mesh const*const mesh (FileIO::readMeshFromFile(mesh_in.getValue())); if (!mesh) { ERR("Mesh file %s not found", mesh_in.getValue().c_str()); return 1; } INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements()); // add line elements std::unique_ptr<MeshLib::Mesh> new_mesh = MeshGeoToolsLib::appendLinesAlongPolylines(*mesh, *ply_vec); INFO("Mesh created: %d nodes, %d elements.", new_mesh->getNNodes(), new_mesh->getNElements()); // write into a file FileIO::Legacy::MeshIO meshIO; meshIO.setMesh(new_mesh.get()); meshIO.writeToFile(mesh_out.getValue()); delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 1; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *const custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Converting a mesh in FEFLOW file format (ASCII, version 5.4) to a vtk unstructured grid file (new OGS file format) or to the old OGS file format - see options.", ' ', "0.1"); TCLAP::ValueArg<std::string> ogs_mesh_arg( "o", "out", "filename for output mesh (if extension is msh, old OGS fileformat is written)", true, "", "filename as string"); cmd.add(ogs_mesh_arg); TCLAP::ValueArg<std::string> feflow_mesh_arg( "i", "in", "FEFLOW input file (*.fem)", true, "", "filename as string"); cmd.add(feflow_mesh_arg); cmd.parse(argc, argv); // *** read mesh INFO("Reading %s.", feflow_mesh_arg.getValue().c_str()); #ifndef WIN32 BaseLib::MemWatch mem_watch; unsigned long mem_without_mesh (mem_watch.getVirtMemUsage()); #endif BaseLib::RunTime run_time; run_time.start(); FileIO::FEFLOWInterface feflowIO(nullptr); MeshLib::Mesh const*const mesh(feflowIO.readFEFLOWFile(feflow_mesh_arg.getValue())); if (mesh == nullptr) { INFO("Could not read mesh from %s.", feflow_mesh_arg.getValue().c_str()); return -1; } #ifndef WIN32 unsigned long mem_with_mesh (mem_watch.getVirtMemUsage()); INFO("Mem for mesh: %i MB", (mem_with_mesh - mem_without_mesh)/(1024*1024)); #endif run_time.stop(); INFO("Time for reading: %f seconds.", run_time.elapsed()); INFO("Read %d nodes and %d elements.", mesh->getNNodes(), mesh->getNElements()); // *** write mesh in new format std::string ogs_mesh_fname(ogs_mesh_arg.getValue()); if (BaseLib::getFileExtension(ogs_mesh_fname).compare("msh") == 0) { INFO("Writing %s.", ogs_mesh_fname.c_str()); FileIO::Legacy::MeshIO mesh_io; mesh_io.setMesh(mesh); mesh_io.writeToFile(ogs_mesh_fname); } else { if (BaseLib::getFileExtension(ogs_mesh_fname).compare("vtu") != 0) { ogs_mesh_fname += ".vtu"; } INFO("Writing %s.", ogs_mesh_fname.c_str()); FileIO::BoostVtuInterface mesh_io; mesh_io.setMesh(mesh); mesh_io.writeToFile(ogs_mesh_fname); } INFO("\tDone."); delete mesh; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Edit material IDs of mesh elements.", ' ', "0.1"); TCLAP::SwitchArg replaceArg("r", "replace", "replace material IDs", false); TCLAP::SwitchArg condenseArg("c", "condense", "condense material IDs", false); TCLAP::SwitchArg specifyArg("s", "specify", "specify material IDs by element types (-e)", false); std::vector<TCLAP::Arg*> vec_xors; vec_xors.push_back(&replaceArg); vec_xors.push_back(&condenseArg); vec_xors.push_back(&specifyArg); cmd.xorAdd(vec_xors); TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file", "the name of the file containing the input mesh", true, "", "file name"); cmd.add(mesh_in); TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file", "the name of the file the mesh will be written to", true, "", "file name"); cmd.add(mesh_out); TCLAP::MultiArg<unsigned> matIDArg("m", "current-material-id", "current material id to be replaced", false, "number"); cmd.add(matIDArg); TCLAP::ValueArg<unsigned> newIDArg("n", "new-material-id", "new material id", false, 0, "number"); cmd.add(newIDArg); std::vector<std::string> eleList(MeshLib::getMeshElemTypeStringsShort()); TCLAP::ValuesConstraint<std::string> allowedVals(eleList); TCLAP::ValueArg<std::string> eleTypeArg("e", "element-type", "element type", false, "", &allowedVals); cmd.add(eleTypeArg); cmd.parse(argc, argv); if (!replaceArg.isSet() && !condenseArg.isSet() && !specifyArg.isSet()) { INFO("Please select editing mode: -r or -c or -s"); return 0; } else if (replaceArg.isSet() && condenseArg.isSet()) { INFO("Please select only one editing mode: -r or -c or -s"); return 0; } else if (replaceArg.isSet()) { if (!matIDArg.isSet() || !newIDArg.isSet()) { INFO("current and new material IDs must be provided for replacement"); return 0; } } else if (specifyArg.isSet()) { if (!eleTypeArg.isSet() || !newIDArg.isSet()) { INFO("element type and new material IDs must be provided to specify elements"); return 0; } } MeshLib::Mesh* mesh (FileIO::readMeshFromFile(mesh_in.getValue())); INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements()); if (condenseArg.isSet()) { INFO("Condensing material ID..."); MeshLib::ElementValueModification::condense(*mesh); } else if (replaceArg.isSet()) { INFO("Replacing material ID..."); const auto vecOldID = matIDArg.getValue(); const unsigned newID = newIDArg.getValue(); for (auto oldID : vecOldID) { INFO("%d -> %d", oldID, newID); MeshLib::ElementValueModification::replace(*mesh, oldID, newID, true); } } else if (specifyArg.isSet()) { INFO("Specifying material ID..."); const std::string eleTypeName(eleTypeArg.getValue()); const MeshLib::MeshElemType eleType = MeshLib::String2MeshElemType(eleTypeName); const unsigned newID = newIDArg.getValue(); unsigned cnt = MeshLib::ElementValueModification::setByElementType(*mesh, eleType, newID); INFO("updated %d elements", cnt); } // write into a file FileIO::writeMeshToFile(*mesh, mesh_out.getValue()); delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 0; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd( "Generates properties for mesh elements of an input mesh deploying a ASC raster file", ' ', "0.1"); TCLAP::ValueArg<std::string> out_mesh_arg("o", "out-mesh", "the mesh is stored to a file of this name", false, "", "filename for mesh output"); cmd.add( out_mesh_arg ); TCLAP::ValueArg<bool> refinement_raster_output_arg("", "output-refined-raster", "write refined raster to a new ASC file", false, false, "0"); cmd.add( refinement_raster_output_arg ); TCLAP::ValueArg<unsigned> refinement_arg( "r", "refine", "refinement factor that raises the resolution of the raster data", false, 1, "factor (default = 1)"); cmd.add( refinement_arg ); TCLAP::ValueArg<std::string> mapping_arg("", "mapping-name", "file name of mapping", true, "", "file name"); cmd.add( mapping_arg ); TCLAP::ValueArg<std::string> raster_arg("", "raster-file", "the name of the ASC raster file", true, "", "file name"); cmd.add( raster_arg ); TCLAP::ValueArg<std::string> mesh_arg("m", "mesh", "the mesh is read from this file", true, "test.msh", "file name"); cmd.add( mesh_arg ); cmd.parse( argc, argv ); // read mesh MeshLib::Mesh* dest_mesh(FileIO::readMeshFromFile(mesh_arg.getValue())); // read raster and if required manipulate it GeoLib::Raster* raster(FileIO::AsciiRasterInterface::getRasterFromASCFile( raster_arg.getValue())); if (refinement_arg.getValue() > 1) { raster->refineRaster(refinement_arg.getValue()); if (refinement_raster_output_arg.getValue()) { // write new asc file std::string new_raster_fname (BaseLib::dropFileExtension( raster_arg.getValue())); new_raster_fname += "-" + std::to_string(raster->getNRows()) + "x" + std::to_string(raster->getNCols()) + ".asc"; FileIO::AsciiRasterInterface::writeRasterAsASC(*raster, new_raster_fname); } } // put raster data in a std::vector GeoLib::Raster::const_iterator raster_it(raster->begin()); std::size_t n_cols(raster->getNCols()), n_rows(raster->getNRows()); std::size_t size(n_cols * n_rows); std::vector<double> src_properties(size); for (unsigned row(0); row<n_rows; row++) { for (unsigned col(0); col<n_cols; col++) { src_properties[row * n_cols + col] = *raster_it; ++raster_it; } } { double mu, var; std::tie(mu, var) = computeMeanAndVariance(src_properties.begin(), src_properties.end()); INFO("Mean value of source: %f.", mu); INFO("Variance of source: %f.", var); } MeshLib::Mesh* src_mesh(MeshLib::ConvertRasterToMesh(*raster, MeshLib::MeshElemType::QUAD, MeshLib::UseIntensityAs::MATERIAL).execute()); std::vector<std::size_t> src_perm(size); std::iota(src_perm.begin(), src_perm.end(), 0); BaseLib::Quicksort<double>(src_properties, 0, size, src_perm); // compress the property data structure const std::size_t mat_map_size(src_properties.size()); std::vector<std::size_t> mat_map(mat_map_size); mat_map[0] = 0; std::size_t n_mat(1); for (std::size_t k(1); k<mat_map_size; ++k) { if (std::fabs(src_properties[k] - src_properties[k-1]) > std::numeric_limits<double>::epsilon()) { mat_map[k] = mat_map[k - 1] + 1; n_mat++; } else mat_map[k] = mat_map[k - 1]; } std::vector<double> compressed_src_properties(n_mat); compressed_src_properties[0] = src_properties[0]; for (std::size_t k(1), id(1); k<mat_map_size; ++k) { if (std::fabs(src_properties[k] - src_properties[k-1]) > std::numeric_limits<double>::epsilon()) { compressed_src_properties[id] = src_properties[k]; id++; } } compressed_src_properties[n_mat - 1] = src_properties[mat_map_size - 1]; // reset materials in source mesh const std::size_t n_mesh_elements(src_mesh->getNElements()); for (std::size_t k(0); k<n_mesh_elements; k++) { const_cast<MeshLib::Element*>(src_mesh->getElement(src_perm[k]))->setValue(mat_map[k]); } // do the interpolation MeshLib::Mesh2MeshPropertyInterpolation mesh_interpolation(src_mesh, &compressed_src_properties); std::vector<double> dest_properties(dest_mesh->getNElements()); mesh_interpolation.setPropertiesForMesh(const_cast<MeshLib::Mesh*>(dest_mesh), dest_properties); const std::size_t n_dest_mesh_elements(dest_mesh->getNElements()); { // write property file std::string property_fname(mapping_arg.getValue()); std::ofstream property_out(property_fname.c_str()); if (!property_out) { ERR("Could not open file %s for writing the mapping.", property_fname.c_str()); return -1; } for (std::size_t k(0); k < n_dest_mesh_elements; k++) property_out << k << " " << dest_properties[k] << "\n"; property_out.close(); } { double mu, var; std::tie(mu, var) = computeMeanAndVariance(dest_properties.begin(), dest_properties.end()); INFO("Mean value of destination: %f.", mu); INFO("Variance of destination: %f.", var); } if (! out_mesh_arg.getValue().empty()) { std::vector<std::size_t> dest_perm(n_dest_mesh_elements); std::iota(dest_perm.begin(), dest_perm.end(), 0); BaseLib::Quicksort<double>(dest_properties, 0, n_dest_mesh_elements, dest_perm); // reset materials in destination mesh for (std::size_t k(0); k<n_dest_mesh_elements; k++) { const_cast<MeshLib::Element*>(dest_mesh->getElement(dest_perm[k]))->setValue(k); } FileIO::Legacy::MeshIO mesh_writer; mesh_writer.setPrecision(12); mesh_writer.setMesh(dest_mesh); mesh_writer.writeToFile(out_mesh_arg.getValue()); } delete raster; delete src_mesh; delete dest_mesh; delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 0; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Remove mesh elements.", ' ', "0.1"); TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file", "the name of the file containing the input mesh", true, "", "file name of input mesh"); cmd.add(mesh_in); TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file", "the name of the file the mesh will be written to", true, "", "file name of output mesh"); cmd.add(mesh_out); TCLAP::SwitchArg zveArg("z", "zero-volume", "remove zero volume elements", false); cmd.add(zveArg); TCLAP::MultiArg<std::string> eleTypeArg("t", "element-type", "element type to be removed", false, "element type"); cmd.add(eleTypeArg); TCLAP::MultiArg<unsigned> matIDArg("m", "material-id", "material id", false, "material id"); cmd.add(matIDArg); cmd.parse(argc, argv); MeshLib::Mesh* mesh (FileIO::readMeshFromFile(mesh_in.getValue())); INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements()); // search elements IDs to be removed std::vector<std::size_t> vec_elementIDs_removed; if (zveArg.isSet()) { std::vector<std::size_t> vec_matched = searchByZeroContent(mesh->getElements()); updateUnion(vec_matched, vec_elementIDs_removed); INFO("%d zero volume elements found.", vec_matched.size()); } if (eleTypeArg.isSet()) { std::vector<std::string> eleTypeNames = eleTypeArg.getValue(); for (auto typeName : eleTypeNames) { MeshElemType type = String2MeshElemType(typeName); if (type == MeshElemType::INVALID) continue; std::vector<std::size_t> vec_matched = searchByElementType(mesh->getElements(), type); updateUnion(vec_matched, vec_elementIDs_removed); INFO("%d %s elements found.", vec_matched.size(), typeName.c_str()); } } if (matIDArg.isSet()) { std::vector<unsigned> vec_matID = matIDArg.getValue(); for (auto matID : vec_matID) { std::vector<std::size_t> vec_matched = searchByMaterialID(mesh->getElements(), matID); updateUnion(vec_matched, vec_elementIDs_removed); INFO("%d elements with material ID %d found.", vec_matched.size(), matID); } } // remove the elements INFO("Removing total %d elements...", vec_elementIDs_removed.size()); std::vector<MeshLib::Element*> tmp_eles = excludeElements(mesh->getElements(), vec_elementIDs_removed); INFO("%d elements remained.", tmp_eles.size()); std::vector<MeshLib::Node*> new_nodes; std::vector<MeshLib::Element*> new_eles; copyNodesElements(mesh->getNodes(), tmp_eles, new_nodes, new_eles); // create a new mesh object. Unsued nodes are removed while construction MeshLib::Mesh* new_mesh(new MeshLib::Mesh(mesh->getName(), new_nodes, new_eles)); // write into a file FileIO::Legacy::MeshIO meshIO; meshIO.setMesh(new_mesh); meshIO.writeToFile(mesh_out.getValue()); delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); return 0; }
int main (int argc, char* argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *const custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Converting meshes in gmsh file format (ASCII, version 2.2) to a vtk unstructured grid file (new OGS file format) or to the old OGS file format - see options.", ' ', "0.1"); TCLAP::ValueArg<std::string> ogs_mesh_arg( "o", "out", "filename for output mesh (if extension is msh, old OGS fileformat is written)", true, "", "filename as string"); cmd.add(ogs_mesh_arg); TCLAP::ValueArg<std::string> gmsh_mesh_arg( "i", "in", "gmsh input file", true, "", "filename as string"); cmd.add(gmsh_mesh_arg); TCLAP::SwitchArg exclude_lines_arg("e", "exclude-lines", "if set, lines will not be written to the ogs mesh"); cmd.add(exclude_lines_arg); cmd.parse(argc, argv); // *** read mesh INFO("Reading %s.", gmsh_mesh_arg.getValue().c_str()); #ifndef WIN32 BaseLib::MemWatch mem_watch; unsigned long mem_without_mesh (mem_watch.getVirtMemUsage()); #endif BaseLib::RunTime run_time; run_time.start(); MeshLib::Mesh * mesh(FileIO::GMSHInterface::readGMSHMesh(gmsh_mesh_arg.getValue())); if (mesh == nullptr) { INFO("Could not read mesh from %s.", gmsh_mesh_arg.getValue().c_str()); return -1; } #ifndef WIN32 unsigned long mem_with_mesh (mem_watch.getVirtMemUsage()); INFO("Mem for mesh: %i MB", (mem_with_mesh - mem_without_mesh)/(1024*1024)); #endif INFO("Time for reading: %f seconds.", run_time.elapsed()); INFO("Read %d nodes and %d elements.", mesh->getNNodes(), mesh->getNElements()); // *** remove line elements on request if (exclude_lines_arg.getValue()) { auto ex = MeshLib::ElementSearch(*mesh); ex.searchByElementType(MeshLib::MeshElemType::LINE); auto m = MeshLib::removeElements(*mesh, ex.getSearchedElementIDs(), mesh->getName()+"-withoutLines"); if (m != nullptr) { INFO("Removed %d lines.", mesh->getNElements() - m->getNElements()); std::swap(m, mesh); delete m; } else { INFO("Mesh does not contain any lines."); } } // *** write mesh in new format std::string ogs_mesh_fname(ogs_mesh_arg.getValue()); if (BaseLib::getFileExtension(ogs_mesh_fname).compare("msh") == 0) { INFO("Writing %s.", ogs_mesh_fname.c_str()); FileIO::Legacy::MeshIO mesh_io; mesh_io.setMesh(mesh); mesh_io.writeToFile(ogs_mesh_fname); } else { if (BaseLib::getFileExtension(ogs_mesh_fname).compare("vtu") != 0) { ogs_mesh_fname += ".vtu"; } INFO("Writing %s.", ogs_mesh_fname.c_str()); FileIO::VtuInterface mesh_io(mesh); mesh_io.writeToFile(ogs_mesh_fname); } INFO("\tDone."); delete mesh; }
int main(int argc, char *argv[]) { LOGOG_INITIALIZE(); logog::Cout* logog_cout (new logog::Cout); BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter); logog_cout->SetFormatter(*custom_format); TCLAP::CmdLine cmd("Query mesh information", ' ', BaseLib::BuildInfo::git_describe); TCLAP::UnlabeledValueArg<std::string> mesh_arg("mesh-file","input mesh file",true,"","string"); cmd.add( mesh_arg ); TCLAP::MultiArg<std::size_t> eleId_arg("e","element-id","element ID",false,"number"); cmd.add( eleId_arg ); TCLAP::MultiArg<std::size_t> nodeId_arg("n","node-id","node ID",false,"number"); cmd.add( nodeId_arg ); cmd.parse( argc, argv ); const std::string filename(mesh_arg.getValue()); // read the mesh file const MeshLib::Mesh* mesh = FileIO::readMeshFromFile(filename); if (!mesh) return 1; std::cout << std::scientific << std::setprecision(12); for (auto ele_id : eleId_arg.getValue()) { std::cout << "--------------------------------------------------------" << std::endl; auto* ele = mesh->getElement(ele_id); std::cout << "# Element " << ele->getID() << std::endl; std::cout << "Type : " << CellType2String(ele->getCellType()) << std::endl; std::cout << "Mat ID : " << ele->getValue() << std::endl; std::cout << "Nodes: " << std::endl; for (unsigned i=0; i<ele->getNNodes(); i++) std::cout << ele->getNode(i)->getID() << " " << *ele->getNode(i) << std::endl; std::cout << "Content: " << ele->getContent() << std::endl; std::cout << "Neighbors: "; for (unsigned i=0; i<ele->getNNeighbors(); i++) { if (ele->getNeighbor(i)) std::cout << ele->getNeighbor(i)->getID() << " "; else std::cout << "none "; } std::cout << std::endl; } for (auto node_id : nodeId_arg.getValue()) { std::cout << "--------------------------------------------------------" << std::endl; auto* node = mesh->getNode(node_id); std::cout << "# Node" << node->getID() << std::endl; std::cout << "Coordinates: " << *node << std::endl; std::cout << "Connected elements: " ; for (unsigned i=0; i<node->getNElements(); i++) std::cout << node->getElement(i)->getID() << " "; std::cout << std::endl; } delete mesh; delete custom_format; delete logog_cout; LOGOG_SHUTDOWN(); }