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)
template<typename T >
void	fillNodeProperty (std::vector< T > &new_prop, std::vector< T > const &old_prop, std::vector< size_t > const &node_ids)
template<typename T >
void	fillElemProperty (std::vector< T > &new_prop, std::vector< T > const &old_prop, std::vector< size_t > const &elem_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 215 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 161 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 180 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 928 of file MeshRevision.cpp.

{
    auto const prop_names = props.getPropertyVectorNames();
    MeshLib::Properties new_properties;
 
    for (auto name : prop_names)
    {
        if (props.existsPropertyVector<int>(name, MeshLib::MeshItemType::Node,
                                            1))
        {
            auto const* p = props.getPropertyVector<int>(
                name, MeshLib::MeshItemType::Node, 1);
            auto new_node_vec = new_properties.createNewPropertyVector<int>(
                name, MeshLib::MeshItemType::Node, 1);
            fillNodeProperty(*new_node_vec, *p, node_ids);
            continue;
        }
        if (props.existsPropertyVector<float>(name, MeshLib::MeshItemType::Node,
                                              1))
        {
            auto const* p = props.getPropertyVector<float>(
                name, MeshLib::MeshItemType::Node, 1);
            auto new_node_vec = new_properties.createNewPropertyVector<float>(
                name, MeshLib::MeshItemType::Node, 1);
            fillNodeProperty(*new_node_vec, *p, node_ids);
            continue;
        }
        if (props.existsPropertyVector<double>(name,
                                               MeshLib::MeshItemType::Node, 1))
        {
            auto const* p = props.getPropertyVector<double>(
                name, MeshLib::MeshItemType::Node, 1);
            auto new_node_vec = new_properties.createNewPropertyVector<double>(
                name, MeshLib::MeshItemType::Node, 1);
            fillNodeProperty(*new_node_vec, *p, node_ids);
            continue;
        }
        if (props.existsPropertyVector<int>(name, MeshLib::MeshItemType::Cell,
                                            1))
        {
            auto const* p = props.getPropertyVector<int>(
                name, MeshLib::MeshItemType::Cell, 1);
            auto new_cell_vec = new_properties.createNewPropertyVector<int>(
                name, MeshLib::MeshItemType::Cell, 1);
            fillElemProperty(*new_cell_vec, *p, elem_ids);
            continue;
        }
        if (props.existsPropertyVector<float>(name, MeshLib::MeshItemType::Cell,
                                              1))
        {
            auto const* p = props.getPropertyVector<float>(
                name, MeshLib::MeshItemType::Cell, 1);
            auto new_cell_vec = new_properties.createNewPropertyVector<float>(
                name, MeshLib::MeshItemType::Cell, 1);
            fillElemProperty(*new_cell_vec, *p, elem_ids);
            continue;
        }
        if (props.existsPropertyVector<double>(name,
                                               MeshLib::MeshItemType::Cell, 1))
        {
            auto const* p = props.getPropertyVector<double>(
                name, MeshLib::MeshItemType::Cell, 1);
            auto new_cell_vec = new_properties.createNewPropertyVector<double>(
                name, MeshLib::MeshItemType::Cell, 1);
            fillElemProperty(*new_cell_vec, *p, elem_ids);
            continue;
        }
        WARN("PropertyVector {:s} not being converted.", name);
    }
    return new_properties;
}

References MeshLib::Cell, MeshLib::Properties::createNewPropertyVector(), MeshLib::Properties::existsPropertyVector(), fillElemProperty(), fillNodeProperty(), MeshLib::Properties::getPropertyVector(), MeshLib::Properties::getPropertyVectorNames(), MeshLib::Node, and WARN().

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 68 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);
}

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

fillElemProperty()

template<typename T >

void anonymous_namespace{MeshRevision.cpp}::fillElemProperty	(	std::vector< T > &	new_prop,
		std::vector< T > const &	old_prop,
		std::vector< size_t > const &	elem_ids )

Definition at line 916 of file MeshRevision.cpp.

{
    std::transform(elem_ids.cbegin(), elem_ids.cend(),
                   std::back_inserter(new_prop),
                   [&](std::size_t const i) { return old_prop[i]; });
}

Referenced by copyProperties().

fillNodeProperty()

template<typename T >

void anonymous_namespace{MeshRevision.cpp}::fillNodeProperty	(	std::vector< T > &	new_prop,
		std::vector< T > const &	old_prop,
		std::vector< size_t > const &	node_ids )

Definition at line 900 of file MeshRevision.cpp.

{
    std::size_t const n_nodes = node_ids.size();
    for (std::size_t i = 0; i < n_nodes; ++i)
    {
        if (node_ids[i] != i)
        {
            continue;
        }
        new_prop.push_back(old_prop[i]);
    }
}

Referenced by copyProperties().

findPyramidTopNode()

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

Definition at line 556 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 880 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().

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 509 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 392 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 499 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 831 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 582 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::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 303 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(), 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 275 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 806 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 125 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 106 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(), 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 141 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(), 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 88 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 MeshLib::Element::nodes().

Referenced by subdivideElement().