ElementSearch.h

Go to the documentation of this file.

 
#pragma once
 
#include <limits>
#include <vector>
 
#include "GeoLib/AABB.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/MeshEnums.h"
 
namespace MeshLib {
 
// forward declarations
class Mesh;
class Element;
 
class ElementSearch final
{
public:
    explicit ElementSearch(const MeshLib::Mesh &mesh);
 
    const std::vector<std::size_t>& getSearchedElementIDs() const { return _marked_elements; }
 
    template <typename PROPERTY_TYPE>
    std::size_t searchByPropertyValue(std::string const& property_name,
                                      PROPERTY_TYPE const property_value)
    {
        return searchByPropertyValueRange<PROPERTY_TYPE>(
            property_name, property_value, property_value, false);
    }
 
    template <typename PROPERTY_TYPE>
    std::size_t searchByPropertyValueRange(
        std::string const& property_name,
        PROPERTY_TYPE const min_property_value,
        PROPERTY_TYPE const max_property_value,
        bool outside_of)
    {
        MeshLib::PropertyVector<PROPERTY_TYPE> const* pv = nullptr;
        try
        {
            pv = _mesh.getProperties().getPropertyVector<PROPERTY_TYPE>(
                property_name, MeshLib::MeshItemType::Cell, 1);
        }
        catch (std::runtime_error const& e)
        {
            ERR("{:s}", e.what());
            WARN(
                "Value-based element removal currently only works for "
                "scalars.");
            return 0;
        }
 
        std::vector<std::size_t> matchedIDs;
 
        if (outside_of)
        {
            for (std::size_t i(0); i < pv->getNumberOfTuples(); ++i)
            {
                if ((*pv)[i] < min_property_value ||
                    (*pv)[i] > max_property_value)
                {
                    matchedIDs.push_back(i);
                }
            }
        }
        else
        {
            for (std::size_t i(0); i < pv->getNumberOfTuples(); ++i)
            {
                if ((*pv)[i] >= min_property_value &&
                    (*pv)[i] <= max_property_value)
                {
                    matchedIDs.push_back(i);
                }
            }
        }
        updateUnion(matchedIDs);
        return matchedIDs.size();
    }
 
    std::size_t searchByElementType(MeshElemType eleType);
 
    std::size_t searchByContent(double eps = std::numeric_limits<double>::epsilon());
 
    std::size_t searchByBoundingBox(GeoLib::AABB const& aabb);
 
    std::size_t searchByNodeIDs(const std::vector<std::size_t>& nodes);
 
private:
    void updateUnion(const std::vector<std::size_t> &vec);
 
    const MeshLib::Mesh &_mesh;
    std::vector<std::size_t> _marked_elements;
};
 
} // end namespace MeshLib