anonymous_namespace{MeshRevision.cpp} Namespace Reference

Functions
template<typename ElementType>
std::unique_ptr< MeshLib::Element >	createElement (std::span< MeshLib::Node *const > const element_nodes, std::vector< MeshLib::Node * > const &nodes, std::array< std::size_t, ElementType::n_all_nodes > const local_ids)
unsigned	subdivideQuad (MeshLib::Element const *const quad, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &new_elements)
	Subdivides a nonplanar quad into two triangles.
unsigned	subdividePrism (MeshLib::Element const *const prism, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &new_elements)
	Subdivides a prism with nonplanar quad faces into two tets.
unsigned	subdivideHex (MeshLib::Element const *const hex, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &new_elements)
	Subdivides a Hex with nonplanar faces into tets.
unsigned	subdividePyramid (MeshLib::Element const *const pyramid, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &new_elements)
	Subdivides a pyramid with a nonplanar base into two tets.
MeshLib::Element *	constructLine (MeshLib::Element const *const element, const std::vector< MeshLib::Node * > &nodes)
MeshLib::Element *	constructTri (MeshLib::Element const *const element, const std::vector< MeshLib::Node * > &nodes)
MeshLib::Element *	constructFourNodeElement (MeshLib::Element const *const element, std::vector< MeshLib::Node * > const &nodes, unsigned const min_elem_dim=1)
void	reducePyramid (MeshLib::Element const *const org_elem, unsigned const n_unique_nodes, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &new_elements, unsigned const min_elem_dim)
unsigned	reducePrism (MeshLib::Element const *const org_elem, unsigned const n_unique_nodes, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &new_elements, unsigned const min_elem_dim)
std::array< unsigned, 4 >	lutHexCuttingQuadNodes (unsigned id1, unsigned id2)
unsigned	lutHexDiametralNode (unsigned const id)
std::pair< unsigned, unsigned >	lutHexBackNodes (unsigned const i, unsigned const j, unsigned const k, unsigned const l)
unsigned	findPyramidTopNode (MeshLib::Element const &element, std::array< std::size_t, 4 > const &base_node_ids)
unsigned	reduceHex (MeshLib::Element const *const org_elem, unsigned const n_unique_nodes, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &new_elements, unsigned const min_elem_dim)
std::size_t	subdivideElement (MeshLib::Element const *const element, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &elements)
std::size_t	reduceElement (MeshLib::Element const *const element, unsigned const n_unique_nodes, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element * > &elements, unsigned const min_elem_dim)
unsigned	getNumberOfUniqueNodes (MeshLib::Element const *const element)
std::vector< std::size_t >	getSurvivingNodeIds (std::vector< std::size_t > const &node_ids)
template<typename T>
bool	copyProperty (MeshLib::Properties const &props, MeshLib::Properties &new_properties, std::string const &name, MeshLib::MeshItemType const item_type, std::vector< std::size_t > const &source_ids)
template<typename... Ts>
bool	copyPropertyOfAnyValueType (MeshLib::Properties const &props, MeshLib::Properties &new_properties, std::string const &name, MeshLib::MeshItemType const item_type, std::vector< std::size_t > const &source_ids)
MeshLib::Properties	copyProperties (MeshLib::Properties const &props, std::vector< std::size_t > const &node_ids, std::vector< std::size_t > const &elem_ids)

Function Documentation

constructFourNodeElement()

MeshLib::Element * anonymous_namespace{MeshRevision.cpp}::constructFourNodeElement	(	MeshLib::Element const *const	element,
		std::vector< MeshLib::Node * > const &	nodes,
		unsigned const	min_elem_dim = 1 )

Creates a quad or a tet, depending if the four nodes being coplanar or not (element should have exactly four unique nodes!)

Definition at line 207 of file MeshRevision.cpp.

{
    std::array<MeshLib::Node*, 4> new_nodes{};
    unsigned count(0);
    new_nodes[count++] = nodes[element->getNode(0)->getID()];
    for (unsigned i = 1; i < element->getNumberOfBaseNodes(); ++i)
    {
        if (count > 3)
        {
            break;
        }
        bool unique_node(true);
        for (unsigned j = 0; j < i; ++j)
        {
            if (element->getNode(i)->getID() == element->getNode(j)->getID())
            {
                unique_node = false;
                break;
            }
        }
        if (unique_node)
        {
            new_nodes[count++] = nodes[element->getNode(i)->getID()];
        };
    }
 
    // test if quad or tet
    const bool isQuad(MathLib::isCoplanar(*new_nodes[0], *new_nodes[1],
                                          *new_nodes[2], *new_nodes[3]));
    if (isQuad && min_elem_dim < 3)
    {
        MeshLib::Element* elem(new MeshLib::Quad(new_nodes));
        for (unsigned i = 1; i < 3; ++i)
        {
            if (elem->validate().none())
            {
                return elem;
            }
 
            // change node order if not convex
            MeshLib::Node* tmp = new_nodes[i + 1];
            new_nodes[i + 1] = new_nodes[i];
            new_nodes[i] = tmp;
        }
        return elem;
    }
    if (!isQuad)
    {
        return new MeshLib::Tet(new_nodes);
    }
    // is quad but min elem dim == 3
 
    return nullptr;
}

References MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), MeshLib::Element::getNumberOfBaseNodes(), MathLib::isCoplanar(), and MeshLib::Element::validate().

Referenced by reduceHex(), reducePrism(), and reducePyramid().

constructLine()

MeshLib::Element * anonymous_namespace{MeshRevision.cpp}::constructLine	(	MeshLib::Element const *const	element,
		const std::vector< MeshLib::Node * > &	nodes )

Creates a line element from the first two unique nodes found in the element (element should have exactly two unique nodes!)

Definition at line 153 of file MeshRevision.cpp.

{
    std::array<std::size_t, 2> line_node_ids = {0, 0};
    for (unsigned i = 1; i < element->getNumberOfBaseNodes(); ++i)
    {
        if (element->getNode(i)->getID() != element->getNode(0)->getID())
        {
            line_node_ids[1] = i;
            break;
        }
    }
    assert(line_node_ids[1] != 0);
    return createElement<MeshLib::Line>(element->nodes(), nodes, line_node_ids)
        .release();
}

References createElement(), MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), MeshLib::Element::getNumberOfBaseNodes(), and MeshLib::Element::nodes().

Referenced by reduceElement(), reduceHex(), reducePrism(), and reducePyramid().

constructTri()

MeshLib::Element * anonymous_namespace{MeshRevision.cpp}::constructTri	(	MeshLib::Element const *const	element,
		const std::vector< MeshLib::Node * > &	nodes )

Creates a triangle element from the first three unique nodes found in the element (element should have exactly three unique nodes!)

Definition at line 172 of file MeshRevision.cpp.

{
    // TODO?
    // In theory three unique nodes could also be reduced to two lines e.g. with
    // a quad where two diametral nodes collapse. This case is currently not
    // implemented!
    std::array<MeshLib::Node*, 3> tri_nodes{};
    tri_nodes[0] = nodes[element->getNode(0)->getID()];
    tri_nodes[2] = nullptr;
    for (unsigned i = 1; i < element->getNumberOfBaseNodes(); ++i)
    {
        if (element->getNode(i)->getID() != tri_nodes[0]->getID())
        {
            tri_nodes[1] = nodes[element->getNode(i)->getID()];
            for (unsigned j = i + 1; j < element->getNumberOfBaseNodes(); ++j)
            {
                if (element->getNode(j)->getID() != tri_nodes[1]->getID())
                {
                    tri_nodes[2] = nodes[element->getNode(j)->getID()];
                    break;
                }
            }
            if (tri_nodes[2])
            {
                break;
            }
        }
    }
    assert(tri_nodes[2] != nullptr);
    return new MeshLib::Tri(tri_nodes);
}

References MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfBaseNodes().

Referenced by reduceElement(), reduceHex(), reducePrism(), and reducePyramid().

copyProperties()

MeshLib::Properties anonymous_namespace{MeshRevision.cpp}::copyProperties	(	MeshLib::Properties const &	props,
		std::vector< std::size_t > const &	node_ids,
		std::vector< std::size_t > const &	elem_ids )

Copies all scalar arrays according to the restructured Node- and Element-vectors after the mesh revision process (i.e. collapsed nodes, split elements, etc.)

Definition at line 953 of file MeshRevision.cpp.

{
    auto const prop_names = props.getPropertyVectorNames();
    MeshLib::Properties new_properties;
    auto const surviving_node_ids = getSurvivingNodeIds(node_ids);
 
    for (auto const& name : prop_names)
    {
        if (!copyPropertyOfAnyValueType<int, float, double>(
                props, new_properties, name, MeshLib::MeshItemType::Node,
                surviving_node_ids) &&
            !copyPropertyOfAnyValueType<int, float, double>(
                props, new_properties, name, MeshLib::MeshItemType::Cell,
                elem_ids))
        {
            WARN("PropertyVector {:s} not being converted.", name);
        }
    }
    return new_properties;
}

References MeshLib::Cell, copyPropertyOfAnyValueType(), MeshLib::Properties::getPropertyVectorNames(), getSurvivingNodeIds(), MeshLib::Node, and WARN().

copyProperty()

template<typename T>

bool anonymous_namespace{MeshRevision.cpp}::copyProperty	(	MeshLib::Properties const &	props,
		MeshLib::Properties &	new_properties,
		std::string const &	name,
		MeshLib::MeshItemType const	item_type,
		std::vector< std::size_t > const &	source_ids )

Copies the scalar property name of value type T and item type item_type, if such a property exists, to new_properties. The new property holds one value per entry of source_ids, gathered from the old property at that id. Returns false if no such property exists.

Definition at line 907 of file MeshRevision.cpp.

