TemplateElement.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <array>
#include <limits>
 
#include "MathLib/Point3d.h"
 
#include "MeshLib/Node.h"
#include "MeshLib/Elements/Element.h"
#include "MeshLib/Elements/FaceRule.h"
#include "MeshLib/Elements/CellRule.h"
#include "MeshLib/Elements/ElementErrorCode.h"
 
namespace MeshLib
{

template <class ELEMENT_RULE>
class TemplateElement : public Element
{
public:
    static const unsigned n_all_nodes = ELEMENT_RULE::n_all_nodes;

    static const unsigned n_base_nodes = ELEMENT_RULE::n_base_nodes;

    static const unsigned dimension = ELEMENT_RULE::dimension;

    explicit TemplateElement(
        Node* nodes[n_all_nodes],
        std::size_t id = std::numeric_limits<std::size_t>::max());

    explicit TemplateElement(
        std::array<Node*, n_all_nodes> const& nodes,
        std::size_t id = std::numeric_limits<std::size_t>::max());

    explicit TemplateElement(const TemplateElement& e);

    Element* clone() const override { return new TemplateElement(*this); }
    Element* clone(Node** nodes, std::size_t id) const override
    {
        return new TemplateElement(nodes, id);
    }

    constexpr unsigned getDimension() const override { return dimension; }
    const Element* getEdge(unsigned i) const override
    {
        return ELEMENT_RULE::EdgeReturn::getEdge(this, i);
    }

    const Element* getFace(unsigned i) const override
    {
        return ELEMENT_RULE::getFace(this, i);
    }

    const Element* getBoundary(unsigned i) const override
    {
        if constexpr (std::is_convertible<ELEMENT_RULE, FaceRule>::value)
        {
            return ELEMENT_RULE::EdgeReturn::getEdge(this, i);
        }
        if constexpr (std::is_convertible<ELEMENT_RULE, CellRule>::value)
        {
            return ELEMENT_RULE::getFace(this, i);
        }
        OGS_FATAL("TemplateElement::getBoundary for boundary {:d} failed.", i);
    }

    unsigned getNumberOfBoundaries() const override
    {
        if constexpr (std::is_convertible<ELEMENT_RULE, FaceRule>::value)
        {
            return ELEMENT_RULE::n_edges;
        }
        else
        {
            return ELEMENT_RULE::n_faces;
        }
    }

    unsigned getNumberOfEdges() const override { return ELEMENT_RULE::n_edges; }
    unsigned getNumberOfFaces() const override { return ELEMENT_RULE::n_faces; }
    unsigned getNumberOfNeighbors() const override
    {
        return ELEMENT_RULE::n_neighbors;
    }
 
    const Element* getNeighbor(unsigned i) const override
    {
#ifndef NDEBUG
        if (i < ELEMENT_RULE::n_neighbors)
#endif
        {
            return _neighbors[i];
        }
#ifndef NDEBUG
        ERR("Error in MeshLib::TemplateElement::getNeighbor() - Index {:d} "
            "does not exist.",
            i);
        return nullptr;
#endif
    }

    unsigned getNumberOfBaseNodes() const override { return n_base_nodes; }
    unsigned getNumberOfNodes() const override { return n_all_nodes; }
    MeshElemType getGeomType() const override
    {
        return ELEMENT_RULE::mesh_elem_type;
    }

    CellType getCellType() const override { return ELEMENT_RULE::cell_type; }
    bool isEdge(unsigned idx1, unsigned idx2) const override;

    bool isPntInElement(
        MathLib::Point3d const& pnt,
        double eps = std::numeric_limits<double>::epsilon()) const override
    {
        return ELEMENT_RULE::isPntInElement(_nodes.data(), pnt, eps);
    }

    ElementErrorCode validate() const override
    {
        return ELEMENT_RULE::validate(this);
    }

    unsigned identifyFace(Node const* nodes[3]) const override
    {
        return ELEMENT_RULE::identifyFace(_nodes.data(), nodes);
    }

    double computeVolume() override
    {
        return ELEMENT_RULE::computeVolume(_nodes.data());
    }
 
    const Node* getNode(unsigned idx) const override;
    Node* getNode(unsigned idx) override;
    void setNode(unsigned idx, Node* node) override;
    Node* const* getNodes() const override { return _nodes.data(); }

    inline Node* getEdgeNode(unsigned edge_id, unsigned node_id) const override
    {
        if (getNumberOfEdges() > 0)
        {
            return const_cast<Node*>(
                _nodes[ELEMENT_RULE::edge_nodes[edge_id][node_id]]);
        }
 
        return nullptr;
    }

    bool testElementNodeOrder() const override
    {
        return ELEMENT_RULE::testElementNodeOrder(*this);
    }
 
    double getContent() const override final;
 
    std::array<Node*, n_all_nodes> _nodes;
};
 
}  // namespace MeshLib
 
#include "TemplateElement-impl.h"