MeshToolsLib Namespace Reference

Namespaces
namespace	anonymous_namespace{AngleSkewMetric.cpp}
namespace	anonymous_namespace{ConvertToLinearMesh.cpp}
namespace	BoundaryExtraction
namespace	details
namespace	MeshGenerator
namespace	MeshGenerators
namespace	ProjectPointOnMesh
namespace	RasterDataToMesh
	Adding pixel values from a raster onto nodes or cells of a mesh.

Classes
struct	AngleSkewMetric
struct	EdgeRatioMetric
class	ElementQualityInterface
class	ElementQualityMetric
class	ElementSizeMetric
class	ElementValueModification
	A set of methods for manipulating mesh element values. More...
class	Mesh2MeshPropertyInterpolation
class	MeshInformation
	A set of tools for extracting information from a mesh. More...
class	MeshLayerMapper
	Manipulating and adding prism element layers to an existing 2D mesh. More...
class	MeshRevision
class	MeshSurfaceExtraction
	A set of tools concerned with extracting nodes and elements from a mesh surface. More...
struct	MeshValidation
	A collection of methods for testing mesh quality and correctness. More...
struct	RadiusEdgeRatioMetric
class	RasterToMesh
	Converts raster data into an OGS mesh. More...
struct	SizeDifferenceMetric

Functions
template<typename ShapeFunction >
double	computeElementVolumeNumerically (MeshLib::Element const &e)
double	computeElementVolumeNumerically (MeshLib::Element const &e)
bool	convertMeshToGeo (const MeshLib::Mesh &mesh, GeoLib::GEOObjects &geo_objects, double const eps)
MeshLib::Mesh *	convertSurfaceToMesh (const GeoLib::Surface &sfc, const std::string &mesh_name, double eps)
template<typename ElementType >
int	getNumberOfElementIntegrationPointsGeneral (MeshLib::IntegrationPointMetaData const &ip_meta_data)
int	getNumberOfElementIntegrationPoints (MeshLib::IntegrationPointMetaData const &ip_meta_data, MeshLib::Element const &e)
std::vector< std::size_t >	getIntegrationPointDataOffsetsOfMeshElements (std::vector< MeshLib::Element * > const &mesh_elements, MeshLib::PropertyVectorBase const &pv, MeshLib::Properties const &properties)
MeshLib::Element *	extrudeElement (std::vector< MeshLib::Node * > const &subsfc_nodes, MeshLib::Element const &sfc_elem, MeshLib::PropertyVector< std::size_t > const &sfc_to_subsfc_id_map, std::map< std::size_t, std::size_t > const &subsfc_sfc_id_map)
MeshLib::Mesh *	addLayerToMesh (MeshLib::Mesh const &mesh, double const thickness, std::string const &name, bool const on_top, bool const copy_material_ids, std::optional< int > const layer_id)
std::unique_ptr< MeshLib::Mesh >	convertToLinearMesh (MeshLib::Mesh const &mesh, std::string const &new_mesh_name)
std::unique_ptr< MeshLib::Element >	createFlippedElement (MeshLib::Element const &elem, std::vector< MeshLib::Node * > const &nodes)
std::unique_ptr< MeshLib::Mesh >	createFlippedMesh (MeshLib::Mesh const &mesh)
unsigned	lutPrismThirdNode (unsigned const id1, unsigned const id2)
template<typename Iterator >
void	moveMeshNodes (Iterator begin, Iterator end, Eigen::Vector3d const &displacement)
MeshLib::Mesh *	removeElements (const MeshLib::Mesh &mesh, const std::vector< std::size_t > &removed_element_ids, const std::string &new_mesh_name)
std::vector< bool >	markUnusedNodes (std::vector< MeshLib::Element * > const &elements, std::vector< MeshLib::Node * > const &nodes)
	Marks nodes not used by any of the elements.
void	removeMarkedNodes (std::vector< bool > const &nodes_to_delete, std::vector< MeshLib::Node * > &nodes)
	Deallocates and removes nodes marked true.
MeshLib::Mesh *	removeNodes (const MeshLib::Mesh &mesh, const std::vector< std::size_t > &del_nodes_idx, const std::string &new_mesh_name)
std::unique_ptr< MeshLib::Mesh >	createQuadraticOrderMesh (MeshLib::Mesh const &linear_mesh, bool const add_centre_node)
static void	trackSurface (MeshLib::Element const *const element, std::vector< unsigned > &sfc_idx, unsigned const current_index)
template<typename T >
void	processPropertyVector (MeshLib::PropertyVector< T > const &property, std::vector< std::size_t > const &id_map, MeshLib::Mesh &sfc_mesh)
bool	createSfcMeshProperties (MeshLib::Mesh &sfc_mesh, MeshLib::Properties const &properties, std::vector< std::size_t > const &node_ids_map, std::vector< std::size_t > const &element_ids_map)
std::tuple< std::vector< MeshLib::Node * >, std::vector< std::size_t > >	createNodesAndIDMapFromElements (std::vector< MeshLib::Element * > const &elements, std::size_t const n_all_nodes)
void	createSurfaceElementsFromElement (MeshLib::Element const &surface_element, std::vector< MeshLib::Element * > &surface_elements, std::vector< std::size_t > &element_to_bulk_element_id_map, std::vector< std::size_t > &element_to_bulk_face_id_map)
std::tuple< std::vector< MeshLib::Element * >, std::vector< std::size_t >, std::vector< std::size_t > >	createBoundaryElements (MeshLib::Mesh const &bulk_mesh)
void	addBulkIDPropertiesToMesh (MeshLib::Mesh &surface_mesh, std::string_view node_to_bulk_node_id_map_name, std::vector< std::size_t > const &node_to_bulk_node_id_map, std::string_view element_to_bulk_element_id_map_name, std::vector< std::size_t > const &element_to_bulk_element_id_map, std::string_view element_to_bulk_face_id_map_name, std::vector< std::size_t > const &element_to_bulk_face_id_map)
void	zeroMeshFieldDataByMaterialIDs (MeshLib::Mesh &mesh, std::vector< int > const &selected_material_ids)

Function Documentation

addBulkIDPropertiesToMesh()

void MeshToolsLib::addBulkIDPropertiesToMesh	(	MeshLib::Mesh &	surface_mesh,
		std::string_view	node_to_bulk_node_id_map_name,
		std::vector< std::size_t > const &	node_to_bulk_node_id_map,
		std::string_view	element_to_bulk_element_id_map_name,
		std::vector< std::size_t > const &	element_to_bulk_element_id_map,
		std::string_view	element_to_bulk_face_id_map_name,
		std::vector< std::size_t > const &	element_to_bulk_face_id_map )

Definition at line 528 of file MeshSurfaceExtraction.cpp.

{
    // transmit the original node ids of the bulk mesh as a property
    if (!node_to_bulk_node_id_map_name.empty())
    {
        MeshLib::addPropertyToMesh(surface_mesh, node_to_bulk_node_id_map_name,
                                   MeshLib::MeshItemType::Node, 1,
                                   node_to_bulk_node_id_map);
    }
 
    // transmit the original bulk element ids as a property
    if (!element_to_bulk_element_id_map_name.empty())
    {
        MeshLib::addPropertyToMesh(
            surface_mesh, element_to_bulk_element_id_map_name,
            MeshLib::MeshItemType::Cell, 1, element_to_bulk_element_id_map);
    }
 
    // transmit the face id of the original bulk element as a property
    if (!element_to_bulk_face_id_map_name.empty())
    {
        MeshLib::addPropertyToMesh(
            surface_mesh, element_to_bulk_face_id_map_name,
            MeshLib::MeshItemType::Cell, 1, element_to_bulk_face_id_map);
    }
}

References MeshLib::addPropertyToMesh(), MeshLib::Cell, and MeshLib::Node.