{
    if (!props.existsPropertyVector<T>(name, item_type, 1))
    {
        return false;
    }
    auto const& old_prop = *props.getPropertyVector<T>(name, item_type, 1);
    auto* const new_prop = new_properties.createNewPropertyVector<T>(
        name, item_type, source_ids.size(), 1);
    if (new_prop == nullptr)
    {
        // MeshLib::Properties keys its property vectors by name alone, and
        // each name of the source mesh is inserted here at most once, so this
        // is a broken invariant rather than malformed input.
        OGS_FATAL(
            "Could not create the property vector '{:s}' in the revised mesh.",
            name);
    }
    ranges::transform(source_ids, new_prop->begin(),
                      [&old_prop](std::size_t const i) { return old_prop[i]; });
    return true;
}

References MeshLib::Properties::createNewPropertyVector(), MeshLib::Properties::existsPropertyVector(), MeshLib::Properties::getPropertyVector(), and OGS_FATAL.

Referenced by copyPropertyOfAnyValueType().

copyPropertyOfAnyValueType()

template<typename... Ts>

bool anonymous_namespace{MeshRevision.cpp}::copyPropertyOfAnyValueType	(	MeshLib::Properties const &	props,
		MeshLib::Properties &	new_properties,
		std::string const &	name,
		MeshLib::MeshItemType const	item_type,
		std::vector< std::size_t > const &	source_ids )

Copies the scalar property name of item type item_type, trying the supported value types in turn. Returns false if no property of that name and item type exists in any of them.

Definition at line 938 of file MeshRevision.cpp.

{
    // The || fold stops at the first value type that exists.
    return (
        copyProperty<Ts>(props, new_properties, name, item_type, source_ids) ||
        ...);
}

References copyProperty().

Referenced by copyProperties().

createElement()

template<typename ElementType>

std::unique_ptr< MeshLib::Element > anonymous_namespace{MeshRevision.cpp}::createElement	(	std::span< MeshLib::Node *const > const	element_nodes,
		std::vector< MeshLib::Node * > const &	nodes,
		std::array< std::size_t, ElementType::n_all_nodes > const	local_ids )

Definition at line 60 of file MeshRevision.cpp.

{
    using namespace MeshLib::views;
    auto lookup_in = [](auto const& values)
    {
        return ranges::views::transform([&values](std::size_t const n)
                                        { return values[n]; });
    };
 
    std::array<MeshLib::Node*, ElementType::n_all_nodes> new_nodes{};
    ranges::copy(local_ids | lookup_in(element_nodes) | ids | lookup_in(nodes),
                 begin(new_nodes));
 
    return std::make_unique<ElementType>(new_nodes);
}

References MeshLib::views::ids.

Referenced by constructLine(), reduceHex(), reducePrism(), subdivideHex(), subdividePrism(), subdividePyramid(), and subdivideQuad().

findPyramidTopNode()

unsigned anonymous_namespace{MeshRevision.cpp}::findPyramidTopNode	(	MeshLib::Element const &	element,
		std::array< std::size_t, 4 > const &	base_node_ids )

Definition at line 548 of file MeshRevision.cpp.

{
    const std::size_t nNodes(element.getNumberOfBaseNodes());
    for (std::size_t i = 0; i < nNodes; ++i)
    {
        bool top_node = true;
        for (unsigned j = 0; j < 4; ++j)
        {
            if (element.getNode(i)->getID() == base_node_ids[j])
            {
                top_node = false;
            }
        }
        if (top_node)
        {
            return i;
        }
    }
    return std::numeric_limits<unsigned>::max();  // should never be reached if
                                                  // called correctly
}

References MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfBaseNodes().

Referenced by reduceHex().

getNumberOfUniqueNodes()

unsigned anonymous_namespace{MeshRevision.cpp}::getNumberOfUniqueNodes

(

MeshLib::Element const *const

element

)

Calculates the number of unique nodes in an element (i.e. uncollapsed nodes).

Definition at line 872 of file MeshRevision.cpp.

{
    unsigned const nNodes(element->getNumberOfBaseNodes());
    unsigned count(nNodes);
 
    for (unsigned i = 0; i < nNodes - 1; ++i)
    {
        for (unsigned j = i + 1; j < nNodes; ++j)
        {
            if (element->getNode(i)->getID() == element->getNode(j)->getID())
            {
                count--;
                break;
            }
        }
    }
    return count;
}

References MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfBaseNodes().

getSurvivingNodeIds()

std::vector< std::size_t > anonymous_namespace{MeshRevision.cpp}::getSurvivingNodeIds

(

std::vector< std::size_t > const &

node_ids

)

Ids of the nodes surviving the collapsing, i.e. of those mapped onto themselves, in increasing order.

Definition at line 893 of file MeshRevision.cpp.

{
    return ranges::views::iota(std::size_t{0}, node_ids.size()) |
           ranges::views::filter([&node_ids](std::size_t const i)
                                 { return node_ids[i] == i; }) |
           ranges::to<std::vector>;
}

