// Creates a PropertyVector<unsigned> and maps it into a vtkDataArray-equivalent TEST(MeshLibMappedPropertyVector, Unsigned) { const std::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 number_of_tuples(mesh_size*mesh_size*mesh_size); std::string const prop_name("TestProperty"); auto* const properties = mesh->getProperties().createNewPropertyVector<unsigned>( prop_name, MeshLib::MeshItemType::Cell); properties->resize(number_of_tuples); std::iota(properties->begin(), properties->end(), 0); vtkNew<MeshLib::VtkMappedPropertyVectorTemplate<unsigned> > dataArray; dataArray->SetPropertyVector(*properties); ASSERT_EQ(dataArray->GetNumberOfComponents(), 1); ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples); ASSERT_EQ(dataArray->GetValueReference(0), 0); double* range = dataArray->GetRange(0); ASSERT_EQ(range[0], 0); ASSERT_EQ(range[1], 0 + mesh->getNumberOfElements() - 1); delete mesh; }
std::size_t ElementValueModification::setByElementType(MeshLib::Mesh &mesh, MeshElemType ele_type, int const new_value) { MeshLib::PropertyVector<int>* property_value_vector = nullptr; try { property_value_vector = mesh.getProperties().getPropertyVector<int>( "MaterialIDs", MeshLib::MeshItemType::Cell, 1); } catch (std::runtime_error const& e) { ERR("%s", e.what()); return 0; } std::vector<MeshLib::Element*> const& elements(mesh.getElements()); std::size_t cnt(0); for (std::size_t k(0); k < elements.size(); k++) { if (elements[k]->getGeomType() != ele_type) { continue; } (*property_value_vector)[k] = new_value; cnt++; } return cnt; }
std::unique_ptr<PythonBoundaryCondition> createPythonBoundaryCondition( BaseLib::ConfigTree const& config, MeshLib::Mesh const& boundary_mesh, NumLib::LocalToGlobalIndexMap const& dof_table, std::size_t bulk_mesh_id, int const variable_id, int const component_id, unsigned const integration_order, unsigned const shapefunction_order, unsigned const global_dim) { //! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__type} config.checkConfigParameter("type", "Python"); //! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__Python__bc_object} auto const bc_object = config.getConfigParameter<std::string>("bc_object"); //! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__Python__flush_stdout} auto const flush_stdout = config.getConfigParameter("flush_stdout", false); // Evaluate Python code in scope of main module pybind11::object scope = pybind11::module::import("__main__").attr("__dict__"); if (!scope.contains(bc_object)) OGS_FATAL( "Function `%s' is not defined in the python script file, or there " "was no python script file specified.", bc_object.c_str()); auto* bc = scope[bc_object.c_str()] .cast<PythonBoundaryConditionPythonSideInterface*>(); if (variable_id >= static_cast<int>(dof_table.getNumberOfVariables()) || component_id >= dof_table.getNumberOfVariableComponents(variable_id)) { OGS_FATAL( "Variable id or component id too high. Actual values: (%d, %d), " "maximum values: (%d, %d).", variable_id, component_id, dof_table.getNumberOfVariables(), dof_table.getNumberOfVariableComponents(variable_id)); } // In case of partitioned mesh the boundary could be empty, i.e. there is no // boundary condition. #ifdef USE_PETSC // This can be extracted to createBoundaryCondition() but then the config // parameters are not read and will cause an error. // TODO (naumov): Add a function to ConfigTree for skipping the tags of the // subtree and move the code up in createBoundaryCondition(). if (boundary_mesh.getDimension() == 0 && boundary_mesh.getNumberOfNodes() == 0 && boundary_mesh.getNumberOfElements() == 0) { return nullptr; } #endif // USE_PETSC return std::make_unique<PythonBoundaryCondition>( PythonBoundaryConditionData{ bc, dof_table, bulk_mesh_id, dof_table.getGlobalComponent(variable_id, component_id), boundary_mesh}, integration_order, shapefunction_order, global_dim, flush_stdout); }
IntegrationPointMetaData getIntegrationPointMetaData(MeshLib::Mesh const& mesh, std::string const& name) { if (!mesh.getProperties().existsPropertyVector<char>( "IntegrationPointMetaData")) { OGS_FATAL( "Integration point data '%s' is present in the vtk field " "data but the required 'IntegrationPointMetaData' array " "is not available.", name.c_str()); } auto const& mesh_property_ip_meta_data = *mesh.getProperties().template getPropertyVector<char>( "IntegrationPointMetaData"); if (mesh_property_ip_meta_data.getMeshItemType() != MeshLib::MeshItemType::IntegrationPoint) { OGS_FATAL("IntegrationPointMetaData array must be field data."); } // Find the current integration point data entry and extract the // meta data. auto const ip_meta_data = extractIntegrationPointMetaData( json::parse(mesh_property_ip_meta_data.begin(), mesh_property_ip_meta_data.end()), name); return ip_meta_data; }
void MeshSurfaceExtraction::getSurfaceAreaForNodes(const MeshLib::Mesh &mesh, std::vector<double> &node_area_vec) { if (mesh.getDimension() == 2) { double total_area (0); // for each node, a vector containing all the element idget every element const std::vector<MeshLib::Node*> &nodes = mesh.getNodes(); const size_t nNodes ( mesh.getNNodes() ); node_area_vec.reserve(nNodes); for (size_t n=0; n<nNodes; ++n) { double node_area (0); std::vector<MeshLib::Element*> conn_elems = nodes[n]->getElements(); const size_t nConnElems (conn_elems.size()); for (size_t i=0; i<nConnElems; ++i) { const MeshLib::Element* elem (conn_elems[i]); const unsigned nElemParts = (elem->getGeomType() == MeshElemType::TRIANGLE) ? 3 : 4; const double area = conn_elems[i]->getContent() / nElemParts; node_area += area; total_area += area; } node_area_vec.push_back(node_area); } INFO ("Total surface Area: %f", total_area); } else ERR ("Error in MeshSurfaceExtraction::getSurfaceAreaForNodes() - Given mesh is no surface mesh (dimension != 2)."); }
void LayeredVolume::addLayerBoundaries(const MeshLib::Mesh &layer, std::size_t nLayers) { const unsigned nLayerBoundaries (nLayers-1); const std::size_t nNodes (layer.getNNodes()); const std::vector<MeshLib::Element*> &layer_elements (layer.getElements()); for (MeshLib::Element* elem : layer_elements) { const std::size_t nElemNodes (elem->getNBaseNodes()); for (unsigned i=0; i<nElemNodes; ++i) if (elem->getNeighbor(i) == nullptr) for (unsigned j=0; j<nLayerBoundaries; ++j) { const std::size_t offset (j*nNodes); MeshLib::Node* n0 = _nodes[offset + elem->getNodeIndex(i)]; MeshLib::Node* n1 = _nodes[offset + elem->getNodeIndex((i+1)%nElemNodes)]; MeshLib::Node* n2 = _nodes[offset + nNodes + elem->getNodeIndex((i+1)%nElemNodes)]; MeshLib::Node* n3 = _nodes[offset + nNodes + elem->getNodeIndex(i)]; if (MathLib::Vector3(*n1, *n2).getLength() > std::numeric_limits<double>::epsilon()) { const std::array<MeshLib::Node*,3> tri_nodes = {{ n0, n2, n1 }}; _elements.push_back(new MeshLib::Tri(tri_nodes, nLayers+1+j)); } if (MathLib::Vector3(*n0, *n3).getLength() > std::numeric_limits<double>::epsilon()) { const std::array<MeshLib::Node*,3> tri_nodes = {{ n0, n3, n2 }}; _elements.push_back(new MeshLib::Tri(tri_nodes, nLayers+1+j)); } } } }
void HeatTransportBHEProcess::initializeConcreteProcess( NumLib::LocalToGlobalIndexMap const& dof_table, MeshLib::Mesh const& mesh, unsigned const integration_order) { // Quick access map to BHE's through element ids. std::unordered_map<std::size_t, BHE::BHETypes*> element_to_bhe_map; int const n_BHEs = _process_data._vec_BHE_property.size(); for (int i = 0; i < n_BHEs; i++) { auto const& bhe_elements = _bheMeshData.BHE_elements[i]; for (auto const& e : bhe_elements) { element_to_bhe_map[e->getID()] = &_process_data._vec_BHE_property[i]; } } assert(mesh.getDimension() == 3); ProcessLib::HeatTransportBHE::createLocalAssemblers< HeatTransportBHELocalAssemblerSoil, HeatTransportBHELocalAssemblerBHE>( mesh.getElements(), dof_table, _local_assemblers, element_to_bhe_map, mesh.isAxiallySymmetric(), integration_order, _process_data); // Create BHE boundary conditions for each of the BHEs createBHEBoundaryConditionTopBottom(_bheMeshData.BHE_nodes); }
// 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; }
void LiquidFlowProcess::initializeConcreteProcess( NumLib::LocalToGlobalIndexMap const& dof_table, MeshLib::Mesh const& mesh, unsigned const integration_order) { ProcessLib::ProcessVariable const& pv = getProcessVariables()[0]; ProcessLib::createLocalAssemblers<LiquidFlowLocalAssembler>( mesh.getDimension(), mesh.getElements(), dof_table, pv.getShapeFunctionOrder(), _local_assemblers, mesh.isAxiallySymmetric(), integration_order, _gravitational_axis_id, _gravitational_acceleration, _material_properties); _secondary_variables.addSecondaryVariable( "darcy_velocity_x", 1, makeExtrapolator( getExtrapolator(), _local_assemblers, &LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocityX)); if (mesh.getDimension() > 1) { _secondary_variables.addSecondaryVariable( "darcy_velocity_y", 1, makeExtrapolator( getExtrapolator(), _local_assemblers, &LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocityY)); } if (mesh.getDimension() > 2) { _secondary_variables.addSecondaryVariable( "darcy_velocity_z", 1, makeExtrapolator( getExtrapolator(), _local_assemblers, &LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocityZ)); } }
std::size_t ElementValueModification::setByElementType(MeshLib::Mesh &mesh, MeshElemType ele_type, int const new_value) { boost::optional<MeshLib::PropertyVector<int> &> optional_property_value_vec( mesh.getProperties().getPropertyVector<int>("MaterialIDs") ); if (!optional_property_value_vec) { return 0; } MeshLib::PropertyVector<int> & property_value_vector( optional_property_value_vec.get() ); std::vector<MeshLib::Element*> const& elements(mesh.getElements()); std::size_t cnt(0); for (std::size_t k(0); k<elements.size(); k++) { if (elements[k]->getGeomType()!=ele_type) continue; property_value_vector[k] = new_value; cnt++; } return cnt; }
void RichardsComponentTransportProcess::initializeConcreteProcess( NumLib::LocalToGlobalIndexMap const& dof_table, MeshLib::Mesh const& mesh, unsigned const integration_order) { const int monolithic_process_id = 0; ProcessLib::ProcessVariable const& pv = getProcessVariables(monolithic_process_id)[0]; ProcessLib::createLocalAssemblers<LocalAssemblerData>( mesh.getDimension(), mesh.getElements(), dof_table, pv.getShapeFunctionOrder(), _local_assemblers, mesh.isAxiallySymmetric(), integration_order, _process_data); _secondary_variables.addSecondaryVariable( "darcy_velocity", makeExtrapolator(mesh.getDimension(), getExtrapolator(), _local_assemblers, &RichardsComponentTransportLocalAssemblerInterface:: getIntPtDarcyVelocity)); _secondary_variables.addSecondaryVariable( "saturation", makeExtrapolator(1, getExtrapolator(), _local_assemblers, &RichardsComponentTransportLocalAssemblerInterface:: getIntPtSaturation)); }
std::unique_ptr<InitialCondition> createMeshPropertyInitialCondition( BaseLib::ConfigTree const& config, MeshLib::Mesh const& mesh, int const n_components) { auto field_name = config.getConfParam<std::string>("field_name"); DBUG("Using field_name %s", field_name.c_str()); if (!mesh.getProperties().hasPropertyVector(field_name)) { ERR("The required property %s does not exists in the mesh.", field_name.c_str()); std::abort(); } auto const& property = mesh.getProperties().template getPropertyVector<double>(field_name); if (!property) { ERR("The required property %s is not of the requested type.", field_name.c_str()); std::abort(); } if (property->getNumberOfComponents() != static_cast<std::size_t>(n_components)) { ERR("The required property %s has different number of components %d, " "expected %d.", field_name.c_str(), property->getNumberOfComponents(), n_components); std::abort(); } return std::unique_ptr<InitialCondition>( new MeshPropertyInitialCondition(*property)); }
std::unique_ptr<ParameterBase> createMeshPropertyParameter( BaseLib::ConfigTree const config, MeshLib::Mesh const& mesh) { auto field_name = config.get_optional<std::string>("field_name"); if (!field_name) { ERR("Could not find required parameter field_name."); std::abort(); } DBUG("Using field_name %s", field_name->c_str()); if (!mesh.getProperties().hasPropertyVector(*field_name)) { ERR("The required property %s does not exists in the mesh.", field_name->c_str()); std::abort(); } auto const& property = mesh.getProperties().template getPropertyVector<double>(*field_name); if (!property) { ERR("The required property %s is not of the requested type.", field_name->c_str()); std::abort(); } return std::unique_ptr<ParameterBase>( new MeshPropertyParameter<double>(*property)); }
bool MeshLayerMapper::layerMapping(MeshLib::Mesh &new_mesh, GeoLib::Raster const& raster, double noDataReplacementValue = 0.0) { if (new_mesh.getDimension() != 2) { ERR("MshLayerMapper::layerMapping() - requires 2D mesh"); return false; } GeoLib::RasterHeader const& header (raster.getHeader()); const double x0(header.origin[0]); const double y0(header.origin[1]); const double delta(header.cell_size); const std::pair<double, double> xDim(x0, x0 + header.n_cols * delta); // extension in x-dimension const std::pair<double, double> yDim(y0, y0 + header.n_rows * delta); // extension in y-dimension const std::size_t nNodes (new_mesh.getNumberOfNodes()); const std::vector<MeshLib::Node*> &nodes = new_mesh.getNodes(); for (unsigned i = 0; i < nNodes; ++i) { if (!raster.isPntOnRaster(*nodes[i])) { // use either default value or elevation from layer above nodes[i]->updateCoordinates((*nodes[i])[0], (*nodes[i])[1], noDataReplacementValue); continue; } double elevation (raster.interpolateValueAtPoint(*nodes[i])); if (std::abs(elevation - header.no_data) < std::numeric_limits<double>::epsilon()) elevation = noDataReplacementValue; nodes[i]->updateCoordinates((*nodes[i])[0], (*nodes[i])[1], elevation); } return true; }
void LayeredVolume::addLayerToMesh(const MeshLib::Mesh &dem_mesh, unsigned layer_id, GeoLib::Raster const& raster) { const std::size_t nNodes (dem_mesh.getNNodes()); const std::vector<MeshLib::Node*> &nodes (dem_mesh.getNodes()); const std::size_t node_id_offset (_nodes.size()); const std::size_t last_layer_node_offset (node_id_offset-nNodes); for (std::size_t i=0; i<nNodes; ++i) _nodes.push_back(getNewLayerNode(*nodes[i], *_nodes[last_layer_node_offset + i], raster, _nodes.size())); const std::vector<MeshLib::Element*> &layer_elements (dem_mesh.getElements()); for (MeshLib::Element* elem : layer_elements) { if (elem->getGeomType() == MeshLib::MeshElemType::TRIANGLE) { std::array<MeshLib::Node*,3> tri_nodes = {{ _nodes[node_id_offset+elem->getNodeIndex(0)], _nodes[node_id_offset+elem->getNodeIndex(1)], _nodes[node_id_offset+elem->getNodeIndex(2)] }}; _elements.push_back(new MeshLib::Tri(tri_nodes, layer_id)); } else if (elem->getGeomType() == MeshLib::MeshElemType::QUAD) { std::array<MeshLib::Node*,4> quad_nodes = {{ _nodes[node_id_offset+elem->getNodeIndex(0)], _nodes[node_id_offset+elem->getNodeIndex(1)], _nodes[node_id_offset+elem->getNodeIndex(2)], _nodes[node_id_offset+elem->getNodeIndex(3)] }}; _elements.push_back(new MeshLib::Quad(quad_nodes, layer_id)); } } }
std::unique_ptr<DirichletBoundaryCondition> createDirichletBoundaryCondition( BaseLib::ConfigTree const& config, MeshLib::Mesh const& bc_mesh, NumLib::LocalToGlobalIndexMap const& dof_table_bulk, int const variable_id, int const component_id, const std::vector<std::unique_ptr<ProcessLib::ParameterBase>>& parameters) { DBUG("Constructing DirichletBoundaryCondition from config."); //! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__type} config.checkConfigParameter("type", "Dirichlet"); //! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__Dirichlet__parameter} auto const param_name = config.getConfigParameter<std::string>("parameter"); DBUG("Using parameter %s", param_name.c_str()); auto& param = findParameter<double>(param_name, parameters, 1); // In case of partitioned mesh the boundary could be empty, i.e. there is no // boundary condition. #ifdef USE_PETSC // This can be extracted to createBoundaryCondition() but then the config // parameters are not read and will cause an error. // TODO (naumov): Add a function to ConfigTree for skipping the tags of the // subtree and move the code up in createBoundaryCondition(). if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 && bc_mesh.getNumberOfElements() == 0) { return nullptr; } #endif // USE_PETSC return std::make_unique<DirichletBoundaryCondition>( param, bc_mesh, dof_table_bulk, variable_id, component_id); }
GlobalSparsityPattern computeSparsityPatternNonPETSc( NumLib::LocalToGlobalIndexMap const& dof_table, MeshLib::Mesh const& mesh) { MeshLib::NodeAdjacencyTable node_adjacency_table; node_adjacency_table.createTable(mesh.getNodes()); // A mapping mesh node id -> global indices // It acts as a cache for dof table queries. std::vector<std::vector<GlobalIndexType>> global_idcs; global_idcs.reserve(mesh.getNumberOfNodes()); for (std::size_t n = 0; n < mesh.getNumberOfNodes(); ++n) { MeshLib::Location l(mesh.getID(), MeshLib::MeshItemType::Node, n); global_idcs.push_back(dof_table.getGlobalIndices(l)); } GlobalSparsityPattern sparsity_pattern(dof_table.dofSizeWithGhosts()); // Map adjacent mesh nodes to "adjacent global indices". for (std::size_t n = 0; n < mesh.getNumberOfNodes(); ++n) { unsigned n_connected_dof = 0; for (auto an : node_adjacency_table.getAdjacentNodes(n)) n_connected_dof += global_idcs[an].size(); for (auto global_index : global_idcs[n]) sparsity_pattern[global_index] = n_connected_dof; } return sparsity_pattern; }
std::unique_ptr<ParameterBase> createMeshElementParameter( BaseLib::ConfigTree const& config, MeshLib::Mesh const& mesh) { //! \ogs_file_param{parameter__type} config.checkConfigParameter("type", "MeshElement"); //! \ogs_file_param{parameter__MeshElement__field_name} auto const field_name = config.getConfigParameter<std::string>("field_name"); DBUG("Using field_name %s", field_name.c_str()); if (!mesh.getProperties().hasPropertyVector(field_name)) { OGS_FATAL("The required property %s does not exists in the mesh.", field_name.c_str()); } // TODO other data types than only double auto const& property = mesh.getProperties().getPropertyVector<double>(field_name); if (!property) { OGS_FATAL("The mesh property `%s' is not of the requested type.", field_name.c_str()); } if (property->getMeshItemType() != MeshLib::MeshItemType::Cell) { OGS_FATAL("The mesh property `%s' is not an element property.", field_name.c_str()); } return std::unique_ptr<ParameterBase>( new MeshElementParameter<double>(*property)); }
std::vector<GeoLib::PointWithID*> MshEditor::getSurfaceNodes(const MeshLib::Mesh &mesh, const double *dir) { INFO ("Extracting surface nodes..."); const std::vector<MeshLib::Element*> all_elements (mesh.getElements()); const std::vector<MeshLib::Node*> all_nodes (mesh.getNodes()); std::vector<MeshLib::Element*> sfc_elements; get2DSurfaceElements(all_elements, sfc_elements, dir, mesh.getDimension()); std::vector<MeshLib::Node*> sfc_nodes; std::vector<unsigned> node_id_map(mesh.getNNodes()); get2DSurfaceNodes(all_nodes, sfc_nodes, sfc_elements, node_id_map); const unsigned nElements (sfc_elements.size()); for (unsigned i=0; i<nElements; ++i) delete sfc_elements[i]; const size_t nNodes (sfc_nodes.size()); std::vector<GeoLib::PointWithID*> surface_pnts(nNodes); for (unsigned i=0; i<nNodes; ++i) { surface_pnts[i] = new GeoLib::PointWithID(sfc_nodes[i]->getCoords(), sfc_nodes[i]->getID()); delete sfc_nodes[i]; } return surface_pnts; }
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; }
void VtkMeshConverter::convertScalarArrays(vtkUnstructuredGrid& grid, MeshLib::Mesh& mesh) { vtkPointData* point_data = grid.GetPointData(); auto const n_point_arrays = static_cast<unsigned>(point_data->GetNumberOfArrays()); for (unsigned i = 0; i < n_point_arrays; ++i) convertArray(*point_data->GetArray(i), mesh.getProperties(), MeshLib::MeshItemType::Node); vtkCellData* cell_data = grid.GetCellData(); auto const n_cell_arrays = static_cast<unsigned>(cell_data->GetNumberOfArrays()); for (unsigned i = 0; i < n_cell_arrays; ++i) convertArray(*cell_data->GetArray(i), mesh.getProperties(), MeshLib::MeshItemType::Cell); vtkFieldData* field_data = grid.GetFieldData(); auto const n_field_arrays = static_cast<unsigned>(field_data->GetNumberOfArrays()); for (unsigned i = 0; i < n_field_arrays; ++i) convertArray( *vtkDataArray::SafeDownCast(field_data->GetAbstractArray(i)), mesh.getProperties(), MeshLib::MeshItemType::IntegrationPoint); }
void VtkVisPipelineView::convertVTKToOGSMesh() { VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>( static_cast<VtkVisPipeline*>(this->model())->getItem(this->selectionModel()->currentIndex())); vtkSmartPointer<vtkAlgorithm> algorithm = item->algorithm(); vtkUnstructuredGrid* grid(NULL); vtkUnstructuredGridAlgorithm* ugAlg = vtkUnstructuredGridAlgorithm::SafeDownCast(algorithm); if (ugAlg) grid = ugAlg->GetOutput(); else { // for old filetypes vtkGenericDataObjectReader* dataReader = vtkGenericDataObjectReader::SafeDownCast(algorithm); if (dataReader) grid = vtkUnstructuredGrid::SafeDownCast(dataReader->GetOutput()); else { // for new filetypes vtkXMLUnstructuredGridReader* xmlReader = vtkXMLUnstructuredGridReader::SafeDownCast(algorithm); grid = vtkUnstructuredGrid::SafeDownCast(xmlReader->GetOutput()); } } MeshLib::Mesh* mesh = MeshLib::VtkMeshConverter::convertUnstructuredGrid(grid); mesh->setName(item->data(0).toString().toStdString()); emit meshAdded(mesh); }
MeshLib::Mesh* MeshSurfaceExtraction::getMeshSurface( const MeshLib::Mesh& mesh, const MathLib::Vector3& dir, double angle, std::string const& subsfc_node_id_backup_prop_name) { if (angle < 0 || angle > 90) { ERR ("Supported angle between 0 and 90 degrees only."); return nullptr; } INFO ("Extracting mesh surface..."); std::vector<MeshLib::Element*> sfc_elements; get2DSurfaceElements(mesh.getElements(), sfc_elements, dir, angle, mesh.getDimension()); if (sfc_elements.empty()) return nullptr; std::vector<MeshLib::Node*> sfc_nodes; std::vector<std::size_t> node_id_map(mesh.getNNodes()); get2DSurfaceNodes(sfc_nodes, mesh.getNNodes(), sfc_elements, node_id_map); // create new elements vector with newly created nodes std::vector<MeshLib::Element*> new_elements; new_elements.reserve(sfc_elements.size()); for (auto elem = sfc_elements.cbegin(); elem != sfc_elements.cend(); ++elem) { unsigned const n_elem_nodes ((*elem)->getNBaseNodes()); MeshLib::Node** new_nodes = new MeshLib::Node*[n_elem_nodes]; for (unsigned k(0); k<n_elem_nodes; k++) new_nodes[k] = sfc_nodes[node_id_map[(*elem)->getNode(k)->getID()]]; if ((*elem)->getGeomType() == MeshElemType::TRIANGLE) new_elements.push_back(new MeshLib::Tri(new_nodes)); else { assert((*elem)->getGeomType() == MeshElemType::QUAD); new_elements.push_back(new MeshLib::Quad(new_nodes)); } delete *elem; } std::vector<std::size_t> id_map; if (!subsfc_node_id_backup_prop_name.empty()) { id_map.reserve(sfc_nodes.size()); for (auto node = sfc_nodes.cbegin(); node != sfc_nodes.cend(); ++node) id_map.push_back((*node)->getID()); } MeshLib::Mesh* result (new Mesh(mesh.getName()+"-Surface", sfc_nodes, new_elements)); // transmit the original node ids of the subsurface mesh as a property if (!subsfc_node_id_backup_prop_name.empty()) { boost::optional<MeshLib::PropertyVector<std::size_t>&> orig_node_ids( result->getProperties().createNewPropertyVector<std::size_t>( subsfc_node_id_backup_prop_name , MeshLib::MeshItemType::Node, 1)); if (orig_node_ids) { orig_node_ids->resize(id_map.size()); std::copy(id_map.cbegin(), id_map.cend(), orig_node_ids->begin()); } } return result; }
void testZCoords2D(MeshLib::Mesh const& input, MeshLib::Mesh const& output, double height) { std::size_t const nNodes (input.getNumberOfNodes()); for (std::size_t i=0; i<nNodes; ++i) { ASSERT_EQ((*input.getNode(i))[2], (*output.getNode(i))[2]); ASSERT_EQ((*input.getNode(i))[2] + height, (*output.getNode(nNodes+i))[2]); } }
void TESProcess::initializeConcreteProcess( NumLib::LocalToGlobalIndexMap const& dof_table, MeshLib::Mesh const& mesh, unsigned const integration_order) { ProcessLib::createLocalAssemblers<TESLocalAssembler>( mesh.getDimension(), mesh.getElements(), dof_table, _local_assemblers, mesh.isAxiallySymmetric(), integration_order, _assembly_params); initializeSecondaryVariables(); }
void VtkMeshConverter::convertScalarArrays(vtkUnstructuredGrid &grid, MeshLib::Mesh &mesh) { vtkPointData* point_data = grid.GetPointData(); unsigned const n_point_arrays = static_cast<unsigned>(point_data->GetNumberOfArrays()); for (unsigned i=0; i<n_point_arrays; ++i) convertArray(*point_data->GetArray(i), mesh.getProperties(), MeshLib::MeshItemType::Node); vtkCellData* cell_data = grid.GetCellData(); unsigned const n_cell_arrays = static_cast<unsigned>(cell_data->GetNumberOfArrays()); for (unsigned i=0; i<n_cell_arrays; ++i) convertArray(*cell_data->GetArray(i), mesh.getProperties(), MeshLib::MeshItemType::Cell); }
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(); }
bool MeshLayerMapper::mapToStaticValue(MeshLib::Mesh &mesh, double value) { if (mesh.getDimension() != 2) { ERR("MshLayerMapper::mapToStaticValue() - requires 2D mesh"); return false; } std::vector<MeshLib::Node*> const& nodes (mesh.getNodes()); for (MeshLib::Node* node : nodes) node->updateCoordinates((*node)[0], (*node)[1], value); return true; }
// Project to parallels of YZ plane TEST_F(ProjectionTest, ProjectToYZ) { MathLib::Vector3 normal (1,0,0); std::size_t const n_nodes (_mesh->getNumberOfNodes()); for (std::size_t p=0; p<10; p++) { MathLib::Point3d origin (std::array<double,3>{{static_cast<double>(p),0,0}}); MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal); for (std::size_t i=0; i<n_nodes; i++) ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[0], std::numeric_limits<double>::epsilon()); delete result; } }
bool convertMeshToGeo(const MeshLib::Mesh &mesh, GeoLib::GEOObjects &geo_objects, double eps) { if (mesh.getDimension() != 2) { ERR ("Mesh to geometry conversion is only working for 2D meshes."); return false; } // nodes to points conversion std::string mesh_name(mesh.getName()); { auto points = std::make_unique<std::vector<GeoLib::Point*>>(); points->reserve(mesh.getNumberOfNodes()); for (auto node_ptr : mesh.getNodes()) points->push_back(new GeoLib::Point(*node_ptr, node_ptr->getID())); geo_objects.addPointVec(std::move(points), mesh_name, nullptr, eps); } const std::vector<std::size_t> id_map (geo_objects.getPointVecObj(mesh_name)->getIDMap()); // elements to surface triangles conversion std::string const mat_name ("MaterialIDs"); auto bounds (MeshInformation::getValueBounds<int>(mesh, mat_name)); const unsigned nMatGroups(bounds.second-bounds.first+1); auto sfcs = std::make_unique<std::vector<GeoLib::Surface*>>(); sfcs->reserve(nMatGroups); auto const& points = *geo_objects.getPointVec(mesh_name); for (unsigned i=0; i<nMatGroups; ++i) sfcs->push_back(new GeoLib::Surface(points)); const std::vector<MeshLib::Element*> &elements = mesh.getElements(); const std::size_t nElems (mesh.getNumberOfElements()); MeshLib::PropertyVector<int> const*const materialIds = mesh.getProperties().existsPropertyVector<int>("MaterialIDs") ? mesh.getProperties().getPropertyVector<int>("MaterialIDs") : nullptr; for (unsigned i=0; i<nElems; ++i) { auto surfaceId = !materialIds ? 0 : ((*materialIds)[i] - bounds.first); MeshLib::Element* e (elements[i]); if (e->getGeomType() == MeshElemType::TRIANGLE) (*sfcs)[surfaceId]->addTriangle(id_map[e->getNodeIndex(0)], id_map[e->getNodeIndex(1)], id_map[e->getNodeIndex(2)]); if (e->getGeomType() == MeshElemType::QUAD) { (*sfcs)[surfaceId]->addTriangle(id_map[e->getNodeIndex(0)], id_map[e->getNodeIndex(1)], id_map[e->getNodeIndex(2)]); (*sfcs)[surfaceId]->addTriangle(id_map[e->getNodeIndex(0)], id_map[e->getNodeIndex(2)], id_map[e->getNodeIndex(3)]); } // all other element types are ignored (i.e. lines) } std::for_each(sfcs->begin(), sfcs->end(), [](GeoLib::Surface* sfc){ if (sfc->getNumberOfTriangles()==0) delete sfc; sfc = nullptr;}); auto sfcs_end = std::remove(sfcs->begin(), sfcs->end(), nullptr); sfcs->erase(sfcs_end, sfcs->end()); geo_objects.addSurfaceVec(std::move(sfcs), mesh_name); return true; }