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; }
// Creates a PropertyVector<double> and maps it into a vtkDataArray-equivalent TEST(InSituLibMappedPropertyVector, Int) { const size_t mesh_size = 5; const double length = 1.0; MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size); ASSERT_TRUE(mesh != nullptr); const std::size_t size(mesh_size*mesh_size*mesh_size); std::string const prop_name("TestProperty"); boost::optional<MeshLib::PropertyVector<int> &> properties( mesh->getProperties().createNewPropertyVector<int>(prop_name, MeshLib::MeshItemType::Cell)); (*properties).resize(size); std::iota((*properties).begin(), (*properties).end(), 1); vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<int> > dataArray; dataArray->SetPropertyVector(*properties); ASSERT_EQ(dataArray->GetNumberOfComponents(), 1); ASSERT_EQ(dataArray->GetNumberOfTuples(), size); ASSERT_EQ(dataArray->GetValueReference(0), 1); double* range = dataArray->GetRange(0); ASSERT_EQ(range[0], 1); ASSERT_EQ(range[1], 1 + mesh->getNElements() - 1); delete mesh; }
int main(int argc, char *argv[]) { LOGOG_INITIALIZE(); logog::Cout* logogCout = new logog::Cout; TCLAP::CmdLine cmd("Simple mesh loading 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,"homer","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 ); 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()); // std::cout << "mem for mesh: " << (mem_with_mesh - mem_without_mesh)/(1024*1024) << " MB" << std::endl; INFO ("mem for mesh: %i MB", (mem_with_mesh - mem_without_mesh)/(1024*1024)); #endif run_time.stop(); // std::cout << "time for reading: " << run_time.elapsed() << " s" << std::endl; INFO ("time for reading: %f s", run_time.elapsed()); unsigned elem_id = 25000; const MeshLib::Element* e = mesh->getElement(elem_id); const size_t nElems = mesh->getNElements(); for (unsigned i=0; i< e->getNNeighbors(); i++) { for (unsigned j=0; j< nElems; j++) if (mesh->getElement(j) == e->getNeighbor(i)) std::cout << "neighbour of element " << elem_id << elem_id << " : " << j << std::endl; } delete mesh; delete logogCout; LOGOG_SHUTDOWN(); }
TEST(MeshLib, Duplicate) { MeshLib::Mesh* mesh (MeshLib::MeshGenerator::generateRegularQuadMesh(10, 5, 1)); std::vector<MeshLib::Node*> new_nodes (MeshLib::copyNodeVector(mesh->getNodes())); std::vector<MeshLib::Element*> new_elements (MeshLib::copyElementVector(mesh->getElements(), new_nodes)); MeshLib::Mesh new_mesh ("new", new_nodes, new_elements); ASSERT_EQ (mesh->getNElements(), new_mesh.getNElements()); ASSERT_EQ (mesh->getNNodes(), new_mesh.getNNodes()); std::vector<std::size_t> del_idx(1,1); MeshLib::removeMeshNodes(*mesh, del_idx); ASSERT_EQ (mesh->getNElements(), new_mesh.getNElements()-2); ASSERT_EQ (mesh->getNNodes(), new_mesh.getNNodes()-2); ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh->getNode(0), *new_mesh.getNode(0))); ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh->getNode(0), *new_mesh.getNode(2))); ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh->getElement(0)->getNode(0), *new_mesh.getElement(0)->getNode(0))); ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh->getElement(0)->getNode(0), *new_mesh.getElement(2)->getNode(0))); }
bool LayeredVolume::createRasterLayers(const MeshLib::Mesh &mesh, const std::vector<GeoLib::Raster const*> &rasters, double minimum_thickness, double noDataReplacementValue) { if (mesh.getDimension() != 2) return false; _elevation_epsilon = calcEpsilon(*rasters[0], *rasters.back()); if (_elevation_epsilon <= 0) return false; // remove line elements, only tri + quad remain MeshLib::ElementSearch ex(mesh); ex.searchByElementType(MeshLib::MeshElemType::LINE); MeshLib::Mesh* top (removeElements(mesh, ex.getSearchedElementIDs(), "MeshLayer")); if (top==nullptr) top = new MeshLib::Mesh(mesh); if (!MeshLib::MeshLayerMapper::layerMapping(*top, *rasters.back(), noDataReplacementValue)) return false; MeshLib::Mesh* bottom (new MeshLib::Mesh(*top)); if (!MeshLib::MeshLayerMapper::layerMapping(*bottom, *rasters[0], 0)) { delete top; return false; } this->_minimum_thickness = minimum_thickness; _nodes = MeshLib::copyNodeVector(bottom->getNodes()); _elements = MeshLib::copyElementVector(bottom->getElements(), _nodes); delete bottom; // map each layer and attach to subsurface mesh const std::size_t nRasters (rasters.size()); for (std::size_t i=1; i<nRasters; ++i) this->addLayerToMesh(*top, i, *rasters[i]); // close boundaries between layers this->addLayerBoundaries(*top, nRasters); this->removeCongruentElements(nRasters, top->getNElements()); delete top; return true; }
std::vector<ElementErrorCode> MeshValidation::testElementGeometry(const MeshLib::Mesh &mesh, double min_volume) { INFO ("Testing mesh element geometry:"); const std::size_t nErrorCodes (static_cast<std::size_t>(ElementErrorFlag::MaxValue)); unsigned error_count[nErrorCodes]; std::fill_n(error_count, 4, 0); const std::size_t nElements (mesh.getNElements()); const std::vector<MeshLib::Element*> &elements (mesh.getElements()); std::vector<ElementErrorCode> error_code_vector; error_code_vector.reserve(nElements); for (std::size_t i=0; i<nElements; ++i) { const ElementErrorCode e = elements[i]->validate(); error_code_vector.push_back(e); if (e.none()) continue; // increment error statistics const std::bitset< static_cast<std::size_t>(ElementErrorFlag::MaxValue) > flags (static_cast< std::bitset<static_cast<std::size_t>(ElementErrorFlag::MaxValue)> >(e)); for (unsigned j=0; j<nErrorCodes; ++j) error_count[j] += flags[j]; } // if a larger volume threshold is given, evaluate elements again to add them even if they are formally okay if (min_volume > std::numeric_limits<double>::epsilon()) for (std::size_t i=0; i<nElements; ++i) if (elements[i]->getContent() < min_volume) error_code_vector[i].set(ElementErrorFlag::ZeroVolume); // output const unsigned error_sum (static_cast<unsigned>(std::accumulate(error_count, error_count+nErrorCodes, 0.0))); if (error_sum != 0) { ElementErrorFlag flags[nErrorCodes] = { ElementErrorFlag::ZeroVolume, ElementErrorFlag::NonCoplanar, ElementErrorFlag::NonConvex, ElementErrorFlag::NodeOrder }; for (std::size_t i=0; i<nErrorCodes; ++i) if (error_count[i]) INFO ("%d elements found with %s.", error_count[i], ElementErrorCode::toString(flags[i]).c_str()); } else INFO ("No errors found."); return error_code_vector; }
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("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("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; }