Referenced by copyProperties().

lutHexBackNodes()

std::pair< unsigned, unsigned > anonymous_namespace{MeshRevision.cpp}::lutHexBackNodes	(	unsigned const	i,
		unsigned const	j,
		unsigned const	k,
		unsigned const	l )

When a hex is subdivided into two prisms, this returns the nodes of the hex edge that will serve as the back of one of the prisms.

Definition at line 501 of file MeshRevision.cpp.

{
    // collapsed edges are *not* connected
    if (lutHexDiametralNode(i) == k)
    {
        return {i, lutHexDiametralNode(l)};
    }
    if (lutHexDiametralNode(i) == l)
    {
        return {i, lutHexDiametralNode(k)};
    }
    if (lutHexDiametralNode(j) == k)
    {
        return {j, lutHexDiametralNode(l)};
    }
    if (lutHexDiametralNode(j) == l)
    {
        return {j, lutHexDiametralNode(k)};
    }
 
    // collapsed edges *are* connected
    if (i == k)
    {
        return {lutHexDiametralNode(l), j};
    }
    if (i == l)
    {
        return {lutHexDiametralNode(k), j};
    }
    if (j == k)
    {
        return {lutHexDiametralNode(l), i};
    }
    if (j == l)
    {
        return {lutHexDiametralNode(k), i};
    }
 
    return {std::numeric_limits<unsigned>::max(),
            std::numeric_limits<unsigned>::max()};
}

References lutHexDiametralNode().

Referenced by reduceHex().

lutHexCuttingQuadNodes()

std::array< unsigned, 4 > anonymous_namespace{MeshRevision.cpp}::lutHexCuttingQuadNodes	(	unsigned	id1,
		unsigned	id2 )

Lookup-table for returning four nodes connected to the two nodes (id1, id2) forming an edge in a Hex.

Definition at line 384 of file MeshRevision.cpp.

{
    if (id1 == 0 && id2 == 1)
    {
        return {3, 2, 5, 4};
    }
    if (id1 == 1 && id2 == 2)
    {
        return {0, 3, 6, 5};
    }
    if (id1 == 2 && id2 == 3)
    {
        return {1, 0, 7, 6};
    }
    if (id1 == 3 && id2 == 0)
    {
        return {2, 1, 4, 7};
    }
    if (id1 == 4 && id2 == 5)
    {
        return {0, 1, 6, 7};
    }
    if (id1 == 5 && id2 == 6)
    {
        return {1, 2, 7, 4};
    }
    if (id1 == 6 && id2 == 7)
    {
        return {2, 3, 4, 5};
    }
    if (id1 == 7 && id2 == 4)
    {
        return {3, 0, 5, 6};
    }
    if (id1 == 0 && id2 == 4)
    {
        return {3, 7, 5, 1};
    }
    if (id1 == 1 && id2 == 5)
    {
        return {0, 4, 6, 2};
    }
    if (id1 == 2 && id2 == 6)
    {
        return {1, 5, 7, 3};
    }
    if (id1 == 3 && id2 == 7)
    {
        return {2, 6, 4, 0};
    }
    if (id1 == 1 && id2 == 0)
    {
        return {2, 3, 4, 5};
    }
    if (id1 == 2 && id2 == 1)
    {
        return {3, 0, 5, 6};
    }
    if (id1 == 3 && id2 == 2)
    {
        return {0, 1, 6, 7};
    }
    if (id1 == 0 && id2 == 3)
    {
        return {1, 2, 7, 4};
    }
    if (id1 == 5 && id2 == 4)
    {
        return {1, 0, 7, 6};
    }
    if (id1 == 6 && id2 == 5)
    {
        return {2, 1, 4, 7};
    }
    if (id1 == 7 && id2 == 6)
    {
        return {3, 2, 5, 4};
    }
    if (id1 == 4 && id2 == 7)
    {
        return {0, 3, 6, 5};
    }
    if (id1 == 4 && id2 == 0)
    {
        return {7, 3, 1, 5};
    }
    if (id1 == 5 && id2 == 1)
    {
        return {4, 0, 2, 6};
    }
    if (id1 == 6 && id2 == 2)
    {
        return {5, 1, 3, 7};
    }
    if (id1 == 7 && id2 == 3)
    {
        return {6, 2, 0, 4};
    }
 
    OGS_FATAL(
        "lutHexCuttingQuadNodes() for nodes {} and {} does not have a valid "
        "return value.",
        id1, id2);
}

References OGS_FATAL.

Referenced by reduceHex().

lutHexDiametralNode()

unsigned anonymous_namespace{MeshRevision.cpp}::lutHexDiametralNode

(

unsigned const

id

)

Lookup-table for returning the diametral node id of the given node id in a Hex.

Definition at line 491 of file MeshRevision.cpp.

{
    constexpr std::array<unsigned, 8> hex_diametral_node_ids = {
        {6, 7, 4, 5, 2, 3, 0, 1}};
 
    return hex_diametral_node_ids[id];
}

