Detailed Description

Class Mesh2MeshPropertyInterpolation transfers properties of mesh elements of a (source) mesh to mesh elements of another (destination) mesh deploying weighted interpolation. The two meshes must have the same dimension.

Definition at line 34 of file Mesh2MeshPropertyInterpolation.h.

#include <Mesh2MeshPropertyInterpolation.h>

Collaboration diagram for MeshToolsLib::Mesh2MeshPropertyInterpolation:

[legend]

Public Member Functions
	Mesh2MeshPropertyInterpolation (MeshLib::Mesh const &src_mesh, std::string const &property_name)

bool	setPropertiesForMesh (MeshLib::Mesh &dest_mesh) const

Private Member Functions
void	interpolatePropertiesForMesh (MeshLib::Mesh const &dest_mesh, MeshLib::PropertyVector< double > &dest_properties) const

void	interpolateElementPropertiesToNodeProperties (std::vector< double > &interpolated_properties) const

Private Attributes
MeshLib::Mesh const &	_src_mesh

std::string const &	_property_name

Constructor & Destructor Documentation

◆ Mesh2MeshPropertyInterpolation()

MeshToolsLib::Mesh2MeshPropertyInterpolation::Mesh2MeshPropertyInterpolation	(	MeshLib::Mesh const &	src_mesh,
		std::string const &	property_name )

Constructor taking the source or input mesh and properties.

Parameters

src_mesh	the mesh the given property information is assigned to.
property_name	is the name of a PropertyVector in the `source_mesh`

Definition at line 30 of file Mesh2MeshPropertyInterpolation.cpp.

    : _src_mesh(src_mesh), _property_name(property_name)
{
}

Member Function Documentation

◆ interpolateElementPropertiesToNodeProperties()

void MeshToolsLib::Mesh2MeshPropertyInterpolation::interpolateElementPropertiesToNodeProperties ( std::vector< double > & interpolated_properties ) const

private

Method interpolates the element wise given properties to the nodes of the element

Parameters

interpolated_properties the vector must have the same number of entries as the source mesh has number of nodes, the content of the particular entries will be overwritten

Definition at line 152 of file Mesh2MeshPropertyInterpolation.cpp.

{
    // fetch the source of property values
    if (!_src_mesh.getProperties().existsPropertyVector<double>(_property_name))
    {
        WARN("Did not find PropertyVector<double> '{:s}'.", _property_name);
        return;
    }
    auto const* elem_props =
        _src_mesh.getProperties().getPropertyVector<double>(_property_name);
 
    std::vector<MeshLib::Node*> const& src_nodes(_src_mesh.getNodes());
    const std::size_t n_src_nodes(src_nodes.size());
    for (std::size_t k(0); k < n_src_nodes; k++)
    {
        const std::size_t n_con_elems(
            _src_mesh.getElementsConnectedToNode(*src_nodes[k]).size());
        interpolated_properties[k] = (*elem_props)
            [_src_mesh.getElementsConnectedToNode(*src_nodes[k])[0]->getID()];
        for (std::size_t j(1); j < n_con_elems; j++)
        {
            interpolated_properties[k] +=
                (*elem_props)[_src_mesh
                                  .getElementsConnectedToNode(*src_nodes[k])[j]
                                  ->getID()];
        }
        interpolated_properties[k] /= n_con_elems;
    }
}

References _property_name, _src_mesh, MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), and WARN().

Referenced by interpolatePropertiesForMesh().

◆ interpolatePropertiesForMesh()

void MeshToolsLib::Mesh2MeshPropertyInterpolation::interpolatePropertiesForMesh	(	MeshLib::Mesh const &	dest_mesh,
		MeshLib::PropertyVector< double > &	dest_properties ) const

private

Parameters

dest_mesh
dest_properties

Definition at line 88 of file Mesh2MeshPropertyInterpolation.cpp.