Referenced by MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(), and MeshToolsLib::MeshSurfaceExtraction::getMeshSurface().

addLayerToMesh()

MeshLib::Mesh * MeshToolsLib::addLayerToMesh	(	MeshLib::Mesh const &	mesh,
		double const	thickness,
		std::string const &	name,
		bool const	on_top,
		bool const	copy_material_ids,
		std::optional< int > const	layer_id )

Adds a layer to the mesh. If on_top is true, the layer is added on top, if it is false, the layer is added at the bottom.

Definition at line 84 of file AddLayerToMesh.cpp.

{
    INFO("Extracting top surface of mesh '{:s}' ... ", mesh.getName());
    double const flag = on_top ? -1.0 : 1.0;
    Eigen::Vector3d const dir({0, 0, flag});
    double const angle(90);
    std::unique_ptr<MeshLib::Mesh> sfc_mesh(nullptr);
 
    auto const prop_name =
        MeshLib::getBulkIDString(MeshLib::MeshItemType::Node);
 
    if (mesh.getDimension() == 3)
    {
        sfc_mesh.reset(MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(
            mesh, dir, angle, prop_name));
    }
    else
    {
        sfc_mesh = (on_top) ? std::make_unique<MeshLib::Mesh>(mesh)
                            : std::unique_ptr<MeshLib::Mesh>(
                                  MeshToolsLib::createFlippedMesh(mesh));
        // add property storing node ids
        auto* const pv =
            sfc_mesh->getProperties().createNewPropertyVector<std::size_t>(
                prop_name, MeshLib::MeshItemType::Node, 1);
        if (pv)
        {
            pv->resize(sfc_mesh->getNumberOfNodes());
            std::iota(pv->begin(), pv->end(), 0);
        }
        else
        {
            ERR("Could not create and initialize property '{}'.", prop_name);
            return nullptr;
        }
    }
    INFO("done.");
 
    // *** add new surface nodes
    std::vector<MeshLib::Node*> subsfc_nodes =
        MeshLib::copyNodeVector(mesh.getNodes());
    std::vector<MeshLib::Element*> subsfc_elements =
        MeshLib::copyElementVector(mesh.getElements(), subsfc_nodes);
 
    std::size_t const n_subsfc_nodes(subsfc_nodes.size());
 
    std::vector<MeshLib::Node*> const& sfc_nodes(sfc_mesh->getNodes());
    std::size_t const n_sfc_nodes(sfc_nodes.size());
 
    if (!sfc_mesh->getProperties().existsPropertyVector<std::size_t>(prop_name))
    {
        ERR("Need subsurface node ids, but the property '{:s}' is not "
            "available.",
            prop_name);
        return nullptr;
    }
    // fetch subsurface node ids PropertyVector
    auto const* const node_id_pv =
        sfc_mesh->getProperties().getPropertyVector<std::size_t>(prop_name);
 
    // *** copy sfc nodes to subsfc mesh node
    std::map<std::size_t, std::size_t> subsfc_sfc_id_map;
    for (std::size_t k(0); k < n_sfc_nodes; ++k)
    {
        std::size_t const subsfc_id((*node_id_pv)[k]);
        std::size_t const sfc_id(k + n_subsfc_nodes);
        subsfc_sfc_id_map.insert(std::make_pair(subsfc_id, sfc_id));
        MeshLib::Node const& node(*sfc_nodes[k]);
        subsfc_nodes.push_back(new MeshLib::Node(
            node[0], node[1], node[2] - (flag * thickness), sfc_id));
    }
 
    // *** insert new layer elements into subsfc_mesh
    std::vector<MeshLib::Element*> const& sfc_elements(sfc_mesh->getElements());
    std::size_t const n_sfc_elements(sfc_elements.size());
    for (std::size_t k(0); k < n_sfc_elements; ++k)
    {
        subsfc_elements.push_back(extrudeElement(
            subsfc_nodes, *sfc_elements[k], *node_id_pv, subsfc_sfc_id_map));
    }
 
    auto new_mesh = new MeshLib::Mesh(name, subsfc_nodes, subsfc_elements,
                                      true /* compute_element_neighbors */);
 
    if (!mesh.getProperties().existsPropertyVector<int>("MaterialIDs"))
    {
        ERR("Could not copy the property 'MaterialIDs' since the original mesh "
            "does not contain such a property.");
        return new_mesh;
    }
    auto const* const materials =
        mesh.getProperties().getPropertyVector<int>("MaterialIDs");
 
    auto* const new_materials =
        new_mesh->getProperties().createNewPropertyVector<int>(
            "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
    if (!new_materials)
    {
        ERR("Can not set material properties for new layer");
        return new_mesh;
    }
 
    new_materials->reserve(subsfc_elements.size());
    std::copy(materials->cbegin(), materials->cend(),
              std::back_inserter(*new_materials));
 
    if (copy_material_ids &&
        sfc_mesh->getProperties().existsPropertyVector<int>("MaterialIDs"))
    {
        auto const& sfc_material_ids =
            *sfc_mesh->getProperties().getPropertyVector<int>("MaterialIDs");
        std::copy(sfc_material_ids.cbegin(), sfc_material_ids.cend(),
                  std::back_inserter(*new_materials));
    }
    else
    {
        int const new_layer_id =
            layer_id.has_value()
                ? layer_id.value()
                : *(std::max_element(materials->cbegin(), materials->cend())) +
                      1;
        auto const n_new_props(subsfc_elements.size() -
                               mesh.getNumberOfElements());
        std::fill_n(std::back_inserter(*new_materials), n_new_props,
                    new_layer_id);
    }
 
    return new_mesh;
}

References MeshLib::Cell, MeshLib::copyElementVector(), MeshLib::copyNodeVector(), createFlippedMesh(), ERR(), MeshLib::Properties::existsPropertyVector(), extrudeElement(), MeshLib::getBulkIDString(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), INFO(), and MeshLib::Node.

Referenced by MeshToolsLib::MeshGenerator::generateRegularPrismMesh(), main(), and MeshView::openAddLayerDialog().

computeElementVolumeNumerically() [1/2]

template<typename ShapeFunction >

double MeshToolsLib::computeElementVolumeNumerically

(

MeshLib::Element const &

e

)

Definition at line 47 of file ComputeElementVolumeNumerically.cpp.

{
    // Space dimension is set to 3 in case that 1D or 2D element is inclined.
    constexpr int space_dim = 3;
    using ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, space_dim>;
 
    // Integration order is set to 3:
    auto const& integration_method =
        NumLib::IntegrationMethodRegistry::template getIntegrationMethod<
            typename ShapeFunction::MeshElement>(NumLib::IntegrationOrder{3});
 
    auto const shape_function_data =
        NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType, space_dim>(
            e, false /*is_axially_symmetric*/, integration_method);
 
    auto const n_integration_points = integration_method.getNumberOfPoints();
    double volume = 0.0;
    for (unsigned ip = 0; ip < n_integration_points; ++ip)
    {
        auto const weight = integration_method.getWeightedPoint(ip).getWeight();
        volume += shape_function_data[ip].detJ * weight;
    }
 
    return volume;
}

References NumLib::initShapeMatrices().

Referenced by MeshToolsLib::ElementSizeMetric::calc1dQuality(), MeshToolsLib::ElementSizeMetric::calc2dOr3dQuality(), and computeElementVolumeNumerically().

computeElementVolumeNumerically() [2/2]

double MeshToolsLib::computeElementVolumeNumerically

(

MeshLib::Element const &

e

)

Definition at line 73 of file ComputeElementVolumeNumerically.cpp.

{
    switch (e.getCellType())
    {
        case MeshLib::CellType::LINE2:
            return computeElementVolumeNumerically<NumLib::ShapeLine2>(e);
        case MeshLib::CellType::LINE3:
            return computeElementVolumeNumerically<NumLib::ShapeLine3>(e);
        case MeshLib::CellType::TRI3:
            return computeElementVolumeNumerically<NumLib::ShapeTri3>(e);
        case MeshLib::CellType::TRI6:
            return computeElementVolumeNumerically<NumLib::ShapeTri6>(e);
        case MeshLib::CellType::QUAD4:
            return computeElementVolumeNumerically<NumLib::ShapeQuad4>(e);
        case MeshLib::CellType::QUAD8:
            return computeElementVolumeNumerically<NumLib::ShapeQuad8>(e);
        case MeshLib::CellType::QUAD9:
            return computeElementVolumeNumerically<NumLib::ShapeQuad9>(e);
        case MeshLib::CellType::TET4:
            return computeElementVolumeNumerically<NumLib::ShapeTet4>(e);
        case MeshLib::CellType::HEX8:
            return computeElementVolumeNumerically<NumLib::ShapeHex8>(e);
        case MeshLib::CellType::HEX20:
            return computeElementVolumeNumerically<NumLib::ShapeHex20>(e);
        case MeshLib::CellType::TET10:
            return computeElementVolumeNumerically<NumLib::ShapeTet10>(e);
        case MeshLib::CellType::PRISM6:
            return computeElementVolumeNumerically<NumLib::ShapePrism6>(e);
        case MeshLib::CellType::PRISM15:
            return computeElementVolumeNumerically<NumLib::ShapePrism15>(e);
        case MeshLib::CellType::PYRAMID5:
            return computeElementVolumeNumerically<NumLib::ShapePyra5>(e);
        case MeshLib::CellType::PYRAMID13:
            return computeElementVolumeNumerically<NumLib::ShapePyra13>(e);
        default:
            OGS_FATAL(
                "Numerical volume calculation is not available for element "
                "with type {}. ",
                MeshLib::CellType2String(e.getCellType()));
    }
}

References MeshLib::CellType2String(), computeElementVolumeNumerically(), MeshLib::Element::getCellType(), MeshLib::HEX20, MeshLib::HEX8, MeshLib::LINE2, MeshLib::LINE3, OGS_FATAL, MeshLib::PRISM15, MeshLib::PRISM6, MeshLib::PYRAMID13, MeshLib::PYRAMID5, MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, MeshLib::TET10, MeshLib::TET4, MeshLib::TRI3, and MeshLib::TRI6.

convertMeshToGeo()

bool MeshToolsLib::convertMeshToGeo	(	const MeshLib::Mesh &	mesh,
		GeoLib::GEOObjects &	geo_objects,
		double	eps = std::numeric_limits< double >::epsilon() )

Converts a 2D mesh into a geometry. A new geometry with the name of the mesh will be inserted into geo_objects, consisting of points identical with mesh nodes and one surface representing the mesh. Triangles are converted to geometric triangles, quads are split into two triangles, all other elements are ignored.

Definition at line 77 of file convertMeshToGeo.cpp.

{
    if (mesh.getDimension() != 2)
    {
        ERR("Mesh to geometry conversion is only working for 2D meshes.");
        return false;
    }
 
    // Special handling of the bounds in case there are no materialIDs present.
    auto get_material_ids_and_bounds = [&]()
        -> std::tuple<MeshLib::PropertyVector<int> const*, std::pair<int, int>>
    {
        auto const materialIds = materialIDs(mesh);
        if (!materialIds)
        {
            return std::make_tuple(nullptr, std::make_pair(0, 0));
        }
 
        auto const bounds =
            MeshToolsLib::MeshInformation::getValueBounds(*materialIds);
        if (!bounds)
        {
            OGS_FATAL(
                "Could not get minimum/maximum ranges values for the "
                "MaterialIDs property in the mesh '{:s}'.",
                mesh.getName());
        }
        return std::make_tuple(materialIds, *bounds);
    };
 
    auto const [materialIds, bounds] = get_material_ids_and_bounds();
    // elements to surface triangles conversion
    const unsigned nMatGroups(bounds.second - bounds.first + 1);
    std::vector<GeoLib::Surface*> sfcs;
    sfcs.reserve(nMatGroups);
    std::string const geoobject_name =
        convertMeshNodesToGeoPoints(mesh, eps, geo_objects);
    auto const& points = *geo_objects.getPointVec(geoobject_name);
    for (unsigned i = 0; i < nMatGroups; ++i)
    {
        sfcs.push_back(new GeoLib::Surface(points));
    }
 
    const std::vector<std::size_t>& id_map(
        geo_objects.getPointVecObj(geoobject_name)->getIDMap());
    const std::vector<MeshLib::Element*>& elements = mesh.getElements();
    const std::size_t nElems(mesh.getNumberOfElements());
 
    for (unsigned i = 0; i < nElems; ++i)
    {
        auto surfaceId = !materialIds ? 0 : ((*materialIds)[i] - bounds.first);
        addElementToSurface(*elements[i], id_map, *sfcs[surfaceId]);
    }
 
    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), geoobject_name,
                              GeoLib::SurfaceVec::NameIdMap{});
    return true;
}