Referenced by lutHexBackNodes(), and reduceHex().

reduceElement()

std::size_t anonymous_namespace{MeshRevision.cpp}::reduceElement	(	MeshLib::Element const *const	element,
		unsigned const	n_unique_nodes,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	elements,
		unsigned const	min_elem_dim )

Definition at line 823 of file MeshRevision.cpp.

{
    /***************
     * TODO: modify neighbouring elements if one elements has been subdivided
     ***************/
    if (element->getGeomType() == MeshLib::MeshElemType::TRIANGLE &&
        min_elem_dim == 1)
    {
        elements.push_back(constructLine(element, nodes));
        return 1;
    }
    if ((element->getGeomType() == MeshLib::MeshElemType::QUAD) ||
        (element->getGeomType() == MeshLib::MeshElemType::TETRAHEDRON))
    {
        if (n_unique_nodes == 3 && min_elem_dim < 3)
        {
            elements.push_back(constructTri(element, nodes));
        }
        else if (min_elem_dim == 1)
        {
            elements.push_back(constructLine(element, nodes));
        }
        return 1;
    }
    if (element->getGeomType() == MeshLib::MeshElemType::HEXAHEDRON)
    {
        return reduceHex(element, n_unique_nodes, nodes, elements,
                         min_elem_dim);
    }
    if (element->getGeomType() == MeshLib::MeshElemType::PYRAMID)
    {
        reducePyramid(element, n_unique_nodes, nodes, elements, min_elem_dim);
        return 1;
    }
    if (element->getGeomType() == MeshLib::MeshElemType::PRISM)
    {
        return reducePrism(element, n_unique_nodes, nodes, elements,
                           min_elem_dim);
    }
 
    ERR("Unknown element type.");
    return 0;
}

References constructLine(), constructTri(), ERR(), MeshLib::Element::getGeomType(), MeshLib::HEXAHEDRON, MeshLib::PRISM, MeshLib::PYRAMID, MeshLib::QUAD, reduceHex(), reducePrism(), reducePyramid(), MeshLib::TETRAHEDRON, and MeshLib::TRIANGLE.

reduceHex()

unsigned anonymous_namespace{MeshRevision.cpp}::reduceHex	(	MeshLib::Element const *const	org_elem,
		unsigned const	n_unique_nodes,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	new_elements,
		unsigned const	min_elem_dim )

Reduces a hexahedron element by removing collapsed nodes and constructing one or more new elements from the remaining nodes.

Returns

The number of newly created elements

Definition at line 574 of file MeshRevision.cpp.