{
    std::vector<double> interpolated_src_node_properties(
        _src_mesh.getNumberOfNodes());
    interpolateElementPropertiesToNodeProperties(
        interpolated_src_node_properties);
 
    // idea: looping over the destination elements and calculate properties
    // from interpolated_src_node_properties to accelerate the (source) point
    // search construct a grid
    std::vector<MeshLib::Node*> const& src_nodes(_src_mesh.getNodes());
    GeoLib::Grid<MeshLib::Node> src_grid(src_nodes.begin(), src_nodes.end(),
                                         64);
 
    auto const& dest_elements(dest_mesh.getElements());
    const std::size_t n_dest_elements(dest_elements.size());
    for (std::size_t k(0); k < n_dest_elements; k++)
    {
        MeshLib::Element& dest_element(*dest_elements[k]);
        if (dest_element.getGeomType() == MeshLib::MeshElemType::LINE)
        {
            continue;
        }
 
        // compute axis aligned bounding box around the current element
        const GeoLib::AABB elem_aabb(
            dest_element.getNodes(),
            dest_element.getNodes() + dest_element.getNumberOfBaseNodes());
 
        // request "interesting" nodes from grid
        std::vector<std::vector<MeshLib::Node*> const*> const nodes =
            src_grid.getPntVecsOfGridCellsIntersectingCuboid(
                elem_aabb.getMinPoint(), elem_aabb.getMaxPoint());
 
        std::size_t cnt(0);
        double average_value(0.0);
 
        for (auto const* nodes_vec : nodes)
        {
            for (auto const* node : *nodes_vec)
            {
                if (elem_aabb.containsPointXY(*node) &&
                    MeshLib::isPointInElementXY(*node, dest_element))
                {
                    average_value +=
                        interpolated_src_node_properties[node->getID()];
                    cnt++;
                }
            }
        }
 
        if (cnt == 0)
        {
            OGS_FATAL(
                "Mesh2MeshInterpolation: Could not find values in source mesh "
                "for the element {:d}.",
                k);
        }
        dest_properties[k] = average_value / cnt;
    }
}

References _src_mesh, GeoLib::AABB::containsPointXY(), MeshLib::Mesh::getElements(), MeshLib::Element::getGeomType(), GeoLib::AABB::getMaxPoint(), GeoLib::AABB::getMinPoint(), MeshLib::Mesh::getNodes(), MeshLib::Element::getNodes(), MeshLib::Element::getNumberOfBaseNodes(), MeshLib::Mesh::getNumberOfNodes(), GeoLib::Grid< POINT >::getPntVecsOfGridCellsIntersectingCuboid(), interpolateElementPropertiesToNodeProperties(), MeshLib::isPointInElementXY(), MeshLib::LINE, and OGS_FATAL.

Referenced by setPropertiesForMesh().

◆ setPropertiesForMesh()

bool MeshToolsLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh ( MeshLib::Mesh & dest_mesh ) const

Calculates entries for the property vector and sets appropriate indices in the mesh elements.

Parameters

dest_mesh the mesh the property information will be calculated and set via weighted interpolation

Returns: true if the operation was successful, false on error

Definition at line 36 of file Mesh2MeshPropertyInterpolation.cpp.

{
    if (_src_mesh.getDimension() != dest_mesh.getDimension())
    {
        ERR("MeshLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh() "
            "dimension of source (dim = {:d}) and destination (dim = {:d}) "
            "mesh does not match.",
            _src_mesh.getDimension(), dest_mesh.getDimension());
        return false;
    }
 
    if (_src_mesh.getDimension() != 2)
    {
        WARN(
            "MeshLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh() "
            "implemented only for 2D case at the moment.");
        return false;
    }
 
    MeshLib::PropertyVector<double>* dest_properties;
    if (dest_mesh.getProperties().existsPropertyVector<double>(_property_name))
    {
        dest_properties =
            dest_mesh.getProperties().getPropertyVector<double>(_property_name);
    }
    else
    {
        INFO("Create new PropertyVector '{:s}' of type double.",
             _property_name);
        dest_properties =
            dest_mesh.getProperties().createNewPropertyVector<double>(
                _property_name, MeshLib::MeshItemType::Cell, 1);
        if (!dest_properties)
        {
            WARN(
                "Could not get or create a PropertyVector of type double using "
                "the given name '{:s}'.",
                _property_name);
            return false;
        }
    }
    if (dest_properties->size() != dest_mesh.getNumberOfElements())
    {
        dest_properties->resize(dest_mesh.getNumberOfElements());
    }
 
    interpolatePropertiesForMesh(dest_mesh, *dest_properties);
 
    return true;
}