References ERR(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), GeoLib::PointVec::getIDMap(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), GeoLib::GEOObjects::getPointVec(), GeoLib::GEOObjects::getPointVecObj(), MeshToolsLib::MeshInformation::getValueBounds(), and OGS_FATAL.

Referenced by MainWindow::convertMeshToGeometry(), FileIO::createSurface(), and main().

convertSurfaceToMesh()

MeshLib::Mesh * MeshToolsLib::convertSurfaceToMesh	(	const GeoLib::Surface &	sfc,
		const std::string &	mesh_name,
		double	eps = std::numeric_limits< double >::epsilon() )

Converts a surface into a triangular mesh

Parameters

sfc	Surface object
mesh_name	New mesh name
eps	Minimum distance for nodes not to be collapsed

Returns

a pointer to a converted mesh object. nullptr is returned if the conversion fails.

Definition at line 150 of file convertMeshToGeo.cpp.

{
    // convert to a mesh including duplicated nodes
    std::vector<MeshLib::Node*> nodes;
    std::vector<MeshLib::Element*> elements;
    std::size_t nodeId = 0;
    for (std::size_t i = 0; i < sfc.getNumberOfTriangles(); i++)
    {
        auto* tri = sfc[i];
        auto** tri_nodes = new MeshLib::Node*[3];
        for (unsigned j = 0; j < 3; j++)
        {
            tri_nodes[j] =
                new MeshLib::Node(tri->getPoint(j)->data(), nodeId++);
        }
        elements.push_back(new MeshLib::Tri(tri_nodes, i));
        for (unsigned j = 0; j < 3; j++)
        {
            nodes.push_back(tri_nodes[j]);
        }
    }
    MeshLib::Mesh mesh_with_duplicated_nodes(
        mesh_name, nodes, elements, true /* compute_element_neighbors */);
 
    // remove duplicated nodes
    MeshToolsLib::MeshRevision rev(mesh_with_duplicated_nodes);
    return rev.simplifyMesh(mesh_with_duplicated_nodes.getName(), eps);
}

References convertSurfaceToMesh(), MeshLib::Mesh::getName(), GeoLib::Surface::getNumberOfTriangles(), MeshLib::Node, and MeshToolsLib::MeshRevision::simplifyMesh().

Referenced by convertSurfaceToMesh(), and main().

convertToLinearMesh()

std::unique_ptr< MeshLib::Mesh > MeshToolsLib::convertToLinearMesh	(	const MeshLib::Mesh &	mesh,
		const std::string &	new_mesh_name )

Converts a non-linear mesh to a linear mesh. All the mesh properties will be copied except for entries for non-linear nodes.

Definition at line 47 of file ConvertToLinearMesh.cpp.