{
    // TODO?
    // if two diametral nodes collapse, all kinds of bizarre (2D-)element
    // combinations could be the result. this case is currently not implemented!
 
    if (n_unique_nodes == 7)
    {
        // reduce to prism + pyramid
        for (unsigned i = 0; i < 7; ++i)
        {
            for (unsigned j = i + 1; j < 8; ++j)
            {
                if (org_elem->getNode(i)->getID() ==
                    org_elem->getNode(j)->getID())
                {
                    const std::array<unsigned, 4> base_node_ids(
                        lutHexCuttingQuadNodes(i, j));
                    std::array<std::size_t, 5> const pyr_node_ids = {
                        base_node_ids[0], base_node_ids[1], base_node_ids[2],
                        base_node_ids[3], i};
                    new_elements.push_back(
                        createElement<MeshLib::Pyramid>(org_elem->nodes(),
                                                        nodes, pyr_node_ids)
                            .release());
 
                    if (i < 4 && j >= 4)
                    {
                        std::swap(i, j);
                    }
                    std::array<std::size_t, 6> const prism_node_ids{
                        base_node_ids[0],       base_node_ids[3],
                        lutHexDiametralNode(j), base_node_ids[1],
                        base_node_ids[2],       lutHexDiametralNode(i)};
                    new_elements.push_back(
                        createElement<MeshLib::Prism>(org_elem->nodes(), nodes,
                                                      prism_node_ids)
                            .release());
                    return 2;
                }
            }
        }
    }
    else if (n_unique_nodes == 6)
    {
        // reduce to prism
        for (unsigned i = 0; i < 6; ++i)
        {
            const MeshLib::Element* face(org_elem->getFace(i));
            if (face->getNode(0)->getID() == face->getNode(1)->getID() &&
                face->getNode(2)->getID() == face->getNode(3)->getID())
            {
                std::array<std::size_t, 6> const prism_node_ids{
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(0))),
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(1))),
                    getNodeIDinElement(*org_elem, face->getNode(2)),
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(2))),
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(3))),
                    getNodeIDinElement(*org_elem, face->getNode(0))};
 
                new_elements.push_back(
                    createElement<MeshLib::Prism>(org_elem->nodes(), nodes,
                                                  prism_node_ids)
                        .release());
                delete face;
                return 1;
            }
            if (face->getNode(0)->getID() == face->getNode(3)->getID() &&
                face->getNode(1)->getID() == face->getNode(2)->getID())
            {
                std::array<std::size_t, 6> const prism_node_ids{
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(0))),
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(3))),
                    getNodeIDinElement(*org_elem, face->getNode(2)),
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(1))),
                    lutHexDiametralNode(
                        getNodeIDinElement(*org_elem, face->getNode(2))),
                    getNodeIDinElement(*org_elem, face->getNode(0))};
                new_elements.push_back(
                    createElement<MeshLib::Prism>(org_elem->nodes(), nodes,
                                                  prism_node_ids)
                        .release());
                delete face;
                return 1;
            }
            delete face;
        }
        // reduce to four tets -> divide into 2 prisms such that each has one
        // collapsed node
        for (unsigned i = 0; i < 7; ++i)
        {
            for (unsigned j = i + 1; j < 8; ++j)
            {
                if (org_elem->getNode(i)->getID() ==
                    org_elem->getNode(j)->getID())
                {
                    for (unsigned k = i; k < 7; ++k)
                    {
                        for (unsigned l = k + 1; l < 8; ++l)
                        {
                            if ((i != k || j != l) && org_elem->isEdge(i, j) &&
                                org_elem->isEdge(k, l) &&
                                org_elem->getNode(k)->getID() ==
                                    org_elem->getNode(l)->getID())
                            {
                                const std::pair<unsigned, unsigned> back(
                                    lutHexBackNodes(i, j, k, l));
                                if (back.first ==
                                        std::numeric_limits<unsigned>::max() ||
                                    back.second ==
                                        std::numeric_limits<unsigned>::max())
                                {
                                    ERR("Unexpected error during Hex "
                                        "reduction");
                                    return 0;
                                }
 
                                std::array<unsigned, 4> const cutting_plane(
                                    lutHexCuttingQuadNodes(back.first,
                                                           back.second));
                                std::array<std::size_t, 6> const pris1_node_ids{
                                    back.first,       cutting_plane[0],
                                    cutting_plane[3], back.second,
                                    cutting_plane[1], cutting_plane[2]};
                                auto prism1 = createElement<MeshLib::Prism>(
                                    org_elem->nodes(), nodes, pris1_node_ids);
                                unsigned nNewElements =
                                    reducePrism(prism1.get(), 5, nodes,
                                                new_elements, min_elem_dim);
 
                                std::array<std::size_t, 6> const pris2_node_ids{
                                    lutHexDiametralNode(back.first),
                                    cutting_plane[0],
                                    cutting_plane[3],
                                    lutHexDiametralNode(back.second),
                                    cutting_plane[1],
                                    cutting_plane[2]};
                                auto prism2 = createElement<MeshLib::Prism>(
                                    org_elem->nodes(), nodes, pris2_node_ids);
                                nNewElements +=
                                    reducePrism(prism2.get(), 5, nodes,
                                                new_elements, min_elem_dim);
                                return nNewElements;
                            }
                        }
                    }
                }
            }
        }
    }
    else if (n_unique_nodes == 5)
    {
        MeshLib::Element* tet1(constructFourNodeElement(org_elem, nodes));
        std::array<std::size_t, 4> const first_four_node_ids = {
            {tet1->getNode(0)->getID(), tet1->getNode(1)->getID(),
             tet1->getNode(2)->getID(), tet1->getNode(3)->getID()}};
        unsigned const fifth_node =
            findPyramidTopNode(*org_elem, first_four_node_ids);
 
        bool tet_changed(false);
        if (tet1->getGeomType() == MeshLib::MeshElemType::QUAD)
        {
            delete tet1;
            tet_changed = true;
            std::array const tet1_nodes = {
                nodes[first_four_node_ids[0]], nodes[first_four_node_ids[1]],
                nodes[first_four_node_ids[2]],
                nodes[org_elem->getNode(fifth_node)->getID()]};
            new_elements.push_back(new MeshLib::Tet(tet1_nodes));
        }
        else
        {
            new_elements.push_back(tet1);
        }
 
        std::array const tet2_nodes = {
            (tet_changed) ? nodes[first_four_node_ids[0]]
                          : nodes[first_four_node_ids[1]],
            nodes[first_four_node_ids[2]], nodes[first_four_node_ids[3]],
            nodes[org_elem->getNode(fifth_node)->getID()]};
        new_elements.push_back(new MeshLib::Tet(tet2_nodes));
        return 2;
    }
    else if (n_unique_nodes == 4)
    {
        MeshLib::Element* elem(
            constructFourNodeElement(org_elem, nodes, min_elem_dim));
        if (elem)
        {
            new_elements.push_back(elem);
            return 1;
        }
    }
    else if (n_unique_nodes == 3 && min_elem_dim < 3)
    {
        new_elements.push_back(constructTri(org_elem, nodes));
        return 1;
    }
    else if (min_elem_dim == 1)
    {
        new_elements.push_back(constructLine(org_elem, nodes));
        return 1;
    }
    return 0;
}

References constructFourNodeElement(), constructLine(), constructTri(), createElement(), ERR(), findPyramidTopNode(), MeshLib::Element::getFace(), MeshLib::Element::getGeomType(), MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), MeshLib::getNodeIDinElement(), MeshLib::Element::isEdge(), lutHexBackNodes(), lutHexCuttingQuadNodes(), lutHexDiametralNode(), MeshLib::Element::nodes(), MeshLib::QUAD, and reducePrism().

Referenced by reduceElement().

reducePrism()

unsigned anonymous_namespace{MeshRevision.cpp}::reducePrism	(	MeshLib::Element const *const	org_elem,
		unsigned const	n_unique_nodes,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	new_elements,
		unsigned const	min_elem_dim )

Reduces a prism element by removing collapsed nodes and constructing one or two new elements from the remaining nodes.

Returns

The number of newly created elements

Definition at line 295 of file MeshRevision.cpp.

{
    auto addTetrahedron =
        [&org_elem, &nodes, &new_elements](std::array<std::size_t, 4> const ids)
    {
        new_elements.push_back(
            createElement<MeshLib::Tet>(org_elem->nodes(), nodes, ids)
                .release());
    };
 
    // TODO?
    // In theory a node from the bottom triangle and a node from the top
    // triangle that are not connected by an edge could collapse, resulting in a
    // combination of tri and quad elements. This case is currently not tested.
 
    // if one of the non-triangle edges collapsed, elem can be reduced to a
    // pyramid, otherwise it will be two tets
    if (n_unique_nodes == 5)
    {
        for (unsigned i = 0; i < 5; ++i)
        {
            for (unsigned j = i + 1; j < 6; ++j)
            {
                if (i != j && org_elem->getNode(i)->getID() ==
                                  org_elem->getNode(j)->getID())
                {
                    // non triangle edge collapsed
                    if (i % 3 == j % 3)
                    {
                        addTetrahedron(
                            {(i + 1) % 3, (i + 2) % 3, i, (i + 1) % 3 + 3});
                        addTetrahedron(
                            {(i + 1) % 3 + 3, (i + 2) % 3, i, (i + 2) % 3 + 3});
                        return 2;
                    }
 
                    // triangle edge collapsed
                    const unsigned i_offset = (i > 2) ? i - 3 : i + 3;
                    const unsigned j_offset = (i > 2) ? j - 3 : j + 3;
                    const unsigned k = MeshToolsLib::lutPrismThirdNode(i, j);
                    if (k == std::numeric_limits<unsigned>::max())
                    {
                        ERR("Unexpected error during prism reduction.");
                        return 0;
                    }
                    const unsigned k_offset = (i > 2) ? k - 3 : k + 3;
 
                    addTetrahedron({i_offset, j_offset, k_offset, i});
 
                    const unsigned l =
                        (MathLib::isCoplanar(*org_elem->getNode(i_offset),
                                             *org_elem->getNode(k_offset),
                                             *org_elem->getNode(i),
                                             *org_elem->getNode(k)))
                            ? j
                            : i;
                    const unsigned l_offset = (i > 2) ? l - 3 : l + 3;
                    addTetrahedron({l_offset, k_offset, i, k});
                    return 2;
                }
            }
        }
    }
    else if (n_unique_nodes == 4)
    {
        MeshLib::Element* const elem(
            constructFourNodeElement(org_elem, nodes, min_elem_dim));
        if (elem)
        {
            new_elements.push_back(elem);
        }
    }
    else if (n_unique_nodes == 3 && min_elem_dim < 3)
    {
        new_elements.push_back(constructTri(org_elem, nodes));
    }
    else if (n_unique_nodes == 2 && min_elem_dim == 1)
    {
        new_elements.push_back(constructLine(org_elem, nodes));
    }
    return 1;
}

References constructFourNodeElement(), constructLine(), constructTri(), createElement(), ERR(), MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), MeshLib::views::ids, MathLib::isCoplanar(), MeshToolsLib::lutPrismThirdNode(), and MeshLib::Element::nodes().

Referenced by reduceElement(), and reduceHex().

reducePyramid()

void anonymous_namespace{MeshRevision.cpp}::reducePyramid	(	MeshLib::Element const *const	org_elem,
		unsigned const	n_unique_nodes,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	new_elements,
		unsigned const	min_elem_dim )

Reduces a pyramid element by removing collapsed nodes and constructing a new elements from the remaining nodes.

Definition at line 267 of file MeshRevision.cpp.

{
    if (n_unique_nodes == 4)
    {
        MeshLib::Element* elem(
            constructFourNodeElement(org_elem, nodes, min_elem_dim));
        if (elem)
        {
            new_elements.push_back(elem);
        }
    }
    else if (n_unique_nodes == 3 && min_elem_dim < 3)
    {
        new_elements.push_back(constructTri(org_elem, nodes));
    }
    else if (n_unique_nodes == 2 && min_elem_dim == 1)
    {
        new_elements.push_back(constructLine(org_elem, nodes));
    }
}

References constructFourNodeElement(), constructLine(), and constructTri().

Referenced by reduceElement().

subdivideElement()

std::size_t anonymous_namespace{MeshRevision.cpp}::subdivideElement	(	MeshLib::Element const *const	element,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	elements )

Subdivides an element if it has a face that is not coplanar

Parameters

element	the element that will be subdivided
nodes	vector containing the nodes the elements originated by the subdivision are based on
elements	vector of MeshLib::Elements; the elements originated by the subdivision will be inserted into elements

Returns

the number of elements originated by the subdivision

Definition at line 798 of file MeshRevision.cpp.

{
    if (element->getGeomType() == MeshLib::MeshElemType::QUAD)
    {
        return subdivideQuad(element, nodes, elements);
    }
    if (element->getGeomType() == MeshLib::MeshElemType::HEXAHEDRON)
    {
        return subdivideHex(element, nodes, elements);
    }
    if (element->getGeomType() == MeshLib::MeshElemType::PYRAMID)
    {
        return subdividePyramid(element, nodes, elements);
    }
    if (element->getGeomType() == MeshLib::MeshElemType::PRISM)
    {
        return subdividePrism(element, nodes, elements);
    }
    return 0;
}

References MeshLib::Element::getGeomType(), MeshLib::HEXAHEDRON, MeshLib::PRISM, MeshLib::PYRAMID, MeshLib::QUAD, subdivideHex(), subdividePrism(), subdividePyramid(), and subdivideQuad().

subdivideHex()

unsigned anonymous_namespace{MeshRevision.cpp}::subdivideHex	(	MeshLib::Element const *const	hex,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	new_elements )

Subdivides a Hex with nonplanar faces into tets.

Definition at line 117 of file MeshRevision.cpp.

{
    auto prism1 =
        createElement<MeshLib::Prism>(hex->nodes(), nodes, {0, 2, 1, 4, 6, 5});
    subdividePrism(prism1.get(), nodes, new_elements);
 
    auto prism2 =
        createElement<MeshLib::Prism>(hex->nodes(), nodes, {4, 6, 7, 0, 2, 3});
    subdividePrism(prism2.get(), nodes, new_elements);
 
    return 6;
}

References createElement(), MeshLib::Element::nodes(), and subdividePrism().

Referenced by subdivideElement().

subdividePrism()

unsigned anonymous_namespace{MeshRevision.cpp}::subdividePrism	(	MeshLib::Element const *const	prism,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	new_elements )

Subdivides a prism with nonplanar quad faces into two tets.

Definition at line 98 of file MeshRevision.cpp.

{
    auto addTetrahedron =
        [&prism, &nodes, &new_elements](std::array<std::size_t, 4> const ids)
    {
        new_elements.push_back(
            createElement<MeshLib::Tet>(prism->nodes(), nodes, ids).release());
    };
 
    addTetrahedron({0, 1, 2, 3});
    addTetrahedron({3, 2, 4, 5});
    addTetrahedron({2, 1, 3, 4});
 
    return 3;
}

References createElement(), MeshLib::views::ids, and MeshLib::Element::nodes().

Referenced by subdivideElement(), and subdivideHex().

subdividePyramid()

unsigned anonymous_namespace{MeshRevision.cpp}::subdividePyramid	(	MeshLib::Element const *const	pyramid,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	new_elements )

Subdivides a pyramid with a nonplanar base into two tets.

Definition at line 133 of file MeshRevision.cpp.

{
    auto addTetrahedron =
        [&pyramid, &nodes, &new_elements](std::array<std::size_t, 4> const ids)
    {
        new_elements.push_back(
            createElement<MeshLib::Tet>(pyramid->nodes(), nodes, ids)
                .release());
    };
 
    addTetrahedron({0, 1, 2, 4});
    addTetrahedron({0, 2, 3, 4});
 
    return 2;
}

References createElement(), MeshLib::views::ids, and MeshLib::Element::nodes().

Referenced by subdivideElement().

subdivideQuad()

unsigned anonymous_namespace{MeshRevision.cpp}::subdivideQuad	(	MeshLib::Element const *const	quad,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element * > &	new_elements )

Subdivides a nonplanar quad into two triangles.

Definition at line 80 of file MeshRevision.cpp.

{
    std::array<std::size_t, 3> const tri1_node_ids{0, 1, 2};
    new_elements.push_back(
        createElement<MeshLib::Tri>(quad->nodes(), nodes, tri1_node_ids)
            .release());
 
    std::array<std::size_t, 3> const tri2_node_ids{0, 2, 3};
    new_elements.push_back(
        createElement<MeshLib::Tri>(quad->nodes(), nodes, tri2_node_ids)
            .release());
 
    return 2;
}

References createElement(), and MeshLib::Element::nodes().

Referenced by subdivideElement().