Detailed Description

HeuristicSearchLength implements a mesh dependent criterion for searching mesh nodes near a geometry. For this purpose it computes the average \(\mu\) and the standard deviation \(\sigma\) of edge length or node distance of mesh elements. The search length is set to \(\mu-2\sigma\). This strategy is useful for meshes with different sizes of elements.

Definition at line 30 of file HeuristicSearchLength.h.

#include <HeuristicSearchLength.h>

Inheritance diagram for MeshGeoToolsLib::HeuristicSearchLength:

[legend]

Collaboration diagram for MeshGeoToolsLib::HeuristicSearchLength:

[legend]

Public Types
enum class	LengthType { Edge , Node }
	Type of length to be sampled. More...

Public Member Functions
	HeuristicSearchLength (MeshLib::Mesh const &mesh, LengthType length_type=LengthType::Edge)

Public Member Functions inherited from MeshGeoToolsLib::SearchLength
	SearchLength (double search_length=1e-9)

	SearchLength (SearchLength const &)=default

SearchLength &	operator= (SearchLength const &)=default

virtual	~SearchLength ()=default

virtual double	getSearchLength () const

Private Attributes
MeshLib::Mesh const &	_mesh

Additional Inherited Members
Protected Attributes inherited from MeshGeoToolsLib::SearchLength
double	_search_length

Member Enumeration Documentation

◆ LengthType

enum class MeshGeoToolsLib::HeuristicSearchLength::LengthType

strong

Type of length to be sampled.

Enumerator

Edge

Node

edge length of elements, which is recommended for meshes without nonlinear nodes

distance between nodes

Definition at line 34 of file HeuristicSearchLength.h.

    {
        Edge, 
        Node  
    };

Constructor & Destructor Documentation

◆ HeuristicSearchLength()

MeshGeoToolsLib::HeuristicSearchLength::HeuristicSearchLength	(	MeshLib::Mesh const &	mesh,
		LengthType	length_type = LengthType::Edge )

explicit

Constructor

Parameters

mesh	mesh object
length_type	length type to be sampled

Definition at line 20 of file HeuristicSearchLength.cpp.

    : _mesh(mesh)
{
    double sum(0.0);
    double sum_of_sqr(0.0);  // total length of edges
 
    std::size_t n_sampling(0);  // total length of edges squared
    std::vector<MeshLib::Element*> const& elements(_mesh.getElements());
 
    if (length_type == LengthType::Edge)
    {
        for (auto element : elements)
        {
            std::size_t const n_edges(element->getNumberOfEdges());
            for (std::size_t k(0); k < n_edges; k++)
            {
                auto edge =
                    element->getEdge(k);  // allocation inside getEdge().
                double const len = edge->getContent();
                delete edge;
                sum += len;
                sum_of_sqr += len * len;
            }
            n_sampling += n_edges;
        }
    }
    else
    {
        for (const MeshLib::Element* e : elements)
        {
            auto const [min, max] =
                MeshLib::computeSqrNodeDistanceRange(*e, true);
            sum += std::sqrt(min);
            sum_of_sqr += min;
        }
        n_sampling = _mesh.getNumberOfElements();
    }
 
    const double mean(sum / n_sampling);
    const double variance((sum_of_sqr - (sum * sum) / n_sampling) /
                          (n_sampling - 1));
 
    // Set the search length for the case of non-positive variance (which can
    // happen due to numerics).
    _search_length = mean / 2;
 
    if (variance > 0)
    {
        if (variance < mean * mean / 4)
        {
            _search_length -= std::sqrt(variance);
        }
        else
        {
            _search_length = std::numeric_limits<double>::epsilon();
        }
    }
 
    DBUG(
        "[MeshNodeSearcher::MeshNodeSearcher] Calculated search length for "
        "mesh '{:s}' is {:f}.",
        _mesh.getName(), _search_length);
}