{
    auto const& org_elements = mesh.getElements();
 
    // mark base nodes
    std::vector<bool> marked_base_nodes(mesh.getNodes().size(), false);
    for (auto const org_element : org_elements)
    {
        for (std::size_t k = 0; k < org_element->getNumberOfBaseNodes(); ++k)
        {
            auto const& base_node = *org_element->getNode(k);
            marked_base_nodes[base_node.getID()] = true;
        }
    }
 
    // construct map and fill new_mesh_nodes
    std::vector<MeshLib::Node*> new_mesh_nodes{static_cast<std::size_t>(
        std::count(begin(marked_base_nodes), end(marked_base_nodes), true))};
    std::size_t base_node_cnt = 0;
    auto const& org_nodes = mesh.getNodes();
    std::vector<std::size_t> base_node_map(org_nodes.size(), -1);
    for (std::size_t k = 0; k < org_nodes.size(); ++k)
    {
        if (marked_base_nodes[k])
        {
            new_mesh_nodes[base_node_cnt] =
                new MeshLib::Node(org_nodes[k]->data(), base_node_cnt);
            base_node_map[k] = base_node_cnt;
            base_node_cnt++;
        }
    }
 
    // create new elements with the quadratic nodes
    std::vector<MeshLib::Element*> vec_new_eles;
    for (MeshLib::Element const* e : mesh.getElements())
    {
        if (e->getCellType() == MeshLib::CellType::LINE3)
        {
            vec_new_eles.push_back(createLinearElement<MeshLib::Line>(
                e, new_mesh_nodes, base_node_map));
        }
        else if (e->getCellType() == MeshLib::CellType::QUAD8)
        {
            vec_new_eles.push_back(createLinearElement<MeshLib::Quad>(
                e, new_mesh_nodes, base_node_map));
        }
        else if (e->getCellType() == MeshLib::CellType::TRI6)
        {
            vec_new_eles.push_back(createLinearElement<MeshLib::Tri>(
                e, new_mesh_nodes, base_node_map));
        }
        else if (e->getCellType() == MeshLib::CellType::HEX20)
        {
            vec_new_eles.push_back(createLinearElement<MeshLib::Hex>(
                e, new_mesh_nodes, base_node_map));
        }
        else if (e->getCellType() == MeshLib::CellType::TET10)
        {
            vec_new_eles.push_back(createLinearElement<MeshLib::Tet>(
                e, new_mesh_nodes, base_node_map));
        }
        else
        {
            OGS_FATAL("Mesh element type {:s} is not supported",
                      MeshLib::CellType2String(e->getCellType()));
        }
    }
 
    auto new_mesh = std::make_unique<MeshLib::Mesh>(
        new_mesh_name, new_mesh_nodes, vec_new_eles,
        true /* compute_element_neighbors */,
        mesh.getProperties().excludeCopyProperties(
            std::vector<MeshLib::MeshItemType>(1,
                                               MeshLib::MeshItemType::Node)));
 
    // copy property vectors for nodes
    for (auto [name, property] : mesh.getProperties())
    {
        if (property->getMeshItemType() != MeshLib::MeshItemType::Node)
        {
            continue;
        }
        auto double_property =
            dynamic_cast<MeshLib::PropertyVector<double>*>(property);
        if (double_property == nullptr)
        {
            continue;
        }
        auto const n_src_comp = double_property->getNumberOfGlobalComponents();
        auto new_prop =
            new_mesh->getProperties().createNewPropertyVector<double>(
                name, MeshLib::MeshItemType::Node, n_src_comp);
        new_prop->resize(new_mesh->getNumberOfNodes() * n_src_comp);
 
        for (std::size_t k = 0; k < org_nodes.size(); ++k)
        {
            if (!marked_base_nodes[k])
            {
                continue;
            }
            std::copy_n(double_property->begin() + k * n_src_comp,
                        n_src_comp,
                        new_prop->begin() + base_node_map[k] * n_src_comp);
        }
    }
    return new_mesh;
}

References MeshLib::CellType2String(), MeshLib::Properties::excludeCopyProperties(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::Mesh::getProperties(), MeshLib::HEX20, MeshLib::LINE3, MeshLib::Node, OGS_FATAL, MeshLib::QUAD8, MeshLib::TET10, and MeshLib::TRI6.

Referenced by main(), and anonymous_namespace{postLIE.cpp}::postVTU().

createBoundaryElements()

std::tuple< std::vector< MeshLib::Element * >, std::vector< std::size_t >, std::vector< std::size_t > > MeshToolsLib::createBoundaryElements

(

MeshLib::Mesh const &

bulk_mesh

)

Definition at line 443 of file MeshSurfaceExtraction.cpp.

{
    std::vector<std::size_t> element_to_bulk_element_id_map;
    std::vector<std::size_t> element_to_bulk_face_id_map;
    std::vector<MeshLib::Element*> surface_elements;
 
    auto const& bulk_elements = bulk_mesh.getElements();
    auto const mesh_dimension = bulk_mesh.getDimension();
 
    for (auto const* elem : bulk_elements)
    {
        const unsigned element_dimension(elem->getDimension());
        if (element_dimension < mesh_dimension)
        {
            continue;
        }
 
        if (!elem->isBoundaryElement())
        {
            continue;
        }
        createSurfaceElementsFromElement(*elem, surface_elements,
                                         element_to_bulk_element_id_map,
                                         element_to_bulk_face_id_map);
    }
    return {surface_elements, element_to_bulk_element_id_map,
            element_to_bulk_face_id_map};
}

References createSurfaceElementsFromElement(), MeshLib::Mesh::getDimension(), and MeshLib::Mesh::getElements().

Referenced by MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh().

createFlippedElement()

std::unique_ptr< MeshLib::Element > MeshToolsLib::createFlippedElement	(	MeshLib::Element const &	elem,
		std::vector< MeshLib::Node * > const &	nodes )

Creates a copy of an 1d / 2d element where the node order is reversed, such that the direction of a line changes and normals of 2D elements changes its sign.

Parameters

elem	original element
nodes	node vector used for the copy of the element

Returns

a flipped copy of the element

Definition at line 22 of file FlipElements.cpp.

{
    if (elem.getDimension() > 2)
    {
        return nullptr;
    }
 
    unsigned const n_nodes(elem.getNumberOfNodes());
    auto elem_nodes = std::make_unique<MeshLib::Node*[]>(n_nodes);
    for (unsigned i = 0; i < n_nodes; ++i)
    {
        elem_nodes[i] = nodes[elem.getNode(i)->getID()];
    }
    std::swap(elem_nodes[0], elem_nodes[1]);
 
    if (elem.getGeomType() == MeshLib::MeshElemType::LINE)
    {
        return std::make_unique<MeshLib::Line>(elem_nodes.release(),
                                               elem.getID());
    }
    if (elem.getGeomType() == MeshLib::MeshElemType::TRIANGLE)
    {
        return std::make_unique<MeshLib::Tri>(elem_nodes.release(),
                                              elem.getID());
    }
    if (elem.getGeomType() == MeshLib::MeshElemType::QUAD)
    {
        std::swap(elem_nodes[2], elem_nodes[3]);
        return std::make_unique<MeshLib::Quad>(elem_nodes.release(),
                                               elem.getID());
    }
    return nullptr;
}

References MeshLib::Element::getDimension(), MeshLib::Element::getGeomType(), MathLib::Point3dWithID::getID(), MeshLib::Element::getID(), MeshLib::Element::getNode(), MeshLib::Element::getNumberOfNodes(), MeshLib::LINE, MeshLib::QUAD, and MeshLib::TRIANGLE.

Referenced by createFlippedMesh().

createFlippedMesh()

std::unique_ptr< MeshLib::Mesh > MeshToolsLib::createFlippedMesh

(

MeshLib::Mesh const &

mesh

)

Creates a copy of a 1d / 2d mesh where the node order of all elements is reversed such that the direction of lines changes and normals of 2D elements changes their sign.

Parameters

mesh	input mesh

Returns

a flipped copy of the input mesh

Definition at line 57 of file FlipElements.cpp.

{
    if (mesh.getDimension() > 2)
    {
        return nullptr;
    }
 
    std::vector<MeshLib::Node*> new_nodes(copyNodeVector(mesh.getNodes()));
    std::vector<MeshLib::Element*> const& elems(mesh.getElements());
    std::vector<MeshLib::Element*> new_elems;
    std::size_t n_elems(mesh.getNumberOfElements());
    new_elems.reserve(n_elems);
 
    for (std::size_t i = 0; i < n_elems; ++i)
    {
        new_elems.push_back(
            createFlippedElement(*elems[i], new_nodes).release());
    }
 
    return std::make_unique<MeshLib::Mesh>(
        "FlippedElementMesh", new_nodes, new_elems,
        true /* compute_element_neighbors */, mesh.getProperties());
}

References createFlippedElement(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfElements(), and MeshLib::Mesh::getProperties().

Referenced by addLayerToMesh().

createNodesAndIDMapFromElements()

std::tuple< std::vector< MeshLib::Node * >, std::vector< std::size_t > > MeshToolsLib::createNodesAndIDMapFromElements	(	std::vector< MeshLib::Element * > const &	elements,
		std::size_t const	n_all_nodes )

Definition at line 175 of file MeshSurfaceExtraction.cpp.

{
    std::vector<MeshLib::Node const*> tmp_nodes(n_all_nodes, nullptr);
    for (auto const* elem : elements)
    {
        auto const n_nodes = elem->getNumberOfNodes();
        for (unsigned j = 0; j < n_nodes; ++j)
        {
            const MeshLib::Node* node(elem->getNode(j));
            tmp_nodes[node->getID()] = node;
        }
    }
 
    std::vector<MeshLib::Node*> nodes;
    std::vector<std::size_t> node_id_map(n_all_nodes);
    for (unsigned i = 0; i < n_all_nodes; ++i)
    {
        if (tmp_nodes[i])
        {
            node_id_map[i] = nodes.size();
            nodes.push_back(new MeshLib::Node(*tmp_nodes[i]));
        }
    }
    return {nodes, node_id_map};
}

References MathLib::Point3dWithID::getID().

Referenced by MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(), MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(), and MeshToolsLib::MeshSurfaceExtraction::getSurfaceNodes().

createQuadraticOrderMesh()

std::unique_ptr< MeshLib::Mesh > MeshToolsLib::createQuadraticOrderMesh	(	MeshLib::Mesh const &	linear_mesh,
		bool const	add_centre_node )

Create a quadratic order mesh from the linear order mesh. For some element types like Quad-4, a centre node might be added if the add_centre_node flag is set, yielding a Quad-9.

Definition at line 195 of file QuadraticMeshGenerator.cpp.

{
    // Clone the linear mesh nodes.
    auto quadratic_mesh_nodes = MeshLib::copyNodeVector(linear_mesh.getNodes());
 
    // Temporary container for unique quadratic nodes with O(log(n)) search.
    std::set<MeshLib::Node*, nodeByCoordinatesComparator> unique_nodes;
 
    // Create new elements with the quadratic nodes
    std::vector<MeshLib::Element*> quadratic_elements;
    auto const& linear_mesh_elements = linear_mesh.getElements();
    for (MeshLib::Element const* e : linear_mesh_elements)
    {
        auto quadratic_element = createQuadraticElement(*e, add_centre_node);
 
        // Replace the base nodes with cloned linear nodes.
        int const number_base_nodes = quadratic_element->getNumberOfBaseNodes();
        for (int i = 0; i < number_base_nodes; ++i)
        {
            quadratic_element->setNode(
                i, quadratic_mesh_nodes[getNodeIndex(*quadratic_element, i)]);
        }
 
        // Make the new (middle-edge) nodes unique.
        int const number_all_nodes = quadratic_element->getNumberOfNodes();
        for (int i = number_base_nodes; i < number_all_nodes; ++i)
        {
            MeshLib::Node* original_node =
                const_cast<MeshLib::Node*>(quadratic_element->getNode(i));
 
            auto it = unique_nodes.insert(original_node);
            if (!it.second)  // same node was already inserted before, no
                             // insertion
            {
                // Replace the element's node with the unique node.
                quadratic_element->setNode(i, *it.first);
                // And delete the original node
                delete original_node;
            }
        }
 
        quadratic_elements.push_back(quadratic_element.release());
    }
 
    // Add the unique quadratic nodes to the cloned linear nodes.
    quadratic_mesh_nodes.reserve(linear_mesh.getNodes().size() +
                                 unique_nodes.size());
    std::copy(unique_nodes.begin(), unique_nodes.end(),
              std::back_inserter(quadratic_mesh_nodes));
 
    return std::make_unique<MeshLib::Mesh>(
        linear_mesh.getName(), quadratic_mesh_nodes, quadratic_elements,
        true /* compute_element_neighbors */,
        linear_mesh.getProperties().excludeCopyProperties(
            std::vector<MeshLib::MeshItemType>(1,
                                               MeshLib::MeshItemType::Node)));
}

References MeshLib::copyNodeVector(), createQuadraticElement(), MeshLib::Properties::excludeCopyProperties(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), and MeshLib::Node.

Referenced by main().

createSfcMeshProperties()

bool MeshToolsLib::createSfcMeshProperties	(	MeshLib::Mesh &	sfc_mesh,
		MeshLib::Properties const &	properties,
		std::vector< std::size_t > const &	node_ids_map,
		std::vector< std::size_t > const &	element_ids_map )

Definition at line 54 of file MeshSurfaceExtraction.cpp.

{
    std::size_t const n_elems(sfc_mesh.getNumberOfElements());
    std::size_t const n_nodes(sfc_mesh.getNumberOfNodes());
    if (node_ids_map.size() != n_nodes)
    {
        ERR("createSfcMeshProperties() - Incorrect number of node IDs ({:d}) "
            "compared to actual number of surface nodes ({:d}).",
            node_ids_map.size(), n_nodes);
        return false;
    }
 
    if (element_ids_map.size() != n_elems)
    {
        ERR("createSfcMeshProperties() - Incorrect number of element IDs "
            "({:d}) compared to actual number of surface elements ({:d}).",
            element_ids_map.size(), n_elems);
        return false;
    }
    std::map<MeshLib::MeshItemType, std::vector<std::size_t> const*> const
        id_maps = {{MeshLib::MeshItemType::Cell, &element_ids_map},
                   {MeshLib::MeshItemType::Node, &node_ids_map}};
 
    std::size_t vectors_copied(0);
    std::size_t vectors_skipped(0);
    for (auto [name, property] : properties)
    {
        if (property->getMeshItemType() != MeshLib::MeshItemType::Cell &&
            property->getMeshItemType() != MeshLib::MeshItemType::Node)
        {
            WARN(
                "Skipping property vector '{:s}' - not defined on cells or "
                "nodes.",
                name);
            vectors_skipped++;
            continue;
        }
 
        auto const& id_map = *id_maps.at(property->getMeshItemType());
        if (auto const* p =
                dynamic_cast<MeshLib::PropertyVector<double>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<float>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<int>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<long>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<long long>*>(
                         property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned long>*>(
                         property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned long long>*>(
                         property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<std::size_t>*>(
                         property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<char>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else
        {
            WARN(
                "Skipping property vector '{:s}' - no matching data type "
                "'{:s}' found.",
                name, typeid(*property).name());
            vectors_skipped++;
        }
    }
    INFO("{:d} property vectors copied, {:d} vectors skipped.", vectors_copied,
         vectors_skipped);
    return true;
}

References MeshLib::Cell, ERR(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), INFO(), MeshLib::Node, processPropertyVector(), and WARN().

Referenced by MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(), and MeshToolsLib::MeshSurfaceExtraction::getMeshSurface().

createSurfaceElementsFromElement()

void MeshToolsLib::createSurfaceElementsFromElement	(	MeshLib::Element const &	surface_element,
		std::vector< MeshLib::Element * > &	surface_elements,
		std::vector< std::size_t > &	element_to_bulk_element_id_map,
		std::vector< std::size_t > &	element_to_bulk_face_id_map )

Definition at line 420 of file MeshSurfaceExtraction.cpp.

{
    const unsigned n_faces(surface_element.getNumberOfBoundaries());
    for (unsigned j = 0; j < n_faces; ++j)
    {
        if (surface_element.getNeighbor(j) != nullptr)
        {
            continue;
        }
 
        surface_elements.push_back(
            const_cast<MeshLib::Element*>(surface_element.getBoundary(j)));
        element_to_bulk_face_id_map.push_back(j);
        element_to_bulk_element_id_map.push_back(surface_element.getID());
    }
}

References MeshLib::Element::getBoundary(), MeshLib::Element::getID(), MeshLib::Element::getNeighbor(), and MeshLib::Element::getNumberOfBoundaries().

Referenced by createBoundaryElements().

extrudeElement()

MeshLib::Element * MeshToolsLib::extrudeElement	(	std::vector< MeshLib::Node * > const &	subsfc_nodes,
		MeshLib::Element const &	sfc_elem,
		MeshLib::PropertyVector< std::size_t > const &	sfc_to_subsfc_id_map,
		std::map< std::size_t, std::size_t > const &	subsfc_sfc_id_map )

Extrudes point, line, triangle or quad elements to its higher dimensional versions, i.e. line, quad, prism, hexahedron.

Parameters

subsfc_nodes	the nodes the elements are based on
sfc_elem	the element of the surface that will be extruded
sfc_to_subsfc_id_map	relation between the surface nodes of the surface element and the ids of the nodes of the subsurface mesh
subsfc_sfc_id_map	mapping of the surface nodes of the current mesh to the surface nodes of the extruded mesh

Returns

extruded element (point -> line, line -> quad, tri -> prism, quad -> hexahedron)

Definition at line 44 of file AddLayerToMesh.cpp.

{
    if (sfc_elem.getDimension() > 2)
    {
        return nullptr;
    }
 
    const unsigned nElemNodes(sfc_elem.getNumberOfBaseNodes());
    auto new_nodes =
        std::unique_ptr<MeshLib::Node*[]>{new MeshLib::Node*[2 * nElemNodes]};
 
    for (unsigned j = 0; j < nElemNodes; ++j)
    {
        std::size_t const subsfc_id(
            sfc_to_subsfc_id_map[sfc_elem.getNode(j)->getID()]);
        new_nodes[j] = subsfc_nodes[subsfc_id];
        std::size_t new_idx = (nElemNodes == 2) ? (3 - j) : (nElemNodes + j);
        new_nodes[new_idx] = subsfc_nodes[subsfc_sfc_id_map.at(subsfc_id)];
    }
 
    if (sfc_elem.getGeomType() == MeshLib::MeshElemType::LINE)
    {
        return new MeshLib::Quad(new_nodes.release());
    }
    if (sfc_elem.getGeomType() == MeshLib::MeshElemType::TRIANGLE)
    {
        return new MeshLib::Prism(new_nodes.release());
    }
    if (sfc_elem.getGeomType() == MeshLib::MeshElemType::QUAD)
    {
        return new MeshLib::Hex(new_nodes.release());
    }
 
    return nullptr;
}

References MeshLib::Element::getDimension(), MeshLib::Element::getGeomType(), MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), MeshLib::Element::getNumberOfBaseNodes(), MeshLib::LINE, MeshLib::QUAD, and MeshLib::TRIANGLE.

Referenced by addLayerToMesh().

getIntegrationPointDataOffsetsOfMeshElements()

std::vector< std::size_t > MeshToolsLib::getIntegrationPointDataOffsetsOfMeshElements	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		MeshLib::PropertyVectorBase const &	pv,
		MeshLib::Properties const &	properties )

Definition at line 98 of file IntegrationPointDataTools.cpp.

{
    // For special field data such as OGS_VERSION, IntegrationPointMetaData,
    // etc., which are not "real" integration points:
    if (pv.getPropertyName().find("_ip") == std::string::npos)
    {
        return {};
    }
 
    auto const n_components = pv.getNumberOfGlobalComponents();
 
    std::vector<std::size_t> element_ip_data_offsets(mesh_elements.size() + 1);
    std::size_t counter = 0;
    auto const ip_meta_data =
        MeshLib::getIntegrationPointMetaData(properties, pv.getPropertyName());
    for (std::size_t i = 0; i < mesh_elements.size(); i++)
    {
        auto const* const element = mesh_elements[i];
 
        // Assuming that the order of elements in mesh_elements is not touched.
        element_ip_data_offsets[i] = counter;
        counter += getNumberOfElementIntegrationPoints(ip_meta_data, *element) *
                   n_components;
    }
    element_ip_data_offsets[mesh_elements.size()] = counter;
 
    return element_ip_data_offsets;
}

References MeshLib::getIntegrationPointMetaData(), getNumberOfElementIntegrationPoints(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), and MeshLib::PropertyVectorBase::getPropertyName().

Referenced by ApplicationUtils::copyPropertyVector(), createPropertyVector(), and zeroMeshFieldDataByMaterialIDs().

getNumberOfElementIntegrationPoints()

int MeshToolsLib::getNumberOfElementIntegrationPoints	(	MeshLib::IntegrationPointMetaData const &	ip_meta_data,
		MeshLib::Element const &	e )

Definition at line 36 of file IntegrationPointDataTools.cpp.

{
    switch (e.getCellType())
    {
        case MeshLib::CellType::LINE2:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Line>(
                ip_meta_data);
        case MeshLib::CellType::LINE3:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Line3>(
                ip_meta_data);
        case MeshLib::CellType::TRI3:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tri>(
                ip_meta_data);
        case MeshLib::CellType::TRI6:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tri6>(
                ip_meta_data);
        case MeshLib::CellType::QUAD4:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Quad>(
                ip_meta_data);
        case MeshLib::CellType::QUAD8:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Quad8>(
                ip_meta_data);
        case MeshLib::CellType::QUAD9:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Quad9>(
                ip_meta_data);
        case MeshLib::CellType::TET4:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tet>(
                ip_meta_data);
        case MeshLib::CellType::TET10:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tet10>(
                ip_meta_data);
        case MeshLib::CellType::HEX8:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Hex>(
                ip_meta_data);
        case MeshLib::CellType::HEX20:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Hex20>(
                ip_meta_data);
        case MeshLib::CellType::PRISM6:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Prism>(
                ip_meta_data);
        case MeshLib::CellType::PRISM15:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Prism15>(
                ip_meta_data);
        case MeshLib::CellType::PYRAMID5:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Pyramid>(
                ip_meta_data);
        case MeshLib::CellType::PYRAMID13:
            return getNumberOfElementIntegrationPointsGeneral<
                MeshLib::Pyramid13>(ip_meta_data);
        case MeshLib::CellType::PRISM18:
        case MeshLib::CellType::HEX27:
            OGS_FATAL("Mesh element type {:s} is not supported",
                      MeshLib::CellType2String(e.getCellType()));
        case MeshLib::CellType::INVALID:
        default:
            OGS_FATAL("Invalid Element Type");
    }
    return 0;
}

References MeshLib::CellType2String(), MeshLib::Element::getCellType(), getNumberOfElementIntegrationPointsGeneral(), MeshLib::HEX20, MeshLib::HEX27, MeshLib::HEX8, MeshLib::INVALID, MeshLib::LINE2, MeshLib::LINE3, OGS_FATAL, MeshLib::PRISM15, MeshLib::PRISM18, MeshLib::PRISM6, MeshLib::PYRAMID13, MeshLib::PYRAMID5, MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, MeshLib::TET10, MeshLib::TET4, MeshLib::TRI3, and MeshLib::TRI6.

Referenced by ApplicationUtils::checkFieldPropertyVectorSize(), ApplicationUtils::copyFieldPropertyDataToPartitions(), createPropertyVector(), getIntegrationPointDataOffsetsOfMeshElements(), and ApplicationUtils::setIntegrationPointNumberOfPartition().

getNumberOfElementIntegrationPointsGeneral()

template<typename ElementType >

int MeshToolsLib::getNumberOfElementIntegrationPointsGeneral

(

MeshLib::IntegrationPointMetaData const &

ip_meta_data

)

Definition at line 24 of file IntegrationPointDataTools.cpp.

{
    using IntegrationPolicy =
        NumLib::GaussLegendreIntegrationPolicy<ElementType>;
    using NonGenericIntegrationMethod =
        typename IntegrationPolicy::IntegrationMethod;
    NonGenericIntegrationMethod int_met{
        (unsigned int)ip_meta_data.integration_order};
    return int_met.getNumberOfPoints();
}

References MeshLib::IntegrationPointMetaData::integration_order.

Referenced by getNumberOfElementIntegrationPoints().

lutPrismThirdNode()

unsigned MeshToolsLib::lutPrismThirdNode	(	unsigned const	id1,
		unsigned const	id2 )

Lookup-table for returning the third node of bottom or top triangle given the other two.

Definition at line 35 of file MeshRevision.cpp.

{
    if ((id1 == 0 && id2 == 1) || (id1 == 1 && id2 == 0))
    {
        return 2;
    }
    if ((id1 == 1 && id2 == 2) || (id1 == 2 && id2 == 1))
    {
        return 0;
    }
    if ((id1 == 0 && id2 == 2) || (id1 == 2 && id2 == 0))
    {
        return 1;
    }
    if ((id1 == 3 && id2 == 4) || (id1 == 4 && id2 == 3))
    {
        return 5;
    }
    if ((id1 == 4 && id2 == 5) || (id1 == 5 && id2 == 4))
    {
        return 3;
    }
    if ((id1 == 3 && id2 == 5) || (id1 == 5 && id2 == 3))
    {
        return 4;
    }
    return std::numeric_limits<unsigned>::max();
}

Referenced by anonymous_namespace{MeshRevision.cpp}::reducePrism().

markUnusedNodes()

std::vector< bool > MeshToolsLib::markUnusedNodes	(	std::vector< MeshLib::Element * > const &	elements,
		std::vector< MeshLib::Node * > const &	nodes )

Marks nodes not used by any of the elements.

Definition at line 101 of file RemoveMeshComponents.cpp.

{
    std::vector<bool> unused_nodes(nodes.size(), true);
    for (auto e : elements)
    {
        for (unsigned i = 0; i < e->getNumberOfNodes(); i++)
        {
            unused_nodes[getNodeIndex(*e, i)] = false;
        }
    }
 
    return unused_nodes;
}

Referenced by createMeshFromElements(), and removeNodes().

moveMeshNodes()

template<typename Iterator >

void MeshToolsLib::moveMeshNodes	(	Iterator	begin,
		Iterator	end,
		Eigen::Vector3d const &	displacement )

Function that moves mesh nodes.

The function iterates over all mesh nodes between the begin and the end iterator and moves them using the given displacement.

Parameters

begin	begin iterator
end	end iterator
displacement	the displacement to use

Definition at line 33 of file moveMeshNodes.h.

{
    std::for_each(begin, end,
                  [&displacement](MathLib::Point3d* node)
                  { node->asEigenVector3d() += displacement; });
};

References MathLib::Point3d::asEigenVector3d().

Referenced by main(), TranslateDataDialog::moveGeometry(), and TranslateDataDialog::moveMesh().

processPropertyVector()

template<typename T >

void MeshToolsLib::processPropertyVector	(	MeshLib::PropertyVector< T > const &	property,
		std::vector< std::size_t > const &	id_map,
		MeshLib::Mesh &	sfc_mesh )

Definition at line 35 of file MeshSurfaceExtraction.cpp.

{
    auto const number_of_components = property.getNumberOfGlobalComponents();
 
    auto sfc_prop = MeshLib::getOrCreateMeshProperty<T>(
        sfc_mesh, property.getPropertyName(), property.getMeshItemType(),
        number_of_components);
    sfc_prop->clear();
    sfc_prop->reserve(id_map.size());
 
    for (auto bulk_id : id_map)
    {
        std::copy_n(&property.getComponent(bulk_id, 0 /*component_id*/),
                    number_of_components, back_inserter(*sfc_prop));
    }
}

References MeshLib::PropertyVector< PROP_VAL_TYPE >::getComponent(), MeshLib::PropertyVectorBase::getMeshItemType(), MeshLib::getOrCreateMeshProperty(), and MeshLib::PropertyVectorBase::getPropertyName().

Referenced by createSfcMeshProperties().

removeElements()

MeshLib::Mesh * MeshToolsLib::removeElements	(	const MeshLib::Mesh &	mesh,
		const std::vector< std::size_t > &	removed_element_ids,
		const std::string &	new_mesh_name )

Removes mesh elements and returns a new mesh object. The original mesh is kept unchanged.

Parameters

mesh	an original mesh whose elements are removed
removed_element_ids	a vector of element indices to be removed
new_mesh_name	a new mesh name

Returns

a new mesh object

Definition at line 52 of file RemoveMeshComponents.cpp.

{
    if (removed_element_ids.empty())
    {
        INFO("No elements to remove");
        return nullptr;
    }
 
    INFO("Removing total {:d} elements...", removed_element_ids.size());
    std::vector<MeshLib::Element*> tmp_elems =
        details::excludeElementCopy(mesh.getElements(), removed_element_ids);
    INFO("{:d} elements remain in mesh.", tmp_elems.size());
 
    // copy node and element objects
    std::vector<MeshLib::Node*> new_nodes =
        MeshLib::copyNodeVector(mesh.getNodes());
    std::vector<MeshLib::Element*> new_elems =
        MeshLib::copyElementVector(tmp_elems, new_nodes);
 
    // delete unused nodes
    MeshLib::NodeSearch ns(mesh);
    ns.searchNodesConnectedToOnlyGivenElements(removed_element_ids);
    auto& removed_node_ids(ns.getSearchedNodeIDs());
    INFO("Removing total {:d} nodes...", removed_node_ids.size());
    for (auto nodeid : removed_node_ids)
    {
        delete new_nodes[nodeid];
        new_nodes[nodeid] = nullptr;
    }
    new_nodes.erase(std::remove(new_nodes.begin(), new_nodes.end(), nullptr),
                    new_nodes.end());
 
    if (!new_elems.empty())
    {
        MeshLib::Mesh* new_mesh =
            new MeshLib::Mesh(new_mesh_name, new_nodes, new_elems,
                              true /* compute_element_neighbors */,
                              mesh.getProperties().excludeCopyProperties(
                                  removed_element_ids, removed_node_ids));
        return new_mesh;
    }
 
    INFO("Current selection removes all elements.");
    return nullptr;
}

References MeshLib::copyElementVector(), MeshLib::copyNodeVector(), MeshLib::Properties::excludeCopyProperties(), MeshToolsLib::details::excludeElementCopy(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), MeshLib::NodeSearch::getSearchedNodeIDs(), INFO(), and MeshLib::NodeSearch::searchNodesConnectedToOnlyGivenElements().

Referenced by MeshElementRemovalDialog::accept(), MeshToolsLib::RasterToMesh::convert(), LayeredVolume::createRasterLayers(), MeshToolsLib::MeshGenerators::VoxelFromLayeredMeshes::createVoxelFromLayeredMesh(), extractMatGroup(), MeshToolsLib::MeshGenerator::generateRegularPrismMesh(), main(), MeshToolsLib::MeshGenerator::VoxelGridFromMesh::removeUnusedGridCells(), and writeBoundary().

removeMarkedNodes()

void MeshToolsLib::removeMarkedNodes	(	std::vector< bool > const &	nodes_to_delete,
		std::vector< MeshLib::Node * > &	nodes )

Deallocates and removes nodes marked true.

Definition at line 117 of file RemoveMeshComponents.cpp.

{
    assert(nodes_to_delete.size() == nodes.size());
 
    for (std::size_t i = 0; i < nodes.size(); i++)
    {
        if (nodes_to_delete[i])
        {
            delete nodes[i];
            nodes[i] = nullptr;
        }
    }
    nodes.erase(remove(begin(nodes), end(nodes), nullptr), end(nodes));
}

Referenced by createMeshFromElements(), and removeNodes().

removeNodes()

MeshLib::Mesh * MeshToolsLib::removeNodes	(	const MeshLib::Mesh &	mesh,
		const std::vector< std::size_t > &	del_nodes_idx,
		const std::string &	new_mesh_name )

Removes the mesh nodes (and connected elements) given in the nodes-list from the mesh.

Parameters

mesh	an original mesh whose elements are removed
del_nodes_idx	a vector of node indices to be removed
new_mesh_name	a new mesh name

Returns

a new mesh object

Definition at line 133 of file RemoveMeshComponents.cpp.

{
    if (del_nodes_idx.empty())
    {
        return nullptr;
    }
 
    // copy node and element objects
    std::vector<MeshLib::Node*> new_nodes =
        MeshLib::copyNodeVector(mesh.getNodes());
    std::vector<MeshLib::Element*> new_elems =
        MeshLib::copyElementVector(mesh.getElements(), new_nodes);
 
    // delete elements
    MeshLib::ElementSearch es(mesh);
    es.searchByNodeIDs(del_nodes_idx);
    auto& removed_element_ids = es.getSearchedElementIDs();
    for (auto eid : removed_element_ids)
    {
        delete new_elems[eid];
        new_elems[eid] = nullptr;
    }
    new_elems.erase(std::remove(new_elems.begin(), new_elems.end(), nullptr),
                    new_elems.end());
 
    // check unused nodes due to element deletion
    std::vector<bool> const node_delete_flag =
        markUnusedNodes(new_elems, new_nodes);
 
    // delete unused nodes
    removeMarkedNodes(node_delete_flag, new_nodes);
 
    if (!new_elems.empty())
    {
        MeshLib::Mesh* new_mesh =
            new MeshLib::Mesh(new_mesh_name, new_nodes, new_elems,
                              true /* compute_element_neighbors */,
                              mesh.getProperties().excludeCopyProperties(
                                  removed_element_ids, del_nodes_idx));
        return new_mesh;
    }
 
    return nullptr;
}

References MeshLib::copyElementVector(), MeshLib::copyNodeVector(), MeshLib::Properties::excludeCopyProperties(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), MeshLib::ElementSearch::getSearchedElementIDs(), markUnusedNodes(), removeMarkedNodes(), and MeshLib::ElementSearch::searchByNodeIDs().

Referenced by LayeredMeshGenerator::getMesh().

trackSurface()

static void MeshToolsLib::trackSurface ( MeshLib::Element const *const element, std::vector< unsigned > & sfc_idx, unsigned const current_index )

static

Finds all surface elements that can be reached from element. All elements that are found in this way are marked in the global sfc_idx vector using the current_index.

Parameters

element	The mesh element from which the search is started
sfc_idx	The global index vector notifying to which surface elements belong
current_index	The index that all elements reachable from element will be assigned in sfc_idx

Definition at line 40 of file MeshValidation.cpp.

{
    std::stack<MeshLib::Element const*> elem_stack;
    elem_stack.push(element);
    while (!elem_stack.empty())
    {
        MeshLib::Element const* const elem = elem_stack.top();
        elem_stack.pop();
        sfc_idx[elem->getID()] = current_index;
        std::size_t const n_neighbors(elem->getNumberOfNeighbors());
        for (std::size_t i = 0; i < n_neighbors; ++i)
        {
            MeshLib::Element const* neighbor(elem->getNeighbor(i));
            if (neighbor != nullptr && sfc_idx[neighbor->getID()] ==
                                           std::numeric_limits<unsigned>::max())
            {
                elem_stack.push(neighbor);
            }
        }
    }
}

References MeshLib::Element::getID(), MeshLib::Element::getNeighbor(), and MeshLib::Element::getNumberOfNeighbors().

Referenced by MeshToolsLib::MeshValidation::detectHoles().

zeroMeshFieldDataByMaterialIDs()

void MeshToolsLib::zeroMeshFieldDataByMaterialIDs	(	MeshLib::Mesh &	mesh,
		std::vector< int > const &	selected_material_ids )

Definition at line 24 of file ZeroMeshFieldDataByMaterialIDs.cpp.

{
    auto const materialIds = materialIDs(mesh);
    if (!materialIds)
    {
        OGS_FATAL(
            "Mesh contains no int-property vector named 'MaterialIDs' needed "
            "by the 'zero_mesh_field_data_by_materialIDs'");
    }
 
    std::vector<std::size_t> element_ids_for_selected_materials;
    for (std::size_t i = 0; i < materialIds->size(); ++i)
    {
        if (std::find(selected_material_ids.begin(),
                      selected_material_ids.end(),
                      (*materialIds)[i]) != selected_material_ids.end())
        {
            element_ids_for_selected_materials.push_back(i);
        }
    }
 
    MeshLib::Properties& properties = mesh.getProperties();
 
    std::vector<std::size_t> element_ip_data_offsets;
 
    for (auto const& [name, property] : properties)
    {
        if (auto const item_type = property->getMeshItemType();
            item_type != MeshLib::MeshItemType::IntegrationPoint)
        {
            continue;
        }
 
        // For special field data such as OGS_VERSION,
        // IntegrationPointMetaData,
        // etc., which are not "real" integration points:
        if (!property->getPropertyName().ends_with("_ip"))
        {
            continue;
        }
 
        if (properties.template hasPropertyVector<double>(
                name, MeshLib::MeshItemType::IntegrationPoint))
        {
            auto& pv = *properties.template getPropertyVector<double>(name);
            const int n_components = pv.getNumberOfGlobalComponents();
 
            if (element_ip_data_offsets.empty())
            {
                // The returned values has already been multiplied with
                // pv.getNumberOfGlobalComponents()
                element_ip_data_offsets =
                    MeshToolsLib::getIntegrationPointDataOffsetsOfMeshElements(
                        mesh.getElements(), pv, properties);
 
                // element_ip_data_offsets / pv.getNumberOfGlobalComponents()
                std::transform(element_ip_data_offsets.begin(),
                               element_ip_data_offsets.end(),
                               element_ip_data_offsets.begin(),
                               [n = n_components](std::size_t const v)
                               { return v / n; });
            }
 
            for (auto const element_id : element_ids_for_selected_materials)
            {
                std::fill(
                    pv.begin() +
                        n_components * element_ip_data_offsets[element_id],
                    pv.begin() +
                        n_components * element_ip_data_offsets[element_id + 1],
                    0.0);
            }
        }
    }
}

References MeshLib::Mesh::getElements(), getIntegrationPointDataOffsetsOfMeshElements(), MeshLib::Mesh::getProperties(), MeshLib::IntegrationPoint, and OGS_FATAL.

Referenced by anonymous_namespace{ProjectData.cpp}::readMeshes().