MeshToolsLib Namespace Reference

Namespaces
namespace	anonymous_namespace{AngleSkewMetric.cpp}
namespace	anonymous_namespace{ConvertToLinearMesh.cpp}
namespace	BoundaryExtraction
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	NodesPartitionResult
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::IntegrationPointMetaDataSingleField const &ip_meta_data)
int	getNumberOfElementIntegrationPoints (MeshLib::IntegrationPointMetaDataSingleField 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)
template<typename T >
void	setSigma0 (int const pv_num_components, MeshLib::PropertyVector< T > const *const pv_bulk_mesh, std::unordered_map< std::string, double > &initial_value_dict, MeshLib::PropertyVector< T > &new_pv)
template<typename T >
bool	createNodeProperties (MeshLib::Mesh &merged_mesh, std::string const &pv_name, int const pv_num_components, MeshLib::PropertyVector< T > const *const pv_bulk_mesh, std::unordered_map< std::string, double > &initial_value_dict)
template<typename T >
bool	createCellProperties (MeshLib::Mesh &merged_mesh, std::string const &pv_name, int const pv_num_components, MeshLib::PropertyVector< T > const *const pv_bulk_mesh, std::unordered_map< std::string, double > &initial_value_dict)
template<typename T >
bool	createIntegrationPointProperties (MeshLib::Mesh &merged_mesh, std::string const &pv_name, int const pv_num_components, MeshLib::PropertyVector< T > const *const pv_bulk_mesh, std::unordered_map< std::string, double > &initial_value_dict, std::optional< MeshLib::IntegrationPointMetaData > const &integration_point_meta_data)
template<typename T >
bool	createMergedPropertyVector (MeshLib::Mesh &merged_mesh, std::unordered_map< std::string, double > &initial_value_dict, MeshLib::PropertyVector< T > const *const pv_bulk_mesh, std::optional< MeshLib::IntegrationPointMetaData > const &integration_point_meta_data)
std::vector< MeshLib::Node * >	findNodesInBoundedDomain (std::vector< MeshLib::Node * > const &nodes, GeoLib::AABB const &aabb)
std::unique_ptr< MeshLib::Mesh >	mergeMeshToBulkMesh (MeshLib::Mesh const &bulk_mesh, MeshLib::Mesh const &other_mesh, std::unordered_map< std::string, double > &initial_value_dict)
unsigned	lutPrismThirdNode (unsigned const id1, unsigned const id2)
template<typename Iterator >
void	moveMeshNodes (Iterator begin, Iterator end, Eigen::Vector3d const &displacement)
NodesPartitionResult	partitionNodesByCoordinateMatch (std::vector< MeshLib::Node * > const &node_vector, std::vector< MeshLib::Node * > const &tool_node_vector, GeoLib::AABB const &aabb, bool const return_non_paired_nodes)
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().

createCellProperties()

template<typename T >

bool MeshToolsLib::createCellProperties	(	MeshLib::Mesh &	merged_mesh,
		std::string const &	pv_name,
		int const	pv_num_components,
		MeshLib::PropertyVector< T > const *const	pv_bulk_mesh,
		std::unordered_map< std::string, double > &	initial_value_dict )

Definition at line 101 of file MergeMeshToBulkMesh.cpp.

{
    auto new_pv = MeshLib::getOrCreateMeshProperty<T>(
        merged_mesh, pv_name, MeshLib::MeshItemType::Cell, pv_num_components);
    new_pv->resize(merged_mesh.getNumberOfElements() * pv_num_components);
 
    std::copy(pv_bulk_mesh->begin(), pv_bulk_mesh->end(), new_pv->begin());
 
    double const value =
        (pv_name == "MaterialIDs") ? (initial_value_dict["mat_id"]) : 0.0;
 
    std::fill(new_pv->begin() + pv_bulk_mesh->size(), new_pv->end(),
              static_cast<T>(value));
    return true;
}

References MeshLib::Cell, MeshLib::Mesh::getNumberOfElements(), MeshLib::getOrCreateMeshProperty(), and MeshLib::PropertyVector< T >::size().

Referenced by createMergedPropertyVector().

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().

createIntegrationPointProperties()

template<typename T >

bool MeshToolsLib::createIntegrationPointProperties	(	MeshLib::Mesh &	merged_mesh,
		std::string const &	pv_name,
		int const	pv_num_components,
		MeshLib::PropertyVector< T > const *const	pv_bulk_mesh,
		std::unordered_map< std::string, double > &	initial_value_dict,
		std::optional< MeshLib::IntegrationPointMetaData > const &	integration_point_meta_data )

Definition at line 122 of file MergeMeshToBulkMesh.cpp.

{
    auto new_pv = MeshLib::getOrCreateMeshProperty<T>(
        merged_mesh, pv_name, MeshLib::MeshItemType::IntegrationPoint,
        pv_num_components);
 
    // Count the integration points
    std::size_t counter = 0;
    auto const ip_meta_data = MeshLib::getIntegrationPointMetaDataSingleField(
        integration_point_meta_data, pv_name);
 
    for (auto const element : merged_mesh.getElements())
    {
        int const number_of_integration_points =
            MeshToolsLib::getNumberOfElementIntegrationPoints(ip_meta_data,
                                                              *element);
        counter += number_of_integration_points;
    }
    new_pv->resize(counter * pv_num_components);
 
    std::copy(pv_bulk_mesh->begin(), pv_bulk_mesh->end(), new_pv->begin());
 
    if (pv_name.find("sigma") != std::string::npos)
    {
        setSigma0(pv_num_components, pv_bulk_mesh, initial_value_dict, *new_pv);
    }
 
    return true;
}

References MeshLib::Mesh::getElements(), MeshLib::getIntegrationPointMetaDataSingleField(), getNumberOfElementIntegrationPoints(), MeshLib::getOrCreateMeshProperty(), MeshLib::IntegrationPoint, and setSigma0().

Referenced by createMergedPropertyVector().

createMergedPropertyVector()

template<typename T >

bool MeshToolsLib::createMergedPropertyVector	(	MeshLib::Mesh &	merged_mesh,
		std::unordered_map< std::string, double > &	initial_value_dict,
		MeshLib::PropertyVector< T > const *const	pv_bulk_mesh,
		std::optional< MeshLib::IntegrationPointMetaData > const &	integration_point_meta_data )

Definition at line 159 of file MergeMeshToBulkMesh.cpp.

{
    if (pv_bulk_mesh == nullptr)
    {
        return false;
    }
 
    if (pv_bulk_mesh->getPropertyName() == "vtkGhostType")
    {
        // Do nothing
        return true;
    }
 
    auto const item_type = pv_bulk_mesh->getMeshItemType();
 
    auto const pv_name = pv_bulk_mesh->getPropertyName();
 
    auto const pv_num_components = pv_bulk_mesh->getNumberOfGlobalComponents();
 
    if (pv_name == "OGS_VERSION" || pv_name == "IntegrationPointMetaData")
    {
        auto new_pv = MeshLib::getOrCreateMeshProperty<T>(
            merged_mesh, pv_name, item_type, pv_num_components);
        new_pv->resize(pv_bulk_mesh->size());
 
        std::copy(pv_bulk_mesh->begin(), pv_bulk_mesh->end(), new_pv->begin());
        return true;
    }
 
    if (item_type == MeshLib::MeshItemType::Node)
    {
        return createNodeProperties(merged_mesh, pv_name, pv_num_components,
                                    pv_bulk_mesh, initial_value_dict);
    }
 
    if (item_type == MeshLib::MeshItemType::Cell)
    {
        return createCellProperties(merged_mesh, pv_name, pv_num_components,
                                    pv_bulk_mesh, initial_value_dict);
    }
 
    if (item_type == MeshLib::MeshItemType::IntegrationPoint)
    {
        return createIntegrationPointProperties(
            merged_mesh, pv_name, pv_num_components, pv_bulk_mesh,
            initial_value_dict, integration_point_meta_data);
    }
 
    return false;
}

References MeshLib::Cell, createCellProperties(), createIntegrationPointProperties(), createNodeProperties(), MeshLib::PropertyVectorBase::getMeshItemType(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::getOrCreateMeshProperty(), MeshLib::PropertyVectorBase::getPropertyName(), MeshLib::IntegrationPoint, MeshLib::Node, and MeshLib::PropertyVector< T >::size().

Referenced by mergeMeshToBulkMesh().

createNodeProperties()

template<typename T >

bool MeshToolsLib::createNodeProperties	(	MeshLib::Mesh &	merged_mesh,
		std::string const &	pv_name,
		int const	pv_num_components,
		MeshLib::PropertyVector< T > const *const	pv_bulk_mesh,
		std::unordered_map< std::string, double > &	initial_value_dict )

Definition at line 56 of file MergeMeshToBulkMesh.cpp.

{
    auto new_pv = MeshLib::getOrCreateMeshProperty<T>(
        merged_mesh, pv_name, MeshLib::MeshItemType::Node, pv_num_components);
    new_pv->resize(merged_mesh.getNumberOfNodes() * pv_num_components);
 
    std::copy(pv_bulk_mesh->begin(), pv_bulk_mesh->end(), new_pv->begin());
 
    if (pv_num_components > 1)
    {
        if (pv_name.find("sigma") != std::string::npos)
        {
            setSigma0(pv_num_components, pv_bulk_mesh, initial_value_dict,
                      *new_pv);
        }
        return true;
    }
 
    // Map possible pv_name values to their corresponding dictionary
    // keys
    const std::unordered_map<std::string, std::string> pv_to_dict_key = {
        {"pressure", "p"},
        {"p", "p"},
        {"gas_pressure", "pg"},
        {"pg", "pg"},
        {"capillary_pressure", "pc"},
        {"pc", "pc"},
        {"temperature", "T"},
        {"T", "T"}};
 
    T value = static_cast<T>(0.0);
    auto it = pv_to_dict_key.find(pv_name);
    if (it != pv_to_dict_key.end() && initial_value_dict.contains(it->second))
    {
        value = static_cast<T>(initial_value_dict[it->second]);
    }
    std::fill(new_pv->begin() + pv_bulk_mesh->size(), new_pv->end(), value);
    return true;
}

References MeshLib::Mesh::getNumberOfNodes(), MeshLib::getOrCreateMeshProperty(), MeshLib::Node, setSigma0(), and MeshLib::PropertyVector< T >::size().

Referenced by createMergedPropertyVector().

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().

findNodesInBoundedDomain()

std::vector< MeshLib::Node * > MeshToolsLib::findNodesInBoundedDomain	(	std::vector< MeshLib::Node * > const &	nodes,
		GeoLib::AABB const &	aabb )

Definition at line 215 of file MergeMeshToBulkMesh.cpp.

{
    return nodes |
           ranges::views::filter(
               [&](MeshLib::Node* n)
               { return aabb.containsPoint(n->asEigenVector3d(), 1e-16); }) |
           ranges::to<std::vector<MeshLib::Node*>>();
}

References MathLib::Point3d::asEigenVector3d(), and GeoLib::AABB::containsPoint().

Referenced by mergeMeshToBulkMesh().

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::getIntegrationPointMetaDataSingleField(
        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(), MeshLib::getIntegrationPointMetaDataSingleField(), getNumberOfElementIntegrationPoints(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), and MeshLib::PropertyVectorBase::getPropertyName().

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

getNumberOfElementIntegrationPoints()

int MeshToolsLib::getNumberOfElementIntegrationPoints	(	MeshLib::IntegrationPointMetaDataSingleField 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(), createIntegrationPointProperties(), createPropertyVector(), getIntegrationPointDataOffsetsOfMeshElements(), and ApplicationUtils::setIntegrationPointNumberOfPartition().

getNumberOfElementIntegrationPointsGeneral()

template<typename ElementType >

int MeshToolsLib::getNumberOfElementIntegrationPointsGeneral

(

MeshLib::IntegrationPointMetaDataSingleField 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::IntegrationPointMetaDataSingleField::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 70 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().

mergeMeshToBulkMesh()

std::unique_ptr< MeshLib::Mesh > MeshToolsLib::mergeMeshToBulkMesh	(	MeshLib::Mesh const &	bulk_mesh,
		MeshLib::Mesh const &	other_mesh,
		std::unordered_map< std::string, double > &	initial_value_dict )

Merges the mesh other_mesh into the bulk mesh bulk_mesh. Optionally sets constant integration point stress and primary nodal variables in the bulk mesh to specified values for the merged part.

Note: This function moves nodes and elements from other_mesh to the merged mesh (bulk_mesh). It deletes the duplicate nodes of other_mesh at the mesh interface. The merged mesh manages memory deallocation for nodes and elements. The member function shallowClean must be called on bulk_mesh and other_mesh afterward to prevent memory leaks.

Parameters

bulk_mesh	Bulk mesh.
other_mesh	Mesh to be merged.
initial_value_dict	Initial values to be specified for the merged part.

Returns

Definition at line 225 of file MergeMeshToBulkMesh.cpp.

{
    auto const& other_mesh_nodes = other_mesh.getNodes();
    GeoLib::AABB aabb(other_mesh_nodes.begin(), other_mesh_nodes.end());
 
    auto const& bulk_mesh_nodes = bulk_mesh.getNodes();
    auto const bulk_nodes_in_aabb =
        findNodesInBoundedDomain(bulk_mesh_nodes, aabb);
 
    // Find the interface nodes in the bulk nodes
    auto const pn_bulk_mesh = partitionNodesByCoordinateMatch(
        bulk_nodes_in_aabb, other_mesh_nodes, aabb,
        false /*return_non_paired_nodes*/);
    auto interface_nodes_of_bulk_mesh = pn_bulk_mesh.paired_nodes;
 
    // Partitioned node vector of the other mesh
    auto const pn_other_mesh = partitionNodesByCoordinateMatch(
        other_mesh_nodes, bulk_nodes_in_aabb, aabb);
    auto const interface_nodes_of_other_mesh = pn_other_mesh.paired_nodes;
    auto const internal_nodes_of_other_mesh = *(pn_other_mesh.non_paired_nodes);
 
    // Interface node id mapping: from the other mesh to the bulk mesh
    auto cn_id_mapping_m2b = *(pn_other_mesh.id_mapping);
 
    std::unordered_map<std::size_t, std::size_t> other_mesh_node_id_dict;
 
    for (auto const&& [id_mapping, node] :
         ranges::views::zip(cn_id_mapping_m2b, interface_nodes_of_other_mesh))
    {
        other_mesh_node_id_dict.insert({node->getID(), id_mapping});
    }
 
    // Create new mesh node vector
    std::vector<MeshLib::Node*> new_node_vector;
    new_node_vector.reserve(bulk_mesh_nodes.size() +
                            internal_nodes_of_other_mesh.size());
    // First, copy the nodes from the bulk mesh
    new_node_vector.insert(new_node_vector.end(), bulk_mesh_nodes.begin(),
                           bulk_mesh_nodes.end());
    // Second, append the inside nodes of the merge mesh
    std::size_t new_node_id = bulk_mesh_nodes.size();
    for (auto node : internal_nodes_of_other_mesh)
    {
        other_mesh_node_id_dict.insert({node->getID(), new_node_id});
        new_node_vector.push_back(node);
        new_node_id++;
    }
 
    // Create new mesh element vector
    auto const elements_bulk = bulk_mesh.getElements();
    auto const elements_other_mesh = other_mesh.getElements();
    std::vector<MeshLib::Element*> new_element_vector;
    new_element_vector.reserve(elements_bulk.size() +
                               elements_other_mesh.size());
    // First, copy the elements from the bulk mesh
    new_element_vector.insert(new_element_vector.end(), elements_bulk.begin(),
                              elements_bulk.end());
    // Append the elements of the mesh to be merged to the element vector of the
    // bulk mesh:
    for (auto element : elements_other_mesh)
    {
        auto const nn = element->getNumberOfNodes();
        for (unsigned i = 0; i < nn; ++i)
        {
            // `node` cannot be declared as `const` because `element` is not
            // `const`.
            MeshLib::Node* node = element->getNode(i);
            auto const new_id = other_mesh_node_id_dict[node->getID()];
            element->setNode(i, new_node_vector[new_id]);
        }
        new_element_vector.push_back(element);
    }
 
    // Node IDs are reset in the constructor of MeshLib::Mesh according to their
    // order of appearance (see MeshLib::Mesh::resetNodeIDs()). Since the order
    // of nodes in the bulk mesh remains unchanged, the corresponding segments
    // of property vectors of the original bulk mesh are also preserved.
    auto merged_mesh = std::make_unique<MeshLib::Mesh>(
        "merged_mesh", new_node_vector, new_element_vector);
 
    MeshLib::Properties const& properties_bulk_mesh = bulk_mesh.getProperties();
    auto const integration_point_meta_data =
        MeshLib::getIntegrationPointMetaData(properties_bulk_mesh);
 
    MeshLib::applyToPropertyVectors(
        properties_bulk_mesh,
        [&](auto type, auto const& property)
        {
            return createMergedPropertyVector<decltype(type)>(
                *merged_mesh, initial_value_dict,
                dynamic_cast<MeshLib::PropertyVector<decltype(type)> const*>(
                    property),
                integration_point_meta_data);
        });
 
    for (auto node : interface_nodes_of_other_mesh)
    {
        delete node;
    }
 
    return merged_mesh;
}

References MeshLib::applyToPropertyVectors(), createMergedPropertyVector(), findNodesInBoundedDomain(), MeshLib::Mesh::getElements(), MathLib::Point3dWithID::getID(), MeshLib::getIntegrationPointMetaData(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), and partitionNodesByCoordinateMatch().

Referenced by main().

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().

partitionNodesByCoordinateMatch()

NodesPartitionResult MeshToolsLib::partitionNodesByCoordinateMatch	(	std::vector< MeshLib::Node * > const &	node_vector,
		std::vector< MeshLib::Node * > const &	tool_node_vector,
		GeoLib::AABB const &	aabb,
		bool const	return_non_paired_nodes = true )

Assuming at least one element in node_vector can be paired with an element in tool_node_vector based on identical coordinates, this function partitions node_vector into two vectors: one containing nodes that can be paired with elements in tool_node_vector, and another containing the remaining nodes or empty depending on the argument return_non_paired_nodes.

Parameters

node_vector	Node vector to be partitioned.
tool_node_vector	Node vector as a tool for partitioning.
aabb	Axis-aligned bounding box (AABB) for spatial filtering and the optional return of non-paired nodes.
return_non_paired_nodes	Indicator whether to return unpaired nodes.

Returns

1. paired nodes of node_vector,
2. node ID mapping from the paired node of node_vector to its pair in tool_node_vector or nothing if return_non_paired_nodes is false,
3. unpaired nodes of node_vector or nothing if return_non_paired_nodes is false.

Definition at line 20 of file PartitionNodesByCoordinateMatch.cpp.

{
    auto oct_tree = std::unique_ptr<GeoLib::OctTree<MeshLib::Node, 16>>(
        GeoLib::OctTree<MeshLib::Node, 16>::createOctTree(
            aabb.getMinPoint(), aabb.getMaxPoint(), 1e-16));
 
    // Push all tool nodes into oct_tree:
    for (auto const node : tool_node_vector)
    {
        MeshLib::Node* node_ptr = nullptr;
        oct_tree->addPoint(node, node_ptr);
    }
 
    // Find the paired nodes in the node_vector
    std::vector<MeshLib::Node*> paired_nodes;
    std::vector<MeshLib::Node*> other_nodes;
    std::vector<std::size_t> ip_mapping;
    for (auto node : node_vector)
    {
        MeshLib::Node* node_ptr = nullptr;
        if (oct_tree->addPoint(node, node_ptr))
        {
            if (return_non_paired_nodes)
            {
                other_nodes.push_back(node);
            }
            continue;
        }
        paired_nodes.push_back(node);
        ip_mapping.push_back(node_ptr->getID());
    }
 
    if (return_non_paired_nodes)
    {
        return {paired_nodes, ip_mapping, other_nodes};
    }
 
    return {paired_nodes, std::nullopt, std::nullopt};
}

References GeoLib::OctTree< POINT, MAX_POINTS >::createOctTree(), MathLib::Point3dWithID::getID(), GeoLib::AABB::getMaxPoint(), and GeoLib::AABB::getMinPoint().

Referenced by mergeMeshToBulkMesh().

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< T >::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 21 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 =
        BaseLib::excludeObjectCopy(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(), BaseLib::excludeObjectCopy(), 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 86 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 102 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().

setSigma0()

template<typename T >

void MeshToolsLib::setSigma0	(	int const	pv_num_components,
		MeshLib::PropertyVector< T > const *const	pv_bulk_mesh,
		std::unordered_map< std::string, double > &	initial_value_dict,
		MeshLib::PropertyVector< T > &	new_pv )

Definition at line 38 of file MergeMeshToBulkMesh.cpp.

{
    std::vector<double> sigma0(pv_num_components, 0.0);
    sigma0[0] = initial_value_dict["sxx"];
    sigma0[1] = initial_value_dict["syy"];
    sigma0[2] = initial_value_dict["szz"];
 
    std::transform(new_pv.begin() + pv_bulk_mesh->size(),
                   new_pv.end(),
                   new_pv.begin() + pv_bulk_mesh->size(),
                   [&, i = 0](T) mutable
                   { return static_cast<T>(sigma0[i++ % sigma0.size()]); });
}

References MeshLib::PropertyVector< T >::size().

Referenced by createIntegrationPointProperties(), and createNodeProperties().